{"mappings":"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","names":["Context","forEachUnescaped","getGroupContents","hasUnescaped","replaceUnescaped","r","gRToken","recursiveToken","namedCaptureDelim","captureDelim","token","overlappingRecursionMsg","recursion","pattern","data","hiddenCaptures","mode","captureTransfers","addedHiddenCaptures","hasNumberedBackref","groupContentsStartPos","openGroups","hasRecursed","numCharClassesOpen","numCapturesPassed","match","m","captureName","rDepth","gRNameOrNum","gRDepth","assertMaxInBounds","left","right","reps","makeRecursive","mapCaptureTransfers","isWithinReffedGroup","g","startPos","groupContents","groupContentsLeft","groupContentsRight","numAddedHiddenCapturesPreExpansion","expansion","pre","post","isUnnamedCapture","max","errMsg","isSubpattern","namesInRecursed","rest","repeatWithDepth","direction","getDepthNum","result","depthNum","unnamed","backref","suffix","addedCaptureNum","incrementIfAtLeast","arr","threshold","i","numCapturesAddedInExpansion","numCapturesInLeft","recursionDelimCaptureNum","newCaptureTransfers","from","to","numCapturesInRight","numCapturesAddedInLeft","newTo","newFrom","f"],"sources":["../esm/npm/regex-recursion@6.0.2/node_modules/regex-recursion/src/index.js"],"sourcesContent":["import {Context, forEachUnescaped, getGroupContents, hasUnescaped, replaceUnescaped} from 'regex-utilities';\n\nconst r = String.raw;\nconst gRToken = r`\\\\g\u003c(?\u003cgRNameOrNum\u003e[^\u003e\u0026]+)\u0026R=(?\u003cgRDepth\u003e[^\u003e]+)\u003e`;\nconst recursiveToken = r`\\(\\?R=(?\u003crDepth\u003e[^\\)]+)\\)|${gRToken}`;\nconst namedCaptureDelim = r`\\(\\?\u003c(?![=!])(?\u003ccaptureName\u003e[^\u003e]+)\u003e`;\nconst captureDelim = r`${namedCaptureDelim}|(?\u003cunnamed\u003e\\()(?!\\?)`;\nconst token = new RegExp(r`${namedCaptureDelim}|${recursiveToken}|\\(\\?|\\\\?.`, 'gsu');\nconst overlappingRecursionMsg = 'Cannot use multiple overlapping recursions';\n\n/**\n@param {string} pattern\n@param {{\n  flags?: string;\n  captureTransfers?: Map\u003cnumber, Array\u003cnumber\u003e\u003e;\n  hiddenCaptures?: Array\u003cnumber\u003e;\n  mode?: 'plugin' | 'external';\n}} [data]\n@returns {{\n  pattern: string;\n  captureTransfers: Map\u003cnumber, Array\u003cnumber\u003e\u003e;\n  hiddenCaptures: Array\u003cnumber\u003e;\n}}\n*/\nfunction recursion(pattern, data) {\n  const {hiddenCaptures, mode} = {\n    hiddenCaptures: [],\n    mode: 'plugin',\n    ...data,\n  };\n  // Capture transfer is used by \u003cgithub.com/slevithan/oniguruma-to-es\u003e\n  let captureTransfers = data?.captureTransfers ?? new Map();\n  // Keep the initial fail-check (which avoids unneeded processing) as fast as possible by testing\n  // without the accuracy improvement of using `hasUnescaped` with `Context.DEFAULT`\n  if (!(new RegExp(recursiveToken, 'su').test(pattern))) {\n    return {\n      pattern,\n      captureTransfers,\n      hiddenCaptures,\n    };\n  }\n  if (mode === 'plugin' \u0026\u0026 hasUnescaped(pattern, r`\\(\\?\\(DEFINE\\)`, Context.DEFAULT)) {\n    throw new Error('DEFINE groups cannot be used with recursion');\n  }\n\n  const addedHiddenCaptures = [];\n  const hasNumberedBackref = hasUnescaped(pattern, r`\\\\[1-9]`, Context.DEFAULT);\n  const groupContentsStartPos = new Map();\n  const openGroups = [];\n  let hasRecursed = false;\n  let numCharClassesOpen = 0;\n  let numCapturesPassed = 0;\n  let match;\n  token.lastIndex = 0;\n  while ((match = token.exec(pattern))) {\n    const {0: m, groups: {captureName, rDepth, gRNameOrNum, gRDepth}} = match;\n    if (m === '[') {\n      numCharClassesOpen++;\n    } else if (!numCharClassesOpen) {\n\n      // `(?R=N)`\n      if (rDepth) {\n        assertMaxInBounds(rDepth);\n        if (hasRecursed) {\n          throw new Error(overlappingRecursionMsg);\n        }\n        if (hasNumberedBackref) {\n          // Could add support for numbered backrefs with extra effort, but it's probably not worth\n          // it. To trigger this error, the regex must include recursion and one of the following:\n          // - An interpolated regex that contains a numbered backref (since other numbered\n          //   backrefs are prevented by implicit flag n).\n          // - A numbered backref, when flag n is explicitly disabled.\n          // Note that Regex+'s extended syntax (atomic groups and sometimes subroutines) can also\n          // add numbered backrefs, but those work fine because external plugins like this one run\n          // *before* the transformation of built-in syntax extensions\n          throw new Error(\n            // When used in `external` mode by transpilers other than Regex+, backrefs might have\n            // gone through conversion from named to numbered, so avoid a misleading error\n            `${mode === 'external' ? 'Backrefs' : 'Numbered backrefs'} cannot be used with global recursion`\n          );\n        }\n        const left = pattern.slice(0, match.index);\n        const right = pattern.slice(token.lastIndex);\n        if (hasUnescaped(right, recursiveToken, Context.DEFAULT)) {\n          throw new Error(overlappingRecursionMsg);\n        }\n        const reps = +rDepth - 1;\n        pattern = makeRecursive(\n          left,\n          right,\n          reps,\n          false,\n          hiddenCaptures,\n          addedHiddenCaptures,\n          numCapturesPassed\n        );\n        captureTransfers = mapCaptureTransfers(\n          captureTransfers,\n          left,\n          reps,\n          addedHiddenCaptures.length,\n          0,\n          numCapturesPassed\n        );\n        // No need to parse further\n        break;\n      // `\\g\u003cname\u0026R=N\u003e`, `\\g\u003cnumber\u0026R=N\u003e`\n      } else if (gRNameOrNum) {\n        assertMaxInBounds(gRDepth);\n        let isWithinReffedGroup = false;\n        for (const g of openGroups) {\n          if (g.name === gRNameOrNum || g.num === +gRNameOrNum) {\n            isWithinReffedGroup = true;\n            if (g.hasRecursedWithin) {\n              throw new Error(overlappingRecursionMsg);\n            }\n            break;\n          }\n        }\n        if (!isWithinReffedGroup) {\n          throw new Error(r`Recursive \\g cannot be used outside the referenced group \"${\n            mode === 'external' ? gRNameOrNum : r`\\g\u003c${gRNameOrNum}\u0026R=${gRDepth}\u003e`\n          }\"`);\n        }\n        const startPos = groupContentsStartPos.get(gRNameOrNum);\n        const groupContents = getGroupContents(pattern, startPos);\n        if (\n          hasNumberedBackref \u0026\u0026\n          hasUnescaped(groupContents, r`${namedCaptureDelim}|\\((?!\\?)`, Context.DEFAULT)\n        ) {\n          throw new Error(\n            // When used in `external` mode by transpilers other than Regex+, backrefs might have\n            // gone through conversion from named to numbered, so avoid a misleading error\n            `${mode === 'external' ? 'Backrefs' : 'Numbered backrefs'} cannot be used with recursion of capturing groups`\n          );\n        }\n        const groupContentsLeft = pattern.slice(startPos, match.index);\n        const groupContentsRight = groupContents.slice(groupContentsLeft.length + m.length);\n        const numAddedHiddenCapturesPreExpansion = addedHiddenCaptures.length;\n        const reps = +gRDepth - 1;\n        const expansion = makeRecursive(\n          groupContentsLeft,\n          groupContentsRight,\n          reps,\n          true,\n          hiddenCaptures,\n          addedHiddenCaptures,\n          numCapturesPassed\n        );\n        captureTransfers = mapCaptureTransfers(\n          captureTransfers,\n          groupContentsLeft,\n          reps,\n          addedHiddenCaptures.length - numAddedHiddenCapturesPreExpansion,\n          numAddedHiddenCapturesPreExpansion,\n          numCapturesPassed\n        );\n        const pre = pattern.slice(0, startPos);\n        const post = pattern.slice(startPos + groupContents.length);\n        // Modify the string we're looping over\n        pattern = `${pre}${expansion}${post}`;\n        // Step forward for the next loop iteration\n        token.lastIndex += expansion.length - m.length - groupContentsLeft.length - groupContentsRight.length;\n        openGroups.forEach(g =\u003e g.hasRecursedWithin = true);\n        hasRecursed = true;\n      } else if (captureName) {\n        numCapturesPassed++;\n        groupContentsStartPos.set(String(numCapturesPassed), token.lastIndex);\n        groupContentsStartPos.set(captureName, token.lastIndex);\n        openGroups.push({\n          num: numCapturesPassed,\n          name: captureName,\n        });\n      } else if (m[0] === '(') {\n        const isUnnamedCapture = m === '(';\n        if (isUnnamedCapture) {\n          numCapturesPassed++;\n          groupContentsStartPos.set(String(numCapturesPassed), token.lastIndex);\n        }\n        openGroups.push(isUnnamedCapture ? {num: numCapturesPassed} : {});\n      } else if (m === ')') {\n        openGroups.pop();\n      }\n\n    } else if (m === ']') {\n      numCharClassesOpen--;\n    }\n  }\n\n  hiddenCaptures.push(...addedHiddenCaptures);\n\n  return {\n    pattern,\n    captureTransfers,\n    hiddenCaptures,\n  };\n}\n\n/**\n@param {string} max\n*/\nfunction assertMaxInBounds(max) {\n  const errMsg = `Max depth must be integer between 2 and 100; used ${max}`;\n  if (!/^[1-9]\\d*$/.test(max)) {\n    throw new Error(errMsg);\n  }\n  max = +max;\n  if (max \u003c 2 || max \u003e 100) {\n    throw new Error(errMsg);\n  }\n}\n\n/**\n@param {string} left\n@param {string} right\n@param {number} reps\n@param {boolean} isSubpattern\n@param {Array\u003cnumber\u003e} hiddenCaptures\n@param {Array\u003cnumber\u003e} addedHiddenCaptures\n@param {number} numCapturesPassed\n@returns {string}\n*/\nfunction makeRecursive(\n  left,\n  right,\n  reps,\n  isSubpattern,\n  hiddenCaptures,\n  addedHiddenCaptures,\n  numCapturesPassed\n) {\n  const namesInRecursed = new Set();\n  // Can skip this work if not needed\n  if (isSubpattern) {\n    forEachUnescaped(left + right, namedCaptureDelim, ({groups: {captureName}}) =\u003e {\n      namesInRecursed.add(captureName);\n    }, Context.DEFAULT);\n  }\n  const rest = [\n    reps,\n    isSubpattern ? namesInRecursed : null,\n    hiddenCaptures,\n    addedHiddenCaptures,\n    numCapturesPassed,\n  ];\n  // Depth 2: 'left(?:left(?:)right)right'\n  // Depth 3: 'left(?:left(?:left(?:)right)right)right'\n  // Empty group in the middle separates tokens and absorbs a following quantifier if present\n  return `${left}${\n    repeatWithDepth(`(?:${left}`, 'forward', ...rest)\n  }(?:)${\n    repeatWithDepth(`${right})`, 'backward', ...rest)\n  }${right}`;\n}\n\n/**\n@param {string} pattern\n@param {'forward' | 'backward'} direction\n@param {number} reps\n@param {Set\u003cstring\u003e | null} namesInRecursed\n@param {Array\u003cnumber\u003e} hiddenCaptures\n@param {Array\u003cnumber\u003e} addedHiddenCaptures\n@param {number} numCapturesPassed\n@returns {string}\n*/\nfunction repeatWithDepth(\n  pattern,\n  direction,\n  reps,\n  namesInRecursed,\n  hiddenCaptures,\n  addedHiddenCaptures,\n  numCapturesPassed\n) {\n  const startNum = 2;\n  const getDepthNum = i =\u003e direction === 'forward' ? (i + startNum) : (reps - i + startNum - 1);\n  let result = '';\n  for (let i = 0; i \u003c reps; i++) {\n    const depthNum = getDepthNum(i);\n    result += replaceUnescaped(\n      pattern,\n      r`${captureDelim}|\\\\k\u003c(?\u003cbackref\u003e[^\u003e]+)\u003e`,\n      ({0: m, groups: {captureName, unnamed, backref}}) =\u003e {\n        if (backref \u0026\u0026 namesInRecursed \u0026\u0026 !namesInRecursed.has(backref)) {\n          // Don't alter backrefs to groups outside the recursed subpattern\n          return m;\n        }\n        const suffix = `_$${depthNum}`;\n        if (unnamed || captureName) {\n          const addedCaptureNum = numCapturesPassed + addedHiddenCaptures.length + 1;\n          addedHiddenCaptures.push(addedCaptureNum);\n          incrementIfAtLeast(hiddenCaptures, addedCaptureNum);\n          return unnamed ? m : `(?\u003c${captureName}${suffix}\u003e`;\n        }\n        return r`\\k\u003c${backref}${suffix}\u003e`;\n      },\n      Context.DEFAULT\n    );\n  }\n  return result;\n}\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 {Map\u003cnumber, Array\u003cnumber\u003e\u003e} captureTransfers\n@param {string} left\n@param {number} reps\n@param {number} numCapturesAddedInExpansion\n@param {number} numAddedHiddenCapturesPreExpansion\n@param {number} numCapturesPassed\n@returns {Map\u003cnumber, Array\u003cnumber\u003e\u003e}\n*/\nfunction mapCaptureTransfers(captureTransfers, left, reps, numCapturesAddedInExpansion, numAddedHiddenCapturesPreExpansion, numCapturesPassed) {\n  if (captureTransfers.size \u0026\u0026 numCapturesAddedInExpansion) {\n    let numCapturesInLeft = 0;\n    forEachUnescaped(left, captureDelim, () =\u003e numCapturesInLeft++, Context.DEFAULT);\n    // Is 0 for global recursion\n    const recursionDelimCaptureNum = numCapturesPassed - numCapturesInLeft + numAddedHiddenCapturesPreExpansion;\n    const newCaptureTransfers = new Map();\n    captureTransfers.forEach((from, to) =\u003e {\n      const numCapturesInRight = (numCapturesAddedInExpansion - (numCapturesInLeft * reps)) / reps;\n      const numCapturesAddedInLeft = numCapturesInLeft * reps;\n      const newTo = to \u003e (recursionDelimCaptureNum + numCapturesInLeft) ? to + numCapturesAddedInExpansion : to;\n      const newFrom = [];\n      for (const f of from) {\n        // Before the recursed subpattern\n        if (f \u003c= recursionDelimCaptureNum) {\n          newFrom.push(f);\n        // After the recursed subpattern\n        } else if (f \u003e (recursionDelimCaptureNum + numCapturesInLeft + numCapturesInRight)) {\n          newFrom.push(f + numCapturesAddedInExpansion);\n        // Within the recursed subpattern, on the left of the recursion token\n        } else if (f \u003c= (recursionDelimCaptureNum + numCapturesInLeft)) {\n          for (let i = 0; i \u003c= reps; i++) {\n            newFrom.push(f + (numCapturesInLeft * i));\n          }\n        // Within the recursed subpattern, on the right of the recursion token\n        } else {\n          for (let i = 0; i \u003c= reps; i++) {\n            newFrom.push(f + numCapturesAddedInLeft + (numCapturesInRight * i));\n          }\n        }\n      }\n      newCaptureTransfers.set(newTo, newFrom);\n    });\n    return newCaptureTransfers;\n  }\n  return captureTransfers;\n}\n\nexport {\n  recursion,\n};\n"],"version":3}