@luan.sh/pi-view-image 0.3.7

package/node_modules/regex/src/utils.js

@@ -0,0 +1,401 @@
+import {Pattern, pattern} from './pattern.js';
+import {Context, forEachUnescaped, replaceUnescaped} from 'regex-utilities';
+/**
+@import {InterpolatedValue, RawTemplate, RegexTagOptions} from './regex.js';
+*/
+
+const RegexContext = {
+  DEFAULT: 'DEFAULT',
+  CHAR_CLASS: 'CHAR_CLASS',
+  ENCLOSED_P: 'ENCLOSED_P',
+  ENCLOSED_U: 'ENCLOSED_U',
+  GROUP_NAME: 'GROUP_NAME',
+  INTERVAL_QUANTIFIER: 'INTERVAL_QUANTIFIER',
+  INVALID_INCOMPLETE_TOKEN: 'INVALID_INCOMPLETE_TOKEN',
+};
+
+const CharClassContext = {
+  DEFAULT: 'DEFAULT',
+  ENCLOSED_P: 'ENCLOSED_P',
+  ENCLOSED_Q: 'ENCLOSED_Q',
+  ENCLOSED_U: 'ENCLOSED_U',
+  INVALID_INCOMPLETE_TOKEN: 'INVALID_INCOMPLETE_TOKEN',
+  RANGE: 'RANGE',
+};
+
+const enclosedTokenRegexContexts = new Set([
+  RegexContext.ENCLOSED_P,
+  RegexContext.ENCLOSED_U,
+]);
+
+const enclosedTokenCharClassContexts = new Set([
+  CharClassContext.ENCLOSED_P,
+  CharClassContext.ENCLOSED_Q,
+  CharClassContext.ENCLOSED_U,
+]);
+
+const envSupportsFlagGroups = (() => {
+  try {
+    new RegExp('(?i:)');
+  } catch {
+    return false;
+  }
+  return true;
+})();
+
+const envSupportsFlagV = (() => {
+  try {
+    new RegExp('', 'v');
+  } catch {
+    return false;
+  }
+  return true;
+})();
+
+const doublePunctuatorChars = '&!#$%*+,.:;<=>?@^`~';
+const namedCapturingDelim = String.raw`\(\?<(?![=!])(?<captureName>[^>]+)>`;
+const capturingDelim = String.raw`\((?!\?)(?!(?<=\(\?\()DEFINE\))|${namedCapturingDelim}`;
+
+/**
+@param {string} expression
+@param {number} precedingCaptures
+@returns {string}
+*/
+function adjustNumberedBackrefs(expression, precedingCaptures) {
+  return replaceUnescaped(
+    expression,
+    String.raw`\\(?<num>[1-9]\d*)`,
+    ({groups: {num}}) => `\\${+num + precedingCaptures}`,
+    Context.DEFAULT
+  );
+}
+
+// Properties of strings as of ES2024
+const stringPropertyNames = [
+  'Basic_Emoji',
+  'Emoji_Keycap_Sequence',
+  'RGI_Emoji_Modifier_Sequence',
+  'RGI_Emoji_Flag_Sequence',
+  'RGI_Emoji_Tag_Sequence',
+  'RGI_Emoji_ZWJ_Sequence',
+  'RGI_Emoji',
+].join('|');
+const charClassUnionToken = new RegExp(String.raw`
+\\(?: c[A-Za-z]
+  | p\{(?<pStrProp>${stringPropertyNames})\}
+  | [pP]\{[^\}]+\}
+  | (?<qStrProp>q)
+  | u(?:[A-Fa-f\d]{4}|\{[A-Fa-f\d]+\})
+  | x[A-Fa-f\d]{2}
+  | .
+)
+| --
+| &&
+| .
+`.replace(/\s+/g, ''), 'gsu');
+
+// Assumes flag v and doesn't worry about syntax errors that are caught by it
+function containsCharClassUnion(charClassPattern) {
+  // Return `true` if it contains:
+  // - `\p` (lowercase only) and the name is a property of strings (case sensitive).
+  // - `\q`.
+  // - Two single-char-matching tokens in sequence.
+  // - One single-char-matching token followed immediately by unescaped `[`.
+  // - One single-char-matching token preceded immediately by unescaped `]`.
+  // Else, `false`.
+  // Ranges with `-` create a single token.
+  // Subtraction and intersection with `--` and `&&` create a single token.
+  // Supports any number of nested classes
+  let hasFirst = false;
+  let lastM;
+  for (const {0: m, groups} of charClassPattern.matchAll(charClassUnionToken)) {
+    if (groups.pStrProp || groups.qStrProp) {
+      return true;
+    }
+    if (m === '[' && hasFirst) {
+      return true;
+    }
+    if (['-', '--', '&&'].includes(m)) {
+      hasFirst = false;
+    } else if (m !== '[' && m !== ']') {
+      if (hasFirst || lastM === ']') {
+        return true;
+      }
+      hasFirst = true;
+    }
+    lastM = m;
+  }
+  return false;
+}
+
+/**
+@param {string} expression
+@returns {number}
+*/
+function countCaptures(expression) {
+  let num = 0;
+  forEachUnescaped(expression, capturingDelim, () => num++, Context.DEFAULT);
+  return num;
+}
+
+/**
+Escape special characters for the given context, assuming flag v.
+@param {string} str String to escape
+@param {'DEFAULT' | 'CHAR_CLASS'} context `Context` option from lib `regex-utilities`
+@returns {string} Escaped string
+*/
+function escapeV(str, context) {
+  if (context === Context.CHAR_CLASS) {
+    // Escape all double punctuators (including ^, which is special on its own in the first
+    // position) in case they're bordered by the same character in or outside of the escaped string
+    return str.replace(new RegExp(String.raw`[()\[\]{}|\\/\-${doublePunctuatorChars}]`, 'g'), '\\$&');
+  }
+  return str.replace(/[()\[\]{}|\\^$*+?.]/g, '\\$&');
+}
+
+// Look for characters that would change the meaning of subsequent tokens outside an interpolated value
+function getBreakoutChar(expression, regexContext, charClassContext) {
+  const escapesRemoved = expression.replace(/\\./gsu, '');
+  // Trailing unescaped `\`; checking `.includes('\\')` would also work
+  if (escapesRemoved.endsWith('\\')) {
+    return '\\';
+  }
+  if (regexContext === RegexContext.DEFAULT) {
+    // Unbalanced `[` or `]` are also errors but don't breakout; they're caught by the wrapper
+    return getUnbalancedChar(escapesRemoved, '(', ')');
+  } else if (
+    regexContext === RegexContext.CHAR_CLASS &&
+    !enclosedTokenCharClassContexts.has(charClassContext)
+  ) {
+    return getUnbalancedChar(escapesRemoved, '[', ']');
+  } else if (
+    regexContext === RegexContext.INTERVAL_QUANTIFIER ||
+    enclosedTokenRegexContexts.has(regexContext) ||
+    enclosedTokenCharClassContexts.has(charClassContext)
+  ) {
+    if (escapesRemoved.includes('}')) {
+      return '}';
+    }
+  } else if (regexContext === RegexContext.GROUP_NAME) {
+    if (escapesRemoved.includes('>')) {
+      return '>';
+    }
+  }
+  return '';
+}
+
+const contextToken = new RegExp(String.raw`
+(?<groupN>\(\?<(?![=!])|\\[gk]<)
+| (?<enclosedPU>\\[pPu]\{)
+| (?<enclosedQ>\\q\{)
+| (?<intervalQ>\{)
+| (?<incompleteT>\\(?: $
+  | c(?![A-Za-z])
+  | u(?![A-Fa-f\d]{4})[A-Fa-f\d]{0,3}
+  | x(?![A-Fa-f\d]{2})[A-Fa-f\d]?
+  )
+)
+| --
+| \\?.
+`.replace(/\s+/g, ''), 'gsu');
+
+/**
+@typedef {{
+  regexContext: string;
+  charClassContext: string;
+  charClassDepth: number;
+  lastPos: number;
+}} RunningContext
+*/
+/**
+Accepts and returns its full state so it doesn't have to reprocess parts that have already been
+seen. Assumes flag v and doesn't worry about syntax errors that are caught by it.
+@param {string} incompleteExpression
+@param {Partial<RunningContext>} [runningContext]
+@returns {RunningContext}
+*/
+function getEndContextForIncompleteExpression(incompleteExpression, runningContext) {
+  let {regexContext, charClassContext, charClassDepth, lastPos} = {
+    regexContext: RegexContext.DEFAULT,
+    charClassContext: CharClassContext.DEFAULT,
+    charClassDepth: 0,
+    lastPos: 0,
+    ...runningContext,
+  };
+  contextToken.lastIndex = lastPos;
+  let match;
+  while (match = contextToken.exec(incompleteExpression)) {
+    const {0: m, groups: {groupN, enclosedPU, enclosedQ, intervalQ, incompleteT}} = match;
+    if (m === '[') {
+      charClassDepth++;
+      regexContext = RegexContext.CHAR_CLASS;
+      charClassContext = CharClassContext.DEFAULT;
+    } else if (m === ']' && regexContext === RegexContext.CHAR_CLASS) {
+      if (charClassDepth) {
+        charClassDepth--;
+      }
+      if (!charClassDepth) {
+        regexContext = RegexContext.DEFAULT;
+      }
+      charClassContext = CharClassContext.DEFAULT;
+    } else if (regexContext === RegexContext.CHAR_CLASS) {
+      if (incompleteT) {
+        charClassContext = CharClassContext.INVALID_INCOMPLETE_TOKEN;
+      } else if (m === '-') {
+        charClassContext = CharClassContext.RANGE;
+      } else if (enclosedPU) {
+        charClassContext = m[1] === 'u' ? CharClassContext.ENCLOSED_U : CharClassContext.ENCLOSED_P;
+      } else if (enclosedQ) {
+        charClassContext = CharClassContext.ENCLOSED_Q;
+      } else if (
+        (m === '}' && enclosedTokenCharClassContexts.has(charClassContext)) ||
+        // Don't continue in these contexts since we've advanced another token
+        charClassContext === CharClassContext.INVALID_INCOMPLETE_TOKEN ||
+        charClassContext === CharClassContext.RANGE
+      ) {
+        charClassContext = CharClassContext.DEFAULT;
+      }
+    } else {
+      if (incompleteT) {
+        regexContext = RegexContext.INVALID_INCOMPLETE_TOKEN;
+      } else if (groupN) {
+        regexContext = RegexContext.GROUP_NAME;
+      } else if (enclosedPU) {
+        regexContext = m[1] === 'u' ? RegexContext.ENCLOSED_U : RegexContext.ENCLOSED_P;
+      } else if (intervalQ) {
+        regexContext = RegexContext.INTERVAL_QUANTIFIER;
+      } else if (
+        (m === '>' && regexContext === RegexContext.GROUP_NAME) ||
+        (m === '}' && (regexContext === RegexContext.INTERVAL_QUANTIFIER || enclosedTokenRegexContexts.has(regexContext))) ||
+        // Don't continue in this context since we've advanced another token
+        regexContext === RegexContext.INVALID_INCOMPLETE_TOKEN
+       ) {
+        regexContext = RegexContext.DEFAULT;
+      }
+    }
+  }
+  return {
+    regexContext,
+    charClassContext,
+    charClassDepth,
+    lastPos: incompleteExpression.length,
+  };
+}
+
+// No special handling for escaped versions of the characters
+function getUnbalancedChar(expression, leftChar, rightChar) {
+  let numOpen = 0;
+  for (const [m] of expression.matchAll(new RegExp(`[${escapeV(leftChar + rightChar, Context.CHAR_CLASS)}]`, 'g'))) {
+    numOpen += m === leftChar ? 1 : -1;
+    if (numOpen < 0) {
+      return rightChar;
+    }
+  }
+  if (numOpen > 0) {
+    return leftChar;
+  }
+  return '';
+}
+
+/**
+@typedef {InterpolatedValue} InterpolatedValue
+@typedef {RawTemplate} RawTemplate
+@typedef {RegexTagOptions} RegexTagOptions
+@typedef {(
+  value: InterpolatedValue,
+  runningContext: RunningContext,
+  options: Required<RegexTagOptions>
+) => {
+  transformed: string;
+  runningContext: RunningContext;
+}} Preprocessor
+*/
+/**
+Returns transformed versions of a template and substitutions, using the given preprocessor. Only
+processes substitutions that are instanceof `Pattern`.
+@param {RawTemplate} template
+@param {ReadonlyArray<InterpolatedValue>} substitutions
+@param {Preprocessor} preprocessor
+@param {Required<RegexTagOptions>} options
+@returns {{template: RawTemplate; substitutions: ReadonlyArray<InterpolatedValue>;}}
+*/
+function preprocess(template, substitutions, preprocessor, options) {
+  let /** @type {RawTemplate} */ newTemplate = {raw: []};
+  let newSubstitutions = [];
+  let runningContext;
+  template.raw.forEach((raw, i) => {
+    const result = preprocessor(raw, {...runningContext, lastPos: 0}, options);
+    newTemplate.raw.push(result.transformed);
+    runningContext = result.runningContext;
+    if (i < template.raw.length - 1) {
+      const substitution = substitutions[i];
+      if (substitution instanceof Pattern) {
+        const result = preprocessor(substitution, {...runningContext, lastPos: 0}, options);
+        newSubstitutions.push(pattern(result.transformed));
+        runningContext = result.runningContext;
+      } else {
+        newSubstitutions.push(substitution);
+      }
+    }
+  });
+  return {
+    template: newTemplate,
+    substitutions: newSubstitutions,
+  };
+}
+
+// Sandbox `^` if relevant, done so it can't change the meaning of the surrounding character class
+// if we happen to be at the first position. See `sandboxLoneDoublePunctuatorChar` for more details
+function sandboxLoneCharClassCaret(str) {
+  return str.replace(/^\^/, '\\^^');
+}
+
+// Sandbox without escaping by repeating the character and escaping only the first one. The second
+// one is so that, if followed by the same symbol, the resulting double punctuator will still throw
+// as expected. Details:
+// - Only need to check the first position because, if it's part of an implicit union,
+//   interpolation handling will wrap it in nested `[…]`.
+// - Can't just wrap in nested `[…]` here, since the value might be used in a range.
+// - Can't add a second unescaped symbol if a lone symbol is the entire string because it might be
+//   followed by the same unescaped symbol outside an interpolation, and since it won't be wrapped,
+//   the second symbol wouldn't be sandboxed from the one following it.
+function sandboxLoneDoublePunctuatorChar(str) {
+  return str.replace(new RegExp(`^([${doublePunctuatorChars}])(?!\\1)`), (m, _, pos) => {
+    return `\\${m}${pos + 1 === str.length ? '' : m}`;
+  });
+}
+
+/**
+Converts `\0` tokens to `\x00` in the given context.
+@param {string} str
+@param {'DEFAULT' | 'CHAR_CLASS'} [context] `Context` option from lib `regex-utilities`
+@returns {string}
+*/
+function sandboxUnsafeNulls(str, context) {
+  // regex`[\0${0}]` and regex`[${pattern`\0`}0]` can't be guarded against via nested `[…]`
+  // sandboxing in character classes if the interpolated value doesn't contain union (since it
+  // might be placed on a range boundary). So escape `\0` in character classes as `\x00`
+  return replaceUnescaped(str, String.raw`\\0(?!\d)`, '\\x00', context);
+}
+
+export {
+  adjustNumberedBackrefs,
+  capturingDelim,
+  CharClassContext,
+  containsCharClassUnion,
+  countCaptures,
+  doublePunctuatorChars,
+  enclosedTokenCharClassContexts,
+  enclosedTokenRegexContexts,
+  envSupportsFlagGroups,
+  envSupportsFlagV,
+  escapeV,
+  getBreakoutChar,
+  getEndContextForIncompleteExpression,
+  namedCapturingDelim,
+  preprocess,
+  RegexContext,
+  sandboxLoneCharClassCaret,
+  sandboxLoneDoublePunctuatorChar,
+  sandboxUnsafeNulls,
+};

