{"version":3,"sources":["webpack:///src/components/SignatureFields/Formula.vue","webpack:///./node_modules/core-js/internals/get-substitution.js","webpack:///./node_modules/core-js/internals/regexp-exec-abstract.js","webpack:///./node_modules/core-js/modules/es.regexp.sticky.js","webpack:///./src/components/SignatureFields/Formula.vue","webpack:///./src/components/SignatureFields/Formula.vue?f17d","webpack:///./src/components/SignatureFields/Formula.vue?8c20","webpack:///./node_modules/core-js/internals/is-regexp.js","webpack:///./node_modules/core-js/modules/es.regexp.constructor.js","webpack:///./node_modules/core-js/modules/es.string.replace.js","webpack:///./node_modules/core-js/internals/advance-string-index.js","webpack:///./node_modules/core-js/modules/es.regexp.dot-all.js","webpack:///./node_modules/core-js/internals/fix-regexp-well-known-symbol-logic.js"],"names":["props","field","Object","value","String","Number","signedDocument","components","Icon","watch","handler","eq","defaultValue","_iterator","_createForOfIteratorHelper","document","page","_step","s","n","done","_iterator2","pageField","_step2","reg","RegExp","name","val","pageFieldValue","isNaN","replace","err","e","f","eval","console","error","alertify","$emit","deep","uncurryThis","toObject","floor","Math","charAt","stringSlice","slice","SUBSTITUTION_SYMBOLS","SUBSTITUTION_SYMBOLS_NO_NAMED","module","exports","matched","str","position","captures","namedCaptures","replacement","tailPos","length","m","symbols","undefined","match","ch","capture","call","anObject","isCallable","classof","regexpExec","$TypeError","TypeError","R","S","exec","result","DESCRIPTORS","MISSED_STICKY","defineBuiltInAccessor","getInternalState","get","RegExpPrototype","prototype","configurable","this","sticky","render","_vm","_c","_self","staticClass","_v","_s","staticRenderFns","component","isObject","wellKnownSymbol","MATCH","it","isRegExp","global","isForced","inheritIfRequired","createNonEnumerableProperty","getOwnPropertyNames","isPrototypeOf","toString","getRegExpFlags","stickyHelpers","proxyAccessor","defineBuiltIn","fails","hasOwn","enforceInternalState","enforce","setSpecies","UNSUPPORTED_DOT_ALL","UNSUPPORTED_NCG","NativeRegExp","SyntaxError","stringIndexOf","indexOf","IS_NCG","re1","re2","CORRECT_NEW","UNSUPPORTED_Y","BASE_FORCED","handleDotAll","string","chr","index","brackets","handleNCG","named","names","ncg","groupid","groupname","RegExpWrapper","pattern","flags","rawFlags","dotAll","handled","state","thisIsRegExp","patternIsRegExp","flagsAreUndefined","groups","rawPattern","constructor","source","raw","keys","apply","fixRegExpWellKnownSymbolLogic","isNullOrUndefined","toIntegerOrInfinity","toLength","requireObjectCoercible","advanceStringIndex","getMethod","getSubstitution","regExpExec","REPLACE","max","min","concat","push","maybeToString","REPLACE_KEEPS_$0","REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE","REPLACE_SUPPORTS_NAMED_GROUPS","re","a","_","nativeReplace","maybeCallNative","UNSAFE_SUBSTITUTE","searchValue","replaceValue","O","replacer","rx","res","functionalReplace","fullUnicode","unicode","lastIndex","results","matchStr","accumulatedResult","nextSourcePosition","i","j","replacerArgs","SPECIES","KEY","FORCED","SHAM","SYMBOL","DELEGATES_TO_SYMBOL","DELEGATES_TO_EXEC","execCalled","uncurriedNativeRegExpMethod","methods","nativeMethod","regexp","arg2","forceStringMethod","uncurriedNativeMethod","$exec"],"mappings":"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","file":"js/chunk-1d3c16ec.663f76bb.js","sourcesContent":["<template>\r\n    <div class=\"d-flex\">\r\n        {{value}}\r\n    </div>\r\n</template>\r\n<script>\r\n    import Icon from \"@/components/Icons/Icon.vue\";\r\n    export default {\r\n        props: {\r\n            field: Object,\r\n            value: [String, Number],\r\n            signedDocument: Object\r\n        },\r\n        components: {\r\n            Icon\r\n        },\r\n        watch: {\r\n            signedDocument: {\r\n                handler() {\r\n\r\n                    let eq = this.field.defaultValue;\r\n                    for (let page of this.signedDocument.document.page) {\r\n                        for (let pageField of page.pageField) {\r\n                           \r\n                            let reg = new RegExp(\"\\\\[\" + pageField.name + \"]\", \"gi\");\r\n                           \r\n                            let val = pageField.pageFieldValue.value;\r\n                            if (isNaN(val)) {\r\n                                val = \"\\\"\" + val + \"\\\"\";\r\n                            }\r\n                            if (val == \"\") val = \"\\\"\\\"\";\r\n                            eq = eq.replace(reg, val);\r\n                            \r\n                        }\r\n                    }\r\n                    let value = \"?\";\r\n                    try {\r\n                        value = eval(eq);\r\n                    } catch (e) {\r\n                        console.error(e);\r\n                        alertify.error(\"Equation not solved!\");\r\n                    }\r\n                    if (value == \"\") value = \"?\";\r\n\r\n                    this.$emit('update:value', value);\r\n                },\r\n                deep: true\r\n            } \r\n        }\r\n    }\r\n</script>","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toObject = require('../internals/to-object');\n\nvar floor = Math.floor;\nvar charAt = uncurryThis(''.charAt);\nvar replace = uncurryThis(''.replace);\nvar stringSlice = uncurryThis(''.slice);\n// eslint-disable-next-line redos/no-vulnerable -- safe\nvar SUBSTITUTION_SYMBOLS = /\\$([$&'`]|\\d{1,2}|<[^>]*>)/g;\nvar SUBSTITUTION_SYMBOLS_NO_NAMED = /\\$([$&'`]|\\d{1,2})/g;\n\n// `GetSubstitution` abstract operation\n// https://tc39.es/ecma262/#sec-getsubstitution\nmodule.exports = function (matched, str, position, captures, namedCaptures, replacement) {\n  var tailPos = position + matched.length;\n  var m = captures.length;\n  var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;\n  if (namedCaptures !== undefined) {\n    namedCaptures = toObject(namedCaptures);\n    symbols = SUBSTITUTION_SYMBOLS;\n  }\n  return replace(replacement, symbols, function (match, ch) {\n    var capture;\n    switch (charAt(ch, 0)) {\n      case '$': return '$';\n      case '&': return matched;\n      case '`': return stringSlice(str, 0, position);\n      case \"'\": return stringSlice(str, tailPos);\n      case '<':\n        capture = namedCaptures[stringSlice(ch, 1, -1)];\n        break;\n      default: // \\d\\d?\n        var n = +ch;\n        if (n === 0) return match;\n        if (n > m) {\n          var f = floor(n / 10);\n          if (f === 0) return match;\n          if (f <= m) return captures[f - 1] === undefined ? charAt(ch, 1) : captures[f - 1] + charAt(ch, 1);\n          return match;\n        }\n        capture = captures[n - 1];\n    }\n    return capture === undefined ? '' : capture;\n  });\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar isCallable = require('../internals/is-callable');\nvar classof = require('../internals/classof-raw');\nvar regexpExec = require('../internals/regexp-exec');\n\nvar $TypeError = TypeError;\n\n// `RegExpExec` abstract operation\n// https://tc39.es/ecma262/#sec-regexpexec\nmodule.exports = function (R, S) {\n  var exec = R.exec;\n  if (isCallable(exec)) {\n    var result = call(exec, R, S);\n    if (result !== null) anObject(result);\n    return result;\n  }\n  if (classof(R) === 'RegExp') return call(regexpExec, R, S);\n  throw $TypeError('RegExp#exec called on incompatible receiver');\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar MISSED_STICKY = require('../internals/regexp-sticky-helpers').MISSED_STICKY;\nvar classof = require('../internals/classof-raw');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\nvar getInternalState = require('../internals/internal-state').get;\n\nvar RegExpPrototype = RegExp.prototype;\nvar $TypeError = TypeError;\n\n// `RegExp.prototype.sticky` getter\n// https://tc39.es/ecma262/#sec-get-regexp.prototype.sticky\nif (DESCRIPTORS && MISSED_STICKY) {\n  defineBuiltInAccessor(RegExpPrototype, 'sticky', {\n    configurable: true,\n    get: function sticky() {\n      if (this === RegExpPrototype) return;\n      // We can't use InternalStateModule.getterFor because\n      // we don't add metadata for regexps created by a literal.\n      if (classof(this) === 'RegExp') {\n        return !!getInternalState(this).sticky;\n      }\n      throw $TypeError('Incompatible receiver, RegExp required');\n    }\n  });\n}\n","var render = function render(){var _vm=this,_c=_vm._self._c;return _c('div',{staticClass:\"d-flex\"},[_vm._v(\" \"+_vm._s(_vm.value)+\" \")])\n}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","import mod from \"-!../../../node_modules/cache-loader/dist/cjs.js??ref--13-0!../../../node_modules/thread-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Formula.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../../node_modules/cache-loader/dist/cjs.js??ref--13-0!../../../node_modules/thread-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Formula.vue?vue&type=script&lang=js&\"","import { render, staticRenderFns } from \"./Formula.vue?vue&type=template&id=93709c7c&\"\nimport script from \"./Formula.vue?vue&type=script&lang=js&\"\nexport * from \"./Formula.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","'use strict';\nvar isObject = require('../internals/is-object');\nvar classof = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar MATCH = wellKnownSymbol('match');\n\n// `IsRegExp` abstract operation\n// https://tc39.es/ecma262/#sec-isregexp\nmodule.exports = function (it) {\n  var isRegExp;\n  return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classof(it) === 'RegExp');\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isForced = require('../internals/is-forced');\nvar inheritIfRequired = require('../internals/inherit-if-required');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar getOwnPropertyNames = require('../internals/object-get-own-property-names').f;\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar isRegExp = require('../internals/is-regexp');\nvar toString = require('../internals/to-string');\nvar getRegExpFlags = require('../internals/regexp-get-flags');\nvar stickyHelpers = require('../internals/regexp-sticky-helpers');\nvar proxyAccessor = require('../internals/proxy-accessor');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar fails = require('../internals/fails');\nvar hasOwn = require('../internals/has-own-property');\nvar enforceInternalState = require('../internals/internal-state').enforce;\nvar setSpecies = require('../internals/set-species');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar UNSUPPORTED_DOT_ALL = require('../internals/regexp-unsupported-dot-all');\nvar UNSUPPORTED_NCG = require('../internals/regexp-unsupported-ncg');\n\nvar MATCH = wellKnownSymbol('match');\nvar NativeRegExp = global.RegExp;\nvar RegExpPrototype = NativeRegExp.prototype;\nvar SyntaxError = global.SyntaxError;\nvar exec = uncurryThis(RegExpPrototype.exec);\nvar charAt = uncurryThis(''.charAt);\nvar replace = uncurryThis(''.replace);\nvar stringIndexOf = uncurryThis(''.indexOf);\nvar stringSlice = uncurryThis(''.slice);\n// TODO: Use only proper RegExpIdentifierName\nvar IS_NCG = /^\\?<[^\\s\\d!#%&*+<=>@^][^\\s!#%&*+<=>@^]*>/;\nvar re1 = /a/g;\nvar re2 = /a/g;\n\n// \"new\" should create a new object, old webkit bug\nvar CORRECT_NEW = new NativeRegExp(re1) !== re1;\n\nvar MISSED_STICKY = stickyHelpers.MISSED_STICKY;\nvar UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y;\n\nvar BASE_FORCED = DESCRIPTORS &&\n  (!CORRECT_NEW || MISSED_STICKY || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG || fails(function () {\n    re2[MATCH] = false;\n    // RegExp constructor can alter flags and IsRegExp works correct with @@match\n    return NativeRegExp(re1) !== re1 || NativeRegExp(re2) === re2 || String(NativeRegExp(re1, 'i')) !== '/a/i';\n  }));\n\nvar handleDotAll = function (string) {\n  var length = string.length;\n  var index = 0;\n  var result = '';\n  var brackets = false;\n  var chr;\n  for (; index <= length; index++) {\n    chr = charAt(string, index);\n    if (chr === '\\\\') {\n      result += chr + charAt(string, ++index);\n      continue;\n    }\n    if (!brackets && chr === '.') {\n      result += '[\\\\s\\\\S]';\n    } else {\n      if (chr === '[') {\n        brackets = true;\n      } else if (chr === ']') {\n        brackets = false;\n      } result += chr;\n    }\n  } return result;\n};\n\nvar handleNCG = function (string) {\n  var length = string.length;\n  var index = 0;\n  var result = '';\n  var named = [];\n  var names = {};\n  var brackets = false;\n  var ncg = false;\n  var groupid = 0;\n  var groupname = '';\n  var chr;\n  for (; index <= length; index++) {\n    chr = charAt(string, index);\n    if (chr === '\\\\') {\n      chr = chr + charAt(string, ++index);\n    } else if (chr === ']') {\n      brackets = false;\n    } else if (!brackets) switch (true) {\n      case chr === '[':\n        brackets = true;\n        break;\n      case chr === '(':\n        if (exec(IS_NCG, stringSlice(string, index + 1))) {\n          index += 2;\n          ncg = true;\n        }\n        result += chr;\n        groupid++;\n        continue;\n      case chr === '>' && ncg:\n        if (groupname === '' || hasOwn(names, groupname)) {\n          throw new SyntaxError('Invalid capture group name');\n        }\n        names[groupname] = true;\n        named[named.length] = [groupname, groupid];\n        ncg = false;\n        groupname = '';\n        continue;\n    }\n    if (ncg) groupname += chr;\n    else result += chr;\n  } return [result, named];\n};\n\n// `RegExp` constructor\n// https://tc39.es/ecma262/#sec-regexp-constructor\nif (isForced('RegExp', BASE_FORCED)) {\n  var RegExpWrapper = function RegExp(pattern, flags) {\n    var thisIsRegExp = isPrototypeOf(RegExpPrototype, this);\n    var patternIsRegExp = isRegExp(pattern);\n    var flagsAreUndefined = flags === undefined;\n    var groups = [];\n    var rawPattern = pattern;\n    var rawFlags, dotAll, sticky, handled, result, state;\n\n    if (!thisIsRegExp && patternIsRegExp && flagsAreUndefined && pattern.constructor === RegExpWrapper) {\n      return pattern;\n    }\n\n    if (patternIsRegExp || isPrototypeOf(RegExpPrototype, pattern)) {\n      pattern = pattern.source;\n      if (flagsAreUndefined) flags = getRegExpFlags(rawPattern);\n    }\n\n    pattern = pattern === undefined ? '' : toString(pattern);\n    flags = flags === undefined ? '' : toString(flags);\n    rawPattern = pattern;\n\n    if (UNSUPPORTED_DOT_ALL && 'dotAll' in re1) {\n      dotAll = !!flags && stringIndexOf(flags, 's') > -1;\n      if (dotAll) flags = replace(flags, /s/g, '');\n    }\n\n    rawFlags = flags;\n\n    if (MISSED_STICKY && 'sticky' in re1) {\n      sticky = !!flags && stringIndexOf(flags, 'y') > -1;\n      if (sticky && UNSUPPORTED_Y) flags = replace(flags, /y/g, '');\n    }\n\n    if (UNSUPPORTED_NCG) {\n      handled = handleNCG(pattern);\n      pattern = handled[0];\n      groups = handled[1];\n    }\n\n    result = inheritIfRequired(NativeRegExp(pattern, flags), thisIsRegExp ? this : RegExpPrototype, RegExpWrapper);\n\n    if (dotAll || sticky || groups.length) {\n      state = enforceInternalState(result);\n      if (dotAll) {\n        state.dotAll = true;\n        state.raw = RegExpWrapper(handleDotAll(pattern), rawFlags);\n      }\n      if (sticky) state.sticky = true;\n      if (groups.length) state.groups = groups;\n    }\n\n    if (pattern !== rawPattern) try {\n      // fails in old engines, but we have no alternatives for unsupported regex syntax\n      createNonEnumerableProperty(result, 'source', rawPattern === '' ? '(?:)' : rawPattern);\n    } catch (error) { /* empty */ }\n\n    return result;\n  };\n\n  for (var keys = getOwnPropertyNames(NativeRegExp), index = 0; keys.length > index;) {\n    proxyAccessor(RegExpWrapper, NativeRegExp, keys[index++]);\n  }\n\n  RegExpPrototype.constructor = RegExpWrapper;\n  RegExpWrapper.prototype = RegExpPrototype;\n  defineBuiltIn(global, 'RegExp', RegExpWrapper, { constructor: true });\n}\n\n// https://tc39.es/ecma262/#sec-get-regexp-@@species\nsetSpecies('RegExp');\n","'use strict';\nvar apply = require('../internals/function-apply');\nvar call = require('../internals/function-call');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fixRegExpWellKnownSymbolLogic = require('../internals/fix-regexp-well-known-symbol-logic');\nvar fails = require('../internals/fails');\nvar anObject = require('../internals/an-object');\nvar isCallable = require('../internals/is-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar toLength = require('../internals/to-length');\nvar toString = require('../internals/to-string');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar advanceStringIndex = require('../internals/advance-string-index');\nvar getMethod = require('../internals/get-method');\nvar getSubstitution = require('../internals/get-substitution');\nvar regExpExec = require('../internals/regexp-exec-abstract');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar REPLACE = wellKnownSymbol('replace');\nvar max = Math.max;\nvar min = Math.min;\nvar concat = uncurryThis([].concat);\nvar push = uncurryThis([].push);\nvar stringIndexOf = uncurryThis(''.indexOf);\nvar stringSlice = uncurryThis(''.slice);\n\nvar maybeToString = function (it) {\n  return it === undefined ? it : String(it);\n};\n\n// IE <= 11 replaces $0 with the whole match, as if it was $&\n// https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0\nvar REPLACE_KEEPS_$0 = (function () {\n  // eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing\n  return 'a'.replace(/./, '$0') === '$0';\n})();\n\n// Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string\nvar REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () {\n  if (/./[REPLACE]) {\n    return /./[REPLACE]('a', '$0') === '';\n  }\n  return false;\n})();\n\nvar REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {\n  var re = /./;\n  re.exec = function () {\n    var result = [];\n    result.groups = { a: '7' };\n    return result;\n  };\n  // eslint-disable-next-line regexp/no-useless-dollar-replacements -- false positive\n  return ''.replace(re, '$<a>') !== '7';\n});\n\n// @@replace logic\nfixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNative) {\n  var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0';\n\n  return [\n    // `String.prototype.replace` method\n    // https://tc39.es/ecma262/#sec-string.prototype.replace\n    function replace(searchValue, replaceValue) {\n      var O = requireObjectCoercible(this);\n      var replacer = isNullOrUndefined(searchValue) ? undefined : getMethod(searchValue, REPLACE);\n      return replacer\n        ? call(replacer, searchValue, O, replaceValue)\n        : call(nativeReplace, toString(O), searchValue, replaceValue);\n    },\n    // `RegExp.prototype[@@replace]` method\n    // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace\n    function (string, replaceValue) {\n      var rx = anObject(this);\n      var S = toString(string);\n\n      if (\n        typeof replaceValue == 'string' &&\n        stringIndexOf(replaceValue, UNSAFE_SUBSTITUTE) === -1 &&\n        stringIndexOf(replaceValue, '$<') === -1\n      ) {\n        var res = maybeCallNative(nativeReplace, rx, S, replaceValue);\n        if (res.done) return res.value;\n      }\n\n      var functionalReplace = isCallable(replaceValue);\n      if (!functionalReplace) replaceValue = toString(replaceValue);\n\n      var global = rx.global;\n      var fullUnicode;\n      if (global) {\n        fullUnicode = rx.unicode;\n        rx.lastIndex = 0;\n      }\n\n      var results = [];\n      var result;\n      while (true) {\n        result = regExpExec(rx, S);\n        if (result === null) break;\n\n        push(results, result);\n        if (!global) break;\n\n        var matchStr = toString(result[0]);\n        if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);\n      }\n\n      var accumulatedResult = '';\n      var nextSourcePosition = 0;\n      for (var i = 0; i < results.length; i++) {\n        result = results[i];\n\n        var matched = toString(result[0]);\n        var position = max(min(toIntegerOrInfinity(result.index), S.length), 0);\n        var captures = [];\n        var replacement;\n        // NOTE: This is equivalent to\n        //   captures = result.slice(1).map(maybeToString)\n        // but for some reason `nativeSlice.call(result, 1, result.length)` (called in\n        // the slice polyfill when slicing native arrays) \"doesn't work\" in safari 9 and\n        // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.\n        for (var j = 1; j < result.length; j++) push(captures, maybeToString(result[j]));\n        var namedCaptures = result.groups;\n        if (functionalReplace) {\n          var replacerArgs = concat([matched], captures, position, S);\n          if (namedCaptures !== undefined) push(replacerArgs, namedCaptures);\n          replacement = toString(apply(replaceValue, undefined, replacerArgs));\n        } else {\n          replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);\n        }\n        if (position >= nextSourcePosition) {\n          accumulatedResult += stringSlice(S, nextSourcePosition, position) + replacement;\n          nextSourcePosition = position + matched.length;\n        }\n      }\n\n      return accumulatedResult + stringSlice(S, nextSourcePosition);\n    }\n  ];\n}, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);\n","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\n\n// `AdvanceStringIndex` abstract operation\n// https://tc39.es/ecma262/#sec-advancestringindex\nmodule.exports = function (S, index, unicode) {\n  return index + (unicode ? charAt(S, index).length : 1);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar UNSUPPORTED_DOT_ALL = require('../internals/regexp-unsupported-dot-all');\nvar classof = require('../internals/classof-raw');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\nvar getInternalState = require('../internals/internal-state').get;\n\nvar RegExpPrototype = RegExp.prototype;\nvar $TypeError = TypeError;\n\n// `RegExp.prototype.dotAll` getter\n// https://tc39.es/ecma262/#sec-get-regexp.prototype.dotall\nif (DESCRIPTORS && UNSUPPORTED_DOT_ALL) {\n  defineBuiltInAccessor(RegExpPrototype, 'dotAll', {\n    configurable: true,\n    get: function dotAll() {\n      if (this === RegExpPrototype) return undefined;\n      // We can't use InternalStateModule.getterFor because\n      // we don't add metadata for regexps created by a literal.\n      if (classof(this) === 'RegExp') {\n        return !!getInternalState(this).dotAll;\n      }\n      throw $TypeError('Incompatible receiver, RegExp required');\n    }\n  });\n}\n","'use strict';\n// TODO: Remove from `core-js@4` since it's moved to entry points\nrequire('../modules/es.regexp.exec');\nvar uncurryThis = require('../internals/function-uncurry-this-clause');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar regexpExec = require('../internals/regexp-exec');\nvar fails = require('../internals/fails');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\nvar SPECIES = wellKnownSymbol('species');\nvar RegExpPrototype = RegExp.prototype;\n\nmodule.exports = function (KEY, exec, FORCED, SHAM) {\n  var SYMBOL = wellKnownSymbol(KEY);\n\n  var DELEGATES_TO_SYMBOL = !fails(function () {\n    // String methods call symbol-named RegEp methods\n    var O = {};\n    O[SYMBOL] = function () { return 7; };\n    return ''[KEY](O) !== 7;\n  });\n\n  var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function () {\n    // Symbol-named RegExp methods call .exec\n    var execCalled = false;\n    var re = /a/;\n\n    if (KEY === 'split') {\n      // We can't use real regex here since it causes deoptimization\n      // and serious performance degradation in V8\n      // https://github.com/zloirock/core-js/issues/306\n      re = {};\n      // RegExp[@@split] doesn't call the regex's exec method, but first creates\n      // a new one. We need to return the patched regex when creating the new one.\n      re.constructor = {};\n      re.constructor[SPECIES] = function () { return re; };\n      re.flags = '';\n      re[SYMBOL] = /./[SYMBOL];\n    }\n\n    re.exec = function () { execCalled = true; return null; };\n\n    re[SYMBOL]('');\n    return !execCalled;\n  });\n\n  if (\n    !DELEGATES_TO_SYMBOL ||\n    !DELEGATES_TO_EXEC ||\n    FORCED\n  ) {\n    var uncurriedNativeRegExpMethod = uncurryThis(/./[SYMBOL]);\n    var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {\n      var uncurriedNativeMethod = uncurryThis(nativeMethod);\n      var $exec = regexp.exec;\n      if ($exec === regexpExec || $exec === RegExpPrototype.exec) {\n        if (DELEGATES_TO_SYMBOL && !forceStringMethod) {\n          // The native String method already delegates to @@method (this\n          // polyfilled function), leasing to infinite recursion.\n          // We avoid it by directly calling the native @@method method.\n          return { done: true, value: uncurriedNativeRegExpMethod(regexp, str, arg2) };\n        }\n        return { done: true, value: uncurriedNativeMethod(str, regexp, arg2) };\n      }\n      return { done: false };\n    });\n\n    defineBuiltIn(String.prototype, KEY, methods[0]);\n    defineBuiltIn(RegExpPrototype, SYMBOL, methods[1]);\n  }\n\n  if (SHAM) createNonEnumerableProperty(RegExpPrototype[SYMBOL], 'sham', true);\n};\n"],"sourceRoot":""}