@poe-platform/safe-bash 0.1.755 → 0.1.757

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

@@ -1,1920 +0,0 @@
-import {
-  init_platform
-} from "./chunk-ZG7GWQ5P.js";
-
-// packages/safe-bash-regex-engine/src/ere/errors.ts
-init_platform();
-var EreSyntaxError = class extends Error {
-  constructor(message, offset) {
-    super(`invalid ERE at ${offset}: ${message}`);
-    this.offset = offset;
-    this.name = "EreSyntaxError";
-  }
-  offset;
-  status = 2;
-};
-var EreUnsupportedError = class extends Error {
-  constructor(message, offset) {
-    super(`unsupported ERE profile at ${offset}: ${message}`);
-    this.offset = offset;
-    this.name = "EreUnsupportedError";
-  }
-  offset;
-  status = 2;
-};
-var EreProfileLimitError = class extends Error {
-  constructor(resource, limit) {
-    super(`ERE profile limit exceeded: ${resource} (${limit})`);
-    this.resource = resource;
-    this.limit = limit;
-    this.name = "EreProfileLimitError";
-  }
-  resource;
-  limit;
-  status = 3;
-};
-var EreUsageUnknownError = class extends Error {
-  status = 3;
-  constructor(reason) {
-    super("ERE invocation usage is unknown; further work is refused", { cause: reason });
-    this.name = "EreUsageUnknownError";
-  }
-};
-
-// packages/safe-bash-regex-engine/src/ere/limits.ts
-init_platform();
-import { hasYieldCheckpoint, runYieldCheckpoint, yieldTurn } from "../../safe-bash-contracts/yield.js";
-var resources = Object.freeze([
-  "patternBytes",
-  "subjectBytes",
-  "work",
-  "states",
-  "allocationUnits",
-  "captureBytes",
-  "captureSlots"
-]);
-function integer(value) {
-  if (!Number.isSafeInteger(value) || value < 0) throw new TypeError("ERE bounds must be nonnegative safe integers");
-}
-function deriveEreLimits(bounds) {
-  if (bounds.maxExpansionBytes !== Infinity) integer(bounds.maxExpansionBytes);
-  if (bounds.maxExpansionFields !== Infinity) integer(bounds.maxExpansionFields);
-  return Object.freeze({
-    patternBytes: Infinity,
-    subjectBytes: Infinity,
-    work: Infinity,
-    states: Infinity,
-    allocationUnits: Infinity,
-    captureBytes: bounds.maxExpansionBytes,
-    captureSlots: bounds.maxExpansionFields
-  });
-}
-var EreLedger = class _EreLedger {
-  limits;
-  limitWorkSmi = 1073741823;
-  uPatternBytes = 0;
-  uSubjectBytes = 0;
-  uWork = 0;
-  uStates = 0;
-  uAllocationUnits = 0;
-  uCaptureBytes = 0;
-  uCaptureSlots = 0;
-  poison;
-  lastYield = 0;
-  constructor(bounds, overrides, prevalidated) {
-    if (prevalidated !== void 0) {
-      this.limits = prevalidated;
-      this.limitWorkSmi = prevalidated.work > 1073741823 ? 1073741823 : prevalidated.work | 0;
-      return;
-    }
-    const limits = { ...deriveEreLimits(bounds) };
-    if (overrides !== void 0) {
-      for (const resource of Object.keys(overrides)) {
-        if (!resources.includes(resource)) throw new TypeError("unknown ERE limit");
-        const key = resource;
-        const value = overrides[key];
-        if (value === void 0) throw new TypeError("undefined ERE limit");
-        if (value !== Infinity) integer(value);
-        limits[key] = value;
-      }
-    }
-    this.limits = Object.freeze(limits);
-    this.limitWorkSmi = limits.work > 1073741823 ? 1073741823 : limits.work | 0;
-  }
-  resetWithLimits(limits) {
-    this.limits = limits;
-    this.limitWorkSmi = limits.work > 1073741823 ? 1073741823 : limits.work | 0;
-    this.uPatternBytes = 0;
-    this.uSubjectBytes = 0;
-    this.uWork = 0;
-    this.uStates = 0;
-    this.uAllocationUnits = 0;
-    this.uCaptureBytes = 0;
-    this.uCaptureSlots = 0;
-    this.poison = void 0;
-    this.lastYield = 0;
-    return this;
-  }
-  static withPrevalidatedLimits(limits) {
-    return new _EreLedger({ maxExpansionBytes: Infinity, maxExpansionFields: Infinity }, void 0, limits);
-  }
-  get usage() {
-    return Object.freeze({
-      patternBytes: this.uPatternBytes,
-      subjectBytes: this.uSubjectBytes,
-      work: this.uWork,
-      states: this.uStates,
-      allocationUnits: this.uAllocationUnits,
-      captureBytes: this.uCaptureBytes,
-      captureSlots: this.uCaptureSlots
-    });
-  }
-  getResource(resource) {
-    switch (resource) {
-      case "patternBytes":
-        return this.uPatternBytes;
-      case "subjectBytes":
-        return this.uSubjectBytes;
-      case "work":
-        return this.uWork;
-      case "states":
-        return this.uStates;
-      case "allocationUnits":
-        return this.uAllocationUnits;
-      case "captureBytes":
-        return this.uCaptureBytes;
-      case "captureSlots":
-        return this.uCaptureSlots;
-    }
-  }
-  addResource(resource, amount) {
-    const amtSmi = amount | 0;
-    switch (resource) {
-      case "patternBytes":
-        this.uPatternBytes = amtSmi === amount && this.uPatternBytes + amtSmi <= 1073741823 ? this.uPatternBytes + amtSmi | 0 : this.uPatternBytes + amount;
-        break;
-      case "subjectBytes":
-        this.uSubjectBytes = amtSmi === amount && this.uSubjectBytes + amtSmi <= 1073741823 ? this.uSubjectBytes + amtSmi | 0 : this.uSubjectBytes + amount;
-        break;
-      case "work":
-        this.uWork = amtSmi === amount && this.uWork + amtSmi <= 1073741823 ? this.uWork + amtSmi | 0 : this.uWork + amount;
-        break;
-      case "states":
-        this.uStates = amtSmi === amount && this.uStates + amtSmi <= 1073741823 ? this.uStates + amtSmi | 0 : this.uStates + amount;
-        break;
-      case "allocationUnits":
-        this.uAllocationUnits = amtSmi === amount && this.uAllocationUnits + amtSmi <= 1073741823 ? this.uAllocationUnits + amtSmi | 0 : this.uAllocationUnits + amount;
-        break;
-      case "captureBytes":
-        this.uCaptureBytes = amtSmi === amount && this.uCaptureBytes + amtSmi <= 1073741823 ? this.uCaptureBytes + amtSmi | 0 : this.uCaptureBytes + amount;
-        break;
-      case "captureSlots":
-        this.uCaptureSlots = amtSmi === amount && this.uCaptureSlots + amtSmi <= 1073741823 ? this.uCaptureSlots + amtSmi | 0 : this.uCaptureSlots + amount;
-        break;
-    }
-  }
-  check(signal) {
-    if (signal?.aborted) throw signal.reason;
-    if (this.poison) throw this.poison;
-  }
-  charge(resource, amount, signal) {
-    this.check(signal);
-    integer(amount);
-    const current = this.getResource(resource);
-    const limit = this.limits[resource];
-    if (limit !== Infinity && amount > limit - current) {
-      throw new EreProfileLimitError(resource, limit);
-    }
-    this.addResource(resource, amount);
-  }
-  chargeWork(amount, signal) {
-    if (signal?.aborted) throw signal.reason;
-    if (this.poison) throw this.poison;
-    if (amount > this.limitWorkSmi - this.uWork && amount > this.limits.work - this.uWork) {
-      throw new EreProfileLimitError("work", this.limits.work);
-    }
-    const amtSmi = amount | 0;
-    this.uWork = amtSmi === amount && this.uWork + amtSmi <= 1073741823 ? this.uWork + amtSmi | 0 : this.uWork + amount;
-  }
-  workAllowanceUntilCheckpoint(signal) {
-    const untilLimit = this.limitWorkSmi - (this.uWork | 0) | 0;
-    const interval = hasYieldCheckpoint(signal) ? 256 : 16384;
-    const untilYield = interval - ((this.uWork | 0) - (this.lastYield | 0)) | 0;
-    const min = untilLimit < untilYield ? untilLimit : untilYield;
-    return min > 0 ? min : 0;
-  }
-  advanceSyncCheckpointIfNoExternalYield(signal) {
-    if (hasYieldCheckpoint(signal)) return false;
-    if (signal?.aborted) throw signal.reason;
-    if (this.poison) throw this.poison;
-    this.lastYield = this.uWork;
-    return true;
-  }
-  admitInput(resource, length, signal) {
-    this.check(signal);
-    integer(length);
-    if (length > this.limits[resource]) throw new EreProfileLimitError(resource, this.limits[resource]);
-    if (resource === "patternBytes") this.uPatternBytes = Math.max(this.uPatternBytes, length);
-    else this.uSubjectBytes = Math.max(this.uSubjectBytes, length);
-  }
-  checkpoint(signal) {
-    runYieldCheckpoint(signal);
-    this.check(signal);
-    const hasExt = hasYieldCheckpoint(signal);
-    const interval = hasExt ? 256 : 16384;
-    if (this.uWork - this.lastYield >= interval) {
-      this.lastYield = this.uWork;
-      return yieldTurn(signal).then(() => {
-        this.check(signal);
-      });
-    }
-    return void 0;
-  }
-  markUnknownUsage(reason) {
-    this.poison ??= new EreUsageUnknownError(reason);
-  }
-};
-
-// packages/safe-bash-regex-engine/src/ere/syntax.ts
-init_platform();
-var programs = /* @__PURE__ */ new WeakMap();
-var ereCompilationCache = /* @__PURE__ */ new Map();
-var special = "\\.^$[]()|*+?{}";
-var classes = /* @__PURE__ */ new Set(["alnum", "alpha", "blank", "cntrl", "digit", "graph", "lower", "print", "punct", "space", "upper", "xdigit"]);
-function classMember(name, code) {
-  const upper = code >= 65 && code <= 90;
-  const lower = code >= 97 && code <= 122;
-  const digit = code >= 48 && code <= 57;
-  switch (name) {
-    case "alnum":
-      return upper || lower || digit;
-    case "alpha":
-      return upper || lower;
-    case "blank":
-      return code === 9 || code === 32;
-    case "cntrl":
-      return code < 32 || code === 127;
-    case "digit":
-      return digit;
-    case "graph":
-      return code >= 33 && code <= 126;
-    case "lower":
-      return lower;
-    case "print":
-      return code >= 32 && code <= 126;
-    case "punct":
-      return code >= 33 && code <= 126 && !upper && !lower && !digit;
-    case "space":
-      return code === 32 || code >= 9 && code <= 13;
-    case "upper":
-      return upper;
-    case "xdigit":
-      return digit || code >= 65 && code <= 70 || code >= 97 && code <= 102;
-    default:
-      return false;
-  }
-}
-function admitAscii(text, ledger, signal) {
-  if (ledger.charge === EreLedger.prototype.charge && ledger.workAllowanceUntilCheckpoint(signal) >= text.length + 4) {
-    for (let offset = 0; offset < text.length; offset++) {
-      ledger.chargeWork(1, signal);
-      const code = text.charCodeAt(offset);
-      if (code === 0 || code > 127) throw new EreUnsupportedError("only non-NUL ASCII in the C/POSIX profile", offset);
-    }
-    const c = ledger.checkpoint(signal);
-    if (c) return c;
-    return;
-  }
-  return (async () => {
-    for (let offset = 0; offset < text.length; offset++) {
-      ledger.charge("work", 1, signal);
-      const code = text.charCodeAt(offset);
-      if (code === 0 || code > 127) throw new EreUnsupportedError("only non-NUL ASCII in the C/POSIX profile", offset);
-      {
-        const c = ledger.checkpoint(signal);
-        if (c) await c;
-      }
-    }
-  })();
-}
-async function flatten(input, ledger, signal) {
-  if (typeof input === "string") {
-    ledger.admitInput("patternBytes", input.length, signal);
-    await admitAscii(input, ledger, signal);
-    return { pattern: input, quoted: null };
-  }
-  let size = 0;
-  for (const fragment of input) {
-    if (typeof fragment.text !== "string" || typeof fragment.literal !== "boolean") throw new TypeError("invalid ERE fragment");
-    ledger.charge("work", 1, signal);
-    {
-      const c = ledger.checkpoint(signal);
-      if (c) await c;
-    }
-    ledger.admitInput("patternBytes", fragment.text.length, signal);
-    await admitAscii(fragment.text, ledger, signal);
-    if (fragment.text.length > ledger.limits.patternBytes - size) ledger.admitInput("patternBytes", ledger.limits.patternBytes + 1, signal);
-    size += fragment.text.length;
-    ledger.admitInput("patternBytes", size, signal);
-  }
-  ledger.charge("allocationUnits", size * 2 + input.length + 2, signal);
-  const output = [];
-  const quoted = [];
-  for (const fragment of input) {
-    for (let offset = 0; offset < fragment.text.length; offset++) {
-      ledger.charge("work", 1, signal);
-      {
-        const c = ledger.checkpoint(signal);
-        if (c) await c;
-      }
-      quoted.push(fragment.literal);
-    }
-    output.push(fragment.text);
-    {
-      const c = ledger.checkpoint(signal);
-      if (c) await c;
-    }
-  }
-  return { pattern: output.join(""), quoted: Object.freeze(quoted) };
-}
-var Parser = class {
-  constructor(pattern, quoted, ledger, signal, insensitive, localeProfile) {
-    this.pattern = pattern;
-    this.quoted = quoted;
-    this.ledger = ledger;
-    this.signal = signal;
-    this.insensitive = insensitive;
-    this.localeProfile = localeProfile;
-  }
-  pattern;
-  quoted;
-  ledger;
-  signal;
-  insensitive;
-  localeProfile;
-  offset = 0;
-  groups = 0;
-  at(character, offset = this.offset) {
-    return !this.quoted?.[offset] && this.pattern[offset] === character;
-  }
-  node(create) {
-    this.ledger.charge("allocationUnits", 8, this.signal);
-    return Object.freeze(create());
-  }
-  async expression() {
-    this.ledger.charge("allocationUnits", 1, this.signal);
-    const alternatives = [];
-    while (true) {
-      const child = await this.sequence();
-      this.ledger.charge("allocationUnits", 1, this.signal);
-      alternatives.push(child);
-      if (!this.at("|")) break;
-      this.offset++;
-    }
-    if (alternatives.length === 1) return alternatives[0];
-    this.ledger.charge("work", alternatives.length * 2, this.signal);
-    {
-      const c = this.ledger.checkpoint(this.signal);
-      if (c) await c;
-    }
-    return this.node(() => ({ kind: "alternative", children: Object.freeze(alternatives), nullable: alternatives.some((value) => value.nullable), captured: alternatives.some((value) => value.captured) }));
-  }
-  async sequence() {
-    this.ledger.charge("allocationUnits", 1, this.signal);
-    const children = [];
-    while (this.offset < this.pattern.length && !this.at("|") && !this.at(")")) {
-      this.ledger.charge("work", 1, this.signal);
-      {
-        const c = this.ledger.checkpoint(this.signal);
-        if (c) await c;
-      }
-      let child = await this.atom();
-      const operator = this.quoted?.[this.offset] ? void 0 : this.pattern[this.offset];
-      if (operator === "*" || operator === "+" || operator === "?" || operator === "{") {
-        const begin = this.offset++;
-        let min = operator === "+" ? 1 : 0;
-        let max = operator === "?" ? 1 : Infinity;
-        if (operator === "{") {
-          min = await this.count();
-          max = min;
-          if (this.at(",")) {
-            this.offset++;
-            max = this.at("}") ? Infinity : await this.count();
-          }
-          if (!this.at("}") || max < min) throw new EreSyntaxError("invalid interval", begin);
-          this.offset++;
-        }
-        if (child.kind === "start" || child.kind === "end") throw new EreUnsupportedError("repeated anchor", begin);
-        if (child.nullable && child.captured && max > 1) throw new EreUnsupportedError("nullable captured repetition", begin);
-        const repeated = child;
-        child = this.node(() => ({ kind: "repeat", child: repeated, min, max, nullable: min === 0 || repeated.nullable, captured: repeated.captured }));
-        const next = this.quoted?.[this.offset] ? void 0 : this.pattern[this.offset];
-        if (next === "*" || next === "+" || next === "?" || next === "{") throw new EreUnsupportedError("stacked repetition", this.offset);
-      }
-      this.ledger.charge("allocationUnits", 1, this.signal);
-      children.push(child);
-    }
-    if (children.length === 0) return this.node(() => ({ kind: "empty", nullable: true, captured: false }));
-    if (children.length === 1) return children[0];
-    this.ledger.charge("work", children.length * 2, this.signal);
-    {
-      const c = this.ledger.checkpoint(this.signal);
-      if (c) await c;
-    }
-    return this.node(() => ({ kind: "sequence", children: Object.freeze(children), nullable: children.every((value) => value.nullable), captured: children.some((value) => value.captured) }));
-  }
-  async count() {
-    const begin = this.offset;
-    let value = 0;
-    while (!this.quoted?.[this.offset] && this.pattern[this.offset] !== void 0 && this.pattern[this.offset] >= "0" && this.pattern[this.offset] <= "9") {
-      this.ledger.charge("work", 1, this.signal);
-      {
-        const c = this.ledger.checkpoint(this.signal);
-        if (c) await c;
-      }
-      value = value * 10 + this.pattern.charCodeAt(this.offset++) - 48;
-      if (!Number.isSafeInteger(value)) throw new EreUnsupportedError("interval count is not a safe integer", begin);
-    }
-    if (begin === this.offset) throw new EreSyntaxError("missing interval count", begin);
-    return value;
-  }
-  async atom() {
-    const begin = this.offset;
-    const character = this.pattern[this.offset++];
-    if (this.quoted?.[begin]) return this.node(() => ({ kind: "literal", code: character.charCodeAt(0), insensitive: this.insensitive, nullable: false, captured: false }));
-    if (character === "(") {
-      if (this.at("?")) throw new EreUnsupportedError("extended group syntax", begin);
-      const index = ++this.groups;
-      const child = await this.expression();
-      if (!this.at(")")) throw new EreSyntaxError("unclosed group", begin);
-      this.offset++;
-      return this.node(() => ({ kind: "group", index, child, nullable: child.nullable, captured: true }));
-    }
-    if (character === "[") return this.set(begin);
-    if (character === "\\") {
-      const escaped = this.pattern[this.offset++];
-      if (escaped === void 0) throw new EreSyntaxError("trailing escape", begin);
-      if (!special.includes(escaped)) throw new EreUnsupportedError("backreference or escape extension", begin);
-      return this.node(() => ({ kind: "literal", code: escaped.charCodeAt(0), insensitive: this.insensitive, nullable: false, captured: false }));
-    }
-    if (character === "*" || character === "+" || character === "?" || character === "{") throw new EreSyntaxError("repetition without operand", begin);
-    if (character === ".") return this.node(() => ({ kind: "dot", nullable: false, captured: false }));
-    if (character === "^") return this.node(() => ({ kind: "start", nullable: true, captured: false }));
-    if (character === "$") return this.node(() => ({ kind: "end", nullable: true, captured: false }));
-    return this.node(() => ({ kind: "literal", code: character.charCodeAt(0), insensitive: this.insensitive, nullable: false, captured: false }));
-  }
-  async set(begin) {
-    this.ledger.charge("allocationUnits", 128, this.signal);
-    const members = new Array(128).fill(false);
-    const negate = this.at("^");
-    if (negate) this.offset++;
-    let first = true;
-    while (this.offset < this.pattern.length) {
-      this.ledger.charge("work", 1, this.signal);
-      {
-        const c = this.ledger.checkpoint(this.signal);
-        if (c) await c;
-      }
-      if (this.at("]") && !first) {
-        this.offset++;
-        if (this.insensitive) for (let upper = 65; upper <= 90; upper++) {
-          this.ledger.charge("work", 1, this.signal);
-          {
-            const c = this.ledger.checkpoint(this.signal);
-            if (c) await c;
-          }
-          if (members[upper] || members[upper + 32]) members[upper] = members[upper + 32] = true;
-        }
-        if (negate) for (let code = 1; code < 128; code++) {
-          this.ledger.charge("work", 1, this.signal);
-          {
-            const c = this.ledger.checkpoint(this.signal);
-            if (c) await c;
-          }
-          members[code] = !members[code];
-        }
-        return this.node(() => ({ kind: "set", members: Object.freeze(members), nonAscii: negate, nullable: false, captured: false }));
-      }
-      first = false;
-      if (this.at("[") && (this.at(".", this.offset + 1) || this.at("=", this.offset + 1))) {
-        throw new EreUnsupportedError("collating or equivalence element", this.offset);
-      }
-      if (this.at("[") && this.at(":", this.offset + 1)) {
-        if (!this.localeProfile.classes) throw new EreUnsupportedError("locale character class", this.offset);
-        const classBegin = this.offset;
-        this.offset += 2;
-        let name = "";
-        while (this.offset < this.pattern.length && !this.at(":")) {
-          this.ledger.charge("work", 1, this.signal);
-          {
-            const c = this.ledger.checkpoint(this.signal);
-            if (c) await c;
-          }
-          if (name.length >= 6) throw new EreSyntaxError("unknown character class", classBegin);
-          name += this.pattern[this.offset++];
-        }
-        if (!this.at(":") || !this.at("]", this.offset + 1) || !classes.has(name)) throw new EreSyntaxError("unknown character class", classBegin);
-        this.offset += 2;
-        for (let code = 1; code < 128; code++) {
-          this.ledger.charge("work", 1, this.signal);
-          {
-            const c = this.ledger.checkpoint(this.signal);
-            if (c) await c;
-          }
-          if (classMember(name, code)) members[code] = true;
-        }
-        if (this.at("-") && !this.at("]", this.offset + 1)) throw new EreSyntaxError("class cannot be a range endpoint", this.offset);
-      } else {
-        const lower = this.pattern.charCodeAt(this.offset++);
-        if (this.at("-") && !this.at("]", this.offset + 1) && this.pattern[this.offset + 1] !== void 0) {
-          if (!this.localeProfile.ranges) throw new EreUnsupportedError("collation locale range", this.offset);
-          this.offset++;
-          if (this.at("[")) throw new EreSyntaxError("nonliteral range endpoint", this.offset);
-          const upper = this.pattern.charCodeAt(this.offset++);
-          if (lower > upper) throw new EreSyntaxError("descending range", this.offset - 3);
-          for (let code = lower; code <= upper; code++) {
-            this.ledger.charge("work", 1, this.signal);
-            {
-              const c = this.ledger.checkpoint(this.signal);
-              if (c) await c;
-            }
-            members[code] = true;
-          }
-        } else members[lower] = true;
-      }
-    }
-    throw new EreSyntaxError("unclosed bracket expression", begin);
-  }
-};
-async function compileEre(input, ledger, signal, asciiInsensitive = false, localeProfile = { ranges: true, classes: true }) {
-  ledger.check(signal);
-  if (typeof asciiInsensitive !== "boolean") throw new TypeError("ASCII case mode must be boolean");
-  let cacheKey;
-  if (typeof input === "string" && input.length <= 128) {
-    cacheKey = `S:${asciiInsensitive ? 1 : 0}:${localeProfile.ranges ? 1 : 0}:${localeProfile.classes ? 1 : 0}:${input}`;
-  } else if (Array.isArray(input) && input.length === 1 && typeof input[0]?.text === "string" && typeof input[0]?.literal === "boolean" && input[0].text.length <= 128) {
-    cacheKey = `F:${asciiInsensitive ? 1 : 0}:${localeProfile.ranges ? 1 : 0}:${localeProfile.classes ? 1 : 0}:${input[0].literal ? 1 : 0}:${input[0].text}`;
-  }
-  if (cacheKey !== void 0 && ledger.charge === EreLedger.prototype.charge) {
-    const cached = ereCompilationCache.get(cacheKey);
-    if (cached && ledger.workAllowanceUntilCheckpoint(signal) >= cached.work + 16 && cached.patternBytes <= ledger.limits.patternBytes && cached.states <= ledger.limits.states - ledger.usage.states && cached.allocationUnits <= ledger.limits.allocationUnits - ledger.usage.allocationUnits) {
-      ledger.admitInput("patternBytes", cached.patternBytes, signal);
-      if (cached.work > 0) ledger.chargeWork(cached.work, signal);
-      if (cached.states > 0) ledger.charge("states", cached.states, signal);
-      if (cached.allocationUnits > 0) ledger.charge("allocationUnits", cached.allocationUnits, signal);
-      const c = ledger.checkpoint(signal);
-      if (c) await c;
-      const program2 = Object.freeze({ pattern: cached.pattern, groups: cached.groups });
-      programs.set(program2, { root: cached.root, ledger });
-      return program2;
-    }
-  }
-  const before = cacheKey !== void 0 ? ledger.usage : void 0;
-  const { pattern, quoted } = await flatten(input, ledger, signal);
-  const parser = new Parser(pattern, quoted, ledger, signal, asciiInsensitive, localeProfile);
-  const root = await parser.expression();
-  if (parser.offset !== pattern.length) throw new EreSyntaxError("unmatched closing group", parser.offset);
-  ledger.charge("allocationUnits", 3, signal);
-  const program = Object.freeze({ pattern, groups: parser.groups });
-  programs.set(program, { root, ledger });
-  if (cacheKey !== void 0 && before !== void 0) {
-    const after = ledger.usage;
-    if (ereCompilationCache.size >= 256) ereCompilationCache.clear();
-    ereCompilationCache.set(cacheKey, {
-      pattern,
-      groups: parser.groups,
-      root,
-      patternBytes: after.patternBytes,
-      work: after.work - before.work,
-      states: after.states - before.states,
-      allocationUnits: after.allocationUnits - before.allocationUnits
-    });
-  }
-  return program;
-}
-function tryCompileEreSync(input, ledger, signal, asciiInsensitive = false, localeProfile = { ranges: true, classes: true }) {
-  let cacheKey;
-  if (typeof input === "string" && input.length <= 128) {
-    cacheKey = `S:${asciiInsensitive ? 1 : 0}:${localeProfile.ranges ? 1 : 0}:${localeProfile.classes ? 1 : 0}:${input}`;
-  } else if (Array.isArray(input) && input.length === 1 && typeof input[0]?.text === "string" && typeof input[0]?.literal === "boolean" && input[0].text.length <= 128) {
-    cacheKey = `F:${asciiInsensitive ? 1 : 0}:${localeProfile.ranges ? 1 : 0}:${localeProfile.classes ? 1 : 0}:${input[0].literal ? 1 : 0}:${input[0].text}`;
-  }
-  if (cacheKey === void 0) return void 0;
-  const cached = ereCompilationCache.get(cacheKey);
-  if (!cached || ledger.workAllowanceUntilCheckpoint(signal) < cached.work + 16 || cached.patternBytes > ledger.limits.patternBytes || cached.states > ledger.limits.states - ledger.usage.states || cached.allocationUnits > ledger.limits.allocationUnits - ledger.usage.allocationUnits) {
-    return void 0;
-  }
-  ledger.admitInput("patternBytes", cached.patternBytes, signal);
-  if (cached.work > 0) ledger.chargeWork(cached.work, signal);
-  if (cached.states > 0) ledger.charge("states", cached.states, signal);
-  if (cached.allocationUnits > 0) ledger.charge("allocationUnits", cached.allocationUnits, signal);
-  if (ledger.checkpoint(signal)) return void 0;
-  const program = Object.freeze({ pattern: cached.pattern, groups: cached.groups });
-  programs.set(program, { root: cached.root, ledger });
-  return program;
-}
-function resolveEreProgram(program, ledger) {
-  const entry = programs.get(program);
-  if (!entry || entry.ledger !== ledger) throw new TypeError("ERE program is not bound to this invocation ledger");
-  return entry.root;
-}
-function resolveEreProgramUnchecked(program) {
-  const entry = programs.get(program);
-  if (!entry) throw new TypeError("ERE program is not bound to this invocation ledger");
-  return entry.root;
-}
-
-// packages/safe-bash-regex-engine/src/ere/matcher.ts
-init_platform();
-
-// packages/safe-bash-regex-engine/src/utf8.ts
-init_platform();
-import { PublicDiagnostic } from "../../safe-bash-contracts/public-diagnostic.js";
-function invalidUtf8() {
-  throw new PublicDiagnostic("bounded regex unsupported: literal patterns and subjects require valid non-NUL UTF-8 bytes");
-}
-function validateUtf8(input, ledger, signal) {
-  const len = input.length;
-  if (len === 0) {
-    ledger.check(signal);
-    return void 0;
-  }
-  if (ledger.workAllowanceUntilCheckpoint(signal) >= len) {
-    let ascii = true;
-    if (typeof input === "string") {
-      for (let i = 0; i < len; i++) {
-        const b = input.charCodeAt(i);
-        if (b === 0 || b >= 128) {
-          ascii = false;
-          break;
-        }
-      }
-    } else {
-      for (let i = 0; i < len; i++) {
-        const b = input[i];
-        if (b === 0 || b >= 128) {
-          ascii = false;
-          break;
-        }
-      }
-    }
-    if (ascii) {
-      ledger.chargeWork(len, signal);
-      return ledger.checkpoint(signal);
-    }
-  }
-  return validateUtf8Async(input, ledger, signal);
-}
-async function validateUtf8Async(input, ledger, signal) {
-  for (let index = 0; index < input.length; ) {
-    if (typeof input !== "string") {
-      const allowance = ledger.workAllowanceUntilCheckpoint(signal);
-      if (allowance > 1) {
-        const maxRun = Math.min(input.length, index + allowance);
-        let scan = index;
-        while (scan < maxRun) {
-          const b = input[scan];
-          if (b === 0 || b >= 128) break;
-          scan++;
-        }
-        if (scan > index) {
-          ledger.chargeWork(scan - index, signal);
-          index = scan;
-          const pending2 = ledger.checkpoint(signal);
-          if (pending2) await pending2;
-          if (index >= input.length) break;
-        }
-      }
-    }
-    const first = typeof input === "string" ? input.charCodeAt(index) : input[index];
-    const width = first < 128 ? 1 : first >= 194 && first <= 223 ? 2 : first >= 224 && first <= 239 ? 3 : first >= 240 && first <= 244 ? 4 : 0;
-    ledger.chargeWork(Math.max(width, 1), signal);
-    if (first === 0 || width === 0 || width > input.length - index) invalidUtf8();
-    for (let continuation = 1; continuation < width; continuation++) {
-      const byte = typeof input === "string" ? input.charCodeAt(index + continuation) : input[index + continuation];
-      if (byte < 128 || byte > 191 || continuation === 1 && (first === 224 && byte < 160 || first === 237 && byte > 159 || first === 240 && byte < 144 || first === 244 && byte > 143)) invalidUtf8();
-    }
-    index += width;
-    const pending = ledger.checkpoint(signal);
-    if (pending) await pending;
-  }
-}
-
-// packages/safe-bash-regex-engine/src/ascii.ts
-init_platform();
-function foldAscii(code) {
-  return code >= 65 && code <= 90 ? code + 32 : code;
-}
-function isAsciiWord(code) {
-  return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 95;
-}
-
-// packages/safe-bash-regex-engine/src/ere/matcher.ts
-var initialCharacters = /* @__PURE__ */ new WeakMap();
-var sequenceNullNextTasks = /* @__PURE__ */ new WeakMap();
-var SINGLE_NULL_CAPTURES = Object.freeze([null]);
-var SINGLE_NULL_HISTORIES = Object.freeze([null]);
-var fastLiteralSeqs = /* @__PURE__ */ new WeakMap();
-var fastPrefixAlts = /* @__PURE__ */ new WeakMap();
-function extractLiteralBytes(node) {
-  if (node.kind === "literal") {
-    return node.insensitive ? null : Uint8Array.of(node.code);
-  }
-  if (node.kind === "group") {
-    return extractLiteralBytes(node.child);
-  }
-  if (node.kind === "sequence") {
-    const out = [];
-    for (const c of node.children) {
-      if (c.kind === "literal" && !c.insensitive) out.push(c.code);
-      else return null;
-    }
-    return out.length > 0 ? Uint8Array.from(out) : null;
-  }
-  return null;
-}
-function getFastErePrefixAlt(root) {
-  const existing = fastPrefixAlts.get(root);
-  if (existing !== void 0) return existing;
-  let anchoredStart = false;
-  let anchoredEnd = false;
-  const prefixBytes = [];
-  let alts = null;
-  const nodes = root.kind === "sequence" ? root.children : [root];
-  let idx = 0;
-  let endIdx = nodes.length;
-  if (idx < endIdx && nodes[idx].kind === "start") {
-    anchoredStart = true;
-    idx++;
-  }
-  if (idx < endIdx && nodes[endIdx - 1].kind === "end") {
-    anchoredEnd = true;
-    endIdx--;
-  }
-  while (idx < endIdx) {
-    const n = nodes[idx];
-    if (n.kind === "literal" && !n.insensitive) {
-      prefixBytes.push(n.code);
-      idx++;
-    } else {
-      break;
-    }
-  }
-  if (idx === endIdx - 1) {
-    let tail = nodes[idx];
-    while (tail.kind === "group") tail = tail.child;
-    if (tail.kind === "alternative" && tail.children.length > 0) {
-      const branches = [];
-      let ok = true;
-      for (const b of tail.children) {
-        const bytes = extractLiteralBytes(b);
-        if (!bytes || bytes.length === 0) {
-          ok = false;
-          break;
-        }
-        branches.push(bytes);
-      }
-      if (ok) {
-        alts = branches;
-        idx++;
-      }
-    }
-  }
-  if (idx !== endIdx || prefixBytes.length === 0 && alts === null) {
-    fastPrefixAlts.set(root, null);
-    return null;
-  }
-  const created = {
-    anchoredStart,
-    anchoredEnd,
-    prefix: Uint8Array.from(prefixBytes),
-    alts
-  };
-  fastPrefixAlts.set(root, created);
-  return created;
-}
-function getFastEreLiteralSeq(root) {
-  const existing = fastLiteralSeqs.get(root);
-  if (existing !== void 0) return existing;
-  let anchoredStart = false;
-  let anchoredEnd = false;
-  let insensitive = false;
-  const bytes = [];
-  if (root.kind === "literal") {
-    insensitive = root.insensitive;
-    bytes.push(insensitive ? foldAscii(root.code) : root.code);
-  } else if (root.kind === "sequence") {
-    const children = root.children;
-    for (let i = 0; i < children.length; i++) {
-      const child = children[i];
-      if (child.kind === "start") {
-        if (i !== 0) {
-          fastLiteralSeqs.set(root, null);
-          return null;
-        }
-        anchoredStart = true;
-      } else if (child.kind === "end") {
-        if (i !== children.length - 1) {
-          fastLiteralSeqs.set(root, null);
-          return null;
-        }
-        anchoredEnd = true;
-      } else if (child.kind === "literal") {
-        if (bytes.length === 0) insensitive = child.insensitive;
-        else if (insensitive !== child.insensitive) {
-          fastLiteralSeqs.set(root, null);
-          return null;
-        }
-        bytes.push(insensitive ? foldAscii(child.code) : child.code);
-      } else {
-        fastLiteralSeqs.set(root, null);
-        return null;
-      }
-    }
-  } else {
-    fastLiteralSeqs.set(root, null);
-    return null;
-  }
-  const codes = Uint8Array.from(bytes);
-  const created = {
-    anchoredStart,
-    anchoredEnd,
-    codes,
-    insensitive,
-    spanAtZero: Object.freeze({ start: 0, end: codes.length })
-  };
-  fastLiteralSeqs.set(root, created);
-  return created;
-}
-function getSequenceNullNextTask(node) {
-  let cached = sequenceNullNextTasks.get(node);
-  if (!cached) {
-    let next = null;
-    for (let index = node.children.length - 1; index >= 0; index--) {
-      next = { kind: "node", node: node.children[index], next };
-    }
-    cached = next;
-    sequenceNullNextTasks.set(node, cached);
-  }
-  return cached;
-}
-var warmLedger = EreLedger.withPrevalidatedLimits({
-  patternBytes: Infinity,
-  subjectBytes: Infinity,
-  work: Infinity,
-  states: Infinity,
-  allocationUnits: Infinity,
-  captureBytes: Infinity,
-  captureSlots: Infinity
-});
-async function warmEreProgram(program) {
-  const root = resolveEreProgramUnchecked(program);
-  await prepareInitialCharacters(root, warmLedger);
-}
-function canFastSyncEreProgram(_program) {
-  return true;
-}
-function tryMatchEreAsciiRangeSync(program, buf, rStart, rEnd, ledger, signal, leftmostFirst = false, word = false, skipPerRowLedgerCharge = false) {
-  const root = resolveEreProgramUnchecked(program);
-  if (program.groups !== 0) {
-    if (!skipPerRowLedgerCharge || ledger.limits.work !== Infinity || ledger.limits.states !== Infinity || ledger.limits.allocationUnits !== Infinity || ledger.limits.captureBytes !== Infinity || ledger.limits.captureSlots !== Infinity) {
-      return null;
-    }
-  }
-  const initial = root.nullable ? void 0 : initialCharacters.get(root);
-  if (!root.nullable && !initial) return null;
-  const rLen = rEnd - rStart;
-  if (!skipPerRowLedgerCharge) {
-    ledger.check(signal);
-    ledger.admitInput("subjectBytes", rLen, signal);
-    ledger.charge("allocationUnits", rLen * 11 + 23, signal);
-    ledger.chargeWork(rLen * 4 + 4, signal);
-  }
-  const fastSeq = getFastEreLiteralSeq(root);
-  if (fastSeq !== null) {
-    const { anchoredStart, anchoredEnd, codes, insensitive, spanAtZero } = fastSeq;
-    const patLen = codes.length;
-    if (rLen < patLen || anchoredStart && anchoredEnd && rLen !== patLen) {
-      if (!skipPerRowLedgerCharge) ledger.chargeWork(1, signal);
-      return void 0;
-    }
-    if (anchoredStart) {
-      if (!skipPerRowLedgerCharge) ledger.chargeWork(1 + patLen, signal);
-      if (!insensitive) {
-        for (let i = 0; i < patLen; i++) {
-          if (buf[rStart + i] !== codes[i]) return void 0;
-        }
-      } else {
-        for (let i = 0; i < patLen; i++) {
-          if (foldAscii(buf[rStart + i]) !== codes[i]) return void 0;
-        }
-      }
-      if (word && patLen > 0 && patLen < rLen && isAsciiWord(buf[rStart + patLen])) return void 0;
-      return spanAtZero;
-    }
-    if (anchoredEnd && !word) {
-      const start = rLen - patLen;
-      if (!skipPerRowLedgerCharge) ledger.chargeWork(1 + patLen, signal);
-      if (!insensitive) {
-        for (let i = 0; i < patLen; i++) {
-          if (buf[rStart + start + i] !== codes[i]) return void 0;
-        }
-      } else {
-        for (let i = 0; i < patLen; i++) {
-          if (foldAscii(buf[rStart + start + i]) !== codes[i]) return void 0;
-        }
-      }
-      return start === 0 ? spanAtZero : { start, end: rLen };
-    }
-  }
-  if (ledger.limits.work === Infinity && ledger.limits.states === Infinity && ledger.limits.allocationUnits === Infinity) {
-    const fastPA = getFastErePrefixAlt(root);
-    if (fastPA !== null && fastPA.prefix.length > 0) {
-      const { anchoredStart, anchoredEnd, prefix, alts } = fastPA;
-      const pLen = prefix.length;
-      const p0 = prefix[0];
-      let searchPos = rStart;
-      const maxSearch = anchoredStart ? rStart : rEnd - pLen;
-      while (searchPos <= maxSearch) {
-        const foundAbs = anchoredStart ? buf[rStart] === p0 ? rStart : -1 : buf.indexOf(p0, searchPos);
-        if (foundAbs < 0 || foundAbs > maxSearch) break;
-        const relStart = foundAbs - rStart;
-        let prefixOk = true;
-        for (let k = 1; k < pLen; k++) {
-          if (buf[foundAbs + k] !== prefix[k]) {
-            prefixOk = false;
-            break;
-          }
-        }
-        if (prefixOk && (!word || relStart === 0 || !isAsciiWord(buf[foundAbs - 1]))) {
-          if (alts === null) {
-            const relEnd = relStart + pLen;
-            if ((!anchoredEnd || relEnd === rLen) && (!word || relEnd === rLen || !isAsciiWord(buf[rStart + relEnd]))) {
-              return { start: relStart, end: relEnd };
-            }
-          } else {
-            let bestEnd = -1;
-            const afterPrefixAbs = foundAbs + pLen;
-            for (let a = 0; a < alts.length; a++) {
-              const alt = alts[a];
-              const aLen = alt.length;
-              if (afterPrefixAbs + aLen > rEnd) continue;
-              let altOk = true;
-              for (let k = 0; k < aLen; k++) {
-                if (buf[afterPrefixAbs + k] !== alt[k]) {
-                  altOk = false;
-                  break;
-                }
-              }
-              if (!altOk) continue;
-              const relEnd = relStart + pLen + aLen;
-              if (anchoredEnd && relEnd !== rLen) continue;
-              if (word && relEnd < rLen && isAsciiWord(buf[rStart + relEnd])) continue;
-              if (leftmostFirst) {
-                bestEnd = relEnd;
-                break;
-              }
-              if (relEnd > bestEnd) bestEnd = relEnd;
-            }
-            if (bestEnd >= 0) return { start: relStart, end: bestEnd };
-          }
-        }
-        if (anchoredStart) break;
-        searchPos = foundAbs + 1;
-      }
-      return void 0;
-    }
-  }
-  const unbounded = skipPerRowLedgerCharge && ledger.limits.work === Infinity && ledger.limits.states === Infinity && ledger.limits.allocationUnits === Infinity;
-  return tryMatchEreAsciiRangeNfaSync(root, initial, buf, rStart, rLen, ledger, signal, leftmostFirst, word, unbounded);
-}
-function tryMatchEreAsciiRangeNfaSync(root, initial, buf, rStart, rLen, ledger, signal, leftmostFirst, word, unbounded = false) {
-  let firstLitCode = -1;
-  let secondLitCode = -1;
-  let rootSeqLen = 0;
-  if (root.kind === "sequence" && root.children.length >= 1) {
-    const c0 = root.children[0];
-    if (c0.kind === "literal" && !c0.insensitive) {
-      firstLitCode = c0.code;
-      if (root.children.length >= 2) {
-        const c1 = root.children[1];
-        if (c1.kind === "literal" && !c1.insensitive) {
-          secondLitCode = c1.code;
-          rootSeqLen = root.children.length;
-        }
-      }
-    }
-  }
-  if (unbounded) {
-    if (signal?.aborted) throw signal.reason;
-    const pendingPos = [];
-    const pendingTask = [];
-    const push2 = (position, next) => {
-      pendingPos.push(position);
-      pendingTask.push(next);
-    };
-    const rootTask2 = root.kind === "sequence" ? getSequenceNullNextTask(root) : { kind: "node", node: root, next: null };
-    const anchored = root.kind === "start" || root.kind === "sequence" && root.children[0]?.kind === "start";
-    const maxStart2 = anchored ? 0 : rLen;
-    for (let start = 0; start <= maxStart2; start++) {
-      if (firstLitCode >= 0 && !anchored) {
-        const found = buf.indexOf(firstLitCode, rStart + start);
-        if (found < 0 || found >= rStart + rLen) break;
-        start = found - rStart;
-      } else if (initial) {
-        const firstCode = start < rLen ? buf[rStart + start] : -1;
-        if (firstCode < 0 || !initial[firstCode]) continue;
-      }
-      if (word && start > 0 && isAsciiWord(buf[rStart + start - 1])) continue;
-      if (secondLitCode >= 0 && (start + 1 >= rLen || buf[rStart + start + 1] !== secondLitCode)) continue;
-      push2(start, rootTask2);
-      let bestPos = -1;
-      while (pendingPos.length > 0) {
-        const statePos = pendingPos.pop();
-        const current = pendingTask.pop();
-        if (current === null) {
-          if (word && statePos < rLen && isAsciiWord(buf[rStart + statePos])) continue;
-          if (leftmostFirst) {
-            bestPos = statePos;
-            pendingPos.length = 0;
-            pendingTask.length = 0;
-            break;
-          }
-          if (statePos > bestPos) bestPos = statePos;
-          continue;
-        }
-        if (current.kind === "repeat") {
-          const { node: node2, count } = current;
-          if (count === 0 && node2.child.kind === "dot" && node2.max === Infinity) {
-            let maxDotPos = rLen;
-            if (leftmostFirst) {
-              const nl = buf.indexOf(10, rStart + statePos);
-              if (nl >= 0 && nl < rStart + rLen) maxDotPos = nl - rStart;
-            }
-            const minDotPos = statePos + node2.min;
-            if (minDotPos <= maxDotPos) {
-              const nextTask = current.next;
-              if (nextTask && nextTask.kind === "node" && nextTask.node.kind === "literal" && !nextTask.node.insensitive) {
-                const targetCode = nextTask.node.code;
-                const afterLit = nextTask.next;
-                for (let p = minDotPos; p < maxDotPos; p++) {
-                  if (buf[rStart + p] === targetCode) push2(p + 1, afterLit);
-                }
-              } else {
-                for (let p = minDotPos; p <= maxDotPos; p++) {
-                  push2(p, nextTask);
-                }
-              }
-            }
-            continue;
-          }
-          if (count >= node2.min) push2(statePos, current.next);
-          const noProgress = count > 0 && statePos === current.previous;
-          if (count < node2.max && (!noProgress || count < node2.min)) {
-            const repeat = { kind: "repeat", node: node2, count: count + 1, previous: statePos, next: current.next };
-            push2(statePos, { kind: "node", node: node2.child, next: repeat });
-          }
-          continue;
-        }
-        if (current.kind === "close") return null;
-        const node = current.node;
-        switch (node.kind) {
-          case "empty":
-            push2(statePos, current.next);
-            break;
-          case "start":
-            if (statePos === 0) push2(statePos, current.next);
-            break;
-          case "end":
-            if (statePos === rLen) push2(statePos, current.next);
-            break;
-          case "dot":
-          case "literal":
-          case "set": {
-            if (statePos < rLen) {
-              const code = buf[rStart + statePos];
-              if (node.kind === "dot" && (!leftmostFirst || code !== 10) || node.kind === "literal" && (node.insensitive ? foldAscii(node.code) === foldAscii(code) : node.code === code) || node.kind === "set" && (code < 128 ? node.members[code] : node.nonAscii)) {
-                push2(statePos + 1, current.next);
-              }
-            }
-            break;
-          }
-          case "sequence": {
-            if (current.next === null) {
-              push2(statePos, getSequenceNullNextTask(node));
-            } else {
-              let next = current.next;
-              for (let index = node.children.length - 1; index >= 0; index--) {
-                next = { kind: "node", node: node.children[index], next };
-              }
-              push2(statePos, next);
-            }
-            break;
-          }
-          case "alternative":
-            for (let index = node.children.length - 1; index >= 0; index--) {
-              push2(statePos, { kind: "node", node: node.children[index], next: current.next });
-            }
-            break;
-          case "group":
-            push2(statePos, { kind: "node", node: node.child, next: current.next });
-            break;
-          case "repeat":
-            push2(statePos, { kind: "repeat", node, count: 0, previous: -1, next: current.next });
-            break;
-        }
-      }
-      if (bestPos >= 0) return { start, end: bestPos };
-    }
-    return void 0;
-  }
-  const pending = [];
-  const push = (position, next) => {
-    ledger.charge("states", 1, signal);
-    ledger.charge("allocationUnits", 5, signal);
-    pending.push({ position, task: next, captures: SINGLE_NULL_CAPTURES, histories: SINGLE_NULL_HISTORIES });
-  };
-  const rootTask = root.kind === "sequence" ? getSequenceNullNextTask(root) : { kind: "node", node: root, next: null };
-  const maxStart = root.kind === "start" || root.kind === "sequence" && root.children[0]?.kind === "start" ? 0 : rLen;
-  for (let start = 0; start <= maxStart; start++) {
-    if (initial) {
-      ledger.chargeWork(1, signal);
-      const firstCode = start < rLen ? buf[rStart + start] : -1;
-      if (firstCode < 0 || !initial[firstCode]) continue;
-    }
-    if (word) {
-      ledger.chargeWork(1, signal);
-      if (start > 0 && isAsciiWord(buf[rStart + start - 1])) continue;
-    }
-    if (secondLitCode >= 0) {
-      if (start + 1 >= rLen || buf[rStart + start + 1] !== secondLitCode) {
-        ledger.chargeWork(3 + rootSeqLen, signal);
-        ledger.charge("states", 3, signal);
-        ledger.charge("allocationUnits", (rootSeqLen + 1) * 5 + 15, signal);
-        continue;
-      }
-    }
-    if (root.kind === "sequence") {
-      ledger.charge("allocationUnits", 5, signal);
-      ledger.charge("states", 1, signal);
-      ledger.charge("allocationUnits", 5, signal);
-      ledger.chargeWork(1 + root.children.length, signal);
-      ledger.charge("allocationUnits", root.children.length * 5, signal);
-      push(start, rootTask);
-    } else {
-      ledger.charge("allocationUnits", 5, signal);
-      push(start, rootTask);
-    }
-    let bestPos = -1;
-    while (pending.length > 0) {
-      if (ledger.workAllowanceUntilCheckpoint(signal) < 64 && !ledger.advanceSyncCheckpointIfNoExternalYield(signal)) return null;
-      ledger.chargeWork(1, signal);
-      const state = pending.pop();
-      const current = state.task;
-      if (current === null) {
-        if (word && state.position < rLen && isAsciiWord(buf[rStart + state.position])) continue;
-        if (leftmostFirst) {
-          bestPos = state.position;
-          pending.length = 0;
-          break;
-        }
-        if (state.position > bestPos) bestPos = state.position;
-        continue;
-      }
-      if (current.kind === "repeat") {
-        const { node: node2, count } = current;
-        if (count >= node2.min) push(state.position, current.next);
-        const noProgress = count > 0 && state.position === current.previous;
-        if (count < node2.max && (!noProgress || count < node2.min)) {
-          ledger.charge("allocationUnits", 10, signal);
-          const repeat = { kind: "repeat", node: node2, count: count + 1, previous: state.position, next: current.next };
-          push(state.position, { kind: "node", node: node2.child, next: repeat });
-        }
-        continue;
-      }
-      if (current.kind === "close") return null;
-      const node = current.node;
-      switch (node.kind) {
-        case "empty":
-          push(state.position, current.next);
-          break;
-        case "start":
-          if (state.position === 0) push(state.position, current.next);
-          break;
-        case "end":
-          if (state.position === rLen) push(state.position, current.next);
-          break;
-        case "dot":
-        case "literal":
-        case "set": {
-          if (state.position < rLen) {
-            const code = buf[rStart + state.position];
-            if (node.kind === "dot" && (!leftmostFirst || code !== 10) || node.kind === "literal" && (node.insensitive ? foldAscii(node.code) === foldAscii(code) : node.code === code) || node.kind === "set" && (code < 128 ? node.members[code] : node.nonAscii)) {
-              push(state.position + 1, current.next);
-            }
-          }
-          break;
-        }
-        case "sequence": {
-          if (ledger.workAllowanceUntilCheckpoint(signal) < node.children.length + 4 && !ledger.advanceSyncCheckpointIfNoExternalYield(signal)) return null;
-          ledger.chargeWork(node.children.length, signal);
-          ledger.charge("allocationUnits", node.children.length * 5, signal);
-          if (current.next === null) {
-            push(state.position, getSequenceNullNextTask(node));
-          } else {
-            let next = current.next;
-            for (let index = node.children.length - 1; index >= 0; index--) {
-              next = { kind: "node", node: node.children[index], next };
-            }
-            push(state.position, next);
-          }
-          break;
-        }
-        case "alternative":
-          if (ledger.workAllowanceUntilCheckpoint(signal) < node.children.length + 4 && !ledger.advanceSyncCheckpointIfNoExternalYield(signal)) return null;
-          for (let index = node.children.length - 1; index >= 0; index--) {
-            ledger.chargeWork(1, signal);
-            ledger.charge("allocationUnits", 5, signal);
-            push(state.position, { kind: "node", node: node.children[index], next: current.next });
-          }
-          break;
-        case "group":
-          ledger.charge("allocationUnits", 5, signal);
-          push(state.position, { kind: "node", node: node.child, next: current.next });
-          break;
-        case "repeat":
-          ledger.charge("allocationUnits", 5, signal);
-          push(state.position, { kind: "repeat", node, count: 0, previous: -1, next: current.next });
-          break;
-      }
-    }
-    if (bestPos >= 0) {
-      ledger.charge("allocationUnits", 4, signal);
-      ledger.check(signal);
-      return { start, end: bestPos };
-    }
-  }
-  return void 0;
-}
-async function prepareInitialCharacters(root, ledger, signal) {
-  if (root.nullable) return void 0;
-  const cached = initialCharacters.get(root);
-  if (cached) return cached;
-  ledger.charge("work", 129, signal);
-  ledger.charge("allocationUnits", 133, signal);
-  {
-    const c = ledger.checkpoint(signal);
-    if (c) await c;
-  }
-  const codes = new Array(129).fill(false);
-  const pending = [root];
-  while (pending.length > 0) {
-    ledger.charge("work", 1, signal);
-    {
-      const c = ledger.checkpoint(signal);
-      if (c) await c;
-    }
-    const node = pending.pop();
-    switch (node.kind) {
-      case "literal": {
-        codes[node.code] = true;
-        const folded = foldAscii(node.code);
-        if (node.insensitive && folded >= 97 && folded <= 122) {
-          codes[folded] = codes[folded - 32] = true;
-        }
-        break;
-      }
-      case "dot":
-      case "set":
-        for (let code = 0; code < codes.length; code++) {
-          ledger.charge("work", 1, signal);
-          {
-            const c = ledger.checkpoint(signal);
-            if (c) await c;
-          }
-          if (node.kind === "dot" || node.kind === "set" && (code < 128 ? node.members[code] : node.nonAscii)) codes[code] = true;
-        }
-        break;
-      case "group":
-      case "repeat":
-        if (node.kind === "repeat" && node.max === 0) break;
-        ledger.charge("allocationUnits", 1, signal);
-        pending.push(node.child);
-        break;
-      case "sequence":
-      case "alternative":
-        for (const child of node.children) {
-          ledger.charge("work", 1, signal);
-          ledger.charge("allocationUnits", 1, signal);
-          {
-            const c = ledger.checkpoint(signal);
-            if (c) await c;
-          }
-          pending.push(child);
-          if (node.kind === "sequence" && !child.nullable) break;
-        }
-        break;
-    }
-  }
-  ledger.check(signal);
-  initialCharacters.set(root, Object.freeze(codes));
-  return codes;
-}
-function spanOrder(left, right) {
-  if (left === null) return right === null ? 0 : -1;
-  if (right === null) return 1;
-  const length = left.end - left.start - (right.end - right.start);
-  return length === 0 ? right.start - left.start : length;
-}
-async function historySpans(history, ledger, signal) {
-  ledger.charge("work", history.count, signal);
-  ledger.charge("allocationUnits", history.count + 1, signal);
-  {
-    const c = ledger.checkpoint(signal);
-    if (c) await c;
-  }
-  const spans = new Array(history.count);
-  for (let entry = history; entry !== null; entry = entry.previous) {
-    ledger.charge("work", 1, signal);
-    {
-      const c = ledger.checkpoint(signal);
-      if (c) await c;
-    }
-    spans[entry.count - 1] = entry.span;
-  }
-  return spans;
-}
-async function historyOrder(left, right, ledger, signal) {
-  const leftCount = left?.count ?? 0;
-  const rightCount = right?.count ?? 0;
-  if (left === null || right === null) return leftCount - rightCount;
-  const leftSpans = await historySpans(left, ledger, signal);
-  const rightSpans = await historySpans(right, ledger, signal);
-  for (let ordinal = 0; ordinal < Math.min(leftCount, rightCount); ordinal++) {
-    ledger.charge("work", 1, signal);
-    {
-      const c = ledger.checkpoint(signal);
-      if (c) await c;
-    }
-    const compared = spanOrder(leftSpans[ordinal], rightSpans[ordinal]);
-    if (compared !== 0) return compared;
-  }
-  return leftCount - rightCount;
-}
-async function preferred(candidate, incumbent, ledger, signal) {
-  if (candidate.position !== incumbent.position) return candidate.position > incumbent.position;
-  for (let group = 1; group < candidate.captures.length; group++) {
-    ledger.charge("work", 1, signal);
-    {
-      const c = ledger.checkpoint(signal);
-      if (c) await c;
-    }
-    const compared = await historyOrder(candidate.histories[group], incumbent.histories[group], ledger, signal);
-    if (compared !== 0) return compared > 0;
-  }
-  return false;
-}
-function resetDescendants(node, previous, ledger, signal) {
-  if (ledger.charge === EreLedger.prototype.charge && ledger.workAllowanceUntilCheckpoint(signal) >= previous.length + 32) {
-    ledger.charge("work", previous.length, signal);
-    ledger.charge("allocationUnits", previous.length + 3, signal);
-    const captures = previous.slice();
-    ledger.charge("work", 1, signal);
-    if (node.kind === "group") {
-      captures[node.index] = null;
-      if (!node.child.captured) return captures;
-    }
-    const pending = [node];
-    while (pending.length > 0 && ledger.workAllowanceUntilCheckpoint(signal) >= 16) {
-      ledger.chargeWork(1, signal);
-      const current = pending.pop();
-      if (current.kind === "group") captures[current.index] = null;
-      if (current.kind === "group" || current.kind === "repeat") {
-        if (current.child.captured) {
-          ledger.charge("allocationUnits", 1, signal);
-          pending.push(current.child);
-        }
-      } else if (current.kind === "sequence" || current.kind === "alternative") {
-        for (const child of current.children) {
-          ledger.chargeWork(1, signal);
-          if (child.captured) {
-            ledger.charge("allocationUnits", 1, signal);
-            pending.push(child);
-          }
-        }
-      }
-    }
-    if (pending.length === 0) return captures;
-  }
-  return (async () => {
-    ledger.charge("work", previous.length, signal);
-    ledger.charge("allocationUnits", previous.length + 3, signal);
-    {
-      const c = ledger.checkpoint(signal);
-      if (c) await c;
-    }
-    const captures = previous.slice();
-    const pending = [node];
-    while (pending.length > 0) {
-      ledger.charge("work", 1, signal);
-      {
-        const c = ledger.checkpoint(signal);
-        if (c) await c;
-      }
-      const current = pending.pop();
-      if (current.kind === "group") captures[current.index] = null;
-      if (current.kind === "group" || current.kind === "repeat") {
-        if (current.child.captured) {
-          ledger.charge("allocationUnits", 1, signal);
-          pending.push(current.child);
-        }
-      } else if (current.kind === "sequence" || current.kind === "alternative") {
-        for (const child of current.children) {
-          ledger.charge("work", 1, signal);
-          {
-            const c = ledger.checkpoint(signal);
-            if (c) await c;
-          }
-          if (child.captured) {
-            ledger.charge("allocationUnits", 1, signal);
-            pending.push(child);
-          }
-        }
-      }
-    }
-    return captures;
-  })();
-}
-var ereLinearChainCache = /* @__PURE__ */ new WeakMap();
-function ereAtomMatchesCode(atom, code) {
-  if (atom.kind === "literal") {
-    return atom.insensitive ? foldAscii(atom.code) === foldAscii(code) : atom.code === code;
-  }
-  return code < 128 ? atom.members[code] : atom.nonAscii;
-}
-function ereAtomsDisjoint(a, b) {
-  for (let code = 0; code <= 128; code++) {
-    if (ereAtomMatchesCode(a, code) && ereAtomMatchesCode(b, code)) return false;
-  }
-  return true;
-}
-function admitSynchronousWork(ledger, amount, signal) {
-  if (ledger.workAllowanceUntilCheckpoint(signal) < amount) {
-    ledger.check(signal);
-    return false;
-  }
-  ledger.chargeWork(amount, signal);
-  return true;
-}
-function compileEreLinearChain(root, ledger, signal) {
-  if (!admitSynchronousWork(ledger, 1, signal)) return void 0;
-  const cached = ereLinearChainCache.get(root);
-  if (cached !== void 0) return cached;
-  ledger.charge("allocationUnits", 3, signal);
-  let anchoredStart = false;
-  let anchoredEnd = false;
-  let seenConsuming = false;
-  const steps = [];
-  const pending = [root];
-  let supported = true;
-  while (pending.length > 0 && supported) {
-    if (!admitSynchronousWork(ledger, 1, signal)) return void 0;
-    const node = pending.pop();
-    switch (node.kind) {
-      case "start":
-        if (seenConsuming || steps.length > 0) {
-          supported = false;
-          break;
-        }
-        anchoredStart = true;
-        break;
-      case "end":
-        anchoredEnd = true;
-        break;
-      case "sequence":
-        if (!admitSynchronousWork(ledger, node.children.length, signal)) return void 0;
-        ledger.charge("allocationUnits", node.children.length, signal);
-        for (let i = node.children.length - 1; i >= 0; i--) pending.push(node.children[i]);
-        break;
-      case "group":
-        if (anchoredEnd) {
-          supported = false;
-          break;
-        }
-        ledger.charge("allocationUnits", 7, signal);
-        steps.push({ kind: "groupOpen", index: node.index });
-        pending.push({ kind: "groupClose", index: node.index }, node.child);
-        break;
-      case "groupClose":
-        ledger.charge("allocationUnits", 1, signal);
-        steps.push(node);
-        break;
-      case "literal":
-      case "set":
-        if (anchoredEnd) {
-          supported = false;
-          break;
-        }
-        seenConsuming = true;
-        ledger.charge("allocationUnits", 3, signal);
-        steps.push({ kind: "char", atom: node });
-        break;
-      case "repeat":
-        if (anchoredEnd || node.min < 1 || node.max !== Infinity || node.child.kind !== "literal" && node.child.kind !== "set") {
-          supported = false;
-          break;
-        }
-        seenConsuming = true;
-        ledger.charge("allocationUnits", 4, signal);
-        steps.push({ kind: "repeat", atom: node.child, min: node.min });
-        break;
-      default:
-        supported = false;
-    }
-  }
-  let firstAtom;
-  for (let i = steps.length - 1; supported && i >= 0; i--) {
-    if (!admitSynchronousWork(ledger, 1, signal)) return void 0;
-    const step = steps[i];
-    if (step.kind !== "char" && step.kind !== "repeat") continue;
-    if (step.kind === "repeat" && firstAtom) {
-      if (!admitSynchronousWork(ledger, 129, signal)) return void 0;
-      if (!ereAtomsDisjoint(step.atom, firstAtom)) supported = false;
-    }
-    firstAtom = step.atom;
-  }
-  if (!admitSynchronousWork(ledger, 1, signal)) return void 0;
-  ledger.charge("allocationUnits", supported && seenConsuming ? 6 : 2, signal);
-  if (!supported || !seenConsuming) {
-    ereLinearChainCache.set(root, null);
-    return null;
-  }
-  const compiled = { anchoredStart, anchoredEnd, steps, firstAtom };
-  ereLinearChainCache.set(root, compiled);
-  return compiled;
-}
-function tryMatchEreLinearChainSync(program, root, subject, ledger, signal) {
-  const chain = compileEreLinearChain(root, ledger, signal);
-  if (!chain) return void 0;
-  const width = program.groups + 1;
-  if (!admitSynchronousWork(ledger, width * 2, signal)) return void 0;
-  ledger.charge("allocationUnits", width * 2 + 2, signal);
-  const groupStarts = new Int32Array(width);
-  const groupEnds = new Int32Array(width);
-  const maxStart = chain.anchoredStart ? 0 : subject.length;
-  const steps = chain.steps;
-  const stepsLen = steps.length;
-  for (let start = 0; start <= maxStart; start++) {
-    if (!admitSynchronousWork(ledger, 1, signal)) return void 0;
-    ledger.charge("states", 1, signal);
-    if (chain.firstAtom) {
-      if (start >= subject.length) break;
-      if (!ereAtomMatchesCode(chain.firstAtom, subject.charCodeAt(start))) {
-        continue;
-      }
-    }
-    if (!admitSynchronousWork(ledger, width * 2, signal)) return void 0;
-    groupStarts.fill(-1);
-    groupEnds.fill(-1);
-    let pos = start;
-    let ok = true;
-    for (let s = 0; s < stepsLen; s++) {
-      if (!admitSynchronousWork(ledger, 1, signal)) return void 0;
-      ledger.charge("states", 1, signal);
-      const step = steps[s];
-      if (step.kind === "groupOpen") {
-        groupStarts[step.index] = pos;
-      } else if (step.kind === "groupClose") {
-        groupEnds[step.index] = pos;
-      } else if (step.kind === "char") {
-        if (pos >= subject.length || !ereAtomMatchesCode(step.atom, subject.charCodeAt(pos))) {
-          ok = false;
-          break;
-        }
-        pos++;
-      } else {
-        let count = 0;
-        while (pos < subject.length) {
-          if (!admitSynchronousWork(ledger, 1, signal)) return void 0;
-          ledger.charge("states", 1, signal);
-          if (!ereAtomMatchesCode(step.atom, subject.charCodeAt(pos))) break;
-          pos++;
-          count++;
-        }
-        if (count < step.min) {
-          ok = false;
-          break;
-        }
-      }
-    }
-    if (!ok || chain.anchoredEnd && pos !== subject.length) continue;
-    if (!admitSynchronousWork(ledger, width, signal)) return void 0;
-    let bytes = pos - start;
-    for (let g = 1; g < width; g++) {
-      if (groupStarts[g] >= 0 && groupEnds[g] >= groupStarts[g]) {
-        bytes += groupEnds[g] - groupStarts[g];
-      }
-    }
-    if (!admitSynchronousWork(ledger, width * 3 + bytes, signal)) return void 0;
-    ledger.charge("captureSlots", width, signal);
-    ledger.charge("captureBytes", bytes, signal);
-    ledger.charge("allocationUnits", width * 4 + bytes + 6, signal);
-    const captures = new Array(width);
-    const values = new Array(width);
-    captures[0] = Object.freeze({ start, end: pos });
-    values[0] = subject.slice(start, pos);
-    for (let g = 1; g < width; g++) {
-      const gs = groupStarts[g];
-      const ge = groupEnds[g];
-      if (gs >= 0 && ge >= gs) {
-        captures[g] = Object.freeze({ start: gs, end: ge });
-        values[g] = subject.slice(gs, ge);
-      } else {
-        captures[g] = null;
-        values[g] = "";
-      }
-    }
-    ledger.check(signal);
-    return Object.freeze({ matched: true, captures: Object.freeze(captures), values: Object.freeze(values) });
-  }
-  if (!admitSynchronousWork(ledger, 1, signal)) return void 0;
-  ledger.charge("allocationUnits", 4, signal);
-  ledger.check(signal);
-  return Object.freeze({ matched: false, captures: Object.freeze([]), values: Object.freeze([]) });
-}
-function tryMatchEreSync(program, subject, ledger, signal) {
-  ledger.check(signal);
-  const root = resolveEreProgram(program, ledger);
-  if (subject.length > ledger.limits.subjectBytes || ledger.workAllowanceUntilCheckpoint(signal) < subject.length + 16) {
-    return void 0;
-  }
-  ledger.admitInput("subjectBytes", subject.length, signal);
-  const adm = admitAscii(subject, ledger, signal);
-  if (adm) return void 0;
-  return tryMatchEreLinearChainSync(program, root, subject, ledger, signal);
-}
-async function matchEre(program, subject, ledger, signal) {
-  ledger.check(signal);
-  resolveEreProgram(program, ledger);
-  ledger.admitInput("subjectBytes", subject.length, signal);
-  const root = resolveEreProgram(program, ledger);
-  const adm = admitAscii(subject, ledger, signal);
-  if (adm) await adm;
-  const fastLinear = tryMatchEreLinearChainSync(program, root, subject, ledger, signal);
-  if (fastLinear !== void 0) return fastLinear;
-  return runMatcher(program, subject, ledger, signal, 0, true);
-}
-async function prepareUtf8EreSubject(bytes, ledger, signal, leftmostFirst = false, word = false) {
-  ledger.check(signal);
-  ledger.admitInput("subjectBytes", bytes.length, signal);
-  ledger.charge("allocationUnits", bytes.length * 11 + 16, signal);
-  ledger.charge("work", bytes.length, signal);
-  const owned = new Uint8Array(bytes);
-  await validateUtf8(owned, ledger, signal);
-  const characters = [];
-  const offsets = [];
-  for (let offset = 0; offset < owned.length; ) {
-    const first = owned[offset];
-    const width = word || first < 128 ? 1 : first < 224 ? 2 : first < 240 ? 3 : 4;
-    ledger.charge("work", width, signal);
-    {
-      const c = ledger.checkpoint(signal);
-      if (c) await c;
-    }
-    offsets.push(offset);
-    characters.push(String.fromCharCode(first < 128 ? first : 128));
-    offset += width;
-  }
-  offsets.push(owned.length);
-  ledger.charge("work", characters.length, signal);
-  {
-    const c = ledger.checkpoint(signal);
-    if (c) await c;
-  }
-  const subject = characters.join("");
-  return (program) => {
-    resolveEreProgram(program, ledger);
-    ledger.charge("allocationUnits", 2, signal);
-    return async (start) => {
-      if (!Number.isSafeInteger(start) || start < 0 || start > owned.length) throw new RangeError("Invalid UTF-8 ERE search cursor");
-      let lower = 0, upper = offsets.length - 1;
-      while (lower < upper) {
-        ledger.charge("work", 1, signal);
-        {
-          const c = ledger.checkpoint(signal);
-          if (c) await c;
-        }
-        const middle = Math.floor((lower + upper) / 2);
-        if (offsets[middle] < start) lower = middle + 1;
-        else upper = middle;
-      }
-      if (offsets[lower] !== start) throw new RangeError("UTF-8 ERE cursor must be a scalar boundary");
-      const span = await runMatcher(program, subject, ledger, signal, lower, false, leftmostFirst, word);
-      if (!span) return void 0;
-      ledger.charge("allocationUnits", 2, signal);
-      return Object.freeze({ start: offsets[span.start], end: offsets[span.end] });
-    };
-  };
-}
-async function runMatcher(program, subject, ledger, signal, from, materialize, leftmostFirst = false, word = false) {
-  const root = resolveEreProgram(program, ledger);
-  const initial = await prepareInitialCharacters(root, ledger, signal);
-  const width = program.groups + 1;
-  ledger.charge("work", width * 2, signal);
-  ledger.charge("allocationUnits", width * 2 + 1, signal);
-  {
-    const c = ledger.checkpoint(signal);
-    if (c) await c;
-  }
-  const emptyCaptures = Object.freeze(new Array(width).fill(null));
-  const emptyHistories = Object.freeze(new Array(width).fill(null));
-  const pending = [];
-  const task = (create) => {
-    ledger.charge("allocationUnits", 5, signal);
-    return create();
-  };
-  const push = (position, next, captures, histories) => {
-    ledger.charge("states", 1, signal);
-    ledger.charge("allocationUnits", 5, signal);
-    pending.push({ position, task: next, captures, histories });
-  };
-  for (let start = from; start <= subject.length; start++) {
-    if (initial) {
-      ledger.charge("work", 1, signal);
-      const pendingCheck = ledger.checkpoint(signal);
-      if (pendingCheck) await pendingCheck;
-      if (!initial[subject.charCodeAt(start)]) continue;
-    }
-    if (word) {
-      ledger.charge("work", 1, signal);
-      const pendingCheck = ledger.checkpoint(signal);
-      if (pendingCheck) await pendingCheck;
-      if (isAsciiWord(subject.charCodeAt(start - 1))) continue;
-    }
-    push(start, task(() => ({ kind: "node", node: root, next: null })), emptyCaptures, emptyHistories);
-    let best;
-    while (pending.length > 0) {
-      ledger.charge("work", 1, signal);
-      const pendingCheck = ledger.checkpoint(signal);
-      if (pendingCheck) await pendingCheck;
-      const state = pending.pop();
-      const current = state.task;
-      if (current === null) {
-        if (word && isAsciiWord(subject.charCodeAt(state.position))) continue;
-        if (leftmostFirst) {
-          best = state;
-          break;
-        }
-        if (!best || (state.position !== best.position ? state.position > best.position : await preferred(state, best, ledger, signal))) best = state;
-        continue;
-      }
-      if (current.kind === "close") {
-        ledger.charge("work", width * 2, signal);
-        ledger.charge("allocationUnits", width * 2 + 6, signal);
-        {
-          const c = ledger.checkpoint(signal);
-          if (c) await c;
-        }
-        const span = Object.freeze({ start: current.start, end: state.position });
-        const captures = state.captures.slice();
-        captures[current.group] = span;
-        const histories = state.histories.slice();
-        const previous = histories[current.group];
-        histories[current.group] = { span, previous, count: (previous?.count ?? 0) + 1 };
-        push(state.position, current.next, captures, histories);
-        continue;
-      }
-      if (current.kind === "repeat") {
-        const { node: node2, count } = current;
-        if (count >= node2.min) push(state.position, current.next, state.captures, state.histories);
-        const noProgress = count > 0 && state.position === current.previous;
-        if (count < node2.max && (!noProgress || count < node2.min)) {
-          const repeat = task(() => ({ kind: "repeat", node: node2, count: count + 1, previous: state.position, next: current.next }));
-          push(state.position, task(() => ({ kind: "node", node: node2.child, next: repeat })), state.captures, state.histories);
-        }
-        continue;
-      }
-      const node = current.node;
-      switch (node.kind) {
-        case "empty":
-          push(state.position, current.next, state.captures, state.histories);
-          break;
-        case "start":
-          if (state.position === 0) push(state.position, current.next, state.captures, state.histories);
-          break;
-        case "end":
-          if (state.position === subject.length) push(state.position, current.next, state.captures, state.histories);
-          break;
-        case "dot":
-        case "literal":
-        case "set": {
-          const code = subject.charCodeAt(state.position);
-          if (state.position < subject.length && (node.kind === "dot" && (!leftmostFirst || code !== 10) || node.kind === "literal" && (node.insensitive ? foldAscii(node.code) === foldAscii(code) : node.code === code) || node.kind === "set" && (code < 128 ? node.members[code] : node.nonAscii))) {
-            push(state.position + 1, current.next, state.captures, state.histories);
-          }
-          break;
-        }
-        case "sequence": {
-          let next = current.next;
-          for (let index = node.children.length - 1; index >= 0; index--) {
-            ledger.charge("work", 1, signal);
-            {
-              const c = ledger.checkpoint(signal);
-              if (c) await c;
-            }
-            const following = next;
-            next = task(() => ({ kind: "node", node: node.children[index], next: following }));
-          }
-          push(state.position, next, state.captures, state.histories);
-          break;
-        }
-        case "alternative":
-          for (let index = node.children.length - 1; index >= 0; index--) {
-            ledger.charge("work", 1, signal);
-            {
-              const c = ledger.checkpoint(signal);
-              if (c) await c;
-            }
-            push(state.position, task(() => ({ kind: "node", node: node.children[index], next: current.next })), state.captures, state.histories);
-          }
-          break;
-        case "group": {
-          let captures = state.captures;
-          if (node.child.captured) {
-            const rd = resetDescendants(node.child, state.captures, ledger, signal);
-            captures = rd instanceof Promise ? await rd : rd;
-          }
-          const close = task(() => ({ kind: "close", group: node.index, start: state.position, next: current.next }));
-          push(state.position, task(() => ({ kind: "node", node: node.child, next: close })), captures, state.histories);
-          break;
-        }
-        case "repeat":
-          push(state.position, task(() => ({ kind: "repeat", node, count: 0, previous: -1, next: current.next })), state.captures, state.histories);
-          break;
-      }
-    }
-    if (best) {
-      if (!materialize) {
-        ledger.charge("allocationUnits", 2, signal);
-        ledger.check(signal);
-        return Object.freeze({ start, end: best.position });
-      }
-      ledger.charge("captureSlots", width, signal);
-      let bytes = best.position - start;
-      for (let group = 1; group < width; group++) {
-        ledger.charge("work", 1, signal);
-        {
-          const c = ledger.checkpoint(signal);
-          if (c) await c;
-        }
-        const span = best.captures[group];
-        if (span) bytes += span.end - span.start;
-      }
-      ledger.charge("captureBytes", bytes, signal);
-      ledger.charge("work", width * 2 + bytes, signal);
-      ledger.charge("allocationUnits", width * 2 + bytes + 4, signal);
-      {
-        const c = ledger.checkpoint(signal);
-        if (c) await c;
-      }
-      const captures = best.captures.slice();
-      captures[0] = Object.freeze({ start, end: best.position });
-      const values = new Array(width);
-      for (let group = 0; group < width; group++) {
-        ledger.charge("work", 1, signal);
-        {
-          const c = ledger.checkpoint(signal);
-          if (c) await c;
-        }
-        const span = captures[group];
-        values[group] = span === null ? "" : subject.slice(span.start, span.end);
-      }
-      ledger.check(signal);
-      return Object.freeze({ matched: true, captures: Object.freeze(captures), values: Object.freeze(values) });
-    }
-  }
-  ledger.check(signal);
-  if (!materialize) return void 0;
-  ledger.charge("allocationUnits", 3, signal);
-  return Object.freeze({ matched: false, captures: Object.freeze([]), values: Object.freeze([]) });
-}
-
-export {
-  foldAscii,
-  isAsciiWord,
-  EreSyntaxError,
-  EreUnsupportedError,
-  EreProfileLimitError,
-  EreUsageUnknownError,
-  EreLedger,
-  compileEre,
-  tryCompileEreSync,
-  validateUtf8,
-  warmEreProgram,
-  canFastSyncEreProgram,
-  tryMatchEreAsciiRangeSync,
-  tryMatchEreSync,
-  matchEre,
-  prepareUtf8EreSubject
-};
-//# sourceMappingURL=chunk-BPMCPTNP.js.map