@delali/narsil 0.3.1-next.71 → 0.3.1-next.73

package/dist/chunk-XW25X6AU.mjs

@@ -0,0 +1,614 @@
+import { bitsetHas, bitsetSet, PATTERN_RUN_CODE_POINTS } from './chunk-ZKRV5M2P.mjs';
+
+// src/pattern/constants.ts
+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;
+
+// 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/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/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 spreadRuns(folded) {
+  const runCount = folded.length - PATTERN_RUN_CODE_POINTS + 1;
+  if (runCount <= 0) return new Uint32Array(0);
+  const picks = Math.min(runCount, SHORTLIST_RUN_LOOKUPS);
+  const seen = /* @__PURE__ */ new Set();
+  const runs = [];
+  for (let pick = 0; pick < picks; pick++) {
+    const at = picks === 1 ? 0 : Math.round(pick * (runCount - 1) / (picks - 1));
+    const key = runKey(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 Uint32Array.from(runs);
+}
+function shortlistRuns(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 = spreadRuns(folded);
+  runsByText.set(text, runs);
+  return runs;
+}
+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 shortlist(index, runs, tally) {
+  if (runs.length === 0) return null;
+  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 matcherFor(request) {
+  const { operator, text, caseFold, host } = request;
+  const testCodePoints = [];
+  appendTextCodePoints(text, caseFold, host, testCodePoints);
+  return new LiteralMatcher(Uint32Array.from(testCodePoints), ANCHORED_START.has(operator), ANCHORED_END.has(operator));
+}
+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 matchPattern(request) {
+  const { text, caseFold, index, matches, host } = request;
+  const tally = new WorkTally(request.meter);
+  const shortlisted = shortlist(index, shortlistRuns(text, host, request.meter), 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 ??= matcherFor(request);
+    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
+};
+
+export { GrowableUint32, patternSearchModule };

package/dist/chunk-ZKRV5M2P.mjs

@@ -0,0 +1,75 @@
+// 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 PATTERN_TEST_OPERATORS = ["eq", "ne", "in", "nin", "startsWith", "endsWith", "contains"];
+
+// 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;
+}
+
+export { DEFAULT_PATTERN_WORK_CAP, 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_RUN_CODE_POINTS, PATTERN_TEST_OPERATORS, PATTERN_WORK_FLUSH_UNITS, bitsetAnd, bitsetAndInto, bitsetAndNotInto, bitsetFromSet, bitsetHas, bitsetIsEmpty, bitsetNot, bitsetOrInto, bitsetSet, createBitSet };