package/node_modules/regex-recursion/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Steven Levithan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/regex-recursion/README.md

@@ -0,0 +1,151 @@
+# regex-recursion
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![bundle][bundle-src]][bundle-href]
+
+This is an official plugin for [Regex+](https://github.com/slevithan/regex) that adds support for recursive matching up to a specified max depth *N*, where *N* can be between 2 and 100. Generated regexes are native JavaScript `RegExp` instances.
+
+> [!NOTE]
+> Regex flavors vary on whether they offer infinite or fixed-depth recursion. For example, recursion in Oniguruma uses a depth limit of 20, and doesn't allow changing this.
+
+Recursive matching is added to a regex via one of the following (the recursion depth limit is provided in place of *`N`*):
+
+- `(?R=N)` — Recursively match the entire regex at this position.
+- `\g<name&R=N>` or `\g<number&R=N>` — Recursively match the contents of the group referenced by name or number at this position.
+  - The `\g` subroutine must be *within* the referenced group.
+
+Multiple uses of recursion within the same pattern are allowed if they are non-overlapping. Named captures and backreferences are supported within recursion, and are independent per depth level. So e.g. `groups.name` on a match object is the value captured by group `name` at the top level of the recursion stack.
+
+## Install and use
+
+```sh
+npm install regex regex-recursion
+```
+
+```js
+import {regex} from 'regex';
+import {recursion} from 'regex-recursion';
+
+const re = regex({plugins: [recursion]})`…`;
+```
+
+<details>
+  <summary>Using a global name (no import)</summary>
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/regex@6.0.1/dist/regex.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/regex-recursion@6.0.2/dist/regex-recursion.min.js"></script>
+<script>
+  const {regex} = Regex;
+  const {recursion} = Regex.plugins;
+
+  const re = regex({plugins: [recursion]})`…`;
+</script>
+```
+</details>
+
+## Examples
+
+### Match an equal number of two different subpatterns
+
+#### Anywhere within a string
+
+```js
+// Matches sequences of up to 20 'a' chars followed by the same number of 'b'
+const re = regex({plugins: [recursion]})`a(?R=20)?b`;
+re.exec('test aaaaaabbb')[0];
+// → 'aaabbb'
+```
+
+#### As the entire string
+
+Use `\g<name&R=N>` to recursively match just the specified group.
+
+```js
+const re = regex({plugins: [recursion]})`
+  ^ (?<r> a \g<r&R=20>? b) $
+`;
+re.test('aaabbb'); // → true
+re.test('aaabb'); // → false
+```
+
+### Match balanced parentheses
+
+```js
+// Matches all balanced parentheses up to depth 20
+const parens = regex({flags: 'g', plugins: [recursion]})`
+  \( ([^\(\)] | (?R=20))* \)
+`;
+
+'test ) (balanced ((parens))) () ((a)) ( (b)'.match(parens);
+/* → [
+  '(balanced ((parens)))',
+  '()',
+  '((a))',
+  '(b)'
+] */
+```
+
+Following is an alternative that matches the same strings, but adds a nested quantifier. It then uses an atomic group to prevent this nested quantifier from creating the potential for [catastrophic backtracking](https://www.regular-expressions.info/catastrophic.html). Since the example above doesn't need a nested quantifier, this is not an improvement but merely an alternative that shows how to deal with the general problem of nested quantifiers with multiple ways to divide matches of the same strings.
+
+```js
+const parens = regex({flags: 'g', plugins: [recursion]})`
+  \( ((?> [^\(\)]+) | (?R=20))* \)
+`;
+
+// Or with a possessive quantifier
+const parens = regex({flags: 'g', plugins: [recursion]})`
+  \( ([^\(\)]++ | (?R=20))* \)
+`;
+```
+
+The first example above matches sequences of non-parentheses in one step with the nested `+` quantifier, and avoids backtracking into these sequences by wrapping it with an atomic group `(?>…)`. Given that what the nested quantifier `+` matches overlaps with what the outer group can match with its `*` quantifier, the atomic group is important here. It avoids exponential backtracking when matching long strings with unbalanced parentheses.
+
+In cases where you're you're repeating a single token within an atomic group, possessive quantifiers provide syntax sugar.
+
+Atomic groups and possessive quantifiers are provided by the base Regex+ library.
+
+### Match palindromes
+
+#### Match palindromes anywhere within a string
+
+```js
+const palindromes = regex({flags: 'gi', plugins: [recursion]})`
+  (?<char> \w)
+  # Recurse, or match a lone unbalanced char in the middle
+  ((?R=15) | \w?)
+  \k<char>
+`;
+
+'Racecar, ABBA, and redivided'.match(palindromes);
+// → ['Racecar', 'ABBA', 'edivide']
+```
+
+Palindromes are sequences that read the same backwards as forwards. In the example above, the max length of matched palindromes is 31. That's because it sets the max recursion depth to 15 with `(?R=15)`. So, depth 15 × 2 chars (left + right) for each depth level + 1 optional unbalanced char in the middle = 31. To match longer palindromes, the max recursion depth can be increased to a max of 100, which would enable matching palindromes up to 201 characters long.
+
+#### Match palindromes as complete words
+
+```js
+const palindromeWords = regex({flags: 'gi', plugins: [recursion]})`
+  \b
+  (?<palindrome>
+    (?<char> \w)
+    (\g<palindrome&R=15> | \w?)
+    \k<char>
+  )
+  \b
+`;
+
+'Racecar, ABBA, and redivided'.match(palindromeWords);
+// → ['Racecar', 'ABBA']
+```
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/regex-recursion?color=78C372
+[npm-version-href]: https://npmjs.com/package/regex-recursion
+[npm-downloads-src]: https://img.shields.io/npm/dm/regex-recursion?color=78C372
+[npm-downloads-href]: https://npmjs.com/package/regex-recursion
+[bundle-src]: https://img.shields.io/bundlejs/size/regex-recursion?color=78C372&label=minzip
+[bundle-href]: https://bundlejs.com/?q=regex-recursion&treeshake=[*]

package/node_modules/regex-recursion/dist/regex-recursion.min.js

@@ -0,0 +1,2 @@
+var Regex;(Regex||={}).plugins=(()=>{var N=Object.defineProperty;var q=Object.getOwnPropertyDescriptor;var y=Object.getOwnPropertyNames;var J=Object.prototype.hasOwnProperty;var K=(e,t)=>{for(var n in t)N(e,n,{get:t[n],enumerable:!0})},Q=(e,t,n,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of y(t))!J.call(e,o)&&o!==n&&N(e,o,{get:()=>t[o],enumerable:!(r=q(t,o))||r.enumerable});return e};var V=e=>Q(N({},"__esModule",{value:!0}),e);var ne={};K(ne,{recursion:()=>Z});var m=Object.freeze({DEFAULT:"DEFAULT",CHAR_CLASS:"CHAR_CLASS"});function T(e,t,n,r){let o=new RegExp(String.raw`${t}|(?<$skip>\[\^?|\\?.)`,"gsu"),u=[!1],s=0,c="";for(let i of e.matchAll(o)){let{0:p,groups:{$skip:f}}=i;if(!f&&(!r||r===m.DEFAULT==!s)){n instanceof Function?c+=n(i,{context:s?m.CHAR_CLASS:m.DEFAULT,negated:u[u.length-1]}):c+=n;continue}p[0]==="["?(s++,u.push(p[1]==="^")):p==="]"&&s&&(s--,u.pop()),c+=p}return c}function F(e,t,n,r){T(e,t,n,r)}function X(e,t,n=0,r){if(!new RegExp(t,"su").test(e))return null;let o=new RegExp(`${t}|(?<$skip>\\\\?.)`,"gsu");o.lastIndex=n;let u=0,s;for(;s=o.exec(e);){let{0:c,groups:{$skip:i}}=s;if(!i&&(!r||r===m.DEFAULT==!u))return s;c==="["?u++:c==="]"&&u&&u--,o.lastIndex==s.index&&o.lastIndex++}return null}function k(e,t,n){return!!X(e,t,0,n)}function G(e,t){let n=/\\?./gsu;n.lastIndex=t;let r=e.length,o=0,u=1,s;for(;s=n.exec(e);){let[c]=s;if(c==="[")o++;else if(o)c==="]"&&o--;else if(c==="(")u++;else if(c===")"&&(u--,!u)){r=s.index;break}}return e.slice(t,r)}var w=String.raw,Y=w`\\g<(?<gRNameOrNum>[^>&]+)&R=(?<gRDepth>[^>]+)>`,I=w`\(\?R=(?<rDepth>[^\)]+)\)|${Y}`,L=w`\(\?<(?![=!])(?<captureName>[^>]+)>`,_=w`${L}|(?<unnamed>\()(?!\?)`,x=new RegExp(w`${L}|${I}|\(\?|\\?.`,"gsu"),b="Cannot use multiple overlapping recursions";function Z(e,t){let{hiddenCaptures:n,mode:r}={hiddenCaptures:[],mode:"plugin",...t},o=t?.captureTransfers??new Map;if(!new RegExp(I,"su").test(e))return{pattern:e,captureTransfers:o,hiddenCaptures:n};if(r==="plugin"&&k(e,w`\(\?\(DEFINE\)`,m.DEFAULT))throw new Error("DEFINE groups cannot be used with recursion");let u=[],s=k(e,w`\\[1-9]`,m.DEFAULT),c=new Map,i=[],p=!1,f=0,a=0,$;for(x.lastIndex=0;$=x.exec(e);){let{0:g,groups:{captureName:d,rDepth:h,gRNameOrNum:l,gRDepth:R}}=$;if(g==="[")f++;else if(f)g==="]"&&f--;else if(h){if(B(h),p)throw new Error(b);if(s)throw new Error(`${r==="external"?"Backrefs":"Numbered backrefs"} cannot be used with global recursion`);let C=e.slice(0,$.index),E=e.slice(x.lastIndex);if(k(E,I,m.DEFAULT))throw new Error(b);let D=+h-1;e=H(C,E,D,!1,n,u,a),o=W(o,C,D,u.length,0,a);break}else if(l){B(R);let C=!1;for(let U of i)if(U.name===l||U.num===+l){if(C=!0,U.hasRecursedWithin)throw new Error(b);break}if(!C)throw new Error(w`Recursive \g cannot be used outside the referenced group "${r==="external"?l:w`\g<${l}&R=${R}>`}"`);let E=c.get(l),D=G(e,E);if(s&&k(D,w`${L}|\((?!\?)`,m.DEFAULT))throw new Error(`${r==="external"?"Backrefs":"Numbered backrefs"} cannot be used with recursion of capturing groups`);let A=e.slice(E,$.index),S=D.slice(A.length+g.length),O=u.length,M=+R-1,v=H(A,S,M,!0,n,u,a);o=W(o,A,M,u.length-O,O,a);let z=e.slice(0,E),j=e.slice(E+D.length);e=`${z}${v}${j}`,x.lastIndex+=v.length-g.length-A.length-S.length,i.forEach(U=>U.hasRecursedWithin=!0),p=!0}else if(d)a++,c.set(String(a),x.lastIndex),c.set(d,x.lastIndex),i.push({num:a,name:d});else if(g[0]==="("){let C=g==="(";C&&(a++,c.set(String(a),x.lastIndex)),i.push(C?{num:a}:{})}else g===")"&&i.pop()}return n.push(...u),{pattern:e,captureTransfers:o,hiddenCaptures:n}}function B(e){let t=`Max depth must be integer between 2 and 100; used ${e}`;if(!/^[1-9]\d*$/.test(e))throw new Error(t);if(e=+e,e<2||e>100)throw new Error(t)}function H(e,t,n,r,o,u,s){let c=new Set;r&&F(e+t,L,({groups:{captureName:p}})=>{c.add(p)},m.DEFAULT);let i=[n,r?c:null,o,u,s];return`${e}${P(`(?:${e}`,"forward",...i)}(?:)${P(`${t})`,"backward",...i)}${t}`}function P(e,t,n,r,o,u,s){let i=f=>t==="forward"?f+2:n-f+2-1,p="";for(let f=0;f<n;f++){let a=i(f);p+=T(e,w`${_}|\\k<(?<backref>[^>]+)>`,({0:$,groups:{captureName:g,unnamed:d,backref:h}})=>{if(h&&r&&!r.has(h))return $;let l=`_$${a}`;if(d||g){let R=s+u.length+1;return u.push(R),ee(o,R),d?$:`(?<${g}${l}>`}return w`\k<${h}${l}>`},m.DEFAULT)}return p}function ee(e,t){for(let n=0;n<e.length;n++)e[n]>=t&&e[n]++}function W(e,t,n,r,o,u){if(e.size&&r){let s=0;F(t,_,()=>s++,m.DEFAULT);let c=u-s+o,i=new Map;return e.forEach((p,f)=>{let a=(r-s*n)/n,$=s*n,g=f>c+s?f+r:f,d=[];for(let h of p)if(h<=c)d.push(h);else if(h>c+s+a)d.push(h+r);else if(h<=c+s)for(let l=0;l<=n;l++)d.push(h+s*l);else for(let l=0;l<=n;l++)d.push(h+$+a*l);i.set(g,d)}),i}return e}return V(ne);})();
+//# sourceMappingURL=regex-recursion.min.js.map

package/node_modules/regex-recursion/dist/regex-recursion.min.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/index.js", "../node_modules/.pnpm/regex-utilities@2.3.0/node_modules/regex-utilities/src/index.js"],
+  "sourcesContent": ["import {Context, forEachUnescaped, getGroupContents, hasUnescaped, replaceUnescaped} from 'regex-utilities';\n\nconst r = String.raw;\nconst gRToken = r`\\\\g<(?<gRNameOrNum>[^>&]+)&R=(?<gRDepth>[^>]+)>`;\nconst recursiveToken = r`\\(\\?R=(?<rDepth>[^\\)]+)\\)|${gRToken}`;\nconst namedCaptureDelim = r`\\(\\?<(?![=!])(?<captureName>[^>]+)>`;\nconst captureDelim = r`${namedCaptureDelim}|(?<unnamed>\\()(?!\\?)`;\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<number, Array<number>>;\n  hiddenCaptures?: Array<number>;\n  mode?: 'plugin' | 'external';\n}} [data]\n@returns {{\n  pattern: string;\n  captureTransfers: Map<number, Array<number>>;\n  hiddenCaptures: Array<number>;\n}}\n*/\nfunction recursion(pattern, data) {\n  const {hiddenCaptures, mode} = {\n    hiddenCaptures: [],\n    mode: 'plugin',\n    ...data,\n  };\n  // Capture transfer is used by <github.com/slevithan/oniguruma-to-es>\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' && 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<name&R=N>`, `\\g<number&R=N>`\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<${gRNameOrNum}&R=${gRDepth}>`\n          }\"`);\n        }\n        const startPos = groupContentsStartPos.get(gRNameOrNum);\n        const groupContents = getGroupContents(pattern, startPos);\n        if (\n          hasNumberedBackref &&\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 => 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 < 2 || max > 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<number>} hiddenCaptures\n@param {Array<number>} 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}}) => {\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<string> | null} namesInRecursed\n@param {Array<number>} hiddenCaptures\n@param {Array<number>} 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 => direction === 'forward' ? (i + startNum) : (reps - i + startNum - 1);\n  let result = '';\n  for (let i = 0; i < reps; i++) {\n    const depthNum = getDepthNum(i);\n    result += replaceUnescaped(\n      pattern,\n      r`${captureDelim}|\\\\k<(?<backref>[^>]+)>`,\n      ({0: m, groups: {captureName, unnamed, backref}}) => {\n        if (backref && namesInRecursed && !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 : `(?<${captureName}${suffix}>`;\n        }\n        return r`\\k<${backref}${suffix}>`;\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<number>} arr\n@param {number} threshold\n*/\nfunction incrementIfAtLeast(arr, threshold) {\n  for (let i = 0; i < arr.length; i++) {\n    if (arr[i] >= threshold) {\n      arr[i]++;\n    }\n  }\n}\n\n/**\n@param {Map<number, Array<number>>} captureTransfers\n@param {string} left\n@param {number} reps\n@param {number} numCapturesAddedInExpansion\n@param {number} numAddedHiddenCapturesPreExpansion\n@param {number} numCapturesPassed\n@returns {Map<number, Array<number>>}\n*/\nfunction mapCaptureTransfers(captureTransfers, left, reps, numCapturesAddedInExpansion, numAddedHiddenCapturesPreExpansion, numCapturesPassed) {\n  if (captureTransfers.size && numCapturesAddedInExpansion) {\n    let numCapturesInLeft = 0;\n    forEachUnescaped(left, captureDelim, () => 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) => {\n      const numCapturesInRight = (numCapturesAddedInExpansion - (numCapturesInLeft * reps)) / reps;\n      const numCapturesAddedInLeft = numCapturesInLeft * reps;\n      const newTo = to > (recursionDelimCaptureNum + numCapturesInLeft) ? to + numCapturesAddedInExpansion : to;\n      const newFrom = [];\n      for (const f of from) {\n        // Before the recursed subpattern\n        if (f <= recursionDelimCaptureNum) {\n          newFrom.push(f);\n        // After the recursed subpattern\n        } else if (f > (recursionDelimCaptureNum + numCapturesInLeft + numCapturesInRight)) {\n          newFrom.push(f + numCapturesAddedInExpansion);\n        // Within the recursed subpattern, on the left of the recursion token\n        } else if (f <= (recursionDelimCaptureNum + numCapturesInLeft)) {\n          for (let i = 0; i <= 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 <= 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", "// Constant properties for tracking regex syntax context\nexport const Context = Object.freeze({\n  DEFAULT: 'DEFAULT',\n  CHAR_CLASS: 'CHAR_CLASS',\n});\n\n/**\nReplaces all unescaped instances of a regex pattern in the given context, using a replacement\nstring or callback.\n\nDoesn't skip over complete multicharacter tokens (only `\\` plus its folowing char) so must be used\nwith knowledge of what's safe to do given regex syntax. Assumes UnicodeSets-mode syntax.\n@param {string} expression Search target\n@param {string} needle Search as a regex pattern, with flags `su` applied\n@param {string | (match: RegExpExecArray, details: {\n  context: 'DEFAULT' | 'CHAR_CLASS';\n  negated: boolean;\n}) => string} replacement\n@param {'DEFAULT' | 'CHAR_CLASS'} [context] All contexts if not specified\n@returns {string} Updated expression\n@example\nconst str = '.\\\\.\\\\\\\\.[[\\\\.].].';\nreplaceUnescaped(str, '\\\\.', '@');\n// \u2192 '@\\\\.\\\\\\\\@[[\\\\.]@]@'\nreplaceUnescaped(str, '\\\\.', '@', Context.DEFAULT);\n// \u2192 '@\\\\.\\\\\\\\@[[\\\\.].]@'\nreplaceUnescaped(str, '\\\\.', '@', Context.CHAR_CLASS);\n// \u2192 '.\\\\.\\\\\\\\.[[\\\\.]@].'\n*/\nexport function replaceUnescaped(expression, needle, replacement, context) {\n  const re = new RegExp(String.raw`${needle}|(?<$skip>\\[\\^?|\\\\?.)`, 'gsu');\n  const negated = [false];\n  let numCharClassesOpen = 0;\n  let result = '';\n  for (const match of expression.matchAll(re)) {\n    const {0: m, groups: {$skip}} = match;\n    if (!$skip && (!context || (context === Context.DEFAULT) === !numCharClassesOpen)) {\n      if (replacement instanceof Function) {\n        result += replacement(match, {\n          context: numCharClassesOpen ? Context.CHAR_CLASS : Context.DEFAULT,\n          negated: negated[negated.length - 1],\n        });\n      } else {\n        result += replacement;\n      }\n      continue;\n    }\n    if (m[0] === '[') {\n      numCharClassesOpen++;\n      negated.push(m[1] === '^');\n    } else if (m === ']' && numCharClassesOpen) {\n      numCharClassesOpen--;\n      negated.pop();\n    }\n    result += m;\n  }\n  return result;\n}\n\n/**\nRuns a callback for each unescaped instance of a regex pattern in the given context.\n\nDoesn't skip over complete multicharacter tokens (only `\\` plus its folowing char) so must be used\nwith knowledge of what's safe to do given regex syntax. Assumes UnicodeSets-mode syntax.\n@param {string} expression Search target\n@param {string} needle Search as a regex pattern, with flags `su` applied\n@param {(match: RegExpExecArray, details: {\n  context: 'DEFAULT' | 'CHAR_CLASS';\n  negated: boolean;\n}) => void} callback\n@param {'DEFAULT' | 'CHAR_CLASS'} [context] All contexts if not specified\n*/\nexport function forEachUnescaped(expression, needle, callback, context) {\n  // Do this the easy way\n  replaceUnescaped(expression, needle, callback, context);\n}\n\n/**\nReturns a match object for the first unescaped instance of a regex pattern in the given context, or\n`null`.\n\nDoesn't skip over complete multicharacter tokens (only `\\` plus its folowing char) so must be used\nwith knowledge of what's safe to do given regex syntax. Assumes UnicodeSets-mode syntax.\n@param {string} expression Search target\n@param {string} needle Search as a regex pattern, with flags `su` applied\n@param {number} [pos] Offset to start the search\n@param {'DEFAULT' | 'CHAR_CLASS'} [context] All contexts if not specified\n@returns {RegExpExecArray | null}\n*/\nexport function execUnescaped(expression, needle, pos = 0, context) {\n  // Quick partial test; avoid the loop if not needed\n  if (!(new RegExp(needle, 'su').test(expression))) {\n    return null;\n  }\n  const re = new RegExp(`${needle}|(?<$skip>\\\\\\\\?.)`, 'gsu');\n  re.lastIndex = pos;\n  let numCharClassesOpen = 0;\n  let match;\n  while (match = re.exec(expression)) {\n    const {0: m, groups: {$skip}} = match;\n    if (!$skip && (!context || (context === Context.DEFAULT) === !numCharClassesOpen)) {\n      return match;\n    }\n    if (m === '[') {\n      numCharClassesOpen++;\n    } else if (m === ']' && numCharClassesOpen) {\n      numCharClassesOpen--;\n    }\n    // Avoid an infinite loop on zero-length matches\n    if (re.lastIndex == match.index) {\n      re.lastIndex++;\n    }\n  }\n  return null;\n}\n\n/**\nChecks whether an unescaped instance of a regex pattern appears in the given context.\n\nDoesn't skip over complete multicharacter tokens (only `\\` plus its folowing char) so must be used\nwith knowledge of what's safe to do given regex syntax. Assumes UnicodeSets-mode syntax.\n@param {string} expression Search target\n@param {string} needle Search as a regex pattern, with flags `su` applied\n@param {'DEFAULT' | 'CHAR_CLASS'} [context] All contexts if not specified\n@returns {boolean} Whether the pattern was found\n*/\nexport function hasUnescaped(expression, needle, context) {\n  // Do this the easy way\n  return !!execUnescaped(expression, needle, 0, context);\n}\n\n/**\nExtracts the full contents of a group (subpattern) from the given expression, accounting for\nescaped characters, nested groups, and character classes. The group is identified by the position\nwhere its contents start (the string index just after the group's opening delimiter). Returns the\nrest of the string if the group is unclosed.\n\nAssumes UnicodeSets-mode syntax.\n@param {string} expression Search target\n@param {number} contentsStartPos\n@returns {string}\n*/\nexport function getGroupContents(expression, contentsStartPos) {\n  const token = /\\\\?./gsu;\n  token.lastIndex = contentsStartPos;\n  let contentsEndPos = expression.length;\n  let numCharClassesOpen = 0;\n  // Starting search within an open group, after the group's opening\n  let numGroupsOpen = 1;\n  let match;\n  while (match = token.exec(expression)) {\n    const [m] = match;\n    if (m === '[') {\n      numCharClassesOpen++;\n    } else if (!numCharClassesOpen) {\n      if (m === '(') {\n        numGroupsOpen++;\n      } else if (m === ')') {\n        numGroupsOpen--;\n        if (!numGroupsOpen) {\n          contentsEndPos = match.index;\n          break;\n        }\n      }\n    } else if (m === ']') {\n      numCharClassesOpen--;\n    }\n  }\n  return expression.slice(contentsStartPos, contentsEndPos);\n}\n"],
+  "mappings": "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",
+  "names": ["index_exports", "__export", "recursion", "Context", "replaceUnescaped", "expression", "needle", "replacement", "context", "re", "negated", "numCharClassesOpen", "result", "match", "m", "$skip", "forEachUnescaped", "callback", "execUnescaped", "pos", "hasUnescaped", "getGroupContents", "contentsStartPos", "token", "contentsEndPos", "numGroupsOpen", "r", "gRToken", "recursiveToken", "namedCaptureDelim", "captureDelim", "token", "overlappingRecursionMsg", "recursion", "pattern", "data", "hiddenCaptures", "mode", "captureTransfers", "hasUnescaped", "Context", "addedHiddenCaptures", "hasNumberedBackref", "groupContentsStartPos", "openGroups", "hasRecursed", "numCharClassesOpen", "numCapturesPassed", "match", "m", "captureName", "rDepth", "gRNameOrNum", "gRDepth", "assertMaxInBounds", "left", "right", "reps", "makeRecursive", "mapCaptureTransfers", "isWithinReffedGroup", "g", "startPos", "groupContents", "getGroupContents", "groupContentsLeft", "groupContentsRight", "numAddedHiddenCapturesPreExpansion", "expansion", "pre", "post", "isUnnamedCapture", "max", "errMsg", "isSubpattern", "namesInRecursed", "forEachUnescaped", "rest", "repeatWithDepth", "direction", "getDepthNum", "i", "result", "depthNum", "replaceUnescaped", "unnamed", "backref", "suffix", "addedCaptureNum", "incrementIfAtLeast", "arr", "threshold", "numCapturesAddedInExpansion", "numCapturesInLeft", "recursionDelimCaptureNum", "newCaptureTransfers", "from", "to", "numCapturesInRight", "numCapturesAddedInLeft", "newTo", "newFrom", "f"]
+}