@delali/narsil 0.3.1-next.74 → 0.3.1-next.76

package/dist/chunk-4344I4MR.mjs

@@ -0,0 +1,2217 @@
+import { tabulatedLevenshtein } from './chunk-GES7U2PM.mjs';
+import { NarsilError, ErrorCodes } from './chunk-I64LXKO3.mjs';
+
+// src/core/bitset.ts
+function createBitSet(capacity) {
+  return new Uint32Array(capacity + 31 >>> 5 || 1);
+}
+function bitsetSet(bs, index) {
+  const word = index >>> 5;
+  if (word < bs.length) {
+    bs[word] |= 1 << (index & 31);
+  }
+}
+function bitsetHas(bs, index) {
+  const word = index >>> 5;
+  if (word >= bs.length) return false;
+  return (bs[word] & 1 << (index & 31)) !== 0;
+}
+function bitsetAnd(a, b) {
+  const len = Math.min(a.length, b.length);
+  const result = new Uint32Array(len);
+  for (let i = 0; i < len; i++) {
+    result[i] = a[i] & b[i];
+  }
+  return result;
+}
+function bitsetAndInto(target, other) {
+  const shared = Math.min(target.length, other.length);
+  for (let i = 0; i < shared; i++) target[i] &= other[i];
+  target.fill(0, shared);
+}
+function bitsetOrInto(target, other) {
+  const shared = Math.min(target.length, other.length);
+  for (let i = 0; i < shared; i++) target[i] |= other[i];
+}
+function bitsetAndNotInto(target, removed) {
+  const shared = Math.min(target.length, removed.length);
+  for (let i = 0; i < shared; i++) target[i] &= ~removed[i];
+}
+function bitsetNot(bs, capacity) {
+  const result = new Uint32Array(bs.length);
+  const fullWords = capacity >>> 5;
+  for (let i = 0; i < fullWords; i++) {
+    result[i] = ~bs[i];
+  }
+  const remainder = capacity & 31;
+  if (remainder > 0 && fullWords < bs.length) {
+    result[fullWords] = ~bs[fullWords] & (1 << remainder) - 1;
+  }
+  return result;
+}
+function bitsetIsEmpty(bs) {
+  for (let i = 0; i < bs.length; i++) {
+    if (bs[i] !== 0) return false;
+  }
+  return true;
+}
+function bitsetFromSet(set, capacity) {
+  const bs = createBitSet(capacity);
+  for (const id of set) {
+    bs[id >>> 5] |= 1 << (id & 31);
+  }
+  return bs;
+}
+
+// src/core/pattern-index/constants.ts
+var DEFAULT_PATTERN_WORK_CAP = 25e6;
+var MAX_PATTERN_TEXT_CODE_POINTS = 1024;
+var MAX_PATTERN_POSITIONS = 2048;
+var MATCHER_STATE_BUDGET_BYTES = 1e6;
+var MATCHER_CODE_POINT_BYTES = 8;
+var MATCHER_SIMULATION_BYTES_PER_POSITION = 16;
+var MATCHER_STATE_OVERHEAD_BYTES = 96;
+var PATTERN_WORK_FLUSH_UNITS = 65536;
+var PATTERN_RUN_CODE_POINTS = 3;
+var MAX_PATTERN_TOLERANCE = 2;
+var PATTERN_TEST_OPERATORS = ["eq", "ne", "in", "nin", "startsWith", "endsWith", "contains"];
+var PATTERN_EXPRESSION_OPERATORS = ["wildcard", "regex"];
+
+// src/pattern/constants.ts
+var MATCHER_TRANSITION_BYTES = 48;
+var MATCHER_EDGE_SLOT_BYTES = 8;
+var MAX_DENSE_EDGE_CLASSES = 64;
+var MATCHER_KEY_CHARACTER_BYTES = 2;
+var MATCHER_MIN_CODE_POINTS_PER_STATE = 10;
+var SHORTLIST_RUN_LOOKUPS = 16;
+var SHORTLIST_INTERSECT_RATIO = 8;
+var RUN_LIST_INITIAL_CAPACITY = 4;
+var RUN_LIST_COMPACTION_FRACTION = 0.5;
+var RUN_ENTRY_OVERHEAD_BYTES = 140;
+var DOCUMENT_ENTRY_BYTES = 24;
+var SIMULATION_STATE_BYTES = 8;
+var SIMULATION_POSITION_BYTES = 8;
+var KEPT_PROGRAM_BUDGET_FRACTION = 0.5;
+var DIRECT_CLASS_CODE_POINTS = 128;
+
+// src/pattern/automaton.ts
+var BEFORE_VALUE_START = 0;
+var AFTER_VALUE_END = 0;
+var WORD_CODE_POINT = 1;
+var OTHER_CODE_POINT = 2;
+var EDGE_KINDS = 3;
+var START_MASK = 7;
+var END_MASK = 73;
+var WORD_EDGE_MASK = 170;
+var ANY_CONTEXT_MASK = 511;
+var CONSUME_STATE = 0;
+var SPLIT_STATE = 1;
+var ASSERT_STATE = 2;
+var MATCH_STATE = 3;
+var ANY_CODE_POINT = -2;
+var TESTED_CODE_POINT = -1;
+var MATCH_REACHED = -1;
+var WORD_KIND_EDGES = [48, 58, 65, 91, 95, 96, 97, 123];
+function searchedClass(starts, isFoldTarget, codePoint) {
+  if (isFoldTarget?.(codePoint)) return -1 - codePoint;
+  let low = 0;
+  let high = starts.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (starts[middle] <= codePoint) low = middle + 1;
+    else high = middle;
+  }
+  return low;
+}
+function codePointClasses(starts, isFoldTarget) {
+  const direct = new Int32Array(DIRECT_CLASS_CODE_POINTS);
+  for (let codePoint = 0; codePoint < direct.length; codePoint++) {
+    direct[codePoint] = searchedClass(starts, isFoldTarget, codePoint);
+  }
+  return { starts, isFoldTarget, direct };
+}
+function classOf(program, codePoint) {
+  const { classes } = program;
+  if (codePoint < classes.direct.length) return classes.direct[codePoint];
+  return searchedClass(classes.starts, classes.isFoldTarget, codePoint);
+}
+function isWordCodePoint(codePoint) {
+  return codePoint >= 48 && codePoint <= 57 || codePoint >= 65 && codePoint <= 90 || codePoint >= 97 && codePoint <= 122 || codePoint === 95;
+}
+function kindOf(codePoint) {
+  return isWordCodePoint(codePoint) ? WORD_CODE_POINT : OTHER_CODE_POINT;
+}
+function contextOf(previous, next) {
+  return previous * EDGE_KINDS + next;
+}
+function accepts(program, position, codePoint) {
+  const literal = program.literals[position];
+  if (literal >= 0) return literal === codePoint;
+  if (literal === ANY_CODE_POINT) return true;
+  return program.tests[position]?.has(codePoint) ?? false;
+}
+var LAST_STAMP = 4294967295;
+function createClosureScratch(states) {
+  return { marks: new Uint32Array(states), stack: new Int32Array(states), stamp: 0 };
+}
+function nextStamp(scratch) {
+  if (scratch.stamp === LAST_STAMP) {
+    scratch.marks.fill(0);
+    scratch.stamp = 0;
+  }
+  scratch.stamp++;
+  return scratch.stamp;
+}
+function closeOver(program, seeds, seedCount, fromStart, context, scratch, out) {
+  const { kinds, next, alternative, masks } = program;
+  const { marks, stack } = scratch;
+  const stamp = nextStamp(scratch);
+  let depth = 0;
+  for (let at = 0; at < seedCount; at++) {
+    const state = next[seeds[at]];
+    if (marks[state] === stamp) continue;
+    marks[state] = stamp;
+    stack[depth++] = state;
+  }
+  if (fromStart && marks[program.start] !== stamp) {
+    marks[program.start] = stamp;
+    stack[depth++] = program.start;
+  }
+  let count = 0;
+  while (depth > 0) {
+    const state = stack[--depth];
+    const kind = kinds[state];
+    if (kind === CONSUME_STATE) {
+      out[count++] = state;
+      continue;
+    }
+    if (kind === MATCH_STATE) return MATCH_REACHED;
+    if (kind === ASSERT_STATE && (masks[state] >>> context & 1) === 0) continue;
+    const following = next[state];
+    if (marks[following] !== stamp) {
+      marks[following] = stamp;
+      stack[depth++] = following;
+    }
+    if (kind !== SPLIT_STATE) continue;
+    const other = alternative[state];
+    if (marks[other] !== stamp) {
+      marks[other] = stamp;
+      stack[depth++] = other;
+    }
+  }
+  return count;
+}
+
+// src/pattern/position-simulation.ts
+var STEP_CONTINUES = 0;
+var STEP_MATCHED = 1;
+var STEP_DEAD = 2;
+var CONTEXTS = 9;
+function simulationBytes(program) {
+  const startClosureBytes = CONTEXTS * Uint32Array.BYTES_PER_ELEMENT;
+  return program.states * SIMULATION_STATE_BYTES + program.positions * (SIMULATION_POSITION_BYTES + startClosureBytes);
+}
+var PositionSimulation = class {
+  constructor(program) {
+    this.program = program;
+    this.after = new Uint32Array(program.positions);
+    this.candidates = new Uint32Array(program.positions);
+    this.scratch = createClosureScratch(program.states);
+  }
+  steps = 0;
+  previousKind = BEFORE_VALUE_START;
+  after;
+  afterCount = 0;
+  candidates;
+  scratch;
+  starts = new Array(CONTEXTS).fill(null);
+  get bytes() {
+    return simulationBytes(this.program);
+  }
+  reset() {
+    this.afterCount = 0;
+    this.previousKind = BEFORE_VALUE_START;
+  }
+  load(positions, previousKind) {
+    this.after.set(positions);
+    this.afterCount = positions.length;
+    this.previousKind = previousKind;
+  }
+  sortedAfter() {
+    return this.after.slice(0, this.afterCount).sort();
+  }
+  step(codePoint) {
+    const { program, candidates } = this;
+    const following = kindOf(codePoint);
+    const reached = this.close(contextOf(this.previousKind, following));
+    if (reached === MATCH_REACHED) {
+      this.steps = 0;
+      return STEP_MATCHED;
+    }
+    this.steps = reached;
+    let kept = 0;
+    for (let at = 0; at < reached; at++) {
+      const position = candidates[at];
+      if (accepts(program, position, codePoint)) this.after[kept++] = position;
+    }
+    this.afterCount = kept;
+    this.previousKind = following;
+    return kept === 0 && program.anchoredStart ? STEP_DEAD : STEP_CONTINUES;
+  }
+  endMatches() {
+    return this.close(contextOf(this.previousKind, AFTER_VALUE_END)) === MATCH_REACHED;
+  }
+  startClosure(context) {
+    const known = this.starts[context];
+    if (known !== null) return known;
+    const reached = closeOver(this.program, this.after, 0, true, context, this.scratch, this.candidates);
+    const closure = reached === MATCH_REACHED ? { positions: new Uint32Array(0), matches: true } : { positions: this.candidates.slice(0, reached), matches: false };
+    this.starts[context] = closure;
+    return closure;
+  }
+  close(context) {
+    const fromStart = this.previousKind === BEFORE_VALUE_START || !this.program.anchoredStart;
+    const start = fromStart ? this.startClosure(context) : null;
+    if (start?.matches) return MATCH_REACHED;
+    const { program, scratch, candidates } = this;
+    let count = closeOver(program, this.after, this.afterCount, false, context, scratch, candidates);
+    if (count === MATCH_REACHED || start === null) return count;
+    const { marks, stamp } = scratch;
+    for (const position of start.positions) {
+      if (marks[position] === stamp) continue;
+      marks[position] = stamp;
+      candidates[count++] = position;
+    }
+    return count;
+  }
+};
+
+// src/pattern/expression/constants.ts
+var MAX_PATTERN_GROUP_DEPTH = 32;
+var MAX_PATTERN_REPEAT_COUNT = 2048;
+var MAX_NUMBER_RANGE_DIGITS = 15;
+var CODE_POINT_TEST_ENTRY_BYTES = 8;
+var PROGRAM_STATE_BYTES = 11;
+var PROGRAM_POSITION_BYTES = 12;
+
+// src/pattern/expression/compile.ts
+var UNSET = -1;
+var ProgramBuilder = class {
+  kinds = [];
+  next = [];
+  alternative = [];
+  masks = [];
+  literals = [];
+  tests = [];
+  positions = 0;
+  add(kind, next, alternative, mask) {
+    this.kinds.push(kind);
+    this.next.push(next);
+    this.alternative.push(alternative);
+    this.masks.push(mask);
+    this.literals.push(UNSET);
+    this.tests.push(null);
+    return this.kinds.length - 1;
+  }
+  consume(literal, test, next) {
+    const state = this.add(CONSUME_STATE, next, UNSET, 0);
+    this.literals[state] = literal;
+    this.tests[state] = test;
+    this.positions++;
+    return state;
+  }
+  split(first, second) {
+    return this.add(SPLIT_STATE, first, second, 0);
+  }
+  compile(plan, next) {
+    switch (plan.kind) {
+      case "consume":
+        return this.consume(plan.literal, plan.test, next);
+      case "assert":
+        return plan.mask === ANY_CONTEXT_MASK ? next : this.add(ASSERT_STATE, next, UNSET, plan.mask);
+      case "sequence": {
+        let entry = next;
+        for (let at = plan.items.length - 1; at >= 0; at--) entry = this.compile(plan.items[at], entry);
+        return entry;
+      }
+      case "choice": {
+        let entry = this.compile(plan.branches[plan.branches.length - 1], next);
+        for (let at = plan.branches.length - 2; at >= 0; at--)
+          entry = this.split(this.compile(plan.branches[at], next), entry);
+        return entry;
+      }
+      case "repeat":
+        return this.compileRepeat(plan.body, plan.min, plan.max, next);
+    }
+  }
+  loop(body, next, entersBody) {
+    const loop = this.split(UNSET, next);
+    const entry = this.compile(body, loop);
+    this.next[loop] = entry;
+    return entersBody ? entry : loop;
+  }
+  compileRepeat(body, min, max, next) {
+    let entry;
+    let required = min;
+    if (max === null) {
+      entry = this.loop(body, next, min > 0);
+      if (min > 0) required--;
+    } else {
+      entry = next;
+      for (let optional = max - min; optional > 0; optional--) entry = this.split(this.compile(body, entry), next);
+    }
+    for (; required > 0; required--) entry = this.compile(body, entry);
+    return entry;
+  }
+};
+function startsOnlyAtStart(program) {
+  const scratch = createClosureScratch(program.states);
+  const candidates = new Uint32Array(program.positions);
+  const seeds = new Uint32Array(0);
+  for (const previous of [WORD_CODE_POINT, OTHER_CODE_POINT]) {
+    for (const following of [AFTER_VALUE_END, WORD_CODE_POINT, OTHER_CODE_POINT]) {
+      const reached = closeOver(program, seeds, 0, true, contextOf(previous, following), scratch, candidates);
+      if (reached === MATCH_REACHED || reached > 0) return false;
+    }
+  }
+  return true;
+}
+function collectClassEdges(plan, edges, tests) {
+  switch (plan.kind) {
+    case "consume":
+      if (plan.literal >= 0) {
+        edges.add(plan.literal);
+        edges.add(plan.literal + 1);
+      } else if (plan.test !== null && !tests.has(plan.test)) {
+        tests.add(plan.test);
+        const { ranges } = plan.test;
+        for (let at = 0; at < ranges.length; at += 2) {
+          edges.add(ranges[at]);
+          edges.add(ranges[at + 1] + 1);
+        }
+      }
+      return;
+    case "assert":
+      return;
+    case "sequence":
+      for (const item of plan.items) collectClassEdges(item, edges, tests);
+      return;
+    case "choice":
+      for (const branch of plan.branches) collectClassEdges(branch, edges, tests);
+      return;
+    case "repeat":
+      collectClassEdges(plan.body, edges, tests);
+  }
+}
+function planClasses(plan) {
+  const edges = new Set(WORD_KIND_EDGES);
+  const tests = /* @__PURE__ */ new Set();
+  collectClassEdges(plan, edges, tests);
+  let isFoldTarget = null;
+  for (const test of tests) isFoldTarget ??= test.isFoldTarget;
+  return codePointClasses(Uint32Array.from(edges).sort(), isFoldTarget);
+}
+function programBytes(states, positions, tests, classes) {
+  const distinct = /* @__PURE__ */ new Set();
+  for (const test of tests) if (test !== null) distinct.add(test);
+  let bytes = states * PROGRAM_STATE_BYTES + positions * PROGRAM_POSITION_BYTES + classes.starts.byteLength + classes.direct.byteLength;
+  for (const test of distinct) bytes += test.bytes;
+  return bytes;
+}
+function sizeOf(plan, tests) {
+  switch (plan.kind) {
+    case "consume":
+      if (plan.test !== null) tests.add(plan.test);
+      return { states: 1, positions: 1 };
+    case "assert":
+      return { states: plan.mask === ANY_CONTEXT_MASK ? 0 : 1, positions: 0 };
+    case "sequence":
+    case "choice": {
+      const children = plan.kind === "sequence" ? plan.items : plan.branches;
+      const total = { states: plan.kind === "choice" ? children.length - 1 : 0, positions: 0 };
+      for (const child of children) {
+        const size = sizeOf(child, tests);
+        total.states += size.states;
+        total.positions += size.positions;
+      }
+      return total;
+    }
+    case "repeat": {
+      const body = sizeOf(plan.body, tests);
+      if (plan.max === null) {
+        const copies = Math.max(plan.min, 1);
+        return { states: 1 + copies * body.states, positions: copies * body.positions };
+      }
+      const optional = plan.max - plan.min;
+      return { states: optional + plan.max * body.states, positions: plan.max * body.positions };
+    }
+  }
+}
+function planSize(plan) {
+  const tests = /* @__PURE__ */ new Set();
+  const size = sizeOf(plan, tests);
+  const states = size.states + 1;
+  return {
+    states,
+    positions: size.positions,
+    bytes: programBytes(states, size.positions, tests, planClasses(plan))
+  };
+}
+function compileProgram(plan) {
+  const builder = new ProgramBuilder();
+  const match = builder.add(MATCH_STATE, UNSET, UNSET, 0);
+  const start = builder.compile(plan, match);
+  const count = builder.kinds.length;
+  const renumbered = new Int32Array(count);
+  let nextPosition = 0;
+  let nextOther = builder.positions;
+  for (let state = 0; state < count; state++) {
+    renumbered[state] = builder.kinds[state] === CONSUME_STATE ? nextPosition++ : nextOther++;
+  }
+  const kinds = new Uint8Array(count);
+  const next = new Int32Array(count);
+  const alternative = new Int32Array(count);
+  const masks = new Uint16Array(count);
+  const literals = new Int32Array(builder.positions);
+  const tests = new Array(builder.positions).fill(null);
+  for (let state = 0; state < count; state++) {
+    const target = renumbered[state];
+    kinds[target] = builder.kinds[state];
+    next[target] = builder.next[state] === UNSET ? UNSET : renumbered[builder.next[state]];
+    alternative[target] = builder.alternative[state] === UNSET ? UNSET : renumbered[builder.alternative[state]];
+    masks[target] = builder.masks[state];
+    if (target < builder.positions) {
+      literals[target] = builder.literals[state];
+      tests[target] = builder.tests[state];
+    }
+  }
+  const classes = planClasses(plan);
+  const draft = {
+    positions: builder.positions,
+    states: count,
+    kinds,
+    next,
+    alternative,
+    masks,
+    literals,
+    tests,
+    start: renumbered[start],
+    anchoredStart: false,
+    classes,
+    bytes: programBytes(count, builder.positions, tests, classes)
+  };
+  return { ...draft, anchoredStart: startsOnlyAtStart(draft) };
+}
+
+// src/pattern/expression/code-point-tests.ts
+var CLASS_RANGES = {
+  digit: [48, 57],
+  word: [48, 57, 65, 90, 95, 95, 97, 122],
+  space: [9, 10, 12, 13, 32, 32]
+};
+function mergedRanges(bounds) {
+  const pairs = [];
+  for (let at = 0; at < bounds.length; at += 2) pairs.push([bounds[at], bounds[at + 1]]);
+  pairs.sort((left, right) => left[0] - right[0]);
+  const merged = [];
+  for (const [low, high] of pairs) {
+    const last = merged.length - 1;
+    if (merged.length > 0 && low <= merged[last] + 1) merged[last] = Math.max(merged[last], high);
+    else merged.push(low, high);
+  }
+  return Uint32Array.from(merged);
+}
+function inRanges(ranges, codePoint) {
+  let low = 0;
+  let high = ranges.length / 2;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (codePoint < ranges[middle * 2]) high = middle;
+    else if (codePoint > ranges[middle * 2 + 1]) low = middle + 1;
+    else return true;
+  }
+  return false;
+}
+function rangeBoundsOf(items) {
+  const bounds = [];
+  for (const item of items) {
+    if (item.kind === "member") bounds.push(item.codePoint, item.codePoint);
+    else if (item.kind === "range") bounds.push(item.low, item.high);
+    else bounds.push(...CLASS_RANGES[item.name]);
+  }
+  return bounds;
+}
+function rangeTest(ranges, negated) {
+  return {
+    bytes: ranges.byteLength + CODE_POINT_TEST_ENTRY_BYTES,
+    ranges,
+    isFoldTarget: null,
+    has: (codePoint) => inRanges(ranges, codePoint) !== negated
+  };
+}
+function foldedRangeTest(ranges, negated, host) {
+  const holdsFold = (folded) => {
+    if (inRanges(ranges, folded)) return true;
+    for (const source of host.singleFoldSources(folded)) if (inRanges(ranges, source)) return true;
+    return false;
+  };
+  return {
+    bytes: ranges.byteLength + CODE_POINT_TEST_ENTRY_BYTES,
+    ranges,
+    isFoldTarget: (folded) => host.singleFoldSources(folded).length > 0,
+    has: (folded) => holdsFold(folded) !== negated
+  };
+}
+function classTest(name) {
+  return rangeTest(mergedRanges([...CLASS_RANGES[name]]), false);
+}
+function setTest(items, negated, caseFold, host) {
+  const ranges = mergedRanges(rangeBoundsOf(items));
+  return caseFold ? foldedRangeTest(ranges, negated, host) : rangeTest(ranges, negated);
+}
+function distinctMultiFolds(items, host) {
+  const seen = /* @__PURE__ */ new Set();
+  const folds = [];
+  for (const item of items) {
+    if (item.kind !== "member") continue;
+    const fold = [];
+    host.appendFoldedCodePoint(item.codePoint, fold);
+    if (fold.length < 2) continue;
+    const key = String.fromCodePoint(...fold);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    folds.push(fold);
+  }
+  return folds;
+}
+
+// src/pattern/expression/lower.ts
+var EMPTY = { kind: "assert", mask: ANY_CONTEXT_MASK };
+function literalPlan(codePoint) {
+  return { kind: "consume", literal: codePoint, test: null };
+}
+function testedPlan(test) {
+  return { kind: "consume", literal: TESTED_CODE_POINT, test };
+}
+function sequenceOf(items) {
+  const kept = [];
+  let mask = ANY_CONTEXT_MASK;
+  const flushMask = () => {
+    if (mask !== ANY_CONTEXT_MASK) kept.push({ kind: "assert", mask });
+    mask = ANY_CONTEXT_MASK;
+  };
+  const visit = (item) => {
+    if (item.kind === "sequence") {
+      for (const nested of item.items) visit(nested);
+    } else if (item.kind === "assert") {
+      mask &= item.mask;
+    } else {
+      flushMask();
+      kept.push(item);
+    }
+  };
+  for (const item of items) visit(item);
+  if (kept.length === 0) return { kind: "assert", mask };
+  flushMask();
+  return kept.length === 1 ? kept[0] : { kind: "sequence", items: kept };
+}
+function choiceOf(branches) {
+  const kept = [];
+  let mask = 0;
+  let empty = false;
+  const visit = (branch) => {
+    if (branch.kind === "choice") {
+      for (const nested of branch.branches) visit(nested);
+    } else if (branch.kind === "assert") {
+      mask |= branch.mask;
+      empty = true;
+    } else {
+      kept.push(branch);
+    }
+  };
+  for (const branch of branches) visit(branch);
+  if (kept.length === 0) return { kind: "assert", mask };
+  if (empty) kept.push({ kind: "assert", mask });
+  return kept.length === 1 ? kept[0] : { kind: "choice", branches: kept };
+}
+function isLoose(plan) {
+  return plan.kind === "repeat" && plan.min <= 1 && (plan.max === null || plan.max === 1);
+}
+function repeatOf(body, min, max) {
+  if (max === 0) return EMPTY;
+  if (body.kind === "assert") return min === 0 ? EMPTY : body;
+  if (min === 1 && max === 1) return body;
+  const loose = min <= 1 && (max === null || max === 1);
+  if (loose && isLoose(body)) {
+    const nullable = min === 0 || body.min === 0;
+    const unbounded = max === null || body.max === null;
+    return { kind: "repeat", body: body.body, min: nullable ? 0 : 1, max: unbounded ? null : 1 };
+  }
+  return { kind: "repeat", body, min, max };
+}
+function foldedLiteral(codePoint, host, scratch) {
+  scratch.length = 0;
+  host.appendFoldedCodePoint(codePoint, scratch);
+  return sequenceOf(scratch.map(literalPlan));
+}
+function setPlan(node, caseFold, host) {
+  const single = testedPlan(setTest(node.items, node.negated, caseFold, host));
+  if (!caseFold || node.negated) return single;
+  const sequences = distinctMultiFolds(node.items, host).map((fold) => sequenceOf(fold.map(literalPlan)));
+  return sequences.length === 0 ? single : choiceOf([single, ...sequences]);
+}
+function lowerNode(node, caseFold, host, scratch) {
+  switch (node.kind) {
+    case "literal":
+      return caseFold ? foldedLiteral(node.codePoint, host, scratch) : literalPlan(node.codePoint);
+    case "any":
+      return literalPlan(ANY_CODE_POINT);
+    case "class":
+      return testedPlan(classTest(node.name));
+    case "set":
+      return setPlan(node, caseFold, host);
+    case "assert":
+      return node;
+    case "sequence":
+      return sequenceOf(node.items.map((item) => lowerNode(item, caseFold, host, scratch)));
+    case "choice":
+      return choiceOf(node.branches.map((branch) => lowerNode(branch, caseFold, host, scratch)));
+    case "repeat":
+      return repeatOf(lowerNode(node.body, caseFold, host, scratch), node.min, node.max);
+    case "numberRange":
+      return lowerNode(node.expansion, caseFold, host, scratch);
+  }
+}
+function lowerPattern(node, caseFold, host) {
+  return lowerNode(node, caseFold, host, []);
+}
+
+// src/pattern/expression/number-range.ts
+function digitAt(text, at) {
+  return text.charCodeAt(at) - 48;
+}
+function sameWidth(low, high) {
+  const width = low.length;
+  if (low === high) return low;
+  if (/^0+$/.test(low) && /^9+$/.test(high)) return width === 1 ? "[0-9]" : `[0-9]{${width}}`;
+  if (width === 1) return `[${low}-${high}]`;
+  if (low[0] === high[0]) return low[0] + sameWidth(low.slice(1), high.slice(1));
+  const parts = [low[0] + sameWidth(low.slice(1), "9".repeat(width - 1))];
+  const lowLead = digitAt(low, 0);
+  const highLead = digitAt(high, 0);
+  if (lowLead + 1 <= highLead - 1) parts.push(`[${lowLead + 1}-${highLead - 1}]${"[0-9]".repeat(width - 1)}`);
+  parts.push(high[0] + sameWidth("0".repeat(width - 1), high.slice(1)));
+  return `(${parts.join("|")})`;
+}
+function numberRange(low, high) {
+  if (low.length === high.length) return sameWidth(low, high);
+  const highest = Number(high);
+  const parts = [];
+  let start = Number(low);
+  const widest = String(highest).length;
+  for (let width = String(start).length; width <= widest; width++) {
+    const last = Math.min(highest, 10 ** width - 1);
+    parts.push(sameWidth(String(start), String(last)));
+    start = 10 ** width;
+  }
+  return `(${parts.join("|")})`;
+}
+function compareDigits(low, high) {
+  return Number(low) - Number(high);
+}
+
+// src/pattern/expression/reader.ts
+var TRAILING_ESCAPE = 'ends in a "\\" with no code point after it';
+function toCodePoints(text) {
+  const codePoints = [];
+  for (let at = 0; at < text.length; at++) {
+    const codePoint = text.codePointAt(at) ?? 0;
+    if (codePoint > 65535) at++;
+    codePoints.push(codePoint);
+  }
+  return codePoints;
+}
+function quoted(text) {
+  return `"${text}"`;
+}
+
+// src/pattern/expression/parse-regex.ts
+var BACKSLASH = 92;
+var DOT = 46;
+var BAR = 124;
+var STAR = 42;
+var PLUS = 43;
+var QUESTION = 63;
+var OPEN_BRACE = 123;
+var CLOSE_BRACE = 125;
+var OPEN_PAREN = 40;
+var CLOSE_PAREN = 41;
+var OPEN_BRACKET = 91;
+var CLOSE_BRACKET = 93;
+var CARET = 94;
+var DOLLAR = 36;
+var LESS = 60;
+var GREATER = 62;
+var HYPHEN = 45;
+var COMMA = 44;
+var ZERO = 48;
+var NINE = 57;
+var RESERVED = /* @__PURE__ */ new Set([
+  BACKSLASH,
+  DOT,
+  BAR,
+  STAR,
+  PLUS,
+  QUESTION,
+  OPEN_BRACE,
+  CLOSE_BRACE,
+  OPEN_PAREN,
+  CLOSE_PAREN,
+  OPEN_BRACKET,
+  CLOSE_BRACKET,
+  CARET,
+  DOLLAR,
+  LESS,
+  GREATER
+]);
+var NO_COUNT = `holds a "{" that doesn't open a count such as {2}, {2,}, or {2,5}. Write "\\{" to match the brace itself`;
+var RANGE_ENDS_IN_CLASS = "holds a set range whose high end is a class, while both ends of a set range must be code points";
+var SET_NEVER_CLOSES = "opens a set that it never closes";
+var NEGATED_EMPTY_SET = 'holds the set "[^]", which has no member, because a "^" after "[" always negates the set. Write "\\^" to match a caret, "." to match any code point, or "\\]" to match "]" inside a set';
+var CLASS_ESCAPES = /* @__PURE__ */ new Map([
+  [100, "digit"],
+  [119, "word"],
+  [115, "space"]
+]);
+var WORD_EDGE_ESCAPE = 98;
+function isAsciiPunctuation(codePoint) {
+  return codePoint >= 33 && codePoint <= 47 || codePoint >= 58 && codePoint <= 64 || codePoint >= 91 && codePoint <= 96 || codePoint >= 123 && codePoint <= 126;
+}
+function isDigit(codePoint) {
+  return codePoint !== void 0 && codePoint >= ZERO && codePoint <= NINE;
+}
+function unknownEscape(codePoint) {
+  const shown = quoted(`\\${String.fromCodePoint(codePoint)}`);
+  if (isDigit(codePoint)) return `holds the back-reference ${shown}, which the grammar leaves out`;
+  if (codePoint === 112 || codePoint === 80) {
+    return `holds the Unicode property class ${shown}, which the grammar leaves out`;
+  }
+  return `holds ${shown}. A "\\" can come only before an ASCII punctuation mark, "d", "w", "s", or "b"`;
+}
+function reservedHere(codePoint) {
+  const shown = String.fromCodePoint(codePoint);
+  if (codePoint === STAR || codePoint === PLUS || codePoint === QUESTION) {
+    return `holds the repeat ${quoted(shown)} with nothing before it to repeat`;
+  }
+  return `holds ${quoted(shown)}, which has a meaning of its own in the grammar. Write ${quoted(`\\${shown}`)} to match the code point itself`;
+}
+var RegexReader = class _RegexReader {
+  constructor(codePoints, fail) {
+    this.codePoints = codePoints;
+    this.fail = fail;
+  }
+  at = 0;
+  depth = 0;
+  parse() {
+    const pattern = this.parsePattern();
+    if (this.at < this.codePoints.length) this.fail("closes a group that it never opened", this.at);
+    return pattern;
+  }
+  peek(offset = 0) {
+    return this.codePoints[this.at + offset];
+  }
+  parsePattern() {
+    const branches = [this.parseBranch()];
+    while (this.peek() === BAR) {
+      this.at++;
+      branches.push(this.parseBranch());
+    }
+    return branches.length === 1 ? branches[0] : { kind: "choice", branches };
+  }
+  parseBranch() {
+    const items = [];
+    for (let next = this.peek(); next !== void 0 && next !== BAR && next !== CLOSE_PAREN; next = this.peek()) {
+      items.push(this.parsePiece());
+    }
+    return items.length === 1 ? items[0] : { kind: "sequence", items };
+  }
+  parsePiece() {
+    const atom = this.parseAtom();
+    const repeated = this.parseRepeat(atom);
+    const next = this.peek();
+    if (repeated !== atom && (next === STAR || next === PLUS || next === QUESTION || next === OPEN_BRACE)) {
+      this.fail(
+        `holds a second repeat ${quoted(String.fromCodePoint(next))} after one atom. The grammar allows one repeat for each atom, so it has no lazy or possessive repeats`,
+        this.at
+      );
+    }
+    return repeated;
+  }
+  parseAtom() {
+    const start = this.at;
+    const codePoint = this.codePoints[this.at++];
+    if (codePoint === BACKSLASH) return this.parseEscape(start);
+    if (codePoint === DOT) return { kind: "any" };
+    if (codePoint === CARET) return { kind: "assert", mask: START_MASK };
+    if (codePoint === DOLLAR) return { kind: "assert", mask: END_MASK };
+    if (codePoint === OPEN_BRACKET) return this.parseSet(start);
+    if (codePoint === OPEN_PAREN) return this.parseGroup(start);
+    if (codePoint === LESS) return this.parseNumberRange(start);
+    if (RESERVED.has(codePoint)) this.fail(reservedHere(codePoint), start);
+    return { kind: "literal", codePoint };
+  }
+  parseEscape(start) {
+    const escaped = this.codePoints[this.at++];
+    if (escaped === void 0) this.fail(TRAILING_ESCAPE, start);
+    const name = CLASS_ESCAPES.get(escaped);
+    if (name !== void 0) return { kind: "class", name };
+    if (escaped === WORD_EDGE_ESCAPE) return { kind: "assert", mask: WORD_EDGE_MASK };
+    if (isAsciiPunctuation(escaped)) return { kind: "literal", codePoint: escaped };
+    this.fail(unknownEscape(escaped), start);
+  }
+  parseGroup(start) {
+    if (this.peek() === QUESTION) {
+      this.fail(
+        'holds "(?", which opens a lookaround, an inline flag, or a non-capturing group. The grammar leaves out all three',
+        start
+      );
+    }
+    this.depth++;
+    if (this.depth > MAX_PATTERN_GROUP_DEPTH) {
+      this.fail(`nests its groups more than ${MAX_PATTERN_GROUP_DEPTH} deep`, start);
+    }
+    const body = this.parsePattern();
+    if (this.peek() !== CLOSE_PAREN) this.fail("opens a group that it never closes", start);
+    this.at++;
+    this.depth--;
+    return body;
+  }
+  parseRepeat(atom) {
+    const codePoint = this.peek();
+    if (codePoint === STAR || codePoint === PLUS || codePoint === QUESTION) {
+      this.at++;
+      const min2 = codePoint === PLUS ? 1 : 0;
+      return { kind: "repeat", body: atom, min: min2, max: codePoint === QUESTION ? 1 : null };
+    }
+    if (codePoint !== OPEN_BRACE) return atom;
+    const start = this.at++;
+    const min = this.readCount(start);
+    let max = min;
+    if (this.peek() === COMMA) {
+      this.at++;
+      max = isDigit(this.peek()) ? this.readCount(start) : null;
+    }
+    if (this.peek() !== CLOSE_BRACE) {
+      this.fail(NO_COUNT, start);
+    }
+    this.at++;
+    if (max !== null && min > max) {
+      this.fail(`holds the count {${min},${max}}, whose lower count is above its upper count`, start);
+    }
+    return { kind: "repeat", body: atom, min, max };
+  }
+  readCount(start) {
+    if (!isDigit(this.peek())) {
+      this.fail(NO_COUNT, start);
+    }
+    let count = 0;
+    for (let digit = this.peek(); digit !== void 0 && isDigit(digit); digit = this.peek()) {
+      count = Math.min(count * 10 + digit - ZERO, MAX_PATTERN_REPEAT_COUNT + 1);
+      this.at++;
+    }
+    if (count > MAX_PATTERN_REPEAT_COUNT) {
+      this.fail(`holds a count above the limit of ${MAX_PATTERN_REPEAT_COUNT}`, start);
+    }
+    return count;
+  }
+  parseSet(start) {
+    const negated = this.peek() === CARET;
+    if (negated) this.at++;
+    const items = [];
+    for (; ; ) {
+      const codePoint = this.peek();
+      if (codePoint === void 0) this.fail(SET_NEVER_CLOSES, start);
+      if (codePoint === CLOSE_BRACKET) break;
+      items.push(this.parseSetItem());
+    }
+    this.at++;
+    if (items.length === 0) this.fail(negated ? NEGATED_EMPTY_SET : "holds an empty set", start);
+    return { kind: "set", negated, items };
+  }
+  parseSetItem() {
+    const start = this.at;
+    const low = this.parseSetMember(true);
+    if (typeof low !== "number") return low;
+    if (this.peek() !== HYPHEN || this.peek(1) === CLOSE_BRACKET) return { kind: "member", codePoint: low };
+    this.at++;
+    const high = this.parseSetMember(false);
+    if (typeof high !== "number") this.fail(RANGE_ENDS_IN_CLASS, start);
+    if (low > high) {
+      this.fail(
+        `holds the set range ${quoted(`${String.fromCodePoint(low)}-${String.fromCodePoint(high)}`)}, whose low end is above its high end`,
+        start
+      );
+    }
+    return { kind: "range", low, high };
+  }
+  parseSetMember(classAllowed) {
+    const start = this.at;
+    const codePoint = this.codePoints[this.at++];
+    if (codePoint === void 0) this.fail(SET_NEVER_CLOSES, start);
+    if (codePoint === OPEN_BRACKET || codePoint === CLOSE_BRACKET || codePoint === HYPHEN) {
+      const shown = String.fromCodePoint(codePoint);
+      this.fail(
+        `holds ${quoted(shown)} inside a set. Write ${quoted(`\\${shown}`)} to match that code point there`,
+        start
+      );
+    }
+    if (codePoint !== BACKSLASH) return codePoint;
+    const escaped = this.codePoints[this.at++];
+    if (escaped === void 0) this.fail(TRAILING_ESCAPE, start);
+    const name = CLASS_ESCAPES.get(escaped);
+    if (name !== void 0 && classAllowed) return { kind: "class", name };
+    if (isAsciiPunctuation(escaped)) return escaped;
+    if (name !== void 0) this.fail(RANGE_ENDS_IN_CLASS, start);
+    this.fail(unknownEscape(escaped), start);
+  }
+  parseNumberRange(start) {
+    const low = this.readDigits();
+    const hyphen = this.codePoints[this.at++];
+    const high = hyphen === HYPHEN ? this.readDigits() : "";
+    const closing = this.codePoints[this.at++];
+    if (low === "" || high === "" || closing !== GREATER) {
+      this.fail(
+        `holds a "<" that doesn't open a number range such as <1-65535>. Each end of a number range holds from 1 to ${MAX_NUMBER_RANGE_DIGITS} digits. Write "\\<" to match the "<" itself`,
+        start
+      );
+    }
+    if (compareDigits(low, high) > 0) {
+      this.fail(`holds the number range ${quoted(`<${low}-${high}>`)}, whose low end is above its high end`, start);
+    }
+    const expansion = new _RegexReader(toCodePoints(numberRange(low, high)), this.fail).parse();
+    return { kind: "numberRange", expansion };
+  }
+  readDigits() {
+    let digits = "";
+    for (let digit = this.peek(); isDigit(digit) && digit !== void 0; digit = this.peek()) {
+      if (digits.length === MAX_NUMBER_RANGE_DIGITS) return "";
+      digits += String.fromCodePoint(digit);
+      this.at++;
+    }
+    return digits;
+  }
+};
+function parseRegex(codePoints, fail) {
+  return new RegexReader(codePoints, fail).parse();
+}
+
+// src/pattern/expression/parse-wildcard.ts
+var BACKSLASH2 = 92;
+var STAR2 = 42;
+var QUESTION2 = 63;
+function parseWildcard(codePoints, fail) {
+  const items = [{ kind: "assert", mask: START_MASK }];
+  for (let at = 0; at < codePoints.length; at++) {
+    const codePoint = codePoints[at];
+    if (codePoint === STAR2) {
+      items.push({ kind: "repeat", body: { kind: "any" }, min: 0, max: null });
+    } else if (codePoint === QUESTION2) {
+      items.push({ kind: "any" });
+    } else if (codePoint === BACKSLASH2) {
+      if (at + 1 === codePoints.length) fail(TRAILING_ESCAPE, at);
+      items.push({ kind: "literal", codePoint: codePoints[++at] });
+    } else {
+      items.push({ kind: "literal", codePoint });
+    }
+  }
+  items.push({ kind: "assert", mask: END_MASK });
+  return { kind: "sequence", items };
+}
+
+// src/pattern/expression/positions.ts
+var SATURATED = MAX_PATTERN_POSITIONS + 1;
+function saturating(total) {
+  return Math.min(total, SATURATED);
+}
+function literalPositions(codePoint, caseFold, host, scratch) {
+  if (!caseFold) return 1;
+  scratch.length = 0;
+  host.appendFoldedCodePoint(codePoint, scratch);
+  return scratch.length;
+}
+function positionsOf(node, caseFold, host, scratch) {
+  switch (node.kind) {
+    case "literal":
+      return literalPositions(node.codePoint, caseFold, host, scratch);
+    case "any":
+    case "class":
+      return 1;
+    case "set": {
+      if (!caseFold || node.negated) return 1;
+      let total = 1;
+      for (const fold of distinctMultiFolds(node.items, host)) total = saturating(total + fold.length);
+      return total;
+    }
+    case "assert":
+      return 0;
+    case "sequence":
+    case "choice": {
+      let total = 0;
+      const children = node.kind === "sequence" ? node.items : node.branches;
+      for (const child of children) {
+        total = saturating(total + positionsOf(child, caseFold, host, scratch));
+        if (total === SATURATED) return total;
+      }
+      return total;
+    }
+    case "repeat": {
+      const copies = node.max === null ? Math.max(node.min, 1) : node.max;
+      return saturating(copies * positionsOf(node.body, caseFold, host, scratch));
+    }
+    case "numberRange":
+      return positionsOf(node.expansion, caseFold, host, scratch);
+  }
+}
+function patternPositions(node, caseFold, host) {
+  return positionsOf(node, caseFold, host, []);
+}
+
+// src/pattern/text.ts
+var BASIC_PLANE_LAST = 65535;
+function appendTextCodePoints(text, caseFold, host, out) {
+  for (let at = 0; at < text.length; at++) {
+    const codePoint = text.codePointAt(at) ?? 0;
+    if (codePoint > BASIC_PLANE_LAST) at++;
+    if (caseFold) host.appendFoldedCodePoint(codePoint, out);
+    else out.push(codePoint);
+  }
+}
+function runKey(first, second, third) {
+  return String.fromCodePoint(first, second, third);
+}
+function runKeyCodePoints(key, out, offset) {
+  let slot = offset;
+  for (let at = 0; at < key.length && slot < offset + PATTERN_RUN_CODE_POINTS; at++) {
+    const codePoint = key.codePointAt(at) ?? 0;
+    out[slot++] = codePoint;
+    if (codePoint > BASIC_PLANE_LAST) at++;
+  }
+}
+function compareRuns(left, leftAt, right, rightAt) {
+  for (let offset = 0; offset < PATTERN_RUN_CODE_POINTS; offset++) {
+    const difference = left[leftAt + offset] - right[rightAt + offset];
+    if (difference !== 0) return difference;
+  }
+  return 0;
+}
+function collectRunKeys(foldedCodePoints, out) {
+  for (let at = 0; at + PATTERN_RUN_CODE_POINTS <= foldedCodePoints.length; at++) {
+    out.add(runKey(foldedCodePoints[at], foldedCodePoints[at + 1], foldedCodePoints[at + 2]));
+  }
+}
+function forEachTextValue(value, visit) {
+  if (typeof value === "string") {
+    visit(value);
+    return;
+  }
+  if (!Array.isArray(value)) return;
+  for (const element of value) {
+    if (typeof element === "string") visit(element);
+  }
+}
+function holdsTextValue(value) {
+  return typeof value === "string" || Array.isArray(value);
+}
+
+// src/pattern/expression/required-runs.ts
+var NO_RUNS = new Uint32Array(0);
+var FactorCollector = class {
+  constructor(host) {
+    this.host = host;
+  }
+  factors = [];
+  current = [];
+  flush() {
+    if (this.current.length >= PATTERN_RUN_CODE_POINTS) this.factors.push(this.current);
+    this.current = [];
+  }
+  visit(node) {
+    switch (node.kind) {
+      case "literal":
+        this.host.appendFoldedCodePoint(node.codePoint, this.current);
+        return;
+      case "assert":
+        return;
+      case "sequence":
+        for (const item of node.items) this.visit(item);
+        return;
+      case "repeat":
+        if (node.min === 1 && node.max === 1) {
+          this.visit(node.body);
+          return;
+        }
+        this.flush();
+        if (node.min >= 1) {
+          this.visit(node.body);
+          this.flush();
+        }
+        return;
+      default:
+        this.flush();
+    }
+  }
+};
+function spreadRuns(factors) {
+  let total = 0;
+  for (const factor of factors) total += Math.max(0, factor.length - PATTERN_RUN_CODE_POINTS + 1);
+  if (total === 0) return NO_RUNS;
+  const picks = Math.min(total, SHORTLIST_RUN_LOOKUPS);
+  const seen = /* @__PURE__ */ new Set();
+  const runs = [];
+  let factorAt = 0;
+  let factorStart = 0;
+  for (let pick = 0; pick < picks; pick++) {
+    const target = picks === 1 ? 0 : Math.round(pick * (total - 1) / (picks - 1));
+    let factorRuns = Math.max(0, factors[factorAt].length - PATTERN_RUN_CODE_POINTS + 1);
+    while (target >= factorStart + factorRuns) {
+      factorStart += factorRuns;
+      factorAt++;
+      factorRuns = Math.max(0, factors[factorAt].length - PATTERN_RUN_CODE_POINTS + 1);
+    }
+    const factor = factors[factorAt];
+    const at = target - factorStart;
+    const key = runKey(factor[at], factor[at + 1], factor[at + 2]);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    runs.push(factor[at], factor[at + 1], factor[at + 2]);
+  }
+  return Uint32Array.from(runs);
+}
+function branchRuns(node, host) {
+  const collector = new FactorCollector(host);
+  collector.visit(node);
+  collector.flush();
+  return spreadRuns(collector.factors);
+}
+function requiredRuns(node, host) {
+  if (node.kind !== "choice") return { kind: "all", runs: branchRuns(node, host) };
+  const branches = node.branches.map((branch) => branchRuns(branch, host));
+  if (branches.some((runs) => runs.length === 0)) return { kind: "all", runs: NO_RUNS };
+  return { kind: "any", branches };
+}
+
+// src/pattern/expression/index.ts
+function describe(label) {
+  return label.fieldPath === null ? `the "${label.operator}" pattern` : `the "${label.operator}" pattern on pattern field "${label.fieldPath}"`;
+}
+function failureFor(label) {
+  return (reason, at) => {
+    throw new NarsilError(
+      ErrorCodes.SEARCH_INVALID_FILTER,
+      `The engine refuses ${describe(label)} at code point ${at + 1}. The pattern ${reason}`,
+      { fieldPath: label.fieldPath, operator: label.operator, codePoint: at + 1 }
+    );
+  };
+}
+function parsedWithinLimits(label, text, caseFold, host) {
+  const codePoints = toCodePoints(text);
+  const fail = failureFor(label);
+  const node = label.operator === "regex" ? parseRegex(codePoints, fail) : parseWildcard(codePoints, fail);
+  const positions = patternPositions(node, caseFold, host);
+  if (positions > MAX_PATTERN_POSITIONS) {
+    throw new NarsilError(
+      ErrorCodes.SEARCH_INVALID_FILTER,
+      `The engine refuses ${describe(label)} before it builds a matcher, because the pattern holds more than ${MAX_PATTERN_POSITIONS} positions${caseFold ? " once the engine folds its case" : ""}. A literal code point, a class, and a set each count as one position. A count such as {5} multiplies the positions of what it repeats. A number range counts the positions of the pattern that it stands for`,
+      { fieldPath: label.fieldPath, operator: label.operator, limit: MAX_PATTERN_POSITIONS }
+    );
+  }
+  return node;
+}
+function checkExpression(operator, text, caseFold, fieldPath, host) {
+  parsedWithinLimits({ operator, fieldPath }, text, caseFold, host);
+}
+function prepareExpression(operator, text, caseFold, host) {
+  const node = parsedWithinLimits({ operator, fieldPath: null }, text, caseFold, host);
+  return { plan: lowerPattern(node, caseFold, host), runs: requiredRuns(node, host) };
+}
+function buildProgram(prepared) {
+  return compileProgram(prepared.plan);
+}
+function footprintOf(bytes, states, positions) {
+  return bytes + simulationBytes({ states, positions }) + MATCHER_STATE_OVERHEAD_BYTES + positions * Uint32Array.BYTES_PER_ELEMENT;
+}
+function expressionFootprint(operator, text, caseFold, host) {
+  const { bytes, states, positions } = planSize(prepareExpression(operator, text, caseFold, host).plan);
+  return footprintOf(bytes, states, positions);
+}
+
+// src/pattern/lazy-dfa.ts
+var UNCACHED_GENERATION = -1;
+var DECIDED_GENERATION = -2;
+function decidedState() {
+  return {
+    positions: new Uint32Array(0),
+    previousKind: BEFORE_VALUE_START,
+    generation: DECIDED_GENERATION,
+    denseEdges: null,
+    sparseEdges: null,
+    endMatch: null
+  };
+}
+function clearEdges(state) {
+  state.denseEdges = null;
+  state.sparseEdges = null;
+}
+var MATCHED = decidedState();
+var DEAD = decidedState();
+function stateKey(positions, previousKind) {
+  return `${previousKind}:${positions.join(",")}`;
+}
+function stateBytes(positions, key) {
+  return MATCHER_STATE_OVERHEAD_BYTES + positions.byteLength + key.length * MATCHER_KEY_CHARACTER_BYTES;
+}
+var LazyDfa = class {
+  constructor(program, stateLimitBytes) {
+    this.program = program;
+    this.directClasses = program.classes.direct;
+    const classCount = program.classes.starts.length + 1;
+    this.denseClasses = classCount <= MAX_DENSE_EDGE_CLASSES ? classCount : 0;
+    this.simulation = new PositionSimulation(program);
+    this.cacheLimitBytes = stateLimitBytes - program.bytes - this.simulation.bytes;
+    this.start = this.intern(new Uint32Array(0), BEFORE_VALUE_START);
+    this.state = this.start;
+    if (this.wantsSimulation()) this.simulate(this.start);
+  }
+  states = /* @__PURE__ */ new Map();
+  generation = 0;
+  cachedBytes = 0;
+  codePointsSinceReset = 0;
+  start;
+  state;
+  simulating = false;
+  decided = null;
+  simulation;
+  cacheLimitBytes;
+  directClasses;
+  denseClasses;
+  get heldBytes() {
+    return this.program.bytes + this.simulation.bytes + this.cachedBytes;
+  }
+  begin() {
+    this.decided = null;
+    this.simulating = false;
+    this.state = this.start;
+    if (this.wantsSimulation()) this.simulate(this.start);
+    return true;
+  }
+  feed(codePoint, tally) {
+    if (this.simulating) {
+      const outcome = this.simulation.step(codePoint);
+      tally.add(this.simulation.steps);
+      if (outcome === STEP_MATCHED) return this.decide(true);
+      if (outcome === STEP_DEAD) return this.decide(false);
+      return true;
+    }
+    this.codePointsSinceReset++;
+    const direct = this.directClasses;
+    const codePointClass = codePoint < direct.length ? direct[codePoint] : classOf(this.program, codePoint);
+    const edge = this.edge(this.state, codePoint, codePointClass);
+    tally.add(edge.steps);
+    if (edge.target === MATCHED) return this.decide(true);
+    if (edge.target === DEAD) return this.decide(false);
+    this.state = edge.target;
+    if (this.wantsSimulation()) this.simulate(this.state);
+    return true;
+  }
+  matched() {
+    if (this.decided !== null) return this.decided;
+    if (this.simulating) return this.simulation.endMatches();
+    const { state } = this;
+    if (state.endMatch === null) {
+      this.simulation.load(state.positions, state.previousKind);
+      state.endMatch = this.simulation.endMatches();
+    }
+    return state.endMatch;
+  }
+  decide(outcome) {
+    this.decided = outcome;
+    return false;
+  }
+  wantsSimulation() {
+    return !this.simulating && this.state.generation === UNCACHED_GENERATION;
+  }
+  simulate(from) {
+    this.restartCache();
+    this.state = this.start;
+    this.simulation.load(from.positions, from.previousKind);
+    this.simulating = true;
+  }
+  restartCache() {
+    this.dropCache();
+    this.codePointsSinceReset = 0;
+    this.generation++;
+    this.start = this.intern(this.start.positions, this.start.previousKind);
+  }
+  dropCache() {
+    for (const state of this.states.values()) clearEdges(state);
+    clearEdges(this.start);
+    clearEdges(this.state);
+    this.states = /* @__PURE__ */ new Map();
+    this.cachedBytes = 0;
+  }
+  edge(state, codePoint, codePointClass) {
+    const current = state.generation === this.generation;
+    const dense = codePointClass >= 0 && codePointClass < this.denseClasses;
+    if (current) {
+      const cached = dense ? state.denseEdges?.[codePointClass] : state.sparseEdges?.get(codePointClass);
+      if (cached !== void 0) return cached;
+    }
+    const { simulation } = this;
+    simulation.load(state.positions, state.previousKind);
+    const outcome = simulation.step(codePoint);
+    const steps = simulation.steps;
+    let target = MATCHED;
+    if (outcome === STEP_DEAD) target = DEAD;
+    else if (outcome !== STEP_MATCHED) target = this.intern(simulation.sortedAfter(), simulation.previousKind);
+    const edge = { target, steps };
+    const targetCached = target.generation === DECIDED_GENERATION || target.generation === this.generation;
+    if (!current || state.generation !== this.generation || !targetCached) return edge;
+    if (!this.reserve(MATCHER_TRANSITION_BYTES) || state.generation !== this.generation) return edge;
+    if (!dense) {
+      state.sparseEdges ??= /* @__PURE__ */ new Map();
+      state.sparseEdges.set(codePointClass, edge);
+      return edge;
+    }
+    if (state.denseEdges === null) {
+      const slotBytes = this.denseClasses * MATCHER_EDGE_SLOT_BYTES;
+      if (!this.reserve(slotBytes) || state.generation !== this.generation) return edge;
+      state.denseEdges = new Array(this.denseClasses).fill(void 0);
+    }
+    state.denseEdges[codePointClass] = edge;
+    return edge;
+  }
+  intern(positions, previousKind) {
+    const key = stateKey(positions, previousKind);
+    const existing = this.states.get(key);
+    if (existing !== void 0) return existing;
+    const fresh = (generation) => ({
+      positions,
+      previousKind,
+      generation,
+      denseEdges: null,
+      sparseEdges: null,
+      endMatch: null
+    });
+    if (!this.reserve(stateBytes(positions, key))) return fresh(UNCACHED_GENERATION);
+    const state = fresh(this.generation);
+    this.states.set(key, state);
+    return state;
+  }
+  reserve(bytes) {
+    if (this.cachedBytes + bytes <= this.cacheLimitBytes) {
+      this.cachedBytes += bytes;
+      return true;
+    }
+    if (this.states.size === 0 || this.codePointsSinceReset < MATCHER_MIN_CODE_POINTS_PER_STATE * this.states.size) {
+      return false;
+    }
+    this.restartCache();
+    if (this.start.generation === UNCACHED_GENERATION) return false;
+    return this.reserve(bytes);
+  }
+};
+
+// src/pattern/expression-cache.ts
+var SearchExpressions = class {
+  constructor(budgetBytes) {
+    this.budgetBytes = budgetBytes;
+  }
+  entries = /* @__PURE__ */ new Map();
+  keptProgramBytes = 0;
+  current = null;
+  expression(operator, text, caseFold, host) {
+    const key = `${operator}\0${caseFold ? 1 : 0}\0${text}`;
+    let entry = this.entries.get(key);
+    if (entry === void 0) {
+      entry = { key, prepared: prepareExpression(operator, text, caseFold, host), program: null };
+      this.entries.set(key, entry);
+    }
+    return entry;
+  }
+  matcher(entry) {
+    if (this.current?.key === entry.key) return this.current.dfa;
+    this.current = null;
+    const program = entry.program ?? this.programOf(entry);
+    const othersBytes = this.keptProgramBytes - (entry.program === null ? 0 : program.bytes);
+    const dfa = new LazyDfa(program, this.budgetBytes - othersBytes);
+    this.current = { key: entry.key, dfa };
+    return dfa;
+  }
+  programOf(entry) {
+    const program = buildProgram(entry.prepared);
+    if (this.keptProgramBytes + program.bytes <= this.budgetBytes * KEPT_PROGRAM_BUDGET_FRACTION) {
+      entry.program = program;
+      this.keptProgramBytes += program.bytes;
+    }
+    return program;
+  }
+};
+var expressionsBySearch = /* @__PURE__ */ new WeakMap();
+function searchExpressions(meter) {
+  let expressions = expressionsBySearch.get(meter);
+  if (expressions === void 0) {
+    expressions = new SearchExpressions(meter.matcherStateBytes);
+    expressionsBySearch.set(meter, expressions);
+  }
+  return expressions;
+}
+
+// src/pattern/literal-matcher.ts
+function bordersOf(codePoints) {
+  const length = codePoints.length;
+  const borders = new Uint32Array(length + 1);
+  let border = 0;
+  for (let at = 1; at < length; at++) {
+    while (border > 0 && codePoints[at] !== codePoints[border]) border = borders[border];
+    if (codePoints[at] === codePoints[border]) border++;
+    borders[at + 1] = border;
+  }
+  return borders;
+}
+function reachablePositionsOf(borders, length) {
+  const reachable = new Uint32Array(length + 1);
+  for (let prefix = 1; prefix <= length; prefix++) {
+    reachable[prefix] = (prefix < length ? 1 : 0) + reachable[borders[prefix]];
+  }
+  return reachable;
+}
+var LiteralMatcher = class {
+  constructor(codePoints, anchoredStart, anchoredEnd) {
+    this.codePoints = codePoints;
+    this.anchoredStart = anchoredStart;
+    this.anchoredEnd = anchoredEnd;
+    this.borders = bordersOf(codePoints);
+    this.reachable = reachablePositionsOf(this.borders, codePoints.length);
+  }
+  borders;
+  reachable;
+  prefix = 0;
+  alive = true;
+  accepting = false;
+  decided = null;
+  begin() {
+    this.decided = null;
+    this.prefix = 0;
+    this.alive = this.codePoints.length > 0;
+    this.accepting = this.codePoints.length === 0;
+    if (!this.anchoredEnd && this.accepting) return this.decide(true);
+    return true;
+  }
+  feed(codePoint, tally) {
+    const steps = this.steps();
+    if (steps === 0) return this.decide(!this.anchoredStart && this.codePoints.length === 0);
+    tally.add(steps);
+    if (this.anchoredStart) this.advanceAnchored(codePoint);
+    else this.advance(codePoint);
+    if (!this.anchoredEnd && this.accepting) return this.decide(true);
+    return true;
+  }
+  matched() {
+    return this.decided ?? (this.anchoredEnd && this.accepting);
+  }
+  steps() {
+    const length = this.codePoints.length;
+    if (length === 0) return 0;
+    if (this.anchoredStart) return this.alive && this.prefix < length ? 1 : 0;
+    return 1 + this.reachable[this.prefix];
+  }
+  advanceAnchored(codePoint) {
+    if (this.codePoints[this.prefix] === codePoint) {
+      this.prefix++;
+      this.accepting = this.prefix === this.codePoints.length;
+      return;
+    }
+    this.alive = false;
+    this.accepting = false;
+  }
+  advance(codePoint) {
+    const { codePoints, borders } = this;
+    let prefix = this.prefix === codePoints.length ? borders[this.prefix] : this.prefix;
+    while (prefix > 0 && codePoints[prefix] !== codePoint) prefix = borders[prefix];
+    if (codePoints[prefix] === codePoint) prefix++;
+    this.prefix = prefix;
+    this.accepting = prefix === codePoints.length;
+  }
+  decide(outcome) {
+    this.decided = outcome;
+    return false;
+  }
+};
+
+// src/pattern/shortlist.ts
+function intersect(candidates, list, tally) {
+  const kept = new Uint32Array(Math.min(candidates.length, list.length));
+  let keptCount = 0;
+  let read = 0;
+  for (const candidate of candidates) {
+    while (read < list.length && list[read] < candidate) read++;
+    if (read === list.length) break;
+    if (list[read] === candidate) kept[keptCount++] = candidate;
+  }
+  tally.add(Math.min(list.length, read + 1));
+  return kept.subarray(0, keptCount);
+}
+function shortlistAll(index, runs, tally) {
+  const lists = [];
+  for (let at = 0; at < runs.length; at += PATTERN_RUN_CODE_POINTS) {
+    tally.add(1);
+    lists.push(index.postings(runs[at], runs[at + 1], runs[at + 2]));
+  }
+  lists.sort((left, right) => left.length - right.length);
+  let candidates = lists[0];
+  tally.add(candidates.length);
+  for (let at = 1; at < lists.length && candidates.length > 0; at++) {
+    if (lists[at].length > candidates.length * SHORTLIST_INTERSECT_RATIO) break;
+    candidates = intersect(candidates, lists[at], tally);
+  }
+  return candidates;
+}
+function union(left, right) {
+  if (left.length === 0) return right;
+  if (right.length === 0) return left;
+  const merged = new Uint32Array(left.length + right.length);
+  let count = 0;
+  let fromLeft = 0;
+  let fromRight = 0;
+  while (fromLeft < left.length && fromRight < right.length) {
+    const smaller = Math.min(left[fromLeft], right[fromRight]);
+    if (left[fromLeft] === smaller) fromLeft++;
+    if (right[fromRight] === smaller) fromRight++;
+    merged[count++] = smaller;
+  }
+  while (fromLeft < left.length) merged[count++] = left[fromLeft++];
+  while (fromRight < right.length) merged[count++] = right[fromRight++];
+  return merged.subarray(0, count);
+}
+function shortlist(index, query, tally) {
+  if (query.kind === "all") return query.runs.length === 0 ? null : shortlistAll(index, query.runs, tally);
+  let candidates = new Uint32Array(0);
+  for (const runs of query.branches) candidates = union(candidates, shortlistAll(index, runs, tally));
+  return candidates;
+}
+
+// src/core/pattern-index/typo-runs.ts
+var BASIC_PLANE_LAST2 = 65535;
+function isPatternTolerance(value) {
+  if (value === "auto") return true;
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= MAX_PATTERN_TOLERANCE;
+}
+function foldTypoText(text, host) {
+  const folded = [];
+  let longestFold = 0;
+  for (let at = 0; at < text.length; at++) {
+    const codePoint = text.codePointAt(at) ?? 0;
+    if (codePoint > BASIC_PLANE_LAST2) at++;
+    const before = folded.length;
+    host.appendFoldedCodePoint(codePoint, folded);
+    longestFold = Math.max(longestFold, folded.length - before);
+  }
+  return { folded, longestFold };
+}
+function distinctTypoRuns(text, limit) {
+  const { folded } = text;
+  const seen = /* @__PURE__ */ new Set();
+  const runs = [];
+  for (let at = 0; at + PATTERN_RUN_CODE_POINTS <= folded.length && seen.size < limit; at++) {
+    const key = String.fromCodePoint(folded[at], folded[at + 1], folded[at + 2]);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    runs.push(folded[at], folded[at + 1], folded[at + 2]);
+  }
+  return runs;
+}
+function typoRunsNeeded(tolerance, longestFold) {
+  return tolerance * (2 + longestFold) + 1;
+}
+function distinctTypoRunCount(text, limit) {
+  return distinctTypoRuns(text, limit).length / PATTERN_RUN_CODE_POINTS;
+}
+function resolvedTypoTolerance(tolerance, text) {
+  if (tolerance !== "auto") return tolerance;
+  for (let candidate = MAX_PATTERN_TOLERANCE; candidate > 0; candidate--) {
+    const needed = typoRunsNeeded(candidate, text.longestFold);
+    if (distinctTypoRunCount(text, needed) >= needed) return candidate;
+  }
+  return 0;
+}
+
+// src/pattern/typo.ts
+var TypoComparison = class {
+  constructor(text, caseFold, tolerance, host) {
+    this.caseFold = caseFold;
+    this.tolerance = tolerance;
+    this.host = host;
+    const codePoints = [];
+    appendTextCodePoints(text, caseFold, host, codePoints);
+    this.text = caseFold ? String.fromCodePoint(...codePoints) : text;
+    this.shortest = codePoints.length - tolerance;
+    this.longest = codePoints.length + tolerance;
+  }
+  text;
+  shortest;
+  longest;
+  folded = [];
+  within(value, tally) {
+    const compared = this.comparedForm(value);
+    if (compared === null) return false;
+    const { withinTolerance, cells } = tabulatedLevenshtein(this.text, compared, this.tolerance);
+    tally.add(cells);
+    return withinTolerance;
+  }
+  comparedForm(value) {
+    const folded = this.folded;
+    folded.length = 0;
+    let counted = 0;
+    for (let at = 0; at < value.length && counted <= this.longest; at++) {
+      const codePoint = value.codePointAt(at) ?? 0;
+      if (codePoint > BASIC_PLANE_LAST) at++;
+      if (this.caseFold) {
+        this.host.appendFoldedCodePoint(codePoint, folded);
+        counted = folded.length;
+      } else {
+        counted++;
+      }
+    }
+    if (counted > this.longest || counted < this.shortest) return null;
+    return this.caseFold ? String.fromCodePoint(...folded) : value;
+  }
+};
+var typoTestsBySearch = /* @__PURE__ */ new WeakMap();
+function spreadSample(runs, picks) {
+  const count = runs.length / PATTERN_RUN_CODE_POINTS;
+  if (count <= picks) return Uint32Array.from(runs);
+  const sample = new Uint32Array(picks * PATTERN_RUN_CODE_POINTS);
+  for (let pick = 0; pick < picks; pick++) {
+    const run = Math.round(pick * (count - 1) / (picks - 1));
+    for (let offset = 0; offset < PATTERN_RUN_CODE_POINTS; offset++) {
+      sample[pick * PATTERN_RUN_CODE_POINTS + offset] = runs[run * PATTERN_RUN_CODE_POINTS + offset];
+    }
+  }
+  return sample;
+}
+function preparedTypoTest(request) {
+  const text = foldTypoText(request.text, request.host);
+  const tolerance = resolvedTypoTolerance(request.tolerance, text);
+  if (tolerance === 0) return null;
+  const needed = typoRunsNeeded(tolerance, text.longestFold);
+  return {
+    needed,
+    runs: spreadSample(distinctTypoRuns(text, Number.POSITIVE_INFINITY), Math.max(needed, SHORTLIST_RUN_LOOKUPS)),
+    comparison: new TypoComparison(request.text, request.caseFold, tolerance, request.host)
+  };
+}
+function typoTestFor(request) {
+  let tests = typoTestsBySearch.get(request.meter);
+  if (tests === void 0) {
+    tests = /* @__PURE__ */ new Map();
+    typoTestsBySearch.set(request.meter, tests);
+  }
+  const key = `${request.caseFold}|${request.tolerance}|${request.text}`;
+  const known = tests.get(key);
+  if (known !== void 0) return known;
+  const test = preparedTypoTest(request);
+  tests.set(key, test);
+  return test;
+}
+function rarestLists(index, test, tally) {
+  const { runs, needed } = test;
+  if (runs.length < needed * PATTERN_RUN_CODE_POINTS) return [index.documents()];
+  const lists = [];
+  for (let at = 0; at < runs.length; at += PATTERN_RUN_CODE_POINTS) {
+    tally.add(1);
+    lists.push(index.postings(runs[at], runs[at + 1], runs[at + 2]));
+  }
+  lists.sort((left, right) => left.length - right.length);
+  return lists.slice(0, needed);
+}
+function matchWithinTolerance(request, test, tally) {
+  const { index, matches } = request;
+  const checked = new Uint32Array(matches.length);
+  let matched = false;
+  const testValue = (value) => {
+    if (!matched) matched = test.comparison.within(value, tally);
+  };
+  for (const list of rarestLists(index, test, tally)) {
+    tally.add(list.length);
+    for (const ordinal of list) {
+      if (ordinal >>> 5 >= matches.length || bitsetHas(checked, ordinal)) continue;
+      bitsetSet(checked, ordinal);
+      if (bitsetHas(matches, ordinal)) continue;
+      matched = false;
+      forEachTextValue(request.valueOf(ordinal), testValue);
+      if (matched) bitsetSet(matches, ordinal);
+    }
+  }
+}
+
+// src/pattern/work-tally.ts
+var WorkTally = class {
+  constructor(meter) {
+    this.meter = meter;
+    this.headroom = meter.remaining();
+  }
+  pending = 0;
+  headroom;
+  add(units) {
+    this.pending += units;
+    if (this.pending >= this.meter.flushUnits || this.pending > this.headroom) this.flush();
+  }
+  flush() {
+    if (this.pending === 0) return;
+    const units = this.pending;
+    this.pending = 0;
+    this.meter.add(units);
+    this.headroom = this.meter.remaining();
+  }
+};
+
+// src/pattern/evaluate.ts
+var ANCHORED_START = /* @__PURE__ */ new Set(["eq", "startsWith"]);
+var ANCHORED_END = /* @__PURE__ */ new Set(["eq", "endsWith"]);
+var shortlistRunsBySearch = /* @__PURE__ */ new WeakMap();
+function literalRuns(text, host, meter) {
+  let runsByText = shortlistRunsBySearch.get(meter);
+  if (runsByText === void 0) {
+    runsByText = /* @__PURE__ */ new Map();
+    shortlistRunsBySearch.set(meter, runsByText);
+  }
+  const known = runsByText.get(text);
+  if (known !== void 0) return known;
+  const folded = [];
+  appendTextCodePoints(text, true, host, folded);
+  const runs = { kind: "all", runs: spreadRuns([folded]) };
+  runsByText.set(text, runs);
+  return runs;
+}
+function literalTest(request) {
+  const { operator, text, caseFold, host, meter } = request;
+  return {
+    runs: literalRuns(text, host, meter),
+    matcher: () => {
+      const testCodePoints = [];
+      appendTextCodePoints(text, caseFold, host, testCodePoints);
+      return new LiteralMatcher(
+        Uint32Array.from(testCodePoints),
+        ANCHORED_START.has(operator),
+        ANCHORED_END.has(operator)
+      );
+    }
+  };
+}
+function expressionTest(request, operator) {
+  const { text, caseFold, host, meter } = request;
+  const expressions = searchExpressions(meter);
+  const entry = expressions.expression(operator, text, caseFold, host);
+  return { runs: entry.prepared.runs, matcher: () => expressions.matcher(entry) };
+}
+function matchesText(matcher, text, caseFold, host, folded, tally) {
+  if (!matcher.begin()) return matcher.matched();
+  for (let at = 0; at < text.length; at++) {
+    const codePoint = text.codePointAt(at) ?? 0;
+    if (codePoint > BASIC_PLANE_LAST) at++;
+    if (!caseFold) {
+      if (!matcher.feed(codePoint, tally)) return matcher.matched();
+      continue;
+    }
+    folded.length = 0;
+    host.appendFoldedCodePoint(codePoint, folded);
+    for (const foldedCodePoint of folded) {
+      if (!matcher.feed(foldedCodePoint, tally)) return matcher.matched();
+    }
+  }
+  return matcher.matched();
+}
+function answeredByTypoTest(request, tally) {
+  if (request.operator !== "eq" || request.tolerance === 0) return false;
+  const test = typoTestFor(request);
+  if (test === null) return false;
+  matchWithinTolerance(request, test, tally);
+  return true;
+}
+function matchPattern(request) {
+  const { operator, caseFold, index, matches, host } = request;
+  const tally = new WorkTally(request.meter);
+  if (answeredByTypoTest(request, tally)) {
+    tally.flush();
+    return;
+  }
+  const test = operator === "wildcard" || operator === "regex" ? expressionTest(request, operator) : literalTest(request);
+  const shortlisted = shortlist(index, test.runs, tally);
+  const scanning = shortlisted === null;
+  const candidates = shortlisted ?? index.documents();
+  const folded = [];
+  let matcher = null;
+  let matched = false;
+  const testValue = (value) => {
+    if (!matched && matcher !== null) matched = matchesText(matcher, value, caseFold, host, folded, tally);
+  };
+  for (const ordinal of candidates) {
+    if (ordinal >>> 5 >= matches.length || bitsetHas(matches, ordinal)) continue;
+    if (scanning) tally.add(1);
+    matcher ??= test.matcher();
+    matched = false;
+    forEachTextValue(request.valueOf(ordinal), testValue);
+    if (matched) bitsetSet(matches, ordinal);
+  }
+  tally.flush();
+}
+
+// src/core/partition/growable-uint32.ts
+var GrowableUint32 = class {
+  values;
+  length = 0;
+  constructor(capacity) {
+    this.values = new Uint32Array(capacity);
+  }
+  growTo(needed, kept) {
+    let capacity = this.values.length * 2;
+    while (capacity < needed) capacity *= 2;
+    const next = new Uint32Array(capacity);
+    next.set(this.values.subarray(0, kept));
+    this.values = next;
+  }
+  reserve(extra) {
+    const needed = this.length + extra;
+    if (needed > this.values.length) this.growTo(needed, this.length);
+  }
+  push(value) {
+    if (this.length === this.values.length) this.growTo(this.length + 1, this.length);
+    this.values[this.length++] = value;
+  }
+  ensureIndex(index) {
+    if (index >= this.values.length) this.growTo(index + 1, this.values.length);
+  }
+  clear() {
+    this.length = 0;
+  }
+};
+
+// src/pattern/runs-arrays.ts
+var EMPTY_POSTINGS = new Uint32Array(0);
+function remapAscending(source, remap, out) {
+  const start = out.length;
+  let ordered = true;
+  for (const ordinal of source) {
+    const mapped = remap === null ? ordinal : ordinal < remap.length ? remap[ordinal] : -1;
+    if (mapped < 0) continue;
+    if (out.length > start && out.values[out.length - 1] > mapped) ordered = false;
+    out.push(mapped);
+  }
+  if (!ordered) out.values.subarray(start, out.length).sort();
+}
+function sortedRunOrder(codePoints, count) {
+  const order = new Array(count);
+  for (let run = 0; run < count; run++) order[run] = run;
+  order.sort(
+    (left, right) => compareRuns(codePoints, left * PATTERN_RUN_CODE_POINTS, codePoints, right * PATTERN_RUN_CODE_POINTS)
+  );
+  return order;
+}
+function buildArrays(fieldPath, documents, source, order, remap) {
+  const docIds = new GrowableUint32(Math.max(1, documents.length));
+  remapAscending(documents, remap, docIds);
+  const runs = new GrowableUint32(Math.max(1, source.count * PATTERN_RUN_CODE_POINTS));
+  const offsets = new GrowableUint32(source.count + 1);
+  const postings = new GrowableUint32(Math.max(1, source.count));
+  offsets.push(0);
+  for (let position = 0; position < source.count; position++) {
+    const run = order === null ? position : order[position];
+    const before = postings.length;
+    remapAscending(source.postingsAt(run), remap, postings);
+    if (postings.length === before) continue;
+    const at = run * PATTERN_RUN_CODE_POINTS;
+    runs.push(source.codePoints[at]);
+    runs.push(source.codePoints[at + 1]);
+    runs.push(source.codePoints[at + 2]);
+    offsets.push(postings.length);
+  }
+  return trimmedArrays(fieldPath, docIds, runs, offsets, postings);
+}
+function trimmedArrays(fieldPath, docIds, runs, offsets, postings) {
+  return {
+    fieldPath,
+    docIds: docIds.values.slice(0, docIds.length),
+    runs: runs.values.slice(0, runs.length),
+    offsets: offsets.values.slice(0, offsets.length),
+    postings: postings.values.slice(0, postings.length)
+  };
+}
+function findRun(runs, first, second, third) {
+  let low = 0;
+  let high = runs.length / PATTERN_RUN_CODE_POINTS;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    const at = middle * PATTERN_RUN_CODE_POINTS;
+    const difference = runs[at] - first || runs[at + 1] - second || runs[at + 2] - third;
+    if (difference === 0) return middle;
+    if (difference < 0) low = middle + 1;
+    else high = middle;
+  }
+  return -1;
+}
+
+// src/pattern/frozen-index.ts
+function readPatternArrays(arrays) {
+  const source = {
+    count: arrays.offsets.length - 1,
+    codePoints: arrays.runs,
+    postingsAt: (run) => arrays.postings.subarray(arrays.offsets[run], arrays.offsets[run + 1])
+  };
+  return {
+    documents: () => arrays.docIds,
+    postings(first, second, third) {
+      const run = findRun(arrays.runs, first, second, third);
+      return run < 0 ? EMPTY_POSTINGS : source.postingsAt(run);
+    },
+    toArrays(fieldPath, remap) {
+      return buildArrays(fieldPath, arrays.docIds, source, null, remap);
+    },
+    bytes() {
+      return arrays.docIds.byteLength + arrays.runs.byteLength + arrays.offsets.byteLength + arrays.postings.byteLength;
+    }
+  };
+}
+
+// src/pattern/growing-index.ts
+function createRunList() {
+  return { ids: new Uint32Array(RUN_LIST_INITIAL_CAPACITY), length: 0, removed: null, ordered: true };
+}
+function compactRemoved(list) {
+  const removed = list.removed;
+  if (removed === null) return;
+  let kept = 0;
+  for (let at = 0; at < list.length; at++) {
+    const ordinal = list.ids[at];
+    if (removed.has(ordinal)) continue;
+    list.ids[kept++] = ordinal;
+  }
+  list.length = kept;
+  list.removed = null;
+}
+function compactAndSort(list) {
+  compactRemoved(list);
+  if (!list.ordered) {
+    list.ids.subarray(0, list.length).sort();
+    list.ordered = true;
+  }
+}
+function createGrowingPatternIndex(host) {
+  const runs = /* @__PURE__ */ new Map();
+  const documents = /* @__PURE__ */ new Set();
+  let documentsCache = null;
+  let listBytes = 0;
+  const folded = [];
+  function runKeysOf(value) {
+    const keys = /* @__PURE__ */ new Set();
+    forEachTextValue(value, (text) => {
+      folded.length = 0;
+      appendTextCodePoints(text, true, host, folded);
+      collectRunKeys(folded, keys);
+    });
+    return keys;
+  }
+  function grow(list) {
+    const next = new Uint32Array(list.ids.length * 2);
+    next.set(list.ids.subarray(0, list.length));
+    listBytes += next.byteLength - list.ids.byteLength;
+    list.ids = next;
+  }
+  function listFor(key) {
+    let list = runs.get(key);
+    if (list === void 0) {
+      list = createRunList();
+      listBytes += list.ids.byteLength;
+      runs.set(key, list);
+    }
+    return list;
+  }
+  function append(list, ordinal) {
+    if (list.removed?.delete(ordinal)) return;
+    if (list.length === list.ids.length) grow(list);
+    if (list.length > 0 && list.ids[list.length - 1] > ordinal) list.ordered = false;
+    list.ids[list.length++] = ordinal;
+  }
+  function dropIfEmpty(key, list) {
+    if (list.length > 0) return;
+    listBytes -= list.ids.byteLength;
+    runs.delete(key);
+  }
+  function markRemoved(key, list, ordinal) {
+    if (list.removed === null) list.removed = /* @__PURE__ */ new Set();
+    list.removed.add(ordinal);
+    if (list.removed.size < list.length * RUN_LIST_COMPACTION_FRACTION) return;
+    compactRemoved(list);
+    dropIfEmpty(key, list);
+  }
+  function settledPostings(key) {
+    const list = runs.get(key);
+    if (list === void 0) return EMPTY_POSTINGS;
+    compactAndSort(list);
+    if (list.length === 0) {
+      dropIfEmpty(key, list);
+      return EMPTY_POSTINGS;
+    }
+    return list.ids.subarray(0, list.length);
+  }
+  function sortedDocuments() {
+    if (documentsCache === null) {
+      documentsCache = Uint32Array.from(documents).sort();
+    }
+    return documentsCache;
+  }
+  function runSource() {
+    const keys = [];
+    const lists = [];
+    for (const key of [...runs.keys()]) {
+      const postings = settledPostings(key);
+      if (postings.length === 0) continue;
+      keys.push(key);
+      lists.push(postings);
+    }
+    const codePoints = new Uint32Array(keys.length * PATTERN_RUN_CODE_POINTS);
+    for (let run = 0; run < keys.length; run++) {
+      runKeyCodePoints(keys[run], codePoints, run * PATTERN_RUN_CODE_POINTS);
+    }
+    return { count: keys.length, codePoints, postingsAt: (run) => lists[run] };
+  }
+  return {
+    add(ordinal, value) {
+      if (!holdsTextValue(value)) return;
+      documents.add(ordinal);
+      documentsCache = null;
+      for (const key of runKeysOf(value)) append(listFor(key), ordinal);
+    },
+    remove(ordinal, value) {
+      if (!holdsTextValue(value)) return;
+      if (documents.delete(ordinal)) documentsCache = null;
+      for (const key of runKeysOf(value)) {
+        const list = runs.get(key);
+        if (list !== void 0) markRemoved(key, list, ordinal);
+      }
+    },
+    addArrays(arrays, mapOrdinal) {
+      for (const ordinal of arrays.docIds) {
+        const mapped = mapOrdinal(ordinal);
+        if (mapped < 0) continue;
+        documents.add(mapped);
+        documentsCache = null;
+      }
+      const runCount = arrays.offsets.length - 1;
+      for (let run = 0; run < runCount; run++) {
+        const at = run * PATTERN_RUN_CODE_POINTS;
+        const key = runKey(arrays.runs[at], arrays.runs[at + 1], arrays.runs[at + 2]);
+        const list = listFor(key);
+        for (let posting = arrays.offsets[run]; posting < arrays.offsets[run + 1]; posting++) {
+          const mapped = mapOrdinal(arrays.postings[posting]);
+          if (mapped >= 0) append(list, mapped);
+        }
+        dropIfEmpty(key, list);
+      }
+    },
+    clear() {
+      runs.clear();
+      documents.clear();
+      documentsCache = null;
+      listBytes = 0;
+    },
+    documents: sortedDocuments,
+    postings(first, second, third) {
+      return settledPostings(runKey(first, second, third));
+    },
+    toArrays(fieldPath, remap) {
+      const source = runSource();
+      return buildArrays(fieldPath, sortedDocuments(), source, sortedRunOrder(source.codePoints, source.count), remap);
+    },
+    bytes() {
+      return listBytes + runs.size * RUN_ENTRY_OVERHEAD_BYTES + documents.size * DOCUMENT_ENTRY_BYTES + (documentsCache?.byteLength ?? 0);
+    }
+  };
+}
+
+// src/pattern/merge.ts
+function sortTailIfUnordered(values, start) {
+  for (let at = start + 1; at < values.length; at++) {
+    if (values.values[at - 1] > values.values[at]) {
+      values.values.subarray(start, values.length).sort();
+      return;
+    }
+  }
+}
+function smallestRun(inputs, cursors) {
+  let smallest = -1;
+  for (let input = 0; input < inputs.length; input++) {
+    const runCount = inputs[input].arrays.offsets.length - 1;
+    if (cursors[input] >= runCount) continue;
+    if (smallest < 0) {
+      smallest = input;
+      continue;
+    }
+    const order = compareRuns(
+      inputs[input].arrays.runs,
+      cursors[input] * PATTERN_RUN_CODE_POINTS,
+      inputs[smallest].arrays.runs,
+      cursors[smallest] * PATTERN_RUN_CODE_POINTS
+    );
+    if (order < 0) smallest = input;
+  }
+  return smallest;
+}
+function mergePatternArrays(fieldPath, inputs) {
+  const docIds = new GrowableUint32(1);
+  for (const input of inputs) remapAscending(input.arrays.docIds, input.remap, docIds);
+  sortTailIfUnordered(docIds, 0);
+  const runs = new GrowableUint32(PATTERN_RUN_CODE_POINTS);
+  const offsets = new GrowableUint32(1);
+  const postings = new GrowableUint32(1);
+  offsets.push(0);
+  const cursors = inputs.map(() => 0);
+  for (let smallest = smallestRun(inputs, cursors); smallest >= 0; smallest = smallestRun(inputs, cursors)) {
+    const source = inputs[smallest].arrays.runs;
+    const at = cursors[smallest] * PATTERN_RUN_CODE_POINTS;
+    const first = source[at];
+    const second = source[at + 1];
+    const third = source[at + 2];
+    const before = postings.length;
+    for (let input = 0; input < inputs.length; input++) {
+      const { arrays, remap } = inputs[input];
+      const run = cursors[input];
+      if (run >= arrays.offsets.length - 1) continue;
+      const runAt = run * PATTERN_RUN_CODE_POINTS;
+      if (arrays.runs[runAt] !== first || arrays.runs[runAt + 1] !== second || arrays.runs[runAt + 2] !== third) {
+        continue;
+      }
+      remapAscending(arrays.postings.subarray(arrays.offsets[run], arrays.offsets[run + 1]), remap, postings);
+      cursors[input] = run + 1;
+    }
+    if (postings.length === before) continue;
+    sortTailIfUnordered(postings, before);
+    runs.push(first);
+    runs.push(second);
+    runs.push(third);
+    offsets.push(postings.length);
+  }
+  return trimmedArrays(fieldPath, docIds, runs, offsets, postings);
+}
+
+// src/pattern/module.ts
+var patternSearchModule = {
+  name: "pattern",
+  createIndex: createGrowingPatternIndex,
+  readArrays: readPatternArrays,
+  mergeArrays: mergePatternArrays,
+  matchInto: matchPattern,
+  checkExpression,
+  expressionFootprint
+};
+
+export { DEFAULT_PATTERN_WORK_CAP, GrowableUint32, MATCHER_CODE_POINT_BYTES, MATCHER_SIMULATION_BYTES_PER_POSITION, MATCHER_STATE_BUDGET_BYTES, MATCHER_STATE_OVERHEAD_BYTES, MAX_PATTERN_POSITIONS, MAX_PATTERN_TEXT_CODE_POINTS, PATTERN_EXPRESSION_OPERATORS, PATTERN_RUN_CODE_POINTS, PATTERN_TEST_OPERATORS, PATTERN_WORK_FLUSH_UNITS, bitsetAnd, bitsetAndInto, bitsetAndNotInto, bitsetFromSet, bitsetHas, bitsetIsEmpty, bitsetNot, bitsetOrInto, bitsetSet, createBitSet, distinctTypoRunCount, foldTypoText, isPatternTolerance, patternSearchModule, typoRunsNeeded };