{"mappings":"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","names":["noncapturingDelim","incrementIfAtLeast","arr","threshold","i","spliceStr","str","pos","oldValue","newValue","Context","replaceUnescaped","atomicPluginToken","noncapturingDelim","atomic","expression","data","hiddenCaptures","captureTransfers","aGDelim","emulatedAGDelim","captureNumMap","addedHiddenCaptures","numCapturesBeforeAG","numAGs","aGPos","hasProcessedAG","numCharClassesOpen","numGroupsOpenInAG","inAG","match","m","index","capturingStart","noncapturingStart","addedCaptureNum","incrementIfAtLeast","newCaptureTransfers","from","to","f","backrefNum","wrappedBackrefNum","bNum","baseQuantifier","possessivePluginToken","possessive","openGroupIndices","lastGroupIndex","lastCharClassIndex","lastToken","qBase","qMod","invalidQ","charsAdded","spliceStr","nodeIndex","RegExpSubclass","_RegExpSubclass","expression","flags","options","hiddenCaptures","createCaptureMap","str","match","matchCopy","indicesCopy","captureMap","num"],"sources":["../esm/npm/regex@6.1.0/node_modules/regex/src/utils-internals.js","../esm/npm/regex@6.1.0/node_modules/regex/src/atomic.js","../esm/npm/regex@6.1.0/node_modules/regex/src/subclass.js"],"sourcesContent":["// Separating some utils for improved tree shaking of the `./internals` export\n\nconst noncapturingDelim = String.raw`\\(\\?(?:[:=!\u003eA-Za-z\\-]|\u003c[=!]|\\(DEFINE\\))`;\n\n/**\nUpdates the array in place by incrementing each value greater than or equal to the threshold.\n@param {Array\u003cnumber\u003e} arr\n@param {number} threshold\n*/\nfunction incrementIfAtLeast(arr, threshold) {\n  for (let i = 0; i \u003c arr.length; i++) {\n    if (arr[i] \u003e= threshold) {\n      arr[i]++;\n    }\n  }\n}\n\n/**\n@param {string} str\n@param {number} pos\n@param {string} oldValue\n@param {string} newValue\n@returns {string}\n*/\nfunction spliceStr(str, pos, oldValue, newValue) {\n  return str.slice(0, pos) + newValue + str.slice(pos + oldValue.length);\n}\n\nexport {\n  incrementIfAtLeast,\n  noncapturingDelim,\n  spliceStr,\n};\n","import {incrementIfAtLeast, noncapturingDelim, spliceStr} from './utils-internals.js';\nimport {Context, replaceUnescaped} from 'regex-utilities';\n/**\n@import {PluginData, PluginResult} from './regex.js';\n*/\n\nconst atomicPluginToken = new RegExp(String.raw`(?\u003cnoncapturingStart\u003e${noncapturingDelim})|(?\u003ccapturingStart\u003e\\((?:\\?\u003c[^\u003e]+\u003e)?)|\\\\?.`, 'gsu');\n\n/**\nApply transformations for atomic groups: `(?\u003e…)`.\n@param {string} expression\n@param {PluginData} [data]\n@returns {Required\u003cPluginResult\u003e}\n*/\nfunction atomic(expression, data) {\n  const hiddenCaptures = data?.hiddenCaptures ?? [];\n  // Capture transfer is used by \u003cgithub.com/slevithan/oniguruma-to-es\u003e\n  let captureTransfers = data?.captureTransfers ?? new Map();\n  if (!/\\(\\?\u003e/.test(expression)) {\n    return {\n      pattern: expression,\n      captureTransfers,\n      hiddenCaptures,\n    };\n  }\n\n  const aGDelim = '(?\u003e';\n  const emulatedAGDelim = '(?:(?=(';\n  const captureNumMap = [0];\n  const addedHiddenCaptures = [];\n  let numCapturesBeforeAG = 0;\n  let numAGs = 0;\n  let aGPos = NaN;\n  let hasProcessedAG;\n  do {\n    hasProcessedAG = false;\n    let numCharClassesOpen = 0;\n    let numGroupsOpenInAG = 0;\n    let inAG = false;\n    let match;\n    atomicPluginToken.lastIndex = Number.isNaN(aGPos) ? 0 : aGPos + emulatedAGDelim.length;\n    while (match = atomicPluginToken.exec(expression)) {\n      const {0: m, index, groups: {capturingStart, noncapturingStart}} = match;\n      if (m === '[') {\n        numCharClassesOpen++;\n      } else if (!numCharClassesOpen) {\n\n        if (m === aGDelim \u0026\u0026 !inAG) {\n          aGPos = index;\n          inAG = true;\n        } else if (inAG \u0026\u0026 noncapturingStart) {\n          numGroupsOpenInAG++;\n        } else if (capturingStart) {\n          if (inAG) {\n            numGroupsOpenInAG++;\n          } else {\n            numCapturesBeforeAG++;\n            captureNumMap.push(numCapturesBeforeAG + numAGs);\n          }\n        } else if (m === ')' \u0026\u0026 inAG) {\n          if (!numGroupsOpenInAG) {\n            numAGs++;\n            const addedCaptureNum = numCapturesBeforeAG + numAGs;\n            // Replace `expression` and use `\u003c$$N\u003e` as a temporary wrapper for the backref so it\n            // can avoid backref renumbering afterward. Wrap the whole substitution (including the\n            // lookahead and following backref) in a noncapturing group to handle following\n            // quantifiers and literal digits\n            expression = `${expression.slice(0, aGPos)}${emulatedAGDelim}${\n                expression.slice(aGPos + aGDelim.length, index)\n              }))\u003c$$${addedCaptureNum}\u003e)${expression.slice(index + 1)}`;\n            hasProcessedAG = true;\n            addedHiddenCaptures.push(addedCaptureNum);\n            incrementIfAtLeast(hiddenCaptures, addedCaptureNum);\n            if (captureTransfers.size) {\n              const newCaptureTransfers = new Map();\n              captureTransfers.forEach((from, to) =\u003e {\n                newCaptureTransfers.set(\n                  to \u003e= addedCaptureNum ? to + 1 : to,\n                  from.map(f =\u003e f \u003e= addedCaptureNum ? f + 1 : f)\n                );\n              });\n              captureTransfers = newCaptureTransfers;\n            }\n            break;\n          }\n          numGroupsOpenInAG--;\n        }\n\n      } else if (m === ']') {\n        numCharClassesOpen--;\n      }\n    }\n  // Start over from the beginning of the atomic group's contents, in case the processed group\n  // contains additional atomic groups\n  } while (hasProcessedAG);\n\n  hiddenCaptures.push(...addedHiddenCaptures);\n\n  // Second pass to adjust numbered backrefs\n  expression = replaceUnescaped(\n    expression,\n    String.raw`\\\\(?\u003cbackrefNum\u003e[1-9]\\d*)|\u003c\\$\\$(?\u003cwrappedBackrefNum\u003e\\d+)\u003e`,\n    ({0: m, groups: {backrefNum, wrappedBackrefNum}}) =\u003e {\n      if (backrefNum) {\n        const bNum = +backrefNum;\n        if (bNum \u003e captureNumMap.length - 1) {\n          throw new Error(`Backref \"${m}\" greater than number of captures`);\n        }\n        return `\\\\${captureNumMap[bNum]}`;\n      }\n      return `\\\\${wrappedBackrefNum}`;\n    },\n    Context.DEFAULT\n  );\n\n  return {\n    pattern: expression,\n    captureTransfers,\n    hiddenCaptures,\n  };\n}\n\nconst baseQuantifier = String.raw`(?:[?*+]|\\{\\d+(?:,\\d*)?\\})`;\n// Complete tokenizer for base syntax; doesn't (need to) know about character-class-only syntax\nconst possessivePluginToken = new RegExp(String.raw`\n\\\\(?: \\d+\n  | c[A-Za-z]\n  | [gk]\u003c[^\u003e]+\u003e\n  | [pPu]\\{[^\\}]+\\}\n  | u[A-Fa-f\\d]{4}\n  | x[A-Fa-f\\d]{2}\n  )\n| \\((?: \\? (?: [:=!\u003e]\n  | \u003c(?:[=!]|[^\u003e]+\u003e)\n  | [A-Za-z\\-]+:\n  | \\(DEFINE\\)\n  ))?\n| (?\u003cqBase\u003e${baseQuantifier})(?\u003cqMod\u003e[?+]?)(?\u003cinvalidQ\u003e[?*+\\{]?)\n| \\\\?.\n`.replace(/\\s+/g, ''), 'gsu');\n\n/**\nTransform posessive quantifiers into atomic groups. The posessessive quantifiers are:\n`?+`, `*+`, `++`, `{N}+`, `{N,}+`, `{N,N}+`.\nThis follows Java, PCRE, Perl, and Python.\nPossessive quantifiers in Oniguruma and Onigmo are only: `?+`, `*+`, `++`.\n@param {string} expression\n@returns {PluginResult}\n*/\nfunction possessive(expression) {\n  if (!(new RegExp(`${baseQuantifier}\\\\+`).test(expression))) {\n    return {\n      pattern: expression,\n    };\n  }\n\n  const openGroupIndices = [];\n  let lastGroupIndex = null;\n  let lastCharClassIndex = null;\n  let lastToken = '';\n  let numCharClassesOpen = 0;\n  let match;\n  possessivePluginToken.lastIndex = 0;\n  while (match = possessivePluginToken.exec(expression)) {\n    const {0: m, index, groups: {qBase, qMod, invalidQ}} = match;\n    if (m === '[') {\n      if (!numCharClassesOpen) {\n        lastCharClassIndex = index;\n      }\n      numCharClassesOpen++;\n    } else if (m === ']') {\n      if (numCharClassesOpen) {\n        numCharClassesOpen--;\n      // Unmatched `]`\n      } else {\n        lastCharClassIndex = null;\n      }\n    } else if (!numCharClassesOpen) {\n\n      if (qMod === '+' \u0026\u0026 lastToken \u0026\u0026 !lastToken.startsWith('(')) {\n        // Invalid following quantifier would become valid via the wrapping group\n        if (invalidQ) {\n          throw new Error(`Invalid quantifier \"${m}\"`);\n        }\n        let charsAdded = -1; // -1 for removed trailing `+`\n        // Possessivizing fixed repetition quantifiers like `{2}` does't change their behavior, so\n        // avoid doing so (convert them to greedy)\n        if (/^\\{\\d+\\}$/.test(qBase)) {\n          expression = spliceStr(expression, index + qBase.length, qMod, '');\n        } else {\n          if (lastToken === ')' || lastToken === ']') {\n            const nodeIndex = lastToken === ')' ? lastGroupIndex : lastCharClassIndex;\n            // Unmatched `)` would break out of the wrapping group and mess with handling.\n            // Unmatched `]` wouldn't be a problem, but it's unnecessary to have dedicated support\n            // for unescaped `]++` since this won't work with flag u or v anyway\n            if (nodeIndex === null) {\n              throw new Error(`Invalid unmatched \"${lastToken}\"`);\n            }\n            expression = `${expression.slice(0, nodeIndex)}(?\u003e${expression.slice(nodeIndex, index)}${qBase})${expression.slice(index + m.length)}`;\n          } else {\n            expression = `${expression.slice(0, index - lastToken.length)}(?\u003e${lastToken}${qBase})${expression.slice(index + m.length)}`;\n          }\n          charsAdded += 4; // `(?\u003e)`\n        }\n        possessivePluginToken.lastIndex += charsAdded;\n      } else if (m[0] === '(') {\n        openGroupIndices.push(index);\n      } else if (m === ')') {\n        lastGroupIndex = openGroupIndices.length ? openGroupIndices.pop() : null;\n      }\n\n    }\n    lastToken = m;\n  }\n\n  return {\n    pattern: expression,\n  };\n}\n\nexport {\n  atomic,\n  possessive,\n};\n","/**\nWorks the same as JavaScript's native `RegExp` constructor in all contexts, but automatically\nadjusts subpattern matches and indices (with flag `d`) to account for captures added as part of\nemulating extended syntax.\n*/\nclass RegExpSubclass extends RegExp {\n  // Avoid `#private` to allow for subclassing\n  /**\n  @private\n  @type {Map\u003cnumber, {\n    hidden: true;\n  }\u003e}\n  */\n  _captureMap;\n  /**\n  @overload\n  @param {string} expression\n  @param {string} [flags]\n  @param {{\n    hiddenCaptures?: Array\u003cnumber\u003e;\n  }} [options]\n  */\n  /**\n  @overload\n  @param {RegExpSubclass} expression\n  @param {string} [flags]\n  */\n  constructor(expression, flags, options) {\n    // Argument `options` isn't provided when regexes are copied via `new RegExpSubclass(regexp)`,\n    // including as part of the internal handling of string methods `matchAll` and `split`\n    if (expression instanceof RegExp) {\n      if (options) {\n        throw new Error('Cannot provide options when copying a regexp');\n      }\n      super(expression, flags);\n      if (expression instanceof RegExpSubclass) {\n        this._captureMap = expression._captureMap;\n      } else {\n        this._captureMap = new Map();\n      }\n    } else {\n      super(expression, flags);\n      const hiddenCaptures = options?.hiddenCaptures ?? [];\n      this._captureMap = createCaptureMap(hiddenCaptures);\n    }\n  }\n  /**\n  Called internally by all String/RegExp methods that use regexes.\n  @override\n  @param {string} str\n  @returns {RegExpExecArray | null}\n  */\n  exec(str) {\n    const match = super.exec(str);\n    if (!match || !this._captureMap.size) {\n      return match;\n    }\n    const matchCopy = [...match];\n    // Empty all but the first value of the array while preserving its other properties\n    match.length = 1;\n    let indicesCopy;\n    if (this.hasIndices) {\n      indicesCopy = [...match.indices];\n      match.indices.length = 1;\n    }\n    for (let i = 1; i \u003c matchCopy.length; i++) {\n      if (!this._captureMap.get(i)?.hidden) {\n        match.push(matchCopy[i]);\n        if (this.hasIndices) {\n          match.indices.push(indicesCopy[i]);\n        }\n      }\n    }\n    return match;\n  }\n}\n\n/**\nBuild the capturing group map, with hidden captures marked to indicate their submatches shouldn't\nappear in match results.\n@param {Array\u003cnumber\u003e} hiddenCaptures\n@returns {Map\u003cnumber, {\n  hidden: true;\n}\u003e}\n*/\nfunction createCaptureMap(hiddenCaptures) {\n  const captureMap = new Map();\n  for (const num of hiddenCaptures) {\n    captureMap.set(num, {\n      hidden: true,\n    });\n  }\n  return captureMap;\n}\n\nexport {\n  RegExpSubclass,\n};\n"],"version":3}