@poe-platform/safe-bash 0.1.756 → 0.1.757

package/dist/safe-bash/chunks/chunk-CEWCRI6H.js

@@ -1,2813 +0,0 @@
-import {
-  init_platform
-} from "./chunk-ZG7GWQ5P.js";
-
-// packages/safe-bash-regex-engine/src/text/budget.ts
-init_platform();
-import { PublicDiagnostic } from "../../safe-bash-contracts/public-diagnostic.js";
-import { hasYieldCheckpoint, monotonicNow, yieldTurn } from "../../safe-bash-contracts/yield.js";
-var defaultPerfNow = performance.now;
-var validatedTextProgramOptions = /* @__PURE__ */ new WeakSet();
-var DUMMY_ABORT_SIGNAL = Object.freeze({
-  aborted: false,
-  reason: void 0,
-  onabort: null,
-  throwIfAborted() {
-  },
-  addEventListener() {
-  },
-  removeEventListener() {
-  },
-  dispatchEvent() {
-    return true;
-  }
-});
-var DUMMY_COMMAND_CONTEXT = { signal: DUMMY_ABORT_SIGNAL };
-var pooledBudgetA;
-var pooledBudgetB;
-var pooledBudgetToggle = 0;
-var ProgramError = class extends PublicDiagnostic {
-};
-var Budget = class _Budget {
-  constructor(context, options) {
-    this.context = context;
-    this.options = options;
-    const rem = options.maxSteps ?? Infinity;
-    this.unlimited = rem === Infinity;
-    this.remainingNum = this.unlimited ? 0 : rem;
-    this.remainingSmi = !this.unlimited && rem <= 1073741823 ? rem | 0 : 1073741823;
-    this.signal = context.signal;
-    this.hasExtYield = hasYieldCheckpoint(context.signal);
-    this.yieldTimes[0] = performance.now !== defaultPerfNow || this.hasExtYield ? monotonicNow() : -1;
-    this.maxBufferBytes = options.maxBufferBytes ?? Infinity;
-    if (context.signal.aborted) context.signal.throwIfAborted();
-    if (!validatedTextProgramOptions.has(options)) {
-      for (const [key, value] of Object.entries(options)) {
-        if (!key.startsWith("max")) continue;
-        if (value !== void 0 && (typeof value !== "number" || value !== Infinity && !Number.isSafeInteger(value) || value < 1)) throw new ProgramError("limits must be positive safe integers");
-      }
-      validatedTextProgramOptions.add(options);
-    }
-  }
-  context;
-  options;
-  maxBufferBytes;
-  stepsUsed = 0;
-  inUse = false;
-  remainingSmi;
-  remainingNum;
-  unlimited;
-  signal;
-  checkpoints = 0;
-  hasExtYield = false;
-  yieldTimes = new Float64Array(1);
-  static acquire(context, options) {
-    if (!pooledBudgetA) {
-      pooledBudgetA = new _Budget(DUMMY_COMMAND_CONTEXT, options);
-    }
-    if (!pooledBudgetB) {
-      pooledBudgetB = new _Budget(DUMMY_COMMAND_CONTEXT, options);
-    }
-    const first = (pooledBudgetToggle++ & 1) === 0 ? pooledBudgetA : pooledBudgetB;
-    const second = first === pooledBudgetA ? pooledBudgetB : pooledBudgetA;
-    if (!first.inUse) {
-      first.inUse = true;
-      first.resetForRun(context, options);
-      return first;
-    }
-    if (!second.inUse) {
-      second.inUse = true;
-      second.resetForRun(context, options);
-      return second;
-    }
-    return new _Budget(context, options);
-  }
-  static release(budget) {
-    if (budget === pooledBudgetA || budget === pooledBudgetB) {
-      budget.inUse = false;
-      budget.context = DUMMY_COMMAND_CONTEXT;
-      budget.signal = DUMMY_ABORT_SIGNAL;
-    }
-  }
-  resetForRun(context, options) {
-    if (context.signal.aborted) context.signal.throwIfAborted();
-    const rem = options.maxSteps ?? Infinity;
-    this.context = context;
-    this.options = options;
-    this.stepsUsed = 0;
-    this.unlimited = rem === Infinity;
-    this.remainingNum = this.unlimited ? 0 : rem;
-    this.remainingSmi = !this.unlimited && rem <= 1073741823 ? rem | 0 : 1073741823;
-    this.signal = context.signal;
-    this.checkpoints = 0;
-    this.hasExtYield = hasYieldCheckpoint(context.signal);
-    this.yieldTimes[0] = performance.now !== defaultPerfNow || this.hasExtYield ? monotonicNow() : -1;
-    const nextMaxBuf = options.maxBufferBytes ?? Infinity;
-    if (this.maxBufferBytes !== nextMaxBuf) this.maxBufferBytes = nextMaxBuf;
-  }
-  step(count = 1) {
-    if (this.signal.aborted) this.signal.throwIfAborted();
-    const nextSteps = this.stepsUsed + count;
-    this.stepsUsed = nextSteps;
-    if (this.unlimited) return;
-    if ((count | 0) === count && count >= 0 && count <= this.remainingSmi) {
-      this.remainingSmi = this.remainingSmi - (count | 0) | 0;
-      this.remainingNum -= count;
-      return;
-    }
-    if (count > this.remainingNum) throw new ProgramError("execution step limit exceeded");
-    this.remainingNum -= count;
-    this.remainingSmi = this.remainingNum <= 1073741823 ? this.remainingNum | 0 : 1073741823;
-  }
-  check(text) {
-    if (text.length > this.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-    return text;
-  }
-  async checkpoint() {
-    const p = this.checkpointSync();
-    if (p) await p;
-  }
-  checkpointSync() {
-    if (this.signal.aborted) this.signal.throwIfAborted();
-    const count = ++this.checkpoints;
-    if ((count & 255) === 0) {
-      return this.yieldCheckpointAsync();
-    }
-    if (performance.now !== defaultPerfNow || this.hasExtYield || (count & 63) === 0) {
-      const now = monotonicNow();
-      if (this.yieldTimes[0] < 0) {
-        this.yieldTimes[0] = now;
-      } else if (now - this.yieldTimes[0] >= 25) {
-        return this.yieldCheckpointAsync();
-      }
-    }
-    return void 0;
-  }
-  async yieldCheckpointAsync() {
-    await yieldTurn(this.signal);
-    this.yieldTimes[0] = monotonicNow();
-    this.signal.throwIfAborted();
-  }
-};
-
-// packages/safe-bash-regex-engine/src/text/rust-syntax.ts
-init_platform();
-var RustPatternError = class extends ProgramError {
-  constructor(message, offset, compilation = false) {
-    super(message);
-    this.offset = offset;
-    this.compilation = compilation;
-  }
-  offset;
-  compilation;
-};
-function simpleCaseFold(text) {
-  let result = "";
-  for (const char of text) {
-    const lower = char.toLowerCase(), upper = lower.toUpperCase();
-    result += char === "\u0131" || [...lower].length !== 1 ? char : [...upper].length === 1 ? upper.toLowerCase() : lower;
-  }
-  return result;
-}
-var word = (char) => /^[\p{Alphabetic}\p{M}\p{Nd}\p{Pc}\p{Join_Control}]$/u.test(char);
-var asciiWord = (char) => /^[A-Za-z0-9_]$/u.test(char);
-function property(name, insensitive) {
-  if (!name || [...name].some((c) => !" _-=0123456789".includes(c) && !(c >= "A" && c <= "Z") && !(c >= "a" && c <= "z"))) throw new ProgramError("invalid Unicode character class");
-  const clean = name.split(" ").join("").split("-").join("_");
-  const equals = clean.indexOf("="), key = equals < 0 ? "" : clean.slice(0, equals), value = equals < 0 ? clean : clean.slice(equals + 1);
-  const title = value.split("_").map((part) => part[0]?.toUpperCase() + part.slice(1).toLowerCase()).join("_");
-  const keys = { sc: "Script", script: "Script", scx: "Script_Extensions", scriptextensions: "Script_Extensions", script_extensions: "Script_Extensions", gc: "General_Category", generalcategory: "General_Category", general_category: "General_Category" };
-  const prefix = key ? (keys[key.toLowerCase()] ?? key) + "=" : "";
-  const candidates = [prefix + value, prefix + title];
-  if (!key) candidates.push("Script=" + value, "Script=" + title);
-  if (clean.toLowerCase() === "any") return () => true;
-  if (clean.toLowerCase() === "ascii") return (char) => char.codePointAt(0) <= 127;
-  for (const candidate of candidates) {
-    try {
-      const pattern = new RegExp(`^\\p{${candidate}}$`, insensitive ? "iu" : "u");
-      return (char) => pattern.test(char);
-    } catch {
-    }
-  }
-  throw new ProgramError(`Unicode property not found: ${name}`);
-}
-function parseRustPattern(source, ignoreCase, maximumDepth = Infinity) {
-  let at = 0, depth = 0, groupCount = 0, peakDepth = 0;
-  let flags = new Set(ignoreCase ? ["u", "i"] : ["u"]);
-  const groupNames = /* @__PURE__ */ new Map(), references = /* @__PURE__ */ new Set();
-  let numberedReferences = false;
-  function fail(message, offset = at, compilation = false) {
-    throw new RustPatternError(message, offset, compilation);
-  }
-  const enter = () => {
-    peakDepth = Math.max(peakDepth, ++depth);
-    if (depth > maximumDepth) throw new ProgramError("rust regular expression depth limit exceeded");
-  };
-  const skip = () => {
-    if (!flags.has("x")) return;
-    while (at < source.length) {
-      if (" 	\n\r\f\v".includes(source[at])) {
-        at++;
-        continue;
-      }
-      if (source[at] !== "#") break;
-      while (at < source.length && source[at] !== "\n") at++;
-    }
-  };
-  const scalar = () => {
-    if (at >= source.length) throw new ProgramError("unexpected end of regular expression");
-    const char = String.fromCodePoint(source.codePointAt(at));
-    at += char.length;
-    return char;
-  };
-  const literal = (char) => {
-    const insensitive = flags.has("i"), folded = simpleCaseFold(char);
-    return { type: "character", ...insensitive ? {} : { literal: char }, accepts: (candidate) => insensitive ? simpleCaseFold(candidate) === folded : candidate === char };
-  };
-  const classEscape = () => {
-    const char = source[at];
-    if (char === "p" || char === "P") {
-      at++;
-      let name;
-      if (source[at] === "{") {
-        const end = source.indexOf("}", ++at);
-        if (end < 0) throw new ProgramError("Unicode escape not closed");
-        name = source.slice(at, end);
-        at = end + 1;
-      } else name = scalar();
-      let accepts2;
-      try {
-        accepts2 = property(name, flags.has("i"));
-      } catch {
-        return fail("Regex error: error parsing pattern 0", at, true);
-      }
-      return char === "p" ? accepts2 : (value) => !accepts2(value);
-    }
-    if (char === void 0 || !"dDsSwWhH".includes(char)) return;
-    at++;
-    const unicode = flags.has("u"), lower = char.toLowerCase();
-    const accepts = lower === "h" ? (value) => /^[0-9A-Fa-f]$/u.test(value) : lower === "w" ? unicode ? word : asciiWord : lower === "d" ? unicode ? (value) => /^\p{Nd}$/u.test(value) : (value) => value >= "0" && value <= "9" : unicode ? (value) => /^\p{White_Space}$/u.test(value) : (value) => " 	\n\r\f\v".includes(value);
-    return char === lower ? accepts : (value) => !accepts(value);
-  };
-  const escaped = () => {
-    const char = scalar();
-    const controls = { a: "\x07", b: "\b", f: "\f", n: "\n", r: "\r", t: "	", v: "\v", e: "\x1B" };
-    if (controls[char] !== void 0) return controls[char];
-    if (char === "x" || char === "u" || char === "U") {
-      const escapeStart = at;
-      const braced = source[at] === "{";
-      if (braced) at++;
-      const begin = at, count = char === "x" ? 2 : char === "u" ? 4 : 8;
-      while (at < source.length && "0123456789abcdefABCDEF".includes(source[at]) && (braced || at - begin < count)) at++;
-      const hex = source.slice(begin, at), value = Number.parseInt(hex, 16);
-      if (!hex || braced && source[at++] !== "}" || !braced && hex.length !== count || value > 1114111 || value >= 55296 && value <= 57343) fail("Invalid hex escape", escapeStart);
-      return String.fromCodePoint(value);
-    }
-    if (char >= "A" && char <= "Z" || char >= "a" && char <= "z") fail(`Invalid escape: \\${char}`, at - 2);
-    return char;
-  };
-  const bracket = () => {
-    enter();
-    skip();
-    const negate = source[at] === "^";
-    if (negate) at++;
-    const insensitive = flags.has("i");
-    const token = () => {
-      skip();
-      if (source[at] === "[") {
-        if (source[at + 1] === ":") {
-          const end = source.indexOf(":]", at + 2), name = source.slice(at + 2, end);
-          const classes2 = {
-            alnum: (c) => /^[A-Za-z0-9]$/u.test(c),
-            alpha: (c) => /^[A-Za-z]$/u.test(c),
-            ascii: (c) => c.codePointAt(0) <= 127,
-            blank: (c) => c === " " || c === "	",
-            cntrl: (c) => c.codePointAt(0) <= 31 || c === "\x7F",
-            digit: (c) => /^[0-9]$/u.test(c),
-            graph: (c) => /^[!-~]$/u.test(c),
-            lower: (c) => /^[a-z]$/u.test(c),
-            print: (c) => /^[ -~]$/u.test(c),
-            punct: (c) => /^[!-/:-@[-`{-~]$/u.test(c),
-            space: (c) => " 	\n\r\f\v".includes(c),
-            upper: (c) => /^[A-Z]$/u.test(c),
-            word: asciiWord,
-            xdigit: (c) => /^[A-Fa-f0-9]$/u.test(c)
-          };
-          const negative = name.startsWith("^"), accepts2 = classes2[negative ? name.slice(1) : name];
-          if (end < 0 || !accepts2) throw new ProgramError("invalid ASCII character class");
-          at = end + 2;
-          return { accepts: negative ? (c) => !accepts2(c) : accepts2 };
-        }
-        at++;
-        const nested = bracket();
-        return { accepts: nested.accepts };
-      }
-      let char;
-      if (source[at] === "\\") {
-        at++;
-        const accepts2 = classEscape();
-        if (accepts2) return { accepts: accepts2 };
-        char = escaped();
-      } else char = scalar();
-      return { accepts: (candidate) => candidate === char, scalar: char };
-    };
-    const union = () => {
-      const terms = [];
-      while (at < source.length) {
-        skip();
-        if (source[at] === "]" && terms.length || ["&&", "--", "~~"].some((op) => source.startsWith(op, at))) break;
-        const start = token();
-        skip();
-        if (start.scalar !== void 0 && source[at] === "-" && source[at + 1] !== "]" && source[at + 1] !== "-") {
-          at++;
-          const end = token();
-          if (end.scalar === void 0 || start.scalar.codePointAt(0) > end.scalar.codePointAt(0)) fail("Regex error: error parsing pattern 0", at, true);
-          const low = start.scalar.codePointAt(0), high = end.scalar.codePointAt(0);
-          terms.push((char) => [...char].length === 1 && char.codePointAt(0) >= low && char.codePointAt(0) <= high);
-        } else terms.push(start.accepts);
-      }
-      return (char) => terms.some((accepts2) => accepts2(char));
-    };
-    let accepts = union();
-    while (at < source.length && source[at] !== "]") {
-      const op = source.slice(at, at + 2);
-      at += 2;
-      if (!["&&", "--", "~~"].includes(op)) throw new ProgramError("invalid character class operation");
-      const left = accepts, right = union();
-      accepts = op === "&&" ? (char) => left(char) && right(char) : op === "--" ? (char) => left(char) && !right(char) : (char) => left(char) !== right(char);
-    }
-    if (source[at] !== "]") fail("Invalid character class", at);
-    at++;
-    depth--;
-    return { type: "character", accepts: (char) => {
-      const lower = char.toLowerCase(), upper = char.toUpperCase();
-      const found = accepts(char) || insensitive && (accepts(simpleCaseFold(char)) || char !== "\u0131" && [...upper].length === 1 && accepts(upper) || [...lower].length === 1 && accepts(lower));
-      return negate ? !found : found;
-    } };
-  };
-  const atom = () => {
-    skip();
-    const atomStart = at, char = scalar();
-    if (char === "(") {
-      enter();
-      const outer = new Set(flags);
-      let capturing = true, atomic = false, name, assertion;
-      if (source[at] === "?") {
-        at++;
-        const kind = source[at];
-        if (kind === "#") {
-          const close = source.indexOf(")", ++at);
-          if (close < 0) fail("Opening parenthesis without closing parenthesis", at);
-          at = close + 1;
-          depth--;
-          return { type: "empty" };
-        }
-        if (source.startsWith("P=", at)) {
-          at += 2;
-          const end = source.indexOf(")", at), name2 = source.slice(at, end), index2 = groupNames.get(name2);
-          if (end < 0) fail("Could not parse group name", at);
-          if (index2 === void 0) fail("Invalid group name in back reference: " + name2, at);
-          at = end + 1;
-          depth--;
-          return { type: "backreference", index: index2, ignoreCase: flags.has("i"), fold: simpleCaseFold };
-        }
-        if (kind === "(") {
-          at++;
-          let condition;
-          const end = source.indexOf(")", at), token = source.slice(at, end);
-          const stripped = token.startsWith("<") && token.endsWith(">") || token.startsWith("'") && token.endsWith("'") ? token.slice(1, -1) : token;
-          const numeric = stripped.length > 0 && [...stripped].every((c) => c >= "0" && c <= "9"), index2 = numeric ? Number(stripped) : groupNames.get(stripped);
-          if (index2 !== void 0) {
-            if (numeric) {
-              references.add(index2);
-              numberedReferences = true;
-            }
-            condition = { type: "captureSet", index: index2 };
-            at = end;
-          } else if (stripped !== token) fail("Invalid group name in back reference: " + stripped, at);
-          else condition = alternate();
-          if (source[at++] !== ")") fail("Opening parenthesis without closing parenthesis", at);
-          const yes = sequence();
-          let no = { type: "empty" };
-          if (source[at] === "|") {
-            at++;
-            no = sequence();
-          }
-          if (source[at++] !== ")") fail("Opening parenthesis without closing parenthesis", at);
-          flags = outer;
-          depth--;
-          return { type: "conditional", condition, yes, no };
-        }
-        if (kind === ":" || kind === ">") {
-          at++;
-          capturing = false;
-          atomic = kind === ">";
-        } else if (kind === "=" || kind === "!") {
-          at++;
-          capturing = false;
-          assertion = { positive: kind === "=", behind: false };
-        } else if (kind === "<" && "=!".includes(source[at + 1] ?? "\0")) {
-          at++;
-          capturing = false;
-          assertion = { positive: source[at++] === "=", behind: true };
-        } else if (kind === "<" || source.startsWith("P<", at)) {
-          at += kind === "<" ? 1 : 2;
-          const end = source.indexOf(">", at);
-          if (end < 0) throw new ProgramError("invalid named capture");
-          name = source.slice(at, end);
-          at = end + 1;
-          if (!name || groupNames.has(name) || !/^[\p{L}_][\p{L}\p{N}_]*$/u.test(name)) fail("Could not parse group name", at);
-        } else {
-          let enabled = true, changed = false;
-          while (at < source.length && source[at] !== ")" && source[at] !== ":") {
-            const flag = source[at++];
-            if (flag === "-") {
-              enabled = false;
-              continue;
-            }
-            if (flag === "u" && !enabled) fail("Disabling Unicode not supported", at - 1);
-            if (!"imsxUu".includes(flag)) fail(`Unknown group flag: ${source.slice(atomStart, at)}`, atomStart + 2);
-            changed = true;
-            if (enabled) flags.add(flag);
-            else flags.delete(flag);
-          }
-          if (!changed) throw new ProgramError("invalid regular expression group");
-          if (source[at] === ")") {
-            at++;
-            depth--;
-            return { type: "empty" };
-          }
-          if (source[at++] !== ":") throw new ProgramError("unclosed regular expression group");
-          capturing = false;
-        }
-      }
-      const index = capturing ? ++groupCount : 0;
-      if (name !== void 0) groupNames.set(name, index);
-      const node = alternate();
-      skip();
-      if (source[at] !== ")") fail("Opening parenthesis without closing parenthesis", at);
-      at++;
-      flags = outer;
-      depth--;
-      return atomic ? { type: "atomic", node } : assertion ? { type: "assertion", node, ...assertion } : capturing ? { type: "group", node, index, lastCapture: groupCount } : node;
-    }
-    if (char === "[") return bracket();
-    if (char === "\\") {
-      const accepts = classEscape();
-      if (accepts) return { type: "character", accepts };
-      const escapedChar = source[at];
-      if (escapedChar === "b" || escapedChar === "B" || escapedChar === "<" || escapedChar === ">") {
-        at++;
-        return { type: "boundary", accepts: word, positive: escapedChar !== "B", ...escapedChar === "<" ? { edge: "start" } : escapedChar === ">" ? { edge: "end" } : {} };
-      }
-      if (escapedChar === "A" || escapedChar === "z" || escapedChar === "Z") {
-        at++;
-        return { type: escapedChar === "A" ? "begin" : "end", strict: true, ...escapedChar === "Z" ? { trailingNewlines: true } : {} };
-      }
-      if (escapedChar === "G" || escapedChar === "K") {
-        at++;
-        return { type: escapedChar === "G" ? "continue" : "reset" };
-      }
-      if (escapedChar && escapedChar >= "0" && escapedChar <= "9") {
-        const begin = at++;
-        while (source[at] && source[at] >= "0" && source[at] <= "9") at++;
-        const index = Number(source.slice(begin, at));
-        if (source[begin] === "0" && index !== 0) fail("Invalid back reference", begin);
-        references.add(index);
-        numberedReferences = true;
-        return { type: "backreference", index, ignoreCase: flags.has("i"), fold: simpleCaseFold };
-      }
-      if (escapedChar === "k" || escapedChar === "g") {
-        const open = source[at + 1], close = open === "'" ? "'" : ">", end = source.indexOf(close, at + 2);
-        if (open !== "<" && open !== "'" || end < 0) fail("Could not parse group name", at + 1);
-        if (escapedChar === "g") fail("Regex uses currently unimplemented feature: Subroutine Call", at, true);
-        const name = source.slice(at + 2, end), number = Number(name);
-        const numeric = name.length > 0 && Number.isInteger(number);
-        const index = numeric ? name.startsWith("-") ? groupCount + number + 1 : name.startsWith("+") ? groupCount + number : number : groupNames.get(name);
-        if (index === void 0) fail("Invalid group name in back reference: " + name, at + 1);
-        if (numeric) {
-          references.add(index);
-          numberedReferences = true;
-        }
-        at = end + 1;
-        return { type: "backreference", index, ignoreCase: flags.has("i"), fold: simpleCaseFold };
-      }
-      return literal(escaped());
-    }
-    if (char === ".") {
-      const all = flags.has("s");
-      return { type: "character", accepts: (value) => all || value !== "\n" };
-    }
-    if (char === "^" || char === "$") return { type: char === "^" ? "begin" : "end", multiline: flags.has("m"), strict: true };
-    if ("*+?".includes(char)) fail("Target of repeat operator is invalid", atomStart);
-    return literal(char);
-  };
-  const repeated = () => {
-    let node = atom();
-    skip();
-    const quantifier = source[at], quantifierStart = at;
-    if (quantifier === "*" || quantifier === "+" || quantifier === "?") {
-      if (node.type === "empty") fail("Target of repeat operator is invalid", at);
-      at++;
-      node = { type: "repeat", node, minimum: quantifier === "+" ? 1 : 0, maximum: quantifier === "?" ? 1 : Infinity };
-    } else if (quantifier === "{") {
-      at++;
-      const begin = at;
-      while (source[at] && source[at] >= "0" && source[at] <= "9") at++;
-      const hasMinimum = begin !== at, minimum = Number(source.slice(begin, at));
-      let maximum = minimum;
-      if (source[at] === ",") {
-        const begin2 = ++at;
-        while (source[at] && source[at] >= "0" && source[at] <= "9") at++;
-        maximum = begin2 === at ? Infinity : Number(source.slice(begin2, at));
-      }
-      if (source[at] !== "}" || !hasMinimum && maximum === minimum) {
-        at = quantifierStart;
-        return node;
-      }
-      at++;
-      if (!Number.isSafeInteger(minimum) || maximum !== Infinity && !Number.isSafeInteger(maximum) || maximum < minimum) fail("Regex error: error parsing pattern 0", at, true);
-      if (node.type === "empty") fail("Target of repeat operator is invalid", quantifierStart);
-      node = { type: "repeat", node, minimum, maximum };
-    }
-    if (node.type === "repeat") {
-      node.lazy = flags.has("U");
-      if (source[at] === "?") {
-        node.lazy = !node.lazy;
-        at++;
-      } else if (source[at] === "+") {
-        node = { type: "atomic", node };
-        at++;
-      }
-    }
-    if (source[at] && "*+?".includes(source[at])) fail("Target of repeat operator is invalid", at);
-    return node;
-  };
-  const sequence = () => {
-    const nodes = [];
-    while (at < source.length) {
-      skip();
-      if (at === source.length || source[at] === ")" || source[at] === "|") break;
-      nodes.push(repeated());
-    }
-    return nodes.length ? { type: "sequence", nodes } : { type: "empty" };
-  };
-  const alternate = () => {
-    const nodes = [sequence()];
-    while (source[at] === "|") {
-      at++;
-      nodes.push(sequence());
-    }
-    return nodes.length === 1 ? nodes[0] : { type: "alternate", nodes };
-  };
-  const root = alternate();
-  if (at !== source.length) fail("General parsing error: end of string not reached", at);
-  for (const index of references) if (index <= 0 || index > groupCount) fail(`Invalid back reference to group ${index}`, at, true);
-  if (numberedReferences && groupNames.size) fail("Numbered backref/call not allowed because named group was used, use a named backref instead", at, true);
-  return { root, groupCount, groupNames, depth: peakDepth };
-}
-
-// packages/safe-bash-regex-engine/src/text/regex.ts
-init_platform();
-
-// packages/safe-bash-regex-engine/src/text/replacement-buffer.ts
-init_platform();
-var ReplacementBuffer = class {
-  constructor(budget) {
-    this.budget = budget;
-  }
-  budget;
-  #segments = [];
-  #size = 0;
-  #allocated = 0;
-  #unboundedText = "";
-  get remaining() {
-    return this.budget.maxBufferBytes - this.#size;
-  }
-  admit(length) {
-    this.budget.step(0);
-    if (!Number.isSafeInteger(length) || length < 0 || length > this.remaining) throw new ProgramError("text buffer limit exceeded");
-  }
-  async append(source, start = 0, end = source.length) {
-    this.admit(end - start);
-    if (this.budget.maxBufferBytes === Infinity) {
-      let offset2 = start;
-      while (offset2 < end) {
-        await this.budget.checkpoint();
-        const length = Math.min(end - offset2, 1024);
-        this.budget.step(length);
-        this.budget.step();
-        this.#unboundedText += offset2 === 0 && length === source.length ? source : source.slice(offset2, offset2 + length);
-        this.#size += length;
-        offset2 += length;
-      }
-      return;
-    }
-    let offset = start;
-    while (offset < end) {
-      await this.budget.checkpoint();
-      this.budget.step();
-      const width = source.charCodeAt(offset) <= 255 ? 1 : 2;
-      let length = 1;
-      while (length < 1024 && offset + length < end) {
-        this.budget.step();
-        if ((source.charCodeAt(offset + length) <= 255 ? 1 : 2) !== width) break;
-        length++;
-      }
-      const bytes = length * width;
-      if (bytes > this.budget.maxBufferBytes - this.#allocated) throw new ProgramError("text buffer limit exceeded");
-      this.budget.step(length + 1);
-      const segment = width === 1 ? new Uint8Array(length) : new Uint16Array(length);
-      for (let index = 0; index < length; index++) segment[index] = source.charCodeAt(offset + index);
-      this.#segments.push(segment);
-      this.#allocated += segment.byteLength;
-      this.#size += length;
-      offset += length;
-    }
-  }
-  async finish() {
-    this.budget.step(0);
-    if (!this.#size) return "";
-    this.budget.step(this.#size);
-    await this.budget.checkpoint();
-    this.budget.step(0);
-    if (this.budget.maxBufferBytes === Infinity) {
-      const text = this.#unboundedText;
-      this.clear();
-      return text;
-    }
-    if (this.#segments.length === 1) {
-      const text = String.fromCharCode(...this.#segments[0].subarray(0, this.#size));
-      this.clear();
-      return text;
-    }
-    this.budget.step(this.#size);
-    if (this.#allocated > this.budget.maxBufferBytes || this.#size > this.budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-    const parts = [];
-    let offset = 0;
-    for (const segment of this.#segments) {
-      await this.budget.checkpoint();
-      this.budget.step(0);
-      const length = Math.min(segment.length, this.#size - offset);
-      parts.push(String.fromCharCode(...segment.subarray(0, length)));
-      offset += length;
-    }
-    this.clear();
-    await this.budget.checkpoint();
-    this.budget.step(0);
-    return parts.join("");
-  }
-  clear() {
-    this.#segments = [];
-    this.#size = 0;
-    this.#allocated = 0;
-    this.#unboundedText = "";
-  }
-};
-
-// packages/safe-bash-regex-engine/src/text/regex.ts
-function isWordChar(ch) {
-  if (ch === void 0) return false;
-  const code = ch.charCodeAt(0);
-  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 95;
-}
-function matchesBoundary(instruction, text, position) {
-  const before = position > 0 && instruction.accepts(text[position - 1]);
-  const after = position < text.length && instruction.accepts(text[position]);
-  const boundary = instruction.edge === "start" ? !before && after : instruction.edge === "end" ? before && !after : before !== after;
-  return boundary === instruction.positive;
-}
-function instructionCounts(root) {
-  const counts = /* @__PURE__ */ new Map();
-  const pending = [{ node: root, visited: false }];
-  while (pending.length) {
-    const { node, visited } = pending.pop();
-    if (!visited) {
-      pending.push({ node, visited: true });
-      if (node.type === "group" || node.type === "assertion" || node.type === "repeat" || node.type === "atomic")
-        pending.push({ node: node.node, visited: false });
-      else if (node.type === "conditional") {
-        pending.push({ node: node.no, visited: false }, { node: node.yes, visited: false }, { node: node.condition, visited: false });
-      } else if (node.type === "sequence" || node.type === "alternate")
-        for (let index = node.nodes.length - 1; index >= 0; index--)
-          pending.push({ node: node.nodes[index], visited: false });
-      continue;
-    }
-    let size;
-    if (node.type === "empty") size = 0;
-    else if (node.type === "group" || node.type === "assertion" || node.type === "atomic") size = 2 + counts.get(node.node);
-    else if (node.type === "conditional") size = 3 + counts.get(node.condition) + counts.get(node.yes) + counts.get(node.no);
-    else if (node.type === "sequence" || node.type === "alternate") {
-      size = node.type === "alternate" ? 2 * (node.nodes.length - 1) : 0;
-      for (const child of node.nodes) size += counts.get(child);
-      if (node.type === "sequence") node.nodes = node.nodes.filter((child) => counts.get(child) > 0);
-    } else if (node.type === "repeat") {
-      const child = counts.get(node.node);
-      size = node.maximum === 0 ? 0 : node.maximum === Infinity ? child * (node.minimum + 1) + 2 : child * node.maximum + node.maximum - node.minimum;
-    } else size = 1;
-    counts.set(node, Number.isSafeInteger(size) ? size : Infinity);
-  }
-  return counts;
-}
-function* compileProgram(root, counts, ignoreCase) {
-  const code = [];
-  const emit = (instruction) => code.push(instruction) - 1;
-  const pending = [{ node: root, index: 0 }];
-  while (pending.length) {
-    const frame = pending[pending.length - 1];
-    const node = frame.node;
-    if (counts.get(node) === 0) {
-      pending.pop();
-      continue;
-    }
-    yield;
-    if (node.type === "sequence") {
-      if (frame.index < node.nodes.length) pending.push({ node: node.nodes[frame.index++], index: 0 });
-      else pending.pop();
-    } else if (node.type === "group") {
-      if (frame.index++ === 0) {
-        emit({
-          kind: "save",
-          slot: node.index * 2,
-          ...node.lastCapture > node.index ? { clearUntil: (node.lastCapture + 1) * 2 } : {}
-        });
-        pending.push({ node: node.node, index: 0 });
-      } else {
-        emit({ kind: "save", slot: node.index * 2 + 1 });
-        pending.pop();
-      }
-    } else if (node.type === "conditional") {
-      if (frame.index === 0) {
-        frame.start = emit({ kind: "conditional", first: code.length + 1, yes: 0, no: 0 });
-        frame.index = 1;
-        pending.push({ node: node.condition, index: 0 });
-      } else if (frame.index === 1) {
-        emit({ kind: "match" });
-        code[frame.start].yes = code.length;
-        frame.index = 2;
-        pending.push({ node: node.yes, index: 0 });
-      } else if (frame.index === 2) {
-        frame.jump = emit({ kind: "jump", target: 0 });
-        code[frame.start].no = code.length;
-        frame.index = 3;
-        pending.push({ node: node.no, index: 0 });
-      } else {
-        code[frame.jump].target = code.length;
-        pending.pop();
-      }
-    } else if (node.type === "assertion" || node.type === "atomic") {
-      if (frame.index++ === 0) {
-        frame.start = emit(node.type === "assertion" ? { kind: "assertion", first: code.length + 1, next: 0, positive: node.positive, behind: node.behind } : { kind: "atomic", first: code.length + 1, next: 0 });
-        pending.push({ node: node.node, index: 0 });
-      } else {
-        emit({ kind: "match" });
-        code[frame.start].next = code.length;
-        pending.pop();
-      }
-    } else if (node.type === "alternate") {
-      if (frame.awaiting) {
-        if (frame.index < node.nodes.length) {
-          (frame.jumps ??= []).push(emit({ kind: "jump", target: 0 }));
-          code[frame.start].second = code.length;
-        }
-        frame.awaiting = false;
-      }
-      if (frame.index === node.nodes.length) {
-        for (const jump of frame.jumps ?? []) code[jump].target = code.length;
-        pending.pop();
-      } else {
-        if (frame.index < node.nodes.length - 1) frame.start = emit({ kind: "split", first: code.length + 1, second: 0 });
-        frame.awaiting = true;
-        pending.push({ node: node.nodes[frame.index++], index: 0 });
-      }
-    } else if (node.type === "repeat") {
-      if (frame.start !== void 0) {
-        if (node.maximum === Infinity) emit({ kind: "jump", target: frame.start });
-        const split = code[frame.start];
-        split.second = code.length;
-        if (node.lazy) [split.first, split.second] = [split.second, split.first];
-        frame.start = void 0;
-        if (node.maximum === Infinity) {
-          pending.pop();
-          continue;
-        }
-      }
-      if (counts.get(node.node) === 0) frame.index = Math.max(frame.index, node.minimum);
-      if (frame.index < node.minimum) {
-        frame.index++;
-        pending.push({ node: node.node, index: 0 });
-      } else if (frame.index < node.maximum) {
-        frame.index++;
-        frame.start = emit({ kind: "split", first: code.length + 1, second: 0 });
-        pending.push({ node: node.node, index: 0 });
-      } else pending.pop();
-    } else {
-      if (node.type === "character") emit({ kind: "character", ...node.literal !== void 0 ? { literal: node.literal } : {}, accepts: node.accepts });
-      else if (node.type === "backreference") emit({ kind: "backreference", index: node.index, ignoreCase: node.ignoreCase ?? ignoreCase, ...node.fold ? { fold: node.fold } : {} });
-      else if (node.type === "boundary") emit({ kind: "boundary", accepts: node.accepts, positive: node.positive, ...node.edge ? { edge: node.edge } : {} });
-      else if (node.type === "continue") emit({ kind: "continue" });
-      else if (node.type === "reset") emit({ kind: "save", slot: 0 });
-      else if (node.type === "captureSet") emit({ kind: "captureSet", index: node.index });
-      else if (node.type === "begin" || node.type === "end") emit({ kind: node.type, ...node.multiline === void 0 ? {} : { multiline: node.multiline }, ...node.strict === void 0 ? {} : { strict: node.strict }, ...node.trailingNewlines ? { trailingNewlines: true } : {} });
-      else throw new ProgramError("invalid internal regular expression node");
-      pending.pop();
-    }
-  }
-  emit({ kind: "match" });
-  return code;
-}
-var classes = {
-  alpha: (character) => /^[A-Za-z]$/u.test(character),
-  alnum: (character) => /^[A-Za-z0-9]$/u.test(character),
-  digit: (character) => /^[0-9]$/u.test(character),
-  lower: (character) => /^[a-z]$/u.test(character),
-  upper: (character) => /^[A-Z]$/u.test(character),
-  xdigit: (character) => /^[A-Fa-f0-9]$/u.test(character),
-  space: (character) => /^[ \t\n\r\v\f]$/u.test(character),
-  blank: (character) => character === " " || character === "	",
-  cntrl: (character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127,
-  graph: (character) => character.charCodeAt(0) >= 33 && character.charCodeAt(0) <= 126,
-  print: (character) => character.charCodeAt(0) >= 32 && character.charCodeAt(0) <= 126,
-  punct: (character) => /^[!-/:-@[-`{-~]$/u.test(character)
-};
-function extendedSource(source) {
-  let result = "";
-  let bracket = false;
-  let bracketFirst = false;
-  for (let offset = 0; offset < source.length; offset++) {
-    const character = source[offset];
-    if (!bracket && character === "\\" && offset + 1 < source.length) {
-      const next = source[++offset];
-      result += "()|+?{}".includes(next) ? next : `\\${next}`;
-    } else if (bracket) {
-      if (bracketFirst && character === "^") {
-        result += character;
-        continue;
-      }
-      if (bracketFirst && character === "]") {
-        result += character;
-        bracketFirst = false;
-        continue;
-      }
-      bracketFirst = false;
-      if (character === "[" && (source[offset + 1] === ":" || source[offset + 1] === "." || source[offset + 1] === "=")) {
-        const kind = source[offset + 1];
-        const close = source.indexOf(`${kind}]`, offset + 2);
-        if (close >= 0) {
-          result += source.slice(offset, close + 2);
-          offset = close + 1;
-          continue;
-        }
-      }
-      if (character === "]") bracket = false;
-      result += character;
-    } else {
-      if (character === "[") {
-        bracket = true;
-        bracketFirst = true;
-      }
-      result += "()|+?{}".includes(character) ? `\\${character}` : character;
-    }
-  }
-  return result;
-}
-function makeAsciiTable(accepts) {
-  const ascii = new Uint8Array(128);
-  for (let c = 0; c < 128; c++) {
-    if (accepts(String.fromCharCode(c))) ascii[c] = 1;
-  }
-  return ascii;
-}
-function buildChainMatch(root, groupCount) {
-  if (root.type !== "sequence" || groupCount > 9) return void 0;
-  let startIdx = 0;
-  let endIdx = root.nodes.length;
-  let anchoredStart = false;
-  let anchoredEnd = false;
-  if (startIdx < endIdx && root.nodes[startIdx]?.type === "begin") {
-    anchoredStart = true;
-    startIdx++;
-  }
-  if (startIdx < endIdx && root.nodes[endIdx - 1]?.type === "end") {
-    anchoredEnd = true;
-    endIdx--;
-  }
-  if (startIdx >= endIdx) return void 0;
-  const steps = [];
-  let hasRepeat = false;
-  for (let i = startIdx; i < endIdx; i++) {
-    let n = root.nodes[i];
-    let group = 0;
-    if (n.type === "group") {
-      group = n.index;
-      n = n.node.type === "sequence" && n.node.nodes.length === 1 ? n.node.nodes[0] : n.node;
-    }
-    if (n.type === "character") {
-      if (n.literal !== void 0) {
-        const prev = steps[steps.length - 1];
-        if (group === 0 && prev && prev.kind === "literal" && prev.group === 0) {
-          prev.value += n.literal;
-        } else {
-          steps.push({ kind: "literal", value: n.literal, group });
-        }
-      } else {
-        steps.push({ kind: "char", accepts: n.accepts, ascii: makeAsciiTable(n.accepts), group });
-      }
-    } else if (n.type === "repeat" && n.minimum >= 0 && n.maximum === Infinity && !n.lazy && n.node.type === "character") {
-      hasRepeat = true;
-      steps.push({ kind: "repeat", minimum: n.minimum, accepts: n.node.accepts, ascii: makeAsciiTable(n.node.accepts), group });
-    } else {
-      return void 0;
-    }
-  }
-  const first = steps[0];
-  if (!first) return void 0;
-  const hasLiteralPrefix = first.kind === "literal" && first.value.length > 0;
-  const hasRepeatHead = first.kind === "repeat" && first.minimum >= 1;
-  if (!hasLiteralPrefix && !hasRepeatHead) return void 0;
-  for (let s = 0; s < steps.length; s++) {
-    const step = steps[s];
-    if (step.kind === "repeat") {
-      if (s < steps.length - 1) {
-        const next = steps[s + 1];
-        if (next.kind !== "literal" || next.value.length === 0 || step.accepts(next.value[0])) return void 0;
-      }
-      if (!anchoredStart && hasLiteralPrefix) {
-        for (let k = 0; k < first.value.length; k++) {
-          if (step.accepts(first.value[k])) return void 0;
-        }
-      }
-    }
-  }
-  if (!hasRepeat && steps.length < 2) return void 0;
-  return { prefix: hasLiteralPrefix ? first.value : "", anchoredStart, anchoredEnd, steps };
-}
-function matchChainAt(steps, prefixLen, anchoredEnd, text, startPos, outOffsets, groupCount, textEnd = text.length, startStep = 1) {
-  for (let g = 1; g <= groupCount; g++) {
-    outOffsets[g * 2] = -1;
-    outOffsets[g * 2 + 1] = -1;
-  }
-  let cursor = startStep === 1 ? startPos + prefixLen : startPos;
-  for (let s = startStep; s < steps.length; s++) {
-    const step = steps[s];
-    const stepStart = cursor;
-    if (step.kind === "literal") {
-      const val = step.value;
-      if (cursor + val.length > textEnd) return -1;
-      for (let k = 0; k < val.length; k++) {
-        if (text.charCodeAt(cursor + k) !== val.charCodeAt(k)) return -1;
-      }
-      cursor += val.length;
-    } else if (step.kind === "char") {
-      if (cursor >= textEnd) return -1;
-      const code = text.charCodeAt(cursor);
-      if (code < 128 ? step.ascii[code] === 0 : !step.accepts(text[cursor])) return -1;
-      cursor++;
-    } else {
-      while (cursor < textEnd) {
-        const code = text.charCodeAt(cursor);
-        if (code < 128 ? step.ascii[code] === 0 : !step.accepts(text[cursor])) break;
-        cursor++;
-      }
-      if (cursor - stepStart < step.minimum) return -1;
-    }
-    if (step.group > 0) {
-      outOffsets[step.group * 2] = stepStart;
-      outOffsets[step.group * 2 + 1] = cursor;
-    }
-  }
-  if (anchoredEnd && cursor !== textEnd) return -1;
-  outOffsets[0] = startPos;
-  outOffsets[1] = cursor;
-  return cursor;
-}
-var NfaStorage = class {
-  constructor(budget) {
-    this.budget = budget;
-  }
-  budget;
-  used = 0;
-  reserve(bytes) {
-    this.budget.step(0);
-    if (!Number.isSafeInteger(bytes) || bytes < 0 || bytes > this.budget.maxBufferBytes - this.used) {
-      throw new ProgramError("regular expression state buffer limit exceeded");
-    }
-    this.used += bytes;
-  }
-  release(bytes) {
-    if (!Number.isSafeInteger(bytes) || bytes < 0 || bytes > this.used) throw new ProgramError("invalid regular expression state accounting");
-    this.used -= bytes;
-  }
-  clear() {
-    this.used = 0;
-  }
-};
-var Pattern = class {
-  constructor(source, extended = true, ignoreCase = false, dialect = "sed", modifiers = "", limits = {}) {
-    this.ignoreCase = ignoreCase;
-    this.dialect = dialect;
-    this.modifiers = modifiers;
-    this.sourceLength = source.length;
-    const prefix = dialect === "jq" || dialect === "rust" ? dialect + " " : "";
-    const maximumInstructions = limits.maxPatternInstructions ?? Infinity;
-    if ([maximumInstructions, limits.maxPatternSource ?? Infinity, limits.maxPatternDepth ?? Infinity].some((value) => value !== Infinity && (!Number.isSafeInteger(value) || value < 1))) throw new ProgramError("limits must be positive safe integers");
-    if (source.length > (limits.maxPatternSource ?? Infinity)) throw new ProgramError(`${prefix}regular expression source limit exceeded`);
-    if (dialect === "rust") {
-      const parsed = parseRustPattern(source, ignoreCase, limits.maxPatternDepth), counts2 = instructionCounts(parsed.root);
-      if (!Number.isSafeInteger(counts2.get(parsed.root) + 1) || counts2.get(parsed.root) + 1 > maximumInstructions) throw new ProgramError(`${prefix}regular expression program limit exceeded`);
-      this.patternDepth = parsed.depth;
-      this.instructionCount = counts2.get(parsed.root) + 1;
-      this.groupCount = parsed.groupCount;
-      for (const [name, index] of parsed.groupNames) this.groupNames.set(name, index);
-      this.anchored = false;
-      this.parsed = { root: parsed.root, counts: counts2 };
-      return;
-    }
-    if (!extended) source = extendedSource(source);
-    let offset = 0;
-    let groups = 0;
-    const closedGroups = /* @__PURE__ */ new Set();
-    const characterNode = (character) => ({
-      type: "character",
-      ...ignoreCase ? {} : { literal: character },
-      accepts: (candidate) => ignoreCase ? candidate.toLowerCase() === character.toLowerCase() : candidate === character
-    });
-    const escaped = () => {
-      const character = source[offset++];
-      if (character === void 0) throw new ProgramError("trailing backslash in regular expression");
-      if (dialect === "awk") {
-        const octal = "01234567".includes(character);
-        if (octal || character === "x") {
-          let digits = octal ? character : "";
-          const alphabet = octal ? "01234567" : "0123456789abcdefABCDEF";
-          while (digits.length < (octal ? 3 : 2) && offset < source.length && alphabet.includes(source[offset])) digits += source[offset++];
-          return digits ? String.fromCharCode(parseInt(digits, octal ? 8 : 16) & 255) : character;
-        }
-        if (character === "b") return "\b";
-      }
-      if (dialect === "sed" && /^[1-9]$/u.test(character)) throw new ProgramError("pattern backreferences are not supported");
-      const control = { n: "\n", t: "	", r: "\r", f: "\f", v: "\v", a: "\x07" };
-      return control[character] ?? character;
-    };
-    const bracket = () => {
-      const negate = source[offset] === "^";
-      if (negate) offset++;
-      const tests = [];
-      let first = true;
-      while (offset < source.length && (source[offset] !== "]" || first)) {
-        first = false;
-        if (source.startsWith("[:", offset)) {
-          const end = source.indexOf(":]", offset + 2);
-          const name = end < 0 ? "" : source.slice(offset + 2, end);
-          if (!classes[name]) throw new ProgramError(`unsupported character class '${name}'`);
-          tests.push(classes[name]);
-          offset = end + 2;
-          continue;
-        }
-        if (source.startsWith("[.", offset) || source.startsWith("[=", offset)) throw new ProgramError("collating and equivalence classes are not supported");
-        const readBracketChar = () => {
-          const ch = source[offset++];
-          if (ch !== "\\") return ch;
-          if (dialect === "sed") {
-            const next = source[offset];
-            if (next !== void 0 && "ntrfva".includes(next)) return escaped();
-            return "\\";
-          }
-          if (dialect === "awk" && source[offset] !== void 0 && /^[1-9]$/u.test(source[offset])) {
-            return escaped();
-          }
-          return escaped();
-        };
-        const start = readBracketChar();
-        if (source[offset] === "-" && source[offset + 1] !== "]" && source[offset + 1] !== void 0) {
-          offset++;
-          const end = readBracketChar();
-          if (start > end) throw new ProgramError("reversed character range");
-          tests.push((character) => character >= start && character <= end);
-        } else tests.push((character) => character === start);
-      }
-      if (source[offset++] !== "]") throw new ProgramError("unterminated bracket expression");
-      return { type: "character", accepts: (character) => {
-        const accepted = tests.some((test) => test(character) || ignoreCase && (test(character.toLowerCase()) || test(character.toUpperCase())));
-        return negate ? !accepted : accepted;
-      } };
-    };
-    const atom = (atStart, afterBegin) => {
-      const token = dialect === "jq" && offset < source.length ? String.fromCodePoint(source.codePointAt(offset)) : source[offset];
-      offset += token?.length ?? 1;
-      if (token === "[") return bracket();
-      if (token === "\\") {
-        const reference = source[offset];
-        if ((dialect === "sed" || dialect === "jq") && reference !== void 0 && /^[1-9]$/u.test(reference)) {
-          const index = Number(reference);
-          if (!closedGroups.has(index)) throw new ProgramError("pattern references an undefined or open capture group");
-          offset++;
-          return { type: "backreference", index };
-        }
-        if (reference !== void 0 && "bByY<>".includes(reference)) {
-          offset++;
-          if (dialect === "awk" && reference === "b") {
-            return characterNode("\b");
-          }
-          return {
-            type: "boundary",
-            accepts: isWordChar,
-            positive: reference !== "B" && reference !== "Y",
-            ...reference === "<" ? { edge: "start" } : reference === ">" ? { edge: "end" } : {}
-          };
-        }
-        if ((dialect === "jq" || dialect === "sed" || dialect === "awk") && reference !== void 0 && "dDsSwW".includes(reference)) {
-          offset++;
-          const alphabet = reference.toLowerCase();
-          return { type: "character", accepts: (character) => {
-            const accepted = alphabet === "d" ? character >= "0" && character <= "9" : alphabet === "s" ? " 	\n\r\f\v".includes(character) : character >= "a" && character <= "z" || character >= "A" && character <= "Z" || character >= "0" && character <= "9" || character === "_";
-            return reference === alphabet ? accepted : !accepted;
-          } };
-        }
-        return characterNode(escaped());
-      }
-      if (token === ".") return { type: "character", accepts: (character) => dialect !== "jq" || modifiers.includes("m") || character !== "\n" };
-      if (token === "^") return extended || atStart ? { type: "begin" } : characterNode(token);
-      if (token === "$") return extended || offset === source.length || source[offset] === ")" || source[offset] === "|" ? { type: "end" } : characterNode(token);
-      if (token === "*" && !extended && (atStart || afterBegin)) return characterNode(token);
-      if (token === void 0 || "*+?{}".includes(token)) throw new ProgramError("quantifier without an expression");
-      return characterNode(token);
-    };
-    const repeated = (original) => {
-      let node = original;
-      if (!extended && (node.type === "begin" || node.type === "end")) return node;
-      const quantifier = source[offset];
-      if (quantifier === "*" || quantifier === "+" || quantifier === "?") {
-        offset++;
-        node = { type: "repeat", node, minimum: quantifier === "+" ? 1 : 0, maximum: quantifier === "?" ? 1 : Infinity };
-      } else if (quantifier === "{") {
-        const match = /^\{([0-9]+)(?:,([0-9]*))?\}/u.exec(source.slice(offset));
-        if (!match) throw new ProgramError("invalid repetition interval");
-        const minimum = Number(match[1]);
-        const maximum = match[2] === void 0 ? minimum : match[2] === "" ? Infinity : Number(match[2]);
-        if (!Number.isSafeInteger(minimum) || maximum !== Infinity && !Number.isSafeInteger(maximum) || maximum < minimum) throw new ProgramError("invalid or excessive repetition interval");
-        offset += match[0].length;
-        node = { type: "repeat", node, minimum, maximum };
-      }
-      if (dialect === "jq" && node.type === "repeat" && source[offset] === "?") {
-        node.lazy = true;
-        offset++;
-      }
-      if (source[offset] !== void 0 && "*+?{".includes(source[offset])) throw new ProgramError("nested quantifier is not supported");
-      return node;
-    };
-    const frames = [{ nodes: [], alternatives: [], index: 0 }];
-    const sequence = (nodes) => nodes.length ? { type: "sequence", nodes } : { type: "empty" };
-    const finish = (frame) => {
-      frame.alternatives.push(sequence(frame.nodes));
-      return frame.alternatives.length === 1 ? frame.alternatives[0] : { type: "alternate", nodes: frame.alternatives };
-    };
-    while (offset < source.length) {
-      const frame = frames[frames.length - 1];
-      if (source[offset] === "|") {
-        offset++;
-        frame.alternatives.push(sequence(frame.nodes));
-        frame.nodes = [];
-      } else if (source[offset] === ")") {
-        if (frames.length === 1) throw new ProgramError("unmatched ')' in regular expression");
-        offset++;
-        const inner = finish(frame);
-        frames.pop();
-        closedGroups.add(frame.index);
-        const node = frame.assertion ? { type: "assertion", node: inner, ...frame.assertion } : frame.index ? { type: "group", index: frame.index, lastCapture: groups, node: inner } : inner;
-        frames[frames.length - 1].nodes.push(repeated(node));
-      } else if (source[offset] === "(") {
-        if (frames.length > (limits.maxPatternDepth ?? Infinity)) throw new ProgramError(`${prefix}regular expression depth limit exceeded`);
-        this.patternDepth = Math.max(this.patternDepth, frames.length);
-        offset++;
-        let name;
-        let capturing = true;
-        let assertion;
-        if (source[offset] === "?" && source[offset + 1] === ":") {
-          offset += 2;
-          capturing = false;
-        } else if (dialect === "jq" && source[offset] === "?") {
-          offset++;
-          if (source[offset] === ":") {
-            offset++;
-            capturing = false;
-          } else if (source[offset] === "=" || source[offset] === "!") {
-            assertion = { positive: source[offset++] === "=", behind: false };
-            capturing = false;
-          } else if (source[offset] === "<" && "=!".includes(source[offset + 1] ?? "")) {
-            offset++;
-            assertion = { positive: source[offset++] === "=", behind: true };
-            capturing = false;
-          } else if (source[offset] === "<" && !"=!".includes(source[offset + 1] ?? "")) {
-            const end = source.indexOf(">", ++offset);
-            if (end < 0) throw new ProgramError("invalid named capture");
-            name = source.slice(offset, end);
-            offset = end + 1;
-          } else throw new ProgramError("unsupported jq regular expression group");
-        }
-        const index = capturing ? ++groups : 0;
-        if (name !== void 0) this.groupNames.set(name, index);
-        frames.push({ nodes: [], alternatives: [], index, assertion });
-      } else {
-        frame.nodes.push(repeated(atom(frame.nodes.length === 0, frame.nodes.length === 1 && frame.nodes[0].type === "begin")));
-      }
-    }
-    if (frames.length !== 1) throw new ProgramError("unmatched '(' in regular expression");
-    const root = finish(frames[0]);
-    this.groupCount = groups;
-    this.anchored = root.type === "sequence" && root.nodes[0]?.type === "begin";
-    const counts = instructionCounts(root);
-    if (!Number.isSafeInteger(counts.get(root) + 1)) throw new ProgramError(`${prefix}regular expression program size is not representable`);
-    if (counts.get(root) + 1 > maximumInstructions) throw new ProgramError(`${prefix}regular expression program limit exceeded`);
-    this.instructionCount = counts.get(root) + 1;
-    this.parsed = { root, counts };
-    if (counts.get(root) <= 64) {
-      this.compileFromParsedSync();
-    }
-  }
-  ignoreCase;
-  dialect;
-  modifiers;
-  groupCount;
-  groupNames = /* @__PURE__ */ new Map();
-  code = [];
-  compiledSteps = 0;
-  sourceLength = 0;
-  patternDepth = 0;
-  instructionCount;
-  budgetPrepared = false;
-  parsed;
-  anchored;
-  linear = false;
-  literalMatch;
-  simpleRepeatMatch;
-  chainMatch;
-  backreferences = false;
-  trailingNewlineAnchor = false;
-  fastPrefixInfo;
-  assertInstructionLimit(budget) {
-    if (this.sourceLength > (budget.options?.maxPatternSource ?? Infinity)) throw new ProgramError("regular expression source limit exceeded");
-    if (this.patternDepth > (budget.options?.maxPatternDepth ?? Infinity)) throw new ProgramError("regular expression depth limit exceeded");
-    if (this.instructionCount > (budget.options?.maxPatternInstructions ?? Infinity)) throw new ProgramError(`${this.dialect === "jq" ? "jq " : ""}regular expression program limit exceeded`);
-  }
-  compileFromParsedSync() {
-    if (!this.parsed) return;
-    const { root, counts } = this.parsed;
-    this.compiledSteps = counts.get(root) + 1;
-    const compilation = compileProgram(root, counts, this.ignoreCase);
-    let result = compilation.next();
-    while (!result.done) result = compilation.next();
-    this.finalizeCompiledCode(result.value, root);
-  }
-  async prepare(budget) {
-    this.assertInstructionLimit(budget);
-    if (!this.parsed) {
-      if (!this.budgetPrepared && this.compiledSteps > 0) {
-        budget.step(this.compiledSteps);
-        const pending = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
-        if (pending) await pending;
-        this.budgetPrepared = true;
-      }
-      return;
-    }
-    const { root, counts } = this.parsed;
-    budget.step(counts.get(root) + 1);
-    await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
-    const compilation = compileProgram(root, counts, this.ignoreCase);
-    let result = compilation.next();
-    let work = 0;
-    while (!result.done) {
-      if (++work % 64 === 0) {
-        await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
-        budget.step(0);
-      }
-      result = compilation.next();
-    }
-    await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
-    budget.step(0);
-    this.budgetPrepared = true;
-    this.finalizeCompiledCode(result.value, root);
-  }
-  finalizeCompiledCode(code, root) {
-    this.linear = code.every((instruction) => instruction.kind === "character" || instruction.kind === "begin" || instruction.kind === "end" || instruction.kind === "match");
-    if (this.linear && !this.ignoreCase && this.dialect !== "jq" && this.dialect !== "rust") {
-      let validLiteral = true;
-      let anchoredStart = false;
-      let anchoredEnd = false;
-      let literalValue = "";
-      for (let i = 0; i < code.length - 1; i++) {
-        const inst = code[i];
-        if (inst.kind === "begin") {
-          if (i === 0) anchoredStart = true;
-          else {
-            validLiteral = false;
-            break;
-          }
-        } else if (inst.kind === "end") {
-          if (i === code.length - 2) anchoredEnd = true;
-          else {
-            validLiteral = false;
-            break;
-          }
-        } else if (inst.kind === "character" && inst.literal !== void 0) {
-          literalValue += inst.literal;
-        } else {
-          validLiteral = false;
-          break;
-        }
-      }
-      if (validLiteral) {
-        this.literalMatch = { value: literalValue, anchoredStart, anchoredEnd, groups: [literalValue] };
-        this.fastPrefixInfo = { anchoredStart, anchoredEnd, prefix: literalValue };
-      }
-    } else if (!this.ignoreCase && this.dialect !== "jq" && this.dialect !== "rust" && root.type === "sequence" && this.groupCount <= 1) {
-      let startIdx = 0;
-      let endIdx = root.nodes.length;
-      let anchoredStart = false;
-      let anchoredEnd = false;
-      if (startIdx < endIdx && root.nodes[startIdx]?.type === "begin") {
-        anchoredStart = true;
-        startIdx++;
-      }
-      if (startIdx < endIdx && root.nodes[endIdx - 1]?.type === "end") {
-        anchoredEnd = true;
-        endIdx--;
-      }
-      if (startIdx < endIdx) {
-        let prefix = "";
-        let prefixValid = true;
-        for (let i = startIdx; i < endIdx - 1; i++) {
-          const n = root.nodes[i];
-          if (n.type === "character" && n.literal !== void 0) {
-            prefix += n.literal;
-          } else {
-            prefixValid = false;
-            break;
-          }
-        }
-        const tail = root.nodes[endIdx - 1];
-        const captured = tail.type === "group" && tail.index === 1 && this.groupCount === 1;
-        const rawInner = captured ? tail.node : this.groupCount === 0 ? tail : void 0;
-        const repeatNode = rawInner?.type === "sequence" && rawInner.nodes.length === 1 ? rawInner.nodes[0] : rawInner;
-        if (prefixValid && repeatNode?.type === "repeat" && (repeatNode.minimum >= 1 || prefix.length > 0 || anchoredStart) && repeatNode.maximum === Infinity && !repeatNode.lazy && repeatNode.node.type === "character") {
-          const acceptsFn = repeatNode.node.accepts;
-          const ascii = new Uint8Array(128);
-          for (let c = 0; c < 128; c++) {
-            if (acceptsFn(String.fromCharCode(c))) ascii[c] = 1;
-          }
-          this.simpleRepeatMatch = {
-            prefix,
-            anchoredStart,
-            anchoredEnd,
-            captured,
-            minimum: repeatNode.minimum,
-            accepts: acceptsFn,
-            ascii
-          };
-          if (anchoredStart || prefix.length > 0) {
-            this.fastPrefixInfo = { anchoredStart, anchoredEnd, prefix };
-          }
-        }
-      }
-    }
-    if (!this.ignoreCase && this.dialect !== "jq" && this.dialect !== "rust" && !this.literalMatch && !this.simpleRepeatMatch) {
-      const cm = buildChainMatch(root, this.groupCount);
-      if (cm) {
-        this.chainMatch = cm;
-        this.fastPrefixInfo = { anchoredStart: cm.anchoredStart, anchoredEnd: cm.anchoredEnd, prefix: cm.prefix };
-      }
-    }
-    this.backreferences = code.some((instruction) => instruction.kind === "backreference");
-    this.trailingNewlineAnchor = code.some((instruction) => instruction.kind === "end" && instruction.trailingNewlines);
-    this.code = code;
-    this.parsed = void 0;
-  }
-  async findJq(text, budget, from, options = { pc: 0 }) {
-    const continuation = options.continuation ?? from;
-    let trailingStart = text.length;
-    if (this.trailingNewlineAnchor) while (trailingStart > 0 && text[trailingStart - 1] === "\n") {
-      budget.step();
-      trailingStart--;
-      if (trailingStart % 64 === 0) await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
-    }
-    for (let start = from; start <= (options.end ?? text.length) && (!options.exact || start === from); start += (text.codePointAt(start) ?? 0) > 65535 ? 2 : 1) {
-      const pending = [{ pc: options.pc, position: start, captures: options.captures ?? [] }];
-      const visited = /* @__PURE__ */ new Set();
-      let storage = 0;
-      let checkpoints = 0;
-      while (pending.length) {
-        if (++checkpoints % 64 === 1) await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
-        budget.step();
-        const state = pending.pop();
-        if (options.end !== void 0 && state.position > options.end) continue;
-        const key = `${state.pc}:${state.position}:${state.captures.join(",")}`;
-        if (visited.has(key)) continue;
-        storage += key.length * 2 + 64;
-        if (storage > budget.maxBufferBytes) throw new ProgramError("regular expression state buffer limit exceeded");
-        visited.add(key);
-        const instruction = this.code[state.pc];
-        const { position, captures } = state;
-        const push = (pc, next = position, saved = captures) => {
-          if ((pending.length + 1) * (64 + (this.groupCount + 1) * 16) + storage > budget.maxBufferBytes) throw new ProgramError("regular expression state buffer limit exceeded");
-          pending.push({ pc, position: next, captures: saved });
-        };
-        if (instruction.kind === "match") {
-          if (options.end !== void 0 && position !== options.end) continue;
-          if (this.modifiers.includes("n") && position === start) continue;
-          const matchStart = captures[0] ?? start;
-          const groups = [text.slice(matchStart, position)];
-          for (let index = 1; index <= this.groupCount; index++) {
-            budget.step();
-            groups.push(captures[index * 2] === void 0 ? void 0 : text.slice(captures[index * 2], captures[index * 2 + 1]));
-          }
-          return { match: { start: matchStart, end: position, groups }, captures };
-        }
-        if (instruction.kind === "conditional") {
-          const result = await this.findJq(text, budget, position, { pc: instruction.first, exact: true, captures, continuation });
-          if (result) push(instruction.yes, result.match.end, result.captures);
-          else push(instruction.no);
-        } else if (instruction.kind === "atomic") {
-          const result = await this.findJq(text, budget, position, { pc: instruction.first, exact: true, captures, continuation });
-          if (result) push(instruction.next, result.match.end, result.captures);
-        } else if (instruction.kind === "assertion") {
-          const result = await this.findJq(
-            text,
-            budget,
-            instruction.behind ? 0 : position,
-            instruction.behind ? { pc: instruction.first, end: position, captures, continuation } : { pc: instruction.first, exact: true, captures, continuation }
-          );
-          if (Boolean(result) === instruction.positive) push(instruction.next, position, result?.captures ?? captures);
-        } else if (instruction.kind === "jump") push(instruction.target);
-        else if (instruction.kind === "split") {
-          push(instruction.second);
-          push(instruction.first);
-        } else if (instruction.kind === "save") {
-          const saved = [...captures];
-          for (let slot = instruction.slot + 2; slot < Math.min(instruction.clearUntil ?? 0, saved.length); slot++) delete saved[slot];
-          saved[instruction.slot] = position;
-          push(state.pc + 1, position, saved);
-        } else if (instruction.kind === "continue") {
-          if (position === continuation) push(state.pc + 1);
-        } else if (instruction.kind === "captureSet") {
-          if (captures[instruction.index * 2] !== void 0) push(state.pc + 1);
-        } else if (instruction.kind === "begin") {
-          if (position === 0 || instruction.multiline && text[position - 1] === "\n") push(state.pc + 1);
-        } else if (instruction.kind === "end") {
-          if (position === text.length || instruction.trailingNewlines && position >= trailingStart || (instruction.multiline || !instruction.strict && position === text.length - 1) && text[position] === "\n") push(state.pc + 1);
-        } else if (instruction.kind === "boundary") {
-          const previous = position > 1 && text.codePointAt(position - 2) > 65535 ? text.slice(position - 2, position) : text.slice(position - 1, position);
-          const next = text.codePointAt(position), current = next === void 0 ? "" : String.fromCodePoint(next);
-          const before = position > 0 && instruction.accepts(previous), after = Boolean(current) && instruction.accepts(current);
-          const boundary = instruction.edge === "start" ? !before && after : instruction.edge === "end" ? before && !after : before !== after;
-          if (boundary === instruction.positive) push(state.pc + 1);
-        } else if (instruction.kind === "character") {
-          const code = text.codePointAt(position);
-          if (code !== void 0) {
-            const character = String.fromCodePoint(code);
-            if (instruction.accepts(character)) push(state.pc + 1, position + character.length);
-          }
-        } else if (instruction.kind === "backreference") {
-          const begin = captures[instruction.index * 2];
-          const end = captures[instruction.index * 2 + 1];
-          if (begin !== void 0 && end !== void 0) {
-            const length = end - begin;
-            budget.step(length);
-            const expected = text.slice(begin, end);
-            const actual = text.slice(position, position + length);
-            if (instruction.ignoreCase ? instruction.fold ? instruction.fold(expected) === instruction.fold(actual) : expected.toLowerCase() === actual.toLowerCase() : expected === actual) push(state.pc + 1, position + length);
-          }
-        } else throw new ProgramError("unsupported jq regular expression instruction");
-      }
-    }
-    return void 0;
-  }
-  canFindSync() {
-    return this.code.length > 0 && this.dialect !== "jq" && this.dialect !== "rust" && Boolean(this.literalMatch || this.simpleRepeatMatch || this.chainMatch);
-  }
-  getFastPrefixInfo() {
-    return this.fastPrefixInfo;
-  }
-  getLiteralMatchInfo() {
-    return this.literalMatch;
-  }
-  findSyncFastInto(text, budget, from, outOffsets, textEnd = text.length, textStart = 0) {
-    this.assertInstructionLimit(budget);
-    if (this.chainMatch) {
-      const { prefix, anchoredStart: anchoredStart2, anchoredEnd: anchoredEnd2, steps } = this.chainMatch;
-      if (from > textEnd || anchoredStart2 && from > textStart) return false;
-      const first = steps[0];
-      const startStep = prefix.length > 0 && first.group === 0 ? 1 : 0;
-      let found2 = -1;
-      let matchEnd = -1;
-      if (anchoredStart2) {
-        if (prefix.length === 0 || textStart + prefix.length <= textEnd && text.startsWith(prefix, textStart)) {
-          matchEnd = matchChainAt(steps, prefix.length, anchoredEnd2, text, textStart, outOffsets, this.groupCount, textEnd, startStep);
-          if (matchEnd >= 0) found2 = textStart;
-        }
-      } else if (prefix.length > 0) {
-        let searchFrom = from;
-        while (searchFrom <= textEnd - prefix.length) {
-          const idx = text.indexOf(prefix, searchFrom);
-          if (idx < 0 || idx > textEnd - prefix.length) break;
-          const end = matchChainAt(steps, prefix.length, anchoredEnd2, text, idx, outOffsets, this.groupCount, textEnd, startStep);
-          if (end >= 0) {
-            found2 = idx;
-            matchEnd = end;
-            break;
-          }
-          searchFrom = idx + 1;
-        }
-      } else {
-        const head = first;
-        const headAscii = head.ascii;
-        const headAccepts = head.accepts;
-        const headMin = head.minimum;
-        let searchFrom = from;
-        while (searchFrom < textEnd) {
-          while (searchFrom < textEnd) {
-            const c = text.charCodeAt(searchFrom);
-            if (c < 128 ? headAscii[c] !== 0 : headAccepts(text[searchFrom])) break;
-            searchFrom++;
-          }
-          if (searchFrom >= textEnd) break;
-          let runEnd = searchFrom + 1;
-          while (runEnd < textEnd) {
-            const c = text.charCodeAt(runEnd);
-            if (c < 128 ? headAscii[c] === 0 : !headAccepts(text[runEnd])) break;
-            runEnd++;
-          }
-          if (runEnd - searchFrom >= headMin) {
-            const end = matchChainAt(steps, 0, anchoredEnd2, text, searchFrom, outOffsets, this.groupCount, textEnd, 0);
-            if (end >= 0) {
-              found2 = searchFrom;
-              matchEnd = end;
-              break;
-            }
-          }
-          searchFrom = runEnd + 1;
-        }
-      }
-      const positionsTried2 = anchoredStart2 ? 1 : found2 >= 0 ? found2 - from + 1 : textEnd - from + 1;
-      const len2 = found2 >= 0 ? matchEnd - found2 : 0;
-      budget.step(positionsTried2 * 2 + (found2 >= 0 ? this.code.length * 2 + len2 : 0));
-      if (found2 < 0) return false;
-      if (len2 > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-      return true;
-    }
-    if (this.simpleRepeatMatch) {
-      const { prefix, anchoredStart: anchoredStart2, anchoredEnd: anchoredEnd2, captured, minimum, accepts, ascii } = this.simpleRepeatMatch;
-      if (from > textEnd || anchoredStart2 && from > textStart) return false;
-      let found2 = -1;
-      let matchEnd = -1;
-      let groupStart = -1;
-      let groupEnd = -1;
-      if (anchoredStart2) {
-        if (textStart + prefix.length <= textEnd && text.startsWith(prefix, textStart)) {
-          const pos = textStart + prefix.length;
-          let cursor = pos;
-          while (cursor < textEnd) {
-            const code = text.charCodeAt(cursor);
-            if (code < 128 ? ascii[code] === 0 : !accepts(text[cursor])) break;
-            cursor++;
-          }
-          if (cursor - pos >= minimum && (!anchoredEnd2 || cursor === textEnd)) {
-            found2 = textStart;
-            matchEnd = cursor;
-            groupStart = pos;
-            groupEnd = cursor;
-          }
-        }
-      } else if (prefix.length === 0) {
-        let searchFrom = from;
-        const maxStart = textEnd - minimum;
-        while (searchFrom <= maxStart) {
-          const c0 = text.charCodeAt(searchFrom);
-          if (c0 < 128 ? ascii[c0] === 0 : !accepts(text[searchFrom])) {
-            searchFrom++;
-            continue;
-          }
-          const idx = searchFrom;
-          let cursor = idx + 1;
-          while (cursor < textEnd) {
-            const code = text.charCodeAt(cursor);
-            if (code < 128 ? ascii[code] === 0 : !accepts(text[cursor])) break;
-            cursor++;
-          }
-          if (cursor - idx >= minimum && (!anchoredEnd2 || cursor === textEnd)) {
-            found2 = idx;
-            matchEnd = cursor;
-            groupStart = idx;
-            groupEnd = cursor;
-            break;
-          }
-          searchFrom = cursor + 1;
-        }
-      } else {
-        let searchFrom = from;
-        while (searchFrom <= textEnd - prefix.length) {
-          const idx = text.indexOf(prefix, searchFrom);
-          if (idx < 0 || idx > textEnd - prefix.length) break;
-          const pos = idx + prefix.length;
-          let cursor = pos;
-          while (cursor < textEnd) {
-            const code = text.charCodeAt(cursor);
-            if (code < 128 ? ascii[code] === 0 : !accepts(text[cursor])) break;
-            cursor++;
-          }
-          if (cursor - pos >= minimum && (!anchoredEnd2 || cursor === textEnd)) {
-            found2 = idx;
-            matchEnd = cursor;
-            groupStart = pos;
-            groupEnd = cursor;
-            break;
-          }
-          searchFrom = idx + 1;
-        }
-      }
-      const positionsTried2 = anchoredStart2 ? 1 : found2 >= 0 ? found2 - from + 1 : textEnd - from + 1;
-      const len2 = found2 >= 0 ? matchEnd - found2 : 0;
-      budget.step(positionsTried2 * 2 + (found2 >= 0 ? this.code.length * 2 + len2 : 0));
-      if (found2 < 0) return false;
-      if (len2 > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-      outOffsets[0] = found2;
-      outOffsets[1] = matchEnd;
-      outOffsets[2] = captured ? groupStart : -1;
-      outOffsets[3] = captured ? groupEnd : -1;
-      return true;
-    }
-    const { value, anchoredStart, anchoredEnd } = this.literalMatch;
-    const len = value.length;
-    if (from > textEnd || anchoredStart && from > textStart) return false;
-    let found = -1;
-    if (anchoredStart && anchoredEnd) {
-      if (from === textStart && textEnd - textStart === len && text.startsWith(value, textStart)) found = textStart;
-    } else if (anchoredStart) {
-      if (from === textStart && textStart + len <= textEnd && text.startsWith(value, textStart)) found = textStart;
-    } else if (anchoredEnd) {
-      const candidate = textEnd - len;
-      if (candidate >= from && text.startsWith(value, candidate)) found = candidate;
-    } else {
-      const maxStart = textEnd - len;
-      if (from <= maxStart) {
-        if (textEnd === text.length || maxStart - from > 64) {
-          const idx = text.indexOf(value, from);
-          if (idx >= 0 && idx <= maxStart) found = idx;
-        } else {
-          const c0 = value.charCodeAt(0);
-          const c1 = len > 1 ? value.charCodeAt(1) : -1;
-          for (let i = from; i <= maxStart; i++) {
-            if (text.charCodeAt(i) === c0 && (len === 1 || text.charCodeAt(i + 1) === c1 && (len === 2 || text.startsWith(value, i)))) {
-              found = i;
-              break;
-            }
-          }
-        }
-      }
-    }
-    const positionsTried = anchoredStart ? 1 : found >= 0 ? found - from + 1 : textEnd - from + 1;
-    budget.step(positionsTried * 2 + (found >= 0 ? this.code.length * 2 + len : 0));
-    if (found < 0) return false;
-    if (len > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-    outOffsets[0] = found;
-    outOffsets[1] = found + len;
-    outOffsets[2] = -1;
-    outOffsets[3] = -1;
-    return true;
-  }
-  findAfterCheck(check, text, budget, from) {
-    return check.then(() => this.find(text, budget, from));
-  }
-  finishLiteralAfterCheck(check, found, len, maxBufferBytes, groups) {
-    if (found < 0) return check.then(RETURN_UNDEFINED);
-    return check.then(() => {
-      if (len > maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-      return { start: found, end: found + len, groups };
-    });
-  }
-  tryFindSync(text, budget, from = 0) {
-    this.assertInstructionLimit(budget);
-    if (this.code.length && this.chainMatch && this.dialect !== "jq" && this.dialect !== "rust") {
-      const initialCheck2 = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
-      if (initialCheck2) return this.findAfterCheck(initialCheck2, text, budget, from);
-      if (!this.findSyncFastInto(text, budget, from, FAST_MATCH_OFFSETS)) return void 0;
-      const start = FAST_MATCH_OFFSETS[0];
-      const end = FAST_MATCH_OFFSETS[1];
-      const groups2 = new Array(this.groupCount + 1);
-      groups2[0] = text.slice(start, end);
-      for (let g = 1; g <= this.groupCount; g++) {
-        const gs = FAST_MATCH_OFFSETS[g * 2];
-        const ge = FAST_MATCH_OFFSETS[g * 2 + 1];
-        groups2[g] = gs >= 0 ? text.slice(gs, ge) : void 0;
-      }
-      return { start, end, groups: groups2 };
-    }
-    if (this.code.length && this.simpleRepeatMatch && this.dialect !== "jq" && this.dialect !== "rust") {
-      const initialCheck2 = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
-      if (initialCheck2) return this.findAfterCheck(initialCheck2, text, budget, from);
-      return this.execSimpleRepeat(text, budget, from);
-    }
-    if (!this.code.length || !this.literalMatch || this.dialect === "jq" || this.dialect === "rust") {
-      return this.find(text, budget, from);
-    }
-    const initialCheck = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
-    if (initialCheck) return this.findAfterCheck(initialCheck, text, budget, from);
-    const { value, anchoredStart, anchoredEnd, groups } = this.literalMatch;
-    const len = value.length;
-    if (from > text.length || anchoredStart && from > 0) return void 0;
-    let found = -1;
-    if (anchoredStart && anchoredEnd) {
-      if (from === 0 && text.length === len && text === value) found = 0;
-    } else if (anchoredStart) {
-      if (from === 0 && text.startsWith(value)) found = 0;
-    } else if (anchoredEnd) {
-      const candidate = text.length - len;
-      if (candidate >= from && text.endsWith(value)) found = candidate;
-    } else {
-      found = text.indexOf(value, from);
-    }
-    const positionsTried = anchoredStart ? 1 : found >= 0 ? found - from + 1 : text.length - from + 1;
-    const stepCount = positionsTried * 2 + (found >= 0 ? this.code.length * 2 + len : 0);
-    budget.step(stepCount);
-    if (stepCount >= 64) {
-      const midCheck = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
-      if (midCheck) return this.finishLiteralAfterCheck(midCheck, found, len, budget.maxBufferBytes, groups);
-    }
-    if (found < 0) return void 0;
-    if (len > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-    return { start: found, end: found + len, groups };
-  }
-  tryTestSync(text, budget, textStart = 0, textEnd = text.length) {
-    if (this.canFindSync()) {
-      const initialCheck = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
-      if (!initialCheck) {
-        return this.findSyncFastInto(text, budget, textStart, FAST_MATCH_OFFSETS, textEnd, textStart);
-      }
-      return initialCheck.then(() => this.findSyncFastInto(text, budget, textStart, FAST_MATCH_OFFSETS, textEnd, textStart));
-    }
-    const sub = textStart === 0 && textEnd === text.length ? text : text.slice(textStart, textEnd);
-    const found = this.tryFindSync(sub, budget, 0);
-    if (found instanceof Promise) return found.then((res) => res !== void 0);
-    return found !== void 0;
-  }
-  execSimpleRepeat(text, budget, from) {
-    const { prefix, anchoredStart, anchoredEnd, captured, minimum, accepts, ascii } = this.simpleRepeatMatch;
-    if (from > text.length || anchoredStart && from > 0) return void 0;
-    let found = -1;
-    let matchEnd = -1;
-    let groupStart = -1;
-    let groupEnd = -1;
-    if (anchoredStart) {
-      if (text.startsWith(prefix)) {
-        const pos = prefix.length;
-        let cursor = pos;
-        while (cursor < text.length) {
-          const code = text.charCodeAt(cursor);
-          if (code < 128 ? ascii[code] === 0 : !accepts(text[cursor])) break;
-          cursor++;
-        }
-        if (cursor - pos >= minimum && (!anchoredEnd || cursor === text.length)) {
-          found = 0;
-          matchEnd = cursor;
-          groupStart = pos;
-          groupEnd = cursor;
-        }
-      }
-    } else {
-      let searchFrom = from;
-      while (searchFrom <= text.length - prefix.length) {
-        const idx = text.indexOf(prefix, searchFrom);
-        if (idx < 0) break;
-        const pos = idx + prefix.length;
-        let cursor = pos;
-        while (cursor < text.length) {
-          const code = text.charCodeAt(cursor);
-          if (code < 128 ? ascii[code] === 0 : !accepts(text[cursor])) break;
-          cursor++;
-        }
-        if (cursor - pos >= minimum && (!anchoredEnd || cursor === text.length)) {
-          found = idx;
-          matchEnd = cursor;
-          groupStart = pos;
-          groupEnd = cursor;
-          break;
-        }
-        searchFrom = idx + 1;
-      }
-    }
-    const positionsTried = anchoredStart ? 1 : found >= 0 ? found - from + 1 : text.length - from + 1;
-    const len = found >= 0 ? matchEnd - found : 0;
-    const stepCount = positionsTried * 2 + (found >= 0 ? this.code.length * 2 + len : 0);
-    budget.step(stepCount);
-    if (stepCount >= 64) {
-      const midCheck = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
-      if (midCheck) {
-        return midCheck.then(() => {
-          if (found < 0) return void 0;
-          if (len > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-          const full2 = text.slice(found, matchEnd);
-          const groups2 = captured ? [full2, text.slice(groupStart, groupEnd)] : [full2];
-          return { start: found, end: matchEnd, groups: groups2 };
-        });
-      }
-    }
-    if (found < 0) return void 0;
-    if (len > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-    const full = text.slice(found, matchEnd);
-    const groups = captured ? [full, text.slice(groupStart, groupEnd)] : [full];
-    return { start: found, end: matchEnd, groups };
-  }
-  async find(text, budget, from = 0, continuation = from) {
-    this.assertInstructionLimit(budget);
-    if (!this.code.length) await this.prepare(budget);
-    if (this.dialect === "jq" || this.dialect === "rust") return (await this.findJq(text, budget, from, { pc: 0, continuation }))?.match;
-    if (this.simpleRepeatMatch) {
-      const initialCheck2 = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
-      if (initialCheck2) await initialCheck2;
-      return await this.execSimpleRepeat(text, budget, from);
-    }
-    const initialCheck = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
-    if (initialCheck) await initialCheck;
-    if (this.literalMatch) {
-      const { value, anchoredStart, anchoredEnd, groups } = this.literalMatch;
-      const len = value.length;
-      if (from > text.length || anchoredStart && from > 0) return void 0;
-      let found = -1;
-      if (anchoredStart && anchoredEnd) {
-        if (from === 0 && text.length === len && text === value) found = 0;
-      } else if (anchoredStart) {
-        if (from === 0 && text.startsWith(value)) found = 0;
-      } else if (anchoredEnd) {
-        const candidate = text.length - len;
-        if (candidate >= from && text.endsWith(value)) found = candidate;
-      } else {
-        found = text.indexOf(value, from);
-      }
-      const positionsTried = anchoredStart ? 1 : found >= 0 ? found - from + 1 : text.length - from + 1;
-      const stepCount = positionsTried * 2 + (found >= 0 ? this.code.length * 2 + len : 0);
-      budget.step(stepCount);
-      if (stepCount >= 64) {
-        const midCheck = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
-        if (midCheck) await midCheck;
-      }
-      if (found < 0) return void 0;
-      if (len > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-      const endCheck = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
-      if (endCheck) await endCheck;
-      return { start: found, end: found + len, groups };
-    }
-    let units = 0;
-    const work = (count = 1) => {
-      budget.step(count);
-      units += count;
-      if (units < 64) return void 0;
-      units %= 64;
-      return budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
-    };
-    if (this.linear) {
-      for (let start = from; start <= text.length && (!this.anchored || start === 0); start++) {
-        let position = start;
-        for (const instruction of this.code) {
-          const paused = work(2);
-          if (paused) await paused;
-          if (instruction.kind === "character") {
-            if (position >= text.length || !instruction.accepts(text[position])) break;
-            position++;
-          } else if (instruction.kind === "begin" && position !== 0 || instruction.kind === "end" && position !== text.length) break;
-          else if (instruction.kind === "match") {
-            if (position - start > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-            const copied = work(position - start);
-            if (copied) await copied;
-            const match = { start, end: position, groups: [text.slice(start, position)] };
-            await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
-            return match;
-          }
-        }
-      }
-      return void 0;
-    }
-    const storage = new NfaStorage(budget);
-    const positionDigits = String(text.length).length;
-    const instructionDigits = String(this.code.length).length;
-    if (from > text.length || this.anchored && from !== 0) return void 0;
-    storage.reserve(128);
-    const positions = /* @__PURE__ */ new Map();
-    let earliestStarts;
-    let nextStart = from;
-    let bestStart;
-    let bestEnd;
-    let bestCaptures = [];
-    let bestBytes = 0;
-    try {
-      if (this.groupCount && !this.backreferences && !this.anchored) {
-        storage.reserve(64);
-        earliestStarts = /* @__PURE__ */ new Map();
-      }
-      let position = from;
-      while (position <= text.length) {
-        const advanced = work();
-        if (advanced) await advanced;
-        let pending = positions.get(position);
-        if (bestStart === void 0 && (!this.anchored || position === 0) && (!this.backreferences || position === nextStart)) {
-          storage.reserve(72 + (pending ? 0 : 64));
-          pending ??= [];
-          pending.push({ pc: 0, start: position, captures: [], bytes: 72 });
-        }
-        if (!pending && !positions.size) break;
-        if (!pending) {
-          position++;
-          continue;
-        }
-        const reversed = work(pending.length);
-        if (reversed) await reversed;
-        pending.reverse();
-        positions.delete(position);
-        const visited = /* @__PURE__ */ new Map();
-        let stateBytes = 0;
-        const enqueue = (destination, pc, start, captures, saveSlot, clearUntil) => {
-          const length = saveSlot === void 0 ? captures.length : Math.max(captures.length, saveSlot + 1);
-          const bytes = 72 + length * 8;
-          const waiting = destination === position ? pending : positions.get(destination);
-          storage.reserve(bytes + (waiting ? 0 : 64));
-          const saved = saveSlot === void 0 ? captures : [...captures];
-          if (saveSlot !== void 0) {
-            for (let slot = saveSlot + 2; slot < Math.min(clearUntil ?? 0, saved.length); slot++) delete saved[slot];
-            saved[saveSlot] = position;
-          }
-          const thread = { pc, start, captures: saved, bytes };
-          if (waiting) waiting.push(thread);
-          else positions.set(destination, [thread]);
-        };
-        while (pending.length) {
-          const paused = work();
-          if (paused) await paused;
-          const thread = pending.pop();
-          try {
-            if (bestStart !== void 0 && thread.start > bestStart) continue;
-            if (earliestStarts) {
-              const earliest = earliestStarts.get(thread.pc);
-              if (earliest !== void 0 && earliest < thread.start) continue;
-              if (earliest === void 0) {
-                storage.reserve(40);
-                stateBytes += 40;
-              }
-              earliestStarts.set(thread.pc, thread.start);
-            }
-            let state = thread.pc;
-            let bytes = 40;
-            if (this.groupCount) {
-              const joinedLength = Math.max(0, thread.captures.length - 1) + thread.captures.length * positionDigits;
-              const stateLength = instructionDigits + 1 + joinedLength;
-              const serialized = work(stateLength);
-              if (serialized) await serialized;
-              const reserved = 32 + joinedLength * 2 + 72 + stateLength * 2;
-              storage.reserve(reserved);
-              state = `${thread.pc}:${thread.captures.join(",")}`;
-              bytes = 72 + state.length * 2;
-              storage.release(reserved - bytes);
-            } else storage.reserve(bytes);
-            const priorStart = visited.get(state);
-            if (priorStart !== void 0) {
-              storage.release(bytes);
-              if (priorStart <= thread.start) continue;
-            } else stateBytes += bytes;
-            visited.set(state, thread.start);
-            const instruction = this.code[thread.pc];
-            if (instruction.kind === "character") {
-              if (position < text.length && instruction.accepts(text[position])) enqueue(position + 1, thread.pc + 1, thread.start, thread.captures);
-            } else if (instruction.kind === "backreference") {
-              const begin = thread.captures[instruction.index * 2];
-              const end = thread.captures[instruction.index * 2 + 1];
-              if (begin === void 0 || end === void 0 || position + end - begin > text.length) continue;
-              let matches = true;
-              for (let offset = 0; offset < end - begin; offset++) {
-                const compared = work();
-                if (compared) await compared;
-                const expected = text[begin + offset];
-                const actual = text[position + offset];
-                if (instruction.ignoreCase ? expected.toLowerCase() !== actual.toLowerCase() : expected !== actual) {
-                  matches = false;
-                  break;
-                }
-              }
-              if (matches) enqueue(position + end - begin, thread.pc + 1, thread.start, thread.captures);
-            } else if (instruction.kind === "match") {
-              let preferred = bestStart === void 0 || thread.start < bestStart || thread.start === bestStart && position > bestEnd;
-              if (thread.start === bestStart && position === bestEnd) for (let index = 1; index <= this.groupCount; index++) {
-                const compared = work();
-                if (compared) await compared;
-                const begin = thread.captures[index * 2];
-                const end = thread.captures[index * 2 + 1];
-                const priorBegin = bestCaptures[index * 2];
-                const priorEnd = bestCaptures[index * 2 + 1];
-                const length = begin === void 0 || end === void 0 ? -1 : end - begin;
-                const priorLength = priorBegin === void 0 || priorEnd === void 0 ? -1 : priorEnd - priorBegin;
-                if (length !== priorLength) {
-                  preferred = length > priorLength;
-                  break;
-                }
-              }
-              if (preferred) {
-                const retained = 32 + thread.captures.length * 8;
-                storage.reserve(retained);
-                bestStart = thread.start;
-                bestEnd = position;
-                bestCaptures = thread.captures;
-                storage.release(bestBytes);
-                bestBytes = retained;
-              }
-            } else if (instruction.kind === "split") {
-              enqueue(position, instruction.second, thread.start, thread.captures);
-              enqueue(position, instruction.first, thread.start, thread.captures);
-            } else if (instruction.kind === "jump") enqueue(position, instruction.target, thread.start, thread.captures);
-            else if (instruction.kind === "save") {
-              const copied = work(Math.max(thread.captures.length, instruction.slot + 1));
-              if (copied) await copied;
-              enqueue(position, thread.pc + 1, thread.start, thread.captures, instruction.slot, instruction.clearUntil);
-            } else if (instruction.kind === "boundary") {
-              if (matchesBoundary(instruction, text, position)) enqueue(position, thread.pc + 1, thread.start, thread.captures);
-            } else if (instruction.kind === "begin" ? position === 0 : position === text.length) enqueue(position, thread.pc + 1, thread.start, thread.captures);
-          } finally {
-            storage.release(thread.bytes);
-          }
-        }
-        visited.clear();
-        earliestStarts?.clear();
-        storage.release(stateBytes + 64);
-        if (this.backreferences && !positions.size) {
-          if (bestStart !== void 0 || this.anchored) break;
-          position = ++nextStart;
-        } else position++;
-      }
-      if (bestStart !== void 0 && bestEnd !== void 0) {
-        let characters = bestEnd - bestStart;
-        for (let index = 1; index <= this.groupCount; index++) {
-          const counted = work();
-          if (counted) await counted;
-          const begin = bestCaptures[index * 2];
-          const end = bestCaptures[index * 2 + 1];
-          if (begin !== void 0 && end !== void 0) characters += end - begin;
-        }
-        const copied = work(characters);
-        if (copied) await copied;
-        storage.reserve(64 + (this.groupCount + 1) * 40 + characters * 2);
-        const groups = [text.slice(bestStart, bestEnd)];
-        for (let index = 1; index <= this.groupCount; index++) {
-          const materialized = work();
-          if (materialized) await materialized;
-          const begin = bestCaptures[index * 2];
-          const end = bestCaptures[index * 2 + 1];
-          groups.push(begin === void 0 || end === void 0 ? void 0 : text.slice(begin, end));
-        }
-        await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
-        return { start: bestStart, end: bestEnd, groups };
-      }
-      return void 0;
-    } finally {
-      positions.clear();
-      earliestStarts?.clear();
-      storage.clear();
-    }
-  }
-};
-async function replacementLength(replacement, match, budget, available, syntax) {
-  let length = 0;
-  let tokens = 0;
-  for (let index = 0; index < replacement.length; index++) {
-    if (tokens++ % 256 === 0) await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
-    budget.step();
-    const character = replacement[index];
-    let size = 1;
-    if (character === "&") {
-      budget.step();
-      size = match.groups[0]?.length ?? 0;
-    } else if (character === "\\" && index + 1 < replacement.length) {
-      budget.step();
-      const next = replacement[++index];
-      if (syntax === "awk") {
-        size = next === "&" || next === "\\" ? 1 : 2;
-      } else if (next >= "0" && next <= "9") {
-        budget.step();
-        size = match.groups[Number(next)]?.length ?? 0;
-      }
-    }
-    if (size > available - length) throw new ProgramError("text buffer limit exceeded");
-    length += size;
-  }
-  return length;
-}
-async function replacementText(replacement, match, buffer, budget, syntax) {
-  let literal = 0;
-  let tokens = 0;
-  for (let index = 0; index < replacement.length; index++) {
-    if (tokens++ % 256 === 0) await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
-    budget.step();
-    const character = replacement[index];
-    if (character !== "&" && (character !== "\\" || index + 1 === replacement.length)) continue;
-    await buffer.append(replacement, literal, index);
-    if (character === "&") {
-      budget.step();
-      await buffer.append(match.groups[0] ?? "");
-    } else {
-      budget.step();
-      const next = replacement[++index];
-      if (syntax === "awk") {
-        await buffer.append(replacement, next === "&" || next === "\\" ? index : index - 1, index + 1);
-      } else if (next >= "0" && next <= "9") {
-        budget.step();
-        await buffer.append(match.groups[Number(next)] ?? "");
-      } else await buffer.append(next === "n" ? "\n" : next === "t" ? "	" : next);
-    }
-    literal = index + 1;
-  }
-  await buffer.append(replacement, literal);
-}
-var RETURN_UNDEFINED = () => void 0;
-var FAST_MATCH_OFFSETS = new Int32Array(20);
-var SYNC_SUB_RESULT = { text: "", count: 0 };
-var SIMPLE_REPLACEMENT_CACHE = /* @__PURE__ */ new Map();
-function getSimpleReplacement(replacement, syntax) {
-  const key = syntax === "sed" ? replacement : `awk:${replacement}`;
-  const cached = SIMPLE_REPLACEMENT_CACHE.get(key);
-  if (cached !== void 0) return cached;
-  if (SIMPLE_REPLACEMENT_CACHE.size >= 128) SIMPLE_REPLACEMENT_CACHE.clear();
-  if (!replacement.includes("&") && !replacement.includes("\\")) {
-    const res = { kind: "literal", prefix: replacement, group: -1, mid: "", group2: -1, suffix: "", stepsPerExpansion: replacement.length * 2 + 1, smallInts: [] };
-    SIMPLE_REPLACEMENT_CACHE.set(key, res);
-    return res;
-  }
-  if (syntax === "sed") {
-    let prefix = "";
-    let mid = "";
-    let suffix = "";
-    let group = -1;
-    let group2 = -1;
-    let steps = 1;
-    for (let i = 0; i < replacement.length; i++) {
-      steps++;
-      const ch = replacement[i];
-      if (ch === "&") {
-        if (group2 !== -1) {
-          SIMPLE_REPLACEMENT_CACHE.set(key, null);
-          return null;
-        }
-        steps++;
-        if (group === -1) group = 0;
-        else group2 = 0;
-      } else if (ch === "\\" && i + 1 < replacement.length) {
-        steps++;
-        const next = replacement[++i];
-        if (next >= "0" && next <= "9") {
-          if (group2 !== -1) {
-            SIMPLE_REPLACEMENT_CACHE.set(key, null);
-            return null;
-          }
-          steps++;
-          if (group === -1) group = next.charCodeAt(0) - 48;
-          else group2 = next.charCodeAt(0) - 48;
-        } else {
-          const decoded = next === "n" ? "\n" : next === "t" ? "	" : next;
-          if (group === -1) prefix += decoded;
-          else if (group2 === -1) mid += decoded;
-          else suffix += decoded;
-        }
-      } else {
-        if (group === -1) prefix += ch;
-        else if (group2 === -1) mid += ch;
-        else suffix += ch;
-      }
-    }
-    const res = group === -1 ? { kind: "literal", prefix, group: -1, mid: "", group2: -1, suffix: "", stepsPerExpansion: steps + prefix.length, smallInts: [] } : group2 === -1 ? { kind: "singleRef", prefix, group, mid: "", group2: -1, suffix: mid, stepsPerExpansion: steps + prefix.length + mid.length, smallInts: new Array(100) } : { kind: "twoRefs", prefix, group, mid, group2, suffix, stepsPerExpansion: steps + prefix.length + mid.length + suffix.length, smallInts: [] };
-    SIMPLE_REPLACEMENT_CACHE.set(key, res);
-    return res;
-  }
-  SIMPLE_REPLACEMENT_CACHE.set(key, null);
-  return null;
-}
-function appendReplacementFromOffsetsSync(out, replacement, text, matchStart, matchEnd, group1Start, group1End, budget, maxBufferBytes, syntax, simpleRep = getSimpleReplacement(replacement, syntax)) {
-  if (simpleRep !== null) {
-    if (simpleRep.kind === "literal") {
-      budget.step(simpleRep.stepsPerExpansion);
-      if (out.length + simpleRep.prefix.length > maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-      return out ? out + simpleRep.prefix : simpleRep.prefix;
-    }
-    if (simpleRep.kind === "twoRefs") {
-      const g1Start = simpleRep.group === 0 ? matchStart : simpleRep.group === 1 ? group1Start : FAST_MATCH_OFFSETS[simpleRep.group * 2];
-      const g1End = simpleRep.group === 0 ? matchEnd : simpleRep.group === 1 ? group1End : FAST_MATCH_OFFSETS[simpleRep.group * 2 + 1];
-      const g2Start = simpleRep.group2 === 0 ? matchStart : simpleRep.group2 === 1 ? group1Start : FAST_MATCH_OFFSETS[simpleRep.group2 * 2];
-      const g2End = simpleRep.group2 === 0 ? matchEnd : simpleRep.group2 === 1 ? group1End : FAST_MATCH_OFFSETS[simpleRep.group2 * 2 + 1];
-      const g1Len = g1Start >= 0 && g1End > g1Start ? g1End - g1Start : 0;
-      const g2Len = g2Start >= 0 && g2End > g2Start ? g2End - g2Start : 0;
-      const addedLen2 = simpleRep.prefix.length + g1Len + simpleRep.mid.length + g2Len + simpleRep.suffix.length;
-      budget.step(simpleRep.stepsPerExpansion + g1Len + g2Len);
-      if (out.length + addedLen2 > maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-      const g1Str = g1Len > 0 ? text.slice(g1Start, g1End) : "";
-      const g2Str = g2Len > 0 ? text.slice(g2Start, g2End) : "";
-      const expanded2 = simpleRep.suffix ? simpleRep.prefix + g1Str + simpleRep.mid + g2Str + simpleRep.suffix : simpleRep.prefix + g1Str + simpleRep.mid + g2Str;
-      return out ? out + expanded2 : expanded2;
-    }
-    const gStart = simpleRep.group === 0 ? matchStart : simpleRep.group === 1 ? group1Start : FAST_MATCH_OFFSETS[simpleRep.group * 2];
-    const gEnd = simpleRep.group === 0 ? matchEnd : simpleRep.group === 1 ? group1End : FAST_MATCH_OFFSETS[simpleRep.group * 2 + 1];
-    const gLen = gStart >= 0 && gEnd > gStart ? gEnd - gStart : 0;
-    const addedLen = simpleRep.prefix.length + gLen + simpleRep.suffix.length;
-    budget.step(simpleRep.stepsPerExpansion + gLen);
-    if (out.length + addedLen > maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-    let expanded;
-    if (gLen === 1) {
-      const c0 = text.charCodeAt(gStart) - 48;
-      if (c0 >= 0 && c0 <= 9) {
-        expanded = simpleRep.smallInts[c0] ??= simpleRep.suffix ? simpleRep.prefix + String.fromCharCode(c0 + 48) + simpleRep.suffix : simpleRep.prefix + String.fromCharCode(c0 + 48);
-      }
-    } else if (gLen === 2) {
-      const c0 = text.charCodeAt(gStart) - 48;
-      const c1 = text.charCodeAt(gStart + 1) - 48;
-      if (c0 >= 1 && c0 <= 9 && c1 >= 0 && c1 <= 9) {
-        const num = c0 * 10 + c1;
-        expanded = simpleRep.smallInts[num] ??= simpleRep.suffix ? simpleRep.prefix + String(num) + simpleRep.suffix : simpleRep.prefix + String(num);
-      }
-    }
-    if (expanded === void 0) {
-      const gStr = gLen > 0 ? text.slice(gStart, gEnd) : "";
-      expanded = simpleRep.suffix ? simpleRep.prefix + gStr + simpleRep.suffix : simpleRep.prefix + gStr;
-    }
-    return out ? out + expanded : expanded;
-  }
-  const initialOutLen = out.length;
-  let literalStart = 0;
-  for (let index = 0; index < replacement.length; index++) {
-    budget.step();
-    const character = replacement[index];
-    if (character !== "&" && (character !== "\\" || index + 1 >= replacement.length)) continue;
-    if (index > literalStart) {
-      const litLen = index - literalStart;
-      if (out.length + litLen > maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-      const span = literalStart === 0 && index === replacement.length ? replacement : replacement.slice(literalStart, index);
-      out = out ? out + span : span;
-    }
-    let piece = "";
-    if (character === "&") {
-      budget.step();
-      piece = matchEnd > matchStart ? text.slice(matchStart, matchEnd) : "";
-    } else {
-      budget.step();
-      const next = replacement[++index];
-      if (syntax === "awk") {
-        piece = next === "&" || next === "\\" ? next : `\\${next}`;
-      } else if (next >= "0" && next <= "9") {
-        budget.step();
-        const g = next.charCodeAt(0) - 48;
-        if (g === 0) piece = matchEnd > matchStart ? text.slice(matchStart, matchEnd) : "";
-        else if (g === 1 && group1Start >= 0) piece = group1End > group1Start ? text.slice(group1Start, group1End) : "";
-        else if (g > 1) {
-          const gs = FAST_MATCH_OFFSETS[g * 2];
-          const ge = FAST_MATCH_OFFSETS[g * 2 + 1];
-          if (gs >= 0 && ge > gs) piece = text.slice(gs, ge);
-        }
-      } else {
-        piece = next === "n" ? "\n" : next === "t" ? "	" : next;
-      }
-    }
-    if (out.length + piece.length > maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-    if (piece) out = out ? out + piece : piece;
-    literalStart = index + 1;
-  }
-  if (literalStart < replacement.length) {
-    const tailLen = replacement.length - literalStart;
-    if (out.length + tailLen > maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-    const span = literalStart === 0 ? replacement : replacement.slice(literalStart);
-    out = out ? out + span : span;
-  }
-  budget.step(out.length - initialOutLen + 1);
-  return out;
-}
-function trySubstituteSync(text, pattern, replacement, budget, global, occurrence = 1, syntax = "sed") {
-  if (pattern.canFindSync() && text.length <= 4096 && replacement.length <= 256) {
-    let search = 0;
-    let consumed = 0;
-    let previousEnd = -1;
-    let encountered = 0;
-    let count = 0;
-    let out = "";
-    while (search <= text.length) {
-      budget.step();
-      if (!pattern.findSyncFastInto(text, budget, search, FAST_MATCH_OFFSETS)) break;
-      const matchStart = FAST_MATCH_OFFSETS[0];
-      const matchEnd = FAST_MATCH_OFFSETS[1];
-      const group1Start = FAST_MATCH_OFFSETS[2];
-      const group1End = FAST_MATCH_OFFSETS[3];
-      if (matchStart === matchEnd && matchStart === previousEnd) {
-        search = matchEnd + 1;
-        continue;
-      }
-      encountered++;
-      if (encountered >= occurrence) {
-        const prefixLen = matchStart - consumed;
-        if (out.length + prefixLen > budget.maxBufferBytes) {
-          throw new ProgramError("text buffer limit exceeded");
-        }
-        if (prefixLen > 0) {
-          const pref = text.slice(consumed, matchStart);
-          out = out ? out + pref : pref;
-        }
-        out = appendReplacementFromOffsetsSync(out, replacement, text, matchStart, matchEnd, group1Start, group1End, budget, budget.maxBufferBytes, syntax);
-        consumed = matchEnd;
-        count++;
-        if (!global || pattern.getFastPrefixInfo()?.anchoredStart) break;
-      }
-      previousEnd = matchEnd;
-      search = matchEnd === matchStart ? matchEnd + 1 : matchEnd;
-    }
-    if (count > 0) {
-      const tailLen = text.length - consumed;
-      if (out.length + tailLen > budget.maxBufferBytes) {
-        throw new ProgramError("text buffer limit exceeded");
-      }
-      if (tailLen > 0) {
-        const tail = consumed === 0 ? text : text.slice(consumed);
-        out = out ? out + tail : tail;
-      }
-    } else {
-      out = budget.check(text);
-    }
-    SYNC_SUB_RESULT.text = out;
-    SYNC_SUB_RESULT.count = count;
-    return SYNC_SUB_RESULT;
-  }
-  if (!global && occurrence === 1 && !replacement.includes("&") && !replacement.includes("\\")) {
-    budget.step();
-    const matchOrPromise = pattern.tryFindSync(text, budget, 0);
-    if (matchOrPromise instanceof Promise) {
-      return matchOrPromise.then((match2) => {
-        if (!match2) {
-          budget.step(0);
-          return { text: budget.check(text), count: 0 };
-        }
-        const newLen2 = text.length - (match2.end - match2.start) + replacement.length;
-        if (newLen2 > budget.maxBufferBytes || match2.start + replacement.length > budget.maxBufferBytes) {
-          throw new ProgramError("text buffer limit exceeded");
-        }
-        budget.step(replacement.length * 2 + 1);
-        const out2 = (match2.start === 0 ? "" : text.slice(0, match2.start)) + replacement + (match2.end === text.length ? "" : text.slice(match2.end));
-        return { text: budget.check(out2), count: 1 };
-      });
-    }
-    const match = matchOrPromise;
-    if (!match) {
-      budget.step(0);
-      return { text: budget.check(text), count: 0 };
-    }
-    const newLen = text.length - (match.end - match.start) + replacement.length;
-    if (newLen > budget.maxBufferBytes || match.start + replacement.length > budget.maxBufferBytes) {
-      throw new ProgramError("text buffer limit exceeded");
-    }
-    budget.step(replacement.length * 2 + 1);
-    const out = (match.start === 0 ? "" : text.slice(0, match.start)) + replacement + (match.end === text.length ? "" : text.slice(match.end));
-    return { text: budget.check(out), count: 1 };
-  }
-  return substitute(text, pattern, replacement, budget, global, occurrence, syntax);
-}
-async function substitute(text, pattern, replacement, budget, global, occurrence = 1, syntax = "sed") {
-  if (!global && occurrence === 1 && !replacement.includes("&") && !replacement.includes("\\")) {
-    const check = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
-    if (check) await check;
-    budget.step();
-    const match = await pattern.find(text, budget, 0);
-    if (!match) {
-      budget.step(0);
-      return { text: budget.check(text), count: 0 };
-    }
-    const newLen = text.length - (match.end - match.start) + replacement.length;
-    if (newLen > budget.maxBufferBytes || match.start + replacement.length > budget.maxBufferBytes) {
-      throw new ProgramError("text buffer limit exceeded");
-    }
-    budget.step(replacement.length * 2 + 1);
-    const out = (match.start === 0 ? "" : text.slice(0, match.start)) + replacement + (match.end === text.length ? "" : text.slice(match.end));
-    return { text: budget.check(out), count: 1 };
-  }
-  let search = 0;
-  let consumed = 0;
-  let previousEnd = -1;
-  let encountered = 0;
-  let count = 0;
-  const result = new ReplacementBuffer(budget);
-  try {
-    while (search <= text.length) {
-      await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
-      budget.step();
-      const match = await pattern.find(text, budget, search);
-      if (!match) break;
-      if (match.start === match.end && match.start === previousEnd) {
-        search = match.end + 1;
-        continue;
-      }
-      encountered++;
-      if (encountered >= occurrence) {
-        const prefix = match.start - consumed;
-        result.admit(prefix);
-        const length = await replacementLength(replacement, match, budget, result.remaining - prefix, syntax);
-        result.admit(prefix + length);
-        await result.append(text, consumed, match.start);
-        await replacementText(replacement, match, result, budget, syntax);
-        consumed = match.end;
-        count++;
-        if (!global) break;
-      }
-      previousEnd = match.end > match.start ? match.end : -1;
-      search = match.end > match.start ? match.end : match.end + 1;
-    }
-    budget.step(0);
-    if (!count) return { text: budget.check(text), count };
-    await result.append(text, consumed);
-    return { text: await result.finish(), count };
-  } finally {
-    result.clear();
-  }
-}
-var PAIR_OFFSETS_1 = new Int32Array(4);
-var PAIR_OFFSETS_2 = new Int32Array(4);
-var SYNC_PAIR_RESULT = { text: "", substituted: false };
-function expandSimpleFromOffsets(simpleRep, text, matchStart, matchEnd, group1Start, group1End, budget) {
-  if (simpleRep.kind === "literal") {
-    budget.step(simpleRep.stepsPerExpansion);
-    return simpleRep.prefix;
-  }
-  const gStart = simpleRep.group === 0 ? matchStart : simpleRep.group === 1 ? group1Start : -1;
-  const gEnd = simpleRep.group === 0 ? matchEnd : simpleRep.group === 1 ? group1End : -1;
-  const gLen = gStart >= 0 && gEnd > gStart ? gEnd - gStart : 0;
-  budget.step(simpleRep.stepsPerExpansion + gLen);
-  if (gLen === 1) {
-    const c0 = text.charCodeAt(gStart) - 48;
-    if (c0 >= 0 && c0 <= 9) {
-      return simpleRep.smallInts[c0] ??= simpleRep.suffix ? simpleRep.prefix + String.fromCharCode(c0 + 48) + simpleRep.suffix : simpleRep.prefix + String.fromCharCode(c0 + 48);
-    }
-  } else if (gLen === 2) {
-    const c0 = text.charCodeAt(gStart) - 48;
-    const c1 = text.charCodeAt(gStart + 1) - 48;
-    if (c0 >= 1 && c0 <= 9 && c1 >= 0 && c1 <= 9) {
-      const num = c0 * 10 + c1;
-      return simpleRep.smallInts[num] ??= simpleRep.suffix ? simpleRep.prefix + String(num) + simpleRep.suffix : simpleRep.prefix + String(num);
-    }
-  }
-  const gStr = gLen > 0 ? text.slice(gStart, gEnd) : "";
-  return simpleRep.suffix ? simpleRep.prefix + gStr + simpleRep.suffix : simpleRep.prefix + gStr;
-}
-function trySubstitutePairSync(text, pat1, rep1, global1, occ1, pat2, rep2, global2, occ2, budget) {
-  if (occ1 !== 1 || occ2 !== 1 || text.length > 4096) return void 0;
-  if (!pat1.canFindSync() || !pat2.canFindSync()) return void 0;
-  const info1 = pat1.getFastPrefixInfo();
-  const info2 = pat2.getFastPrefixInfo();
-  if (!info1 || !info2 || !info1.anchoredStart || info2.anchoredStart || info2.prefix.length === 0) return void 0;
-  const sr1 = getSimpleReplacement(rep1, "sed");
-  const sr2 = getSimpleReplacement(rep2, "sed");
-  if (!sr1 || !sr2) return void 0;
-  budget.step();
-  let effectiveE1 = 0;
-  let exp1 = "";
-  let effectiveExp1Len = 0;
-  let matched1 = false;
-  if (pat1.findSyncFastInto(text, budget, 0, PAIR_OFFSETS_1)) {
-    const e1 = PAIR_OFFSETS_1[1];
-    if (e1 === 0) return void 0;
-    matched1 = true;
-    exp1 = expandSimpleFromOffsets(sr1, text, 0, e1, PAIR_OFFSETS_1[2], PAIR_OFFSETS_1[3], budget);
-    let commonSuffix = 0;
-    const maxSuffix = Math.min(exp1.length, e1);
-    while (commonSuffix < maxSuffix && exp1.charCodeAt(exp1.length - 1 - commonSuffix) === text.charCodeAt(e1 - 1 - commonSuffix)) {
-      commonSuffix++;
-    }
-    effectiveExp1Len = exp1.length - commonSuffix;
-    effectiveE1 = e1 - commonSuffix;
-    const firstChar2 = info2.prefix.charCodeAt(0);
-    for (let i = 0; i < effectiveExp1Len; i++) {
-      if (exp1.charCodeAt(i) === firstChar2) return void 0;
-    }
-  }
-  budget.step();
-  if (!pat2.findSyncFastInto(text, budget, effectiveE1, PAIR_OFFSETS_2)) {
-    if (!matched1) {
-      SYNC_PAIR_RESULT.text = budget.check(text);
-      SYNC_PAIR_RESULT.substituted = false;
-      return SYNC_PAIR_RESULT;
-    }
-    const outLen = effectiveExp1Len + (text.length - effectiveE1);
-    if (outLen > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-    budget.step(text.length - effectiveE1 + 1);
-    const expPrefix2 = effectiveExp1Len === exp1.length ? exp1 : exp1.slice(0, effectiveExp1Len);
-    SYNC_PAIR_RESULT.text = effectiveE1 < text.length ? expPrefix2 + text.slice(effectiveE1) : expPrefix2;
-    SYNC_PAIR_RESULT.substituted = true;
-    return SYNC_PAIR_RESULT;
-  }
-  const s2 = PAIR_OFFSETS_2[0];
-  const e2 = PAIR_OFFSETS_2[1];
-  if (s2 < effectiveE1 || e2 === s2) return void 0;
-  const g2s = PAIR_OFFSETS_2[2];
-  const g2e = PAIR_OFFSETS_2[3];
-  if (global2 && e2 <= text.length) {
-    budget.step();
-    if (pat2.findSyncFastInto(text, budget, e2, PAIR_OFFSETS_1)) return void 0;
-  }
-  const exp2 = expandSimpleFromOffsets(sr2, text, s2, e2, g2s, g2e, budget);
-  const midLen = s2 - effectiveE1;
-  const tailLen = text.length - e2;
-  const totalLen = effectiveExp1Len + midLen + exp2.length + tailLen;
-  if (totalLen > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-  budget.step(midLen + tailLen + 2);
-  const expPrefix = effectiveExp1Len === 0 ? "" : effectiveExp1Len === exp1.length ? exp1 : exp1.slice(0, effectiveExp1Len);
-  const mid = midLen > 0 ? text.slice(effectiveE1, s2) : "";
-  const tail = tailLen > 0 ? text.slice(e2) : "";
-  SYNC_PAIR_RESULT.text = expPrefix + mid + exp2 + tail;
-  SYNC_PAIR_RESULT.substituted = true;
-  return SYNC_PAIR_RESULT;
-}
-function trySubstitutePairToBufferSync(text, pat1, rep1, global1, occ1, pat2, rep2, global2, occ2, budget, outBuf, outPos, sepCode, lineStart = 0, lineEnd = text.length) {
-  const lineLen = lineEnd - lineStart;
-  if (occ1 !== 1 || occ2 !== 1 || lineLen > 4096) return -1;
-  if (!pat1.canFindSync() || !pat2.canFindSync()) return -1;
-  const info1 = pat1.getFastPrefixInfo();
-  const info2 = pat2.getFastPrefixInfo();
-  if (!info1 || !info2 || !info1.anchoredStart || info2.anchoredStart || info2.prefix.length === 0) return -1;
-  const sr1 = getSimpleReplacement(rep1, "sed");
-  const sr2 = getSimpleReplacement(rep2, "sed");
-  if (!sr1 || !sr2) return -1;
-  budget.step();
-  let effectiveE1 = lineStart;
-  let exp1 = "";
-  let effectiveExp1Len = 0;
-  if (pat1.findSyncFastInto(text, budget, lineStart, PAIR_OFFSETS_1, lineEnd, lineStart)) {
-    const e1 = PAIR_OFFSETS_1[1];
-    if (e1 === lineStart) return -1;
-    exp1 = expandSimpleFromOffsets(sr1, text, lineStart, e1, PAIR_OFFSETS_1[2], PAIR_OFFSETS_1[3], budget);
-    let commonSuffix = 0;
-    const maxSuffix = Math.min(exp1.length, e1 - lineStart);
-    while (commonSuffix < maxSuffix && exp1.charCodeAt(exp1.length - 1 - commonSuffix) === text.charCodeAt(e1 - 1 - commonSuffix)) {
-      commonSuffix++;
-    }
-    effectiveExp1Len = exp1.length - commonSuffix;
-    effectiveE1 = e1 - commonSuffix;
-    const firstChar2 = info2.prefix.charCodeAt(0);
-    for (let i = 0; i < effectiveExp1Len; i++) {
-      if (exp1.charCodeAt(i) === firstChar2) return -1;
-    }
-  }
-  budget.step();
-  if (!pat2.findSyncFastInto(text, budget, effectiveE1, PAIR_OFFSETS_2, lineEnd, lineStart)) {
-    const outLen = effectiveExp1Len + (lineEnd - effectiveE1);
-    if (outLen > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-    if (outPos + outLen + 1 > outBuf.length) return -1;
-    budget.step(lineEnd - effectiveE1 + 1);
-    let pos2 = outPos;
-    for (let i = 0; i < effectiveExp1Len; i++) outBuf[pos2++] = exp1.charCodeAt(i);
-    for (let i = effectiveE1; i < lineEnd; i++) outBuf[pos2++] = text.charCodeAt(i);
-    outBuf[pos2++] = sepCode;
-    return pos2;
-  }
-  const s2 = PAIR_OFFSETS_2[0];
-  const e2 = PAIR_OFFSETS_2[1];
-  if (s2 < effectiveE1 || e2 === s2) return -1;
-  const g2s = PAIR_OFFSETS_2[2];
-  const g2e = PAIR_OFFSETS_2[3];
-  if (global2 && e2 <= lineEnd) {
-    budget.step();
-    if (pat2.findSyncFastInto(text, budget, e2, PAIR_OFFSETS_1, lineEnd, lineStart)) return -1;
-  }
-  const exp2 = expandSimpleFromOffsets(sr2, text, s2, e2, g2s, g2e, budget);
-  const midLen = s2 - effectiveE1;
-  const tailLen = lineEnd - e2;
-  const totalLen = effectiveExp1Len + midLen + exp2.length + tailLen;
-  if (totalLen > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
-  if (outPos + totalLen + 1 > outBuf.length) return -1;
-  budget.step(midLen + tailLen + 2);
-  let pos = outPos;
-  for (let i = 0; i < effectiveExp1Len; i++) outBuf[pos++] = exp1.charCodeAt(i);
-  for (let i = effectiveE1; i < s2; i++) outBuf[pos++] = text.charCodeAt(i);
-  for (let i = 0; i < exp2.length; i++) outBuf[pos++] = exp2.charCodeAt(i);
-  for (let i = e2; i < lineEnd; i++) outBuf[pos++] = text.charCodeAt(i);
-  outBuf[pos++] = sepCode;
-  return pos;
-}
-var cachedPairOutBuf = new Uint8Array(65536);
-var cachedPairOutView = cachedPairOutBuf.subarray(0, 0);
-var lastPairBatchText = "";
-var lastPairBatchEnds;
-var lastPairEndsLen = -1;
-var lastPairPat1;
-var lastPairRep1 = "";
-var lastPairG1 = false;
-var lastPairPat2;
-var lastPairRep2 = "";
-var lastPairG2 = false;
-var lastPairSepCode = -1;
-var lastPairMaxLine = 0;
-var lastPairStepsCharged = 0;
-var lastPairOutPos = -1;
-function trySubstitutePairBatchToBufferSync(batchText, batchEnds, endsLen, pat1, rep1, global1, occ1, pat2, rep2, global2, occ2, budget, outBuf, sepCode, maxOutLen) {
-  if (lastPairOutPos >= 0 && batchText === lastPairBatchText && batchEnds === lastPairBatchEnds && endsLen === lastPairEndsLen && pat1 === lastPairPat1 && rep1 === lastPairRep1 && global1 === lastPairG1 && pat2 === lastPairPat2 && rep2 === lastPairRep2 && global2 === lastPairG2 && sepCode === lastPairSepCode && occ1 === 1 && occ2 === 1 && lastPairMaxLine <= budget.maxBufferBytes && lastPairOutPos <= maxOutLen && (budget.options.maxSteps ?? Infinity) >= budget.stepsUsed + lastPairStepsCharged) {
-    const pending = budget.checkpointSync ? budget.checkpointSync() : void 0;
-    if (pending) {
-      pending.catch(() => {
-      });
-      return -1;
-    }
-    budget.step(lastPairStepsCharged);
-    outBuf.set(cachedPairOutView, 0);
-    return lastPairOutPos;
-  }
-  const initialSteps = budget.stepsUsed;
-  let maxSeenLine = 0;
-  if (occ1 !== 1 || occ2 !== 1) return -1;
-  if (!pat1.canFindSync() || !pat2.canFindSync()) return -1;
-  const info1 = pat1.getFastPrefixInfo();
-  const info2 = pat2.getFastPrefixInfo();
-  if (!info1 || !info2 || !info1.anchoredStart || info2.anchoredStart || info2.prefix.length === 0) return -1;
-  const sr1 = getSimpleReplacement(rep1, "sed");
-  const sr2 = getSimpleReplacement(rep2, "sed");
-  if (!sr1 || !sr2) return -1;
-  const lit1 = pat1.getLiteralMatchInfo();
-  const lit2 = pat2.getLiteralMatchInfo();
-  const maxBuf = budget.maxBufferBytes;
-  if (lit1 && lit1.anchoredStart && !lit1.anchoredEnd && sr1.kind === "literal" && lit2 && !lit2.anchoredStart && !lit2.anchoredEnd && sr2.kind === "literal") {
-    const v1 = lit1.value;
-    const v1Len = v1.length;
-    const v2 = lit2.value;
-    const v2Len = v2.length;
-    if (v1Len === 0 || v2Len === 0) return -1;
-    const r1Val = sr1.prefix;
-    let commonSuffix = 0;
-    const maxSuffix = Math.min(r1Val.length, v1Len);
-    while (commonSuffix < maxSuffix && r1Val.charCodeAt(r1Val.length - 1 - commonSuffix) === v1.charCodeAt(v1Len - 1 - commonSuffix)) {
-      commonSuffix++;
-    }
-    const effectiveExp1Len = r1Val.length - commonSuffix;
-    const effectiveE1Offset = v1Len - commonSuffix;
-    const v2c0 = v2.charCodeAt(0);
-    for (let i = 0; i < effectiveExp1Len; i++) {
-      if (r1Val.charCodeAt(i) === v2c0) return -1;
-    }
-    const r2Val = sr2.prefix;
-    const r2Len = r2Val.length;
-    const v1c0 = v1.charCodeAt(0);
-    const v1c1 = v1Len > 1 ? v1.charCodeAt(1) : -1;
-    const v2c1 = v2Len > 1 ? v2.charCodeAt(1) : -1;
-    let outPos2 = 0;
-    let lStart2 = 0;
-    for (let idx = 0; idx < endsLen; idx++) {
-      const lEnd = batchEnds[idx];
-      const lineLen = lEnd - lStart2;
-      if (lineLen > 4096) return -1;
-      let effectiveE1 = lStart2;
-      let exp1Len = 0;
-      if (lineLen >= v1Len && batchText.charCodeAt(lStart2) === v1c0 && (v1Len === 1 || batchText.charCodeAt(lStart2 + 1) === v1c1 && (v1Len === 2 || batchText.startsWith(v1, lStart2)))) {
-        effectiveE1 = lStart2 + effectiveE1Offset;
-        exp1Len = effectiveExp1Len;
-      }
-      const maxS2 = lEnd - v2Len;
-      let s2 = -1;
-      for (let i = effectiveE1; i <= maxS2; i++) {
-        if (batchText.charCodeAt(i) === v2c0 && (v2Len === 1 || batchText.charCodeAt(i + 1) === v2c1 && (v2Len === 2 || batchText.startsWith(v2, i)))) {
-          s2 = i;
-          break;
-        }
-      }
-      if (s2 < 0) {
-        const restLen = lEnd - effectiveE1;
-        const outLen = exp1Len + restLen;
-        if (outLen > maxSeenLine) maxSeenLine = outLen;
-        if (outLen > maxBuf) throw new ProgramError("text buffer limit exceeded");
-        if (outPos2 + outLen + 1 >= maxOutLen) return -2;
-        for (let i = 0; i < exp1Len; i++) outBuf[outPos2++] = r1Val.charCodeAt(i);
-        for (let i = effectiveE1; i < lEnd; i++) outBuf[outPos2++] = batchText.charCodeAt(i);
-        outBuf[outPos2++] = sepCode;
-        budget.step(lineLen * 2 + exp1Len * 2 + 8);
-      } else {
-        const e2 = s2 + v2Len;
-        if (global2 && e2 <= maxS2) {
-          for (let i = e2; i <= maxS2; i++) {
-            if (batchText.charCodeAt(i) === v2c0 && (v2Len === 1 || batchText.charCodeAt(i + 1) === v2c1 && (v2Len === 2 || batchText.startsWith(v2, i)))) {
-              return -1;
-            }
-          }
-        }
-        const midLen = s2 - effectiveE1;
-        const tailLen = lEnd - e2;
-        const totalLen = exp1Len + midLen + r2Len + tailLen;
-        if (totalLen > maxSeenLine) maxSeenLine = totalLen;
-        if (totalLen > maxBuf) throw new ProgramError("text buffer limit exceeded");
-        if (outPos2 + totalLen + 1 >= maxOutLen) return -2;
-        for (let i = 0; i < exp1Len; i++) outBuf[outPos2++] = r1Val.charCodeAt(i);
-        for (let i = effectiveE1; i < s2; i++) outBuf[outPos2++] = batchText.charCodeAt(i);
-        for (let i = 0; i < r2Len; i++) outBuf[outPos2++] = r2Val.charCodeAt(i);
-        for (let i = e2; i < lEnd; i++) outBuf[outPos2++] = batchText.charCodeAt(i);
-        outBuf[outPos2++] = sepCode;
-        budget.step(lineLen * 2 + exp1Len * 2 + r2Len * 2 + 16);
-      }
-      if ((idx + 1 & 31) === 0) {
-        const pending = budget.checkpointSync ? budget.checkpointSync() : void 0;
-        if (pending) {
-          pending.catch(() => {
-          });
-          return -1;
-        }
-      }
-      lStart2 = lEnd + 1;
-    }
-    if (outPos2 <= 65536) {
-      lastPairBatchText = batchText;
-      lastPairBatchEnds = batchEnds;
-      lastPairEndsLen = endsLen;
-      lastPairPat1 = pat1;
-      lastPairRep1 = rep1;
-      lastPairG1 = global1;
-      lastPairPat2 = pat2;
-      lastPairRep2 = rep2;
-      lastPairG2 = global2;
-      lastPairSepCode = sepCode;
-      lastPairMaxLine = maxSeenLine;
-      lastPairStepsCharged = budget.stepsUsed - initialSteps;
-      lastPairOutPos = outPos2;
-      cachedPairOutBuf.set(outBuf.subarray(0, outPos2));
-      cachedPairOutView = cachedPairOutBuf.subarray(0, outPos2);
-    }
-    return outPos2;
-  }
-  let outPos = 0;
-  let lStart = 0;
-  const firstChar2 = info2.prefix.charCodeAt(0);
-  for (let idx = 0; idx < endsLen; idx++) {
-    const lEnd = batchEnds[idx];
-    if (lEnd - lStart > 4096) return -1;
-    budget.step();
-    let effectiveE1 = lStart;
-    let exp1 = "";
-    let effectiveExp1Len = 0;
-    if (pat1.findSyncFastInto(batchText, budget, lStart, PAIR_OFFSETS_1, lEnd, lStart)) {
-      const e1 = PAIR_OFFSETS_1[1];
-      if (e1 === lStart) return -1;
-      exp1 = expandSimpleFromOffsets(sr1, batchText, lStart, e1, PAIR_OFFSETS_1[2], PAIR_OFFSETS_1[3], budget);
-      let commonSuffix = 0;
-      const maxSuffix = Math.min(exp1.length, e1 - lStart);
-      while (commonSuffix < maxSuffix && exp1.charCodeAt(exp1.length - 1 - commonSuffix) === batchText.charCodeAt(e1 - 1 - commonSuffix)) {
-        commonSuffix++;
-      }
-      effectiveExp1Len = exp1.length - commonSuffix;
-      effectiveE1 = e1 - commonSuffix;
-      for (let i = 0; i < effectiveExp1Len; i++) {
-        if (exp1.charCodeAt(i) === firstChar2) return -1;
-      }
-    }
-    budget.step();
-    if (!pat2.findSyncFastInto(batchText, budget, effectiveE1, PAIR_OFFSETS_2, lEnd, lStart)) {
-      const outLen = effectiveExp1Len + (lEnd - effectiveE1);
-      if (outLen > maxBuf) throw new ProgramError("text buffer limit exceeded");
-      if (outPos + outLen + 1 >= maxOutLen) return -2;
-      budget.step(lEnd - effectiveE1 + 4);
-      for (let i = 0; i < effectiveExp1Len; i++) outBuf[outPos++] = exp1.charCodeAt(i);
-      for (let i = effectiveE1; i < lEnd; i++) outBuf[outPos++] = batchText.charCodeAt(i);
-      outBuf[outPos++] = sepCode;
-    } else {
-      const s2 = PAIR_OFFSETS_2[0];
-      const e2 = PAIR_OFFSETS_2[1];
-      if (s2 < effectiveE1 || e2 === s2) return -1;
-      const g2s = PAIR_OFFSETS_2[2];
-      const g2e = PAIR_OFFSETS_2[3];
-      if (global2 && e2 <= lEnd) {
-        budget.step();
-        if (pat2.findSyncFastInto(batchText, budget, e2, PAIR_OFFSETS_1, lEnd, lStart)) return -1;
-      }
-      const exp2 = expandSimpleFromOffsets(sr2, batchText, s2, e2, g2s, g2e, budget);
-      const midLen = s2 - effectiveE1;
-      const tailLen = lEnd - e2;
-      const totalLen = effectiveExp1Len + midLen + exp2.length + tailLen;
-      if (totalLen > maxBuf) throw new ProgramError("text buffer limit exceeded");
-      if (outPos + totalLen + 1 >= maxOutLen) return -2;
-      budget.step(midLen + tailLen + 5);
-      for (let i = 0; i < effectiveExp1Len; i++) outBuf[outPos++] = exp1.charCodeAt(i);
-      for (let i = effectiveE1; i < s2; i++) outBuf[outPos++] = batchText.charCodeAt(i);
-      for (let i = 0; i < exp2.length; i++) outBuf[outPos++] = exp2.charCodeAt(i);
-      for (let i = e2; i < lEnd; i++) outBuf[outPos++] = batchText.charCodeAt(i);
-      outBuf[outPos++] = sepCode;
-    }
-    if ((idx + 1 & 31) === 0) {
-      const pending = budget.checkpointSync ? budget.checkpointSync() : void 0;
-      if (pending) {
-        pending.catch(() => {
-        });
-        return -1;
-      }
-    }
-    lStart = lEnd + 1;
-  }
-  return outPos;
-}
-
-export {
-  ProgramError,
-  Budget,
-  RustPatternError,
-  simpleCaseFold,
-  Pattern,
-  trySubstituteSync,
-  substitute,
-  trySubstitutePairSync,
-  trySubstitutePairToBufferSync,
-  trySubstitutePairBatchToBufferSync
-};
-//# sourceMappingURL=chunk-CEWCRI6H.js.map