seqex 0.1.1

package/dist/index.js

@@ -0,0 +1,485 @@
+// src/ast.ts
+function isGreedy(node) {
+  switch (node.type) {
+    case "predicate":
+    case "anchor":
+    case "any":
+      return true;
+    case "sequence":
+      return node.children.every(isGreedy);
+    case "quantifier":
+      return node.greedy && isGreedy(node.child);
+    case "alternation":
+      return isGreedy(node.left) && isGreedy(node.right);
+  }
+}
+
+// src/engine.ts
+function epsilonClosure(states, position, seqLength) {
+  const result = new Set;
+  const stack = [...states];
+  while (stack.length > 0) {
+    const state = stack.pop();
+    if (result.has(state))
+      continue;
+    if (state.anchorCheck && !state.anchorCheck(position, seqLength)) {
+      continue;
+    }
+    result.add(state);
+    for (const target of state.epsilons) {
+      if (!result.has(target)) {
+        stack.push(target);
+      }
+    }
+  }
+  return result;
+}
+function simulate(nfa, sequence, offset, greedy = true) {
+  let active = epsilonClosure(new Set([nfa.start]), offset, sequence.length);
+  let lastAcceptLength = active.has(nfa.accept) ? 0 : -1;
+  if (!greedy && lastAcceptLength >= 0) {
+    return { matched: true, length: 0 };
+  }
+  for (let i = offset;i < sequence.length; i++) {
+    const element = sequence[i];
+    const next = new Set;
+    for (const state of active) {
+      for (const transition of state.transitions) {
+        if (transition.predicate(element)) {
+          next.add(transition.target);
+        }
+      }
+    }
+    active = epsilonClosure(next, i + 1, sequence.length);
+    if (active.size === 0)
+      break;
+    if (active.has(nfa.accept)) {
+      lastAcceptLength = i - offset + 1;
+      if (!greedy)
+        break;
+    }
+  }
+  return {
+    matched: lastAcceptLength >= 0,
+    length: Math.max(lastAcceptLength, 0)
+  };
+}
+function findAll(nfa, sequence, greedy = true) {
+  const results = [];
+  let pos = 0;
+  while (pos < sequence.length) {
+    const result = simulate(nfa, sequence, pos, greedy);
+    if (result.matched && result.length > 0) {
+      results.push({
+        start: pos,
+        end: pos + result.length - 1,
+        data: sequence.slice(pos, pos + result.length)
+      });
+      pos += result.length;
+    } else {
+      pos += 1;
+    }
+  }
+  return results;
+}
+function findFirst(nfa, sequence, greedy = true) {
+  let pos = 0;
+  while (pos < sequence.length) {
+    const result = simulate(nfa, sequence, pos, greedy);
+    if (result.matched && result.length > 0) {
+      return {
+        start: pos,
+        end: pos + result.length - 1,
+        data: sequence.slice(pos, pos + result.length)
+      };
+    }
+    pos += 1;
+  }
+  return null;
+}
+function test(nfa, sequence, greedy = true) {
+  return findFirst(nfa, sequence, greedy) !== null;
+}
+
+// src/scanner.ts
+class Scanner {
+  nfa;
+  greedy;
+  position = 0;
+  scanStart = 0;
+  buffer = [];
+  active = new Set;
+  lastAcceptLength = -1;
+  simulationAlive = false;
+  constructor(nfa, greedy) {
+    this.nfa = nfa;
+    this.greedy = greedy;
+    this.initSimulation(0, Infinity);
+  }
+  push(element) {
+    this.buffer.push(element);
+    if (this.simulationAlive) {
+      this.step(element, this.position, Infinity);
+    }
+    this.position++;
+    return this.drain(Infinity);
+  }
+  end() {
+    const totalLength = this.position;
+    const results = [];
+    if (this.simulationAlive && this.active.size > 0) {
+      const finalActive = epsilonClosure(this.active, this.position, totalLength);
+      if (finalActive.has(this.nfa.accept)) {
+        this.lastAcceptLength = this.position - this.scanStart;
+      }
+    }
+    if (this.lastAcceptLength > 0) {
+      results.push(this.emitMatch());
+    } else if (this.scanStart < totalLength) {
+      this.scanStart++;
+    }
+    while (this.scanStart < totalLength) {
+      this.initSimulation(this.scanStart, totalLength);
+      const bufferOffset = this.scanStart - (this.position - this.buffer.length);
+      for (let i = this.scanStart;i < totalLength; i++) {
+        const element = this.buffer[bufferOffset + (i - this.scanStart)];
+        this.step(element, i, totalLength);
+        if (!this.simulationAlive)
+          break;
+      }
+      if (this.simulationAlive && this.active.size > 0) {
+        const finalActive = epsilonClosure(this.active, totalLength, totalLength);
+        if (finalActive.has(this.nfa.accept)) {
+          this.lastAcceptLength = totalLength - this.scanStart;
+        }
+      }
+      if (this.lastAcceptLength > 0) {
+        results.push(this.emitMatch());
+      } else {
+        this.scanStart++;
+      }
+    }
+    return results;
+  }
+  initSimulation(startPos, seqLength) {
+    this.active = epsilonClosure(new Set([this.nfa.start]), startPos, seqLength);
+    this.lastAcceptLength = this.active.has(this.nfa.accept) ? 0 : -1;
+    this.simulationAlive = true;
+  }
+  step(element, absolutePosition, seqLength) {
+    const next = new Set;
+    for (const state of this.active) {
+      for (const transition of state.transitions) {
+        if (transition.predicate(element)) {
+          next.add(transition.target);
+        }
+      }
+    }
+    this.active = epsilonClosure(next, absolutePosition + 1, seqLength);
+    if (this.active.size === 0) {
+      this.simulationAlive = false;
+      return;
+    }
+    if (this.active.has(this.nfa.accept)) {
+      this.lastAcceptLength = absolutePosition - this.scanStart + 1;
+      if (!this.greedy) {
+        this.simulationAlive = false;
+      }
+    }
+  }
+  drain(seqLength) {
+    const results = [];
+    while (!this.simulationAlive && this.scanStart < this.position) {
+      if (this.lastAcceptLength > 0) {
+        results.push(this.emitMatch());
+      } else {
+        this.scanStart++;
+      }
+      if (this.scanStart >= this.position)
+        break;
+      this.initSimulation(this.scanStart, seqLength);
+      const bufferStart = this.position - this.buffer.length;
+      for (let i = this.scanStart;i < this.position; i++) {
+        if (!this.simulationAlive)
+          break;
+        this.step(this.buffer[i - bufferStart], i, seqLength);
+      }
+    }
+    if (!this.simulationAlive && this.scanStart === this.position) {
+      this.initSimulation(this.scanStart, seqLength);
+    }
+    const consumed = this.scanStart - (this.position - this.buffer.length);
+    if (consumed > 0) {
+      this.buffer = this.buffer.slice(consumed);
+    }
+    return results;
+  }
+  emitMatch() {
+    const bufferStart = this.position - this.buffer.length;
+    const matchStart = this.scanStart;
+    const matchLength = this.lastAcceptLength;
+    const dataStart = matchStart - bufferStart;
+    const result = {
+      start: matchStart,
+      end: matchStart + matchLength - 1,
+      data: this.buffer.slice(dataStart, dataStart + matchLength)
+    };
+    this.scanStart = matchStart + matchLength;
+    this.lastAcceptLength = -1;
+    this.simulationAlive = false;
+    return result;
+  }
+}
+
+// src/matcher.ts
+class Matcher {
+  nfa;
+  greedy;
+  constructor(nfa, greedy) {
+    this.nfa = nfa;
+    this.greedy = greedy;
+  }
+  findAll(sequence) {
+    if (Array.isArray(sequence)) {
+      return findAll(this.nfa, sequence, this.greedy);
+    }
+    const scanner = this.scanner();
+    const results = [];
+    for (const element of sequence) {
+      results.push(...scanner.push(element));
+    }
+    results.push(...scanner.end());
+    return results;
+  }
+  find(sequence) {
+    if (Array.isArray(sequence)) {
+      return findFirst(this.nfa, sequence, this.greedy);
+    }
+    const scanner = this.scanner();
+    for (const element of sequence) {
+      const results2 = scanner.push(element);
+      if (results2.length > 0)
+        return results2[0];
+    }
+    const results = scanner.end();
+    return results.length > 0 ? results[0] : null;
+  }
+  test(sequence) {
+    if (Array.isArray(sequence)) {
+      return test(this.nfa, sequence, this.greedy);
+    }
+    return this.find(sequence) !== null;
+  }
+  scanner() {
+    return new Scanner(this.nfa, this.greedy);
+  }
+}
+
+// src/nfa.ts
+function compile(node) {
+  let nextId = 0;
+  function createState() {
+    return { id: nextId++, epsilons: [], transitions: [] };
+  }
+  function compileNode(node2) {
+    switch (node2.type) {
+      case "predicate":
+        return compilePredicate(node2.fn);
+      case "sequence":
+        return compileSequence(node2.children);
+      case "quantifier":
+        return compileQuantifier(node2.child, node2.min, node2.max, node2.greedy);
+      case "alternation":
+        return compileAlternation(node2.left, node2.right);
+      case "anchor":
+        return compileAnchor(node2.position);
+      case "any":
+        return compilePredicate(() => true);
+    }
+  }
+  function compilePredicate(fn) {
+    const start = createState();
+    const accept = createState();
+    start.transitions.push({ predicate: fn, target: accept });
+    return { start, accept };
+  }
+  function compileSequence(children) {
+    if (children.length === 0) {
+      const start = createState();
+      const accept = createState();
+      start.epsilons.push(accept);
+      return { start, accept };
+    }
+    if (children.length === 1) {
+      return compileNode(children[0]);
+    }
+    const fragments = children.map((child) => compileNode(child));
+    for (let i = 0;i < fragments.length - 1; i++) {
+      fragments[i].accept.epsilons.push(fragments[i + 1].start);
+    }
+    return { start: fragments[0].start, accept: fragments[fragments.length - 1].accept };
+  }
+  function compileQuantifier(child, min, max, greedy) {
+    const start = createState();
+    const accept = createState();
+    let lastState = start;
+    for (let i = 0;i < min; i++) {
+      const fragment = compileNode(child);
+      lastState.epsilons.push(fragment.start);
+      lastState = fragment.accept;
+    }
+    if (max === Infinity) {
+      const loopFragment = compileNode(child);
+      lastState.epsilons.push(...greedy ? [loopFragment.start, accept] : [accept, loopFragment.start]);
+      loopFragment.accept.epsilons.push(lastState);
+    } else {
+      for (let i = min;i < max; i++) {
+        const fragment = compileNode(child);
+        lastState.epsilons.push(...greedy ? [fragment.start, accept] : [accept, fragment.start]);
+        lastState = fragment.accept;
+      }
+      lastState.epsilons.push(accept);
+    }
+    return { start, accept };
+  }
+  function compileAlternation(left, right) {
+    const start = createState();
+    const accept = createState();
+    const leftNFA = compileNode(left);
+    const rightNFA = compileNode(right);
+    start.epsilons.push(leftNFA.start, rightNFA.start);
+    leftNFA.accept.epsilons.push(accept);
+    rightNFA.accept.epsilons.push(accept);
+    return { start, accept };
+  }
+  function compileAnchor(position) {
+    const start = createState();
+    const accept = createState();
+    start.anchorCheck = position === "start" ? (index) => index === 0 : (index, length) => index === length;
+    start.epsilons.push(accept);
+    return { start, accept };
+  }
+  return compileNode(node);
+}
+
+// src/pattern.ts
+class Pattern {
+  ast;
+  constructor(ast) {
+    this.ast = ast;
+  }
+  static where(fn) {
+    return new Pattern({
+      type: "sequence",
+      children: [{ type: "predicate", fn }]
+    });
+  }
+  static any() {
+    return new Pattern({
+      type: "sequence",
+      children: [{ type: "any" }]
+    });
+  }
+  static oneOf(...alternatives) {
+    if (alternatives.length === 0) {
+      throw new Error("Pattern.oneOf() requires at least one alternative");
+    }
+    const toNode = (alt) => alt instanceof Pattern ? alt.ast : { type: "predicate", fn: alt };
+    let node = toNode(alternatives[0]);
+    for (let i = 1;i < alternatives.length; i++) {
+      node = { type: "alternation", left: node, right: toNode(alternatives[i]) };
+    }
+    return new Pattern(node);
+  }
+  followedBy(fnOrPattern) {
+    const seq = this.getSequence();
+    const node = this.resolveNode(fnOrPattern);
+    return new Pattern({
+      type: "sequence",
+      children: [...seq, node]
+    });
+  }
+  followedByAny() {
+    const seq = this.getSequence();
+    return new Pattern({
+      type: "sequence",
+      children: [...seq, { type: "any" }]
+    });
+  }
+  oneOrMore(greedy = true) {
+    return this.applyQuantifier(1, Infinity, greedy);
+  }
+  zeroOrMore(greedy = true) {
+    return this.applyQuantifier(0, Infinity, greedy);
+  }
+  optional(greedy = true) {
+    return this.applyQuantifier(0, 1, greedy);
+  }
+  times(n) {
+    return this.applyQuantifier(n, n, true);
+  }
+  between(min, max, greedy = true) {
+    return this.applyQuantifier(min, max, greedy);
+  }
+  or(fnOrPattern) {
+    return new Pattern({
+      type: "alternation",
+      left: this.ast,
+      right: this.resolveNode(fnOrPattern)
+    });
+  }
+  atStart() {
+    const seq = this.getSequence();
+    return new Pattern({
+      type: "sequence",
+      children: [{ type: "anchor", position: "start" }, ...seq]
+    });
+  }
+  atEnd() {
+    const seq = this.getSequence();
+    return new Pattern({
+      type: "sequence",
+      children: [...seq, { type: "anchor", position: "end" }]
+    });
+  }
+  compile() {
+    return new Matcher(compile(this.ast), isGreedy(this.ast));
+  }
+  toAST() {
+    return this.ast;
+  }
+  resolveNode(fnOrPattern) {
+    return fnOrPattern instanceof Pattern ? fnOrPattern.ast : { type: "predicate", fn: fnOrPattern };
+  }
+  getSequence() {
+    if (this.ast.type === "sequence") {
+      return [...this.ast.children];
+    }
+    return [this.ast];
+  }
+  applyQuantifier(min, max, greedy) {
+    const seq = this.getSequence();
+    if (seq.length === 0) {
+      return this;
+    }
+    const rest = seq.slice(0, -1);
+    const quantified = {
+      type: "quantifier",
+      child: seq[seq.length - 1],
+      min,
+      max,
+      greedy
+    };
+    return new Pattern({
+      type: "sequence",
+      children: [...rest, quantified]
+    });
+  }
+}
+export {
+  Scanner,
+  Pattern,
+  Matcher
+};
+
+//# debugId=9657E6188A58006B64756E2164756E21

package/dist/index.js.map

@@ -0,0 +1,15 @@
+{
+  "version": 3,
+  "sources": ["../src/ast.ts", "../src/engine.ts", "../src/scanner.ts", "../src/matcher.ts", "../src/nfa.ts", "../src/pattern.ts"],
+  "sourcesContent": [
+    "export type Predicate<T> = (element: T) => boolean\n\nexport function isGreedy<T>(node: PatternNode<T>): boolean {\n  switch (node.type) {\n    case 'predicate':\n    case 'anchor':\n    case 'any':\n      return true\n    case 'sequence':\n      return node.children.every(isGreedy)\n    case 'quantifier':\n      return node.greedy && isGreedy(node.child)\n    case 'alternation':\n      return isGreedy(node.left) && isGreedy(node.right)\n  }\n}\n\nexport type PatternNode<T> =\n  | { type: 'predicate'; fn: Predicate<T> }\n  | { type: 'sequence'; children: PatternNode<T>[] }\n  | {\n      type: 'quantifier'\n      child: PatternNode<T>\n      min: number\n      max: number\n      greedy: boolean\n    }\n  | { type: 'alternation'; left: PatternNode<T>; right: PatternNode<T> }\n  | { type: 'anchor'; position: 'start' | 'end' }\n  | { type: 'any' }\n",
+    "import type { NFA, NFAState } from './nfa'\n\nexport interface MatchResult<T> {\n  start: number\n  end: number\n  data: T[]\n}\n\nexport function epsilonClosure<T>(\n  states: Set<NFAState<T>>,\n  position: number,\n  seqLength: number,\n): Set<NFAState<T>> {\n  const result = new Set<NFAState<T>>()\n  const stack = [...states]\n\n  while (stack.length > 0) {\n    const state = stack.pop()!\n    if (result.has(state)) continue\n\n    if (state.anchorCheck && !state.anchorCheck(position, seqLength)) {\n      continue\n    }\n\n    result.add(state)\n\n    for (const target of state.epsilons) {\n      if (!result.has(target)) {\n        stack.push(target)\n      }\n    }\n  }\n\n  return result\n}\n\nexport function simulate<T>(\n  nfa: NFA<T>,\n  sequence: T[],\n  offset: number,\n  greedy = true,\n): { matched: boolean; length: number } {\n  let active = epsilonClosure(new Set([nfa.start]), offset, sequence.length)\n\n  let lastAcceptLength = active.has(nfa.accept) ? 0 : -1\n\n  if (!greedy && lastAcceptLength >= 0) {\n    return { matched: true, length: 0 }\n  }\n\n  for (let i = offset; i < sequence.length; i++) {\n    const element = sequence[i]\n    const next = new Set<NFAState<T>>()\n\n    for (const state of active) {\n      for (const transition of state.transitions) {\n        if (transition.predicate(element)) {\n          next.add(transition.target)\n        }\n      }\n    }\n\n    active = epsilonClosure(next, i + 1, sequence.length)\n\n    if (active.size === 0) break\n\n    if (active.has(nfa.accept)) {\n      lastAcceptLength = i - offset + 1\n      if (!greedy) break\n    }\n  }\n\n  return {\n    matched: lastAcceptLength >= 0,\n    length: Math.max(lastAcceptLength, 0),\n  }\n}\n\nexport function findAll<T>(nfa: NFA<T>, sequence: T[], greedy = true): MatchResult<T>[] {\n  const results: MatchResult<T>[] = []\n  let pos = 0\n\n  while (pos < sequence.length) {\n    const result = simulate(nfa, sequence, pos, greedy)\n    if (result.matched && result.length > 0) {\n      results.push({\n        start: pos,\n        end: pos + result.length - 1,\n        data: sequence.slice(pos, pos + result.length),\n      })\n      pos += result.length\n    } else {\n      pos += 1\n    }\n  }\n\n  return results\n}\n\nexport function findFirst<T>(nfa: NFA<T>, sequence: T[], greedy = true): MatchResult<T> | null {\n  let pos = 0\n\n  while (pos < sequence.length) {\n    const result = simulate(nfa, sequence, pos, greedy)\n    if (result.matched && result.length > 0) {\n      return {\n        start: pos,\n        end: pos + result.length - 1,\n        data: sequence.slice(pos, pos + result.length),\n      }\n    }\n    pos += 1\n  }\n\n  return null\n}\n\nexport function test<T>(nfa: NFA<T>, sequence: T[], greedy = true): boolean {\n  return findFirst(nfa, sequence, greedy) !== null\n}\n",
+    "import type { NFA, NFAState } from './nfa'\nimport { epsilonClosure, type MatchResult } from './engine'\n\nexport class Scanner<T> {\n  private nfa: NFA<T>\n  private greedy: boolean\n\n  private position = 0\n  private scanStart = 0\n  private buffer: T[] = []\n  private active: Set<NFAState<T>> = new Set()\n  private lastAcceptLength = -1\n  private simulationAlive = false\n\n  constructor(nfa: NFA<T>, greedy: boolean) {\n    this.nfa = nfa\n    this.greedy = greedy\n    this.initSimulation(0, Infinity)\n  }\n\n  push(element: T): MatchResult<T>[] {\n    this.buffer.push(element)\n\n    if (this.simulationAlive) {\n      this.step(element, this.position, Infinity)\n    }\n\n    this.position++\n    return this.drain(Infinity)\n  }\n\n  end(): MatchResult<T>[] {\n    const totalLength = this.position\n    const results: MatchResult<T>[] = []\n\n    // Check if current simulation has a pending match with end anchors\n    if (this.simulationAlive && this.active.size > 0) {\n      const finalActive = epsilonClosure(this.active, this.position, totalLength)\n      if (finalActive.has(this.nfa.accept)) {\n        this.lastAcceptLength = this.position - this.scanStart\n      }\n    }\n\n    // Emit pending match if any\n    if (this.lastAcceptLength > 0) {\n      results.push(this.emitMatch())\n    } else if (this.scanStart < totalLength) {\n      this.scanStart++\n    }\n\n    // Process remaining buffer with known total length\n    while (this.scanStart < totalLength) {\n      this.initSimulation(this.scanStart, totalLength)\n\n      const bufferOffset = this.scanStart - (this.position - this.buffer.length)\n      for (let i = this.scanStart; i < totalLength; i++) {\n        const element = this.buffer[bufferOffset + (i - this.scanStart)]\n        this.step(element, i, totalLength)\n        if (!this.simulationAlive) break\n      }\n\n      // Final end-anchor check\n      if (this.simulationAlive && this.active.size > 0) {\n        const finalActive = epsilonClosure(this.active, totalLength, totalLength)\n        if (finalActive.has(this.nfa.accept)) {\n          this.lastAcceptLength = totalLength - this.scanStart\n        }\n      }\n\n      if (this.lastAcceptLength > 0) {\n        results.push(this.emitMatch())\n      } else {\n        this.scanStart++\n      }\n    }\n\n    return results\n  }\n\n  private initSimulation(startPos: number, seqLength: number): void {\n    this.active = epsilonClosure(new Set([this.nfa.start]), startPos, seqLength)\n    this.lastAcceptLength = this.active.has(this.nfa.accept) ? 0 : -1\n    this.simulationAlive = true\n  }\n\n  private step(element: T, absolutePosition: number, seqLength: number): void {\n    const next = new Set<NFAState<T>>()\n\n    for (const state of this.active) {\n      for (const transition of state.transitions) {\n        if (transition.predicate(element)) {\n          next.add(transition.target)\n        }\n      }\n    }\n\n    this.active = epsilonClosure(next, absolutePosition + 1, seqLength)\n\n    if (this.active.size === 0) {\n      this.simulationAlive = false\n      return\n    }\n\n    if (this.active.has(this.nfa.accept)) {\n      this.lastAcceptLength = absolutePosition - this.scanStart + 1\n      if (!this.greedy) {\n        this.simulationAlive = false\n      }\n    }\n  }\n\n  private drain(seqLength: number): MatchResult<T>[] {\n    const results: MatchResult<T>[] = []\n\n    while (!this.simulationAlive && this.scanStart < this.position) {\n      if (this.lastAcceptLength > 0) {\n        results.push(this.emitMatch())\n      } else {\n        this.scanStart++\n      }\n\n      if (this.scanStart >= this.position) break\n\n      // Start new simulation and replay remaining buffer\n      this.initSimulation(this.scanStart, seqLength)\n\n      const bufferStart = this.position - this.buffer.length\n      for (let i = this.scanStart; i < this.position; i++) {\n        if (!this.simulationAlive) break\n        this.step(this.buffer[i - bufferStart], i, seqLength)\n      }\n    }\n\n    // Ensure simulation is ready for next push\n    if (!this.simulationAlive && this.scanStart === this.position) {\n      this.initSimulation(this.scanStart, seqLength)\n    }\n\n    // Trim consumed buffer\n    const consumed = this.scanStart - (this.position - this.buffer.length)\n    if (consumed > 0) {\n      this.buffer = this.buffer.slice(consumed)\n    }\n\n    return results\n  }\n\n  private emitMatch(): MatchResult<T> {\n    const bufferStart = this.position - this.buffer.length\n    const matchStart = this.scanStart\n    const matchLength = this.lastAcceptLength\n    const dataStart = matchStart - bufferStart\n\n    const result: MatchResult<T> = {\n      start: matchStart,\n      end: matchStart + matchLength - 1,\n      data: this.buffer.slice(dataStart, dataStart + matchLength),\n    }\n\n    this.scanStart = matchStart + matchLength\n    this.lastAcceptLength = -1\n    this.simulationAlive = false\n\n    return result\n  }\n}\n",
+    "import type { NFA } from './nfa'\nimport { findAll, findFirst, test, type MatchResult } from './engine'\nimport { Scanner } from './scanner'\n\nexport { type MatchResult } from './engine'\n\nexport class Matcher<T> {\n  private nfa: NFA<T>\n  private greedy: boolean\n\n  constructor(nfa: NFA<T>, greedy: boolean) {\n    this.nfa = nfa\n    this.greedy = greedy\n  }\n\n  findAll(sequence: Iterable<T>): MatchResult<T>[] {\n    if (Array.isArray(sequence)) {\n      return findAll(this.nfa, sequence, this.greedy)\n    }\n    const scanner = this.scanner()\n    const results: MatchResult<T>[] = []\n    for (const element of sequence) {\n      results.push(...scanner.push(element))\n    }\n    results.push(...scanner.end())\n    return results\n  }\n\n  find(sequence: Iterable<T>): MatchResult<T> | null {\n    if (Array.isArray(sequence)) {\n      return findFirst(this.nfa, sequence, this.greedy)\n    }\n    const scanner = this.scanner()\n    for (const element of sequence) {\n      const results = scanner.push(element)\n      if (results.length > 0) return results[0]\n    }\n    const results = scanner.end()\n    return results.length > 0 ? results[0] : null\n  }\n\n  test(sequence: Iterable<T>): boolean {\n    if (Array.isArray(sequence)) {\n      return test(this.nfa, sequence, this.greedy)\n    }\n    return this.find(sequence) !== null\n  }\n\n  scanner(): Scanner<T> {\n    return new Scanner(this.nfa, this.greedy)\n  }\n}\n",
+    "import type { PatternNode, Predicate } from './ast'\n\nexport interface NFAState<T> {\n  id: number\n  epsilons: NFAState<T>[]\n  transitions: Array<{ predicate: Predicate<T>; target: NFAState<T> }>\n  anchorCheck?: (index: number, length: number) => boolean\n}\n\nexport interface NFA<T> {\n  start: NFAState<T>\n  accept: NFAState<T>\n}\n\nexport function compile<T>(node: PatternNode<T>): NFA<T> {\n  let nextId = 0\n\n  function createState(): NFAState<T> {\n    return { id: nextId++, epsilons: [], transitions: [] }\n  }\n\n  function compileNode(node: PatternNode<T>): NFA<T> {\n    switch (node.type) {\n      case 'predicate':\n        return compilePredicate(node.fn)\n      case 'sequence':\n        return compileSequence(node.children)\n      case 'quantifier':\n        return compileQuantifier(node.child, node.min, node.max, node.greedy)\n      case 'alternation':\n        return compileAlternation(node.left, node.right)\n      case 'anchor':\n        return compileAnchor(node.position)\n      case 'any':\n        return compilePredicate(() => true)\n    }\n  }\n\n  function compilePredicate(fn: Predicate<T>): NFA<T> {\n    const start = createState()\n    const accept = createState()\n    start.transitions.push({ predicate: fn, target: accept })\n    return { start, accept }\n  }\n\n  function compileSequence(children: PatternNode<T>[]): NFA<T> {\n    if (children.length === 0) {\n      const start = createState()\n      const accept = createState()\n      start.epsilons.push(accept)\n      return { start, accept }\n    }\n\n    if (children.length === 1) {\n      return compileNode(children[0])\n    }\n\n    const fragments = children.map(child => compileNode(child))\n\n    for (let i = 0; i < fragments.length - 1; i++) {\n      fragments[i].accept.epsilons.push(fragments[i + 1].start)\n    }\n\n    return { start: fragments[0].start, accept: fragments[fragments.length - 1].accept }\n  }\n\n  function compileQuantifier(\n    child: PatternNode<T>,\n    min: number,\n    max: number,\n    greedy: boolean,\n  ): NFA<T> {\n    const start = createState()\n    const accept = createState()\n\n    let lastState = start\n\n    for (let i = 0; i < min; i++) {\n      const fragment = compileNode(child)\n      lastState.epsilons.push(fragment.start)\n      lastState = fragment.accept\n    }\n\n    if (max === Infinity) {\n      const loopFragment = compileNode(child)\n      lastState.epsilons.push(\n        ...(greedy ? [loopFragment.start, accept] : [accept, loopFragment.start]),\n      )\n      loopFragment.accept.epsilons.push(lastState)\n    } else {\n      for (let i = min; i < max; i++) {\n        const fragment = compileNode(child)\n        lastState.epsilons.push(...(greedy ? [fragment.start, accept] : [accept, fragment.start]))\n        lastState = fragment.accept\n      }\n      lastState.epsilons.push(accept)\n    }\n\n    return { start, accept }\n  }\n\n  function compileAlternation(left: PatternNode<T>, right: PatternNode<T>): NFA<T> {\n    const start = createState()\n    const accept = createState()\n    const leftNFA = compileNode(left)\n    const rightNFA = compileNode(right)\n\n    start.epsilons.push(leftNFA.start, rightNFA.start)\n    leftNFA.accept.epsilons.push(accept)\n    rightNFA.accept.epsilons.push(accept)\n\n    return { start, accept }\n  }\n\n  function compileAnchor(position: 'start' | 'end'): NFA<T> {\n    const start = createState()\n    const accept = createState()\n\n    start.anchorCheck =\n      position === 'start'\n        ? (index: number) => index === 0\n        : (index: number, length: number) => index === length\n\n    start.epsilons.push(accept)\n\n    return { start, accept }\n  }\n\n  return compileNode(node)\n}\n",
+    "import { type PatternNode, type Predicate, isGreedy } from './ast'\nimport { Matcher } from './matcher'\nimport { compile } from './nfa'\n\nexport class Pattern<T> {\n  private ast: PatternNode<T>\n\n  private constructor(ast: PatternNode<T>) {\n    this.ast = ast\n  }\n\n  static where<T>(fn: Predicate<T>): Pattern<T> {\n    return new Pattern<T>({\n      type: 'sequence',\n      children: [{ type: 'predicate', fn }],\n    })\n  }\n\n  static any<T>(): Pattern<T> {\n    return new Pattern<T>({\n      type: 'sequence',\n      children: [{ type: 'any' }],\n    })\n  }\n\n  static oneOf<T>(...alternatives: (Predicate<T> | Pattern<T>)[]): Pattern<T> {\n    if (alternatives.length === 0) {\n      throw new Error('Pattern.oneOf() requires at least one alternative')\n    }\n\n    const toNode = (alt: Predicate<T> | Pattern<T>): PatternNode<T> =>\n      alt instanceof Pattern ? alt.ast : { type: 'predicate', fn: alt }\n\n    let node = toNode(alternatives[0])\n    for (let i = 1; i < alternatives.length; i++) {\n      node = { type: 'alternation', left: node, right: toNode(alternatives[i]) }\n    }\n\n    return new Pattern<T>(node)\n  }\n\n  followedBy(fnOrPattern: Predicate<T> | Pattern<T>): Pattern<T> {\n    const seq = this.getSequence()\n    const node = this.resolveNode(fnOrPattern)\n    return new Pattern<T>({\n      type: 'sequence',\n      children: [...seq, node],\n    })\n  }\n\n  followedByAny(): Pattern<T> {\n    const seq = this.getSequence()\n    return new Pattern<T>({\n      type: 'sequence',\n      children: [...seq, { type: 'any' }],\n    })\n  }\n\n  oneOrMore(greedy = true): Pattern<T> {\n    return this.applyQuantifier(1, Infinity, greedy)\n  }\n\n  zeroOrMore(greedy = true): Pattern<T> {\n    return this.applyQuantifier(0, Infinity, greedy)\n  }\n\n  optional(greedy = true): Pattern<T> {\n    return this.applyQuantifier(0, 1, greedy)\n  }\n\n  times(n: number): Pattern<T> {\n    return this.applyQuantifier(n, n, true)\n  }\n\n  between(min: number, max: number, greedy = true): Pattern<T> {\n    return this.applyQuantifier(min, max, greedy)\n  }\n\n  or(fnOrPattern: Predicate<T> | Pattern<T>): Pattern<T> {\n    return new Pattern<T>({\n      type: 'alternation',\n      left: this.ast,\n      right: this.resolveNode(fnOrPattern),\n    })\n  }\n\n  atStart(): Pattern<T> {\n    const seq = this.getSequence()\n    return new Pattern<T>({\n      type: 'sequence',\n      children: [{ type: 'anchor', position: 'start' }, ...seq],\n    })\n  }\n\n  atEnd(): Pattern<T> {\n    const seq = this.getSequence()\n    return new Pattern<T>({\n      type: 'sequence',\n      children: [...seq, { type: 'anchor', position: 'end' }],\n    })\n  }\n\n  compile(): Matcher<T> {\n    return new Matcher<T>(compile(this.ast), isGreedy(this.ast))\n  }\n\n  toAST(): PatternNode<T> {\n    return this.ast\n  }\n\n  private resolveNode(fnOrPattern: Predicate<T> | Pattern<T>): PatternNode<T> {\n    return fnOrPattern instanceof Pattern ? fnOrPattern.ast : { type: 'predicate', fn: fnOrPattern }\n  }\n\n  private getSequence(): PatternNode<T>[] {\n    if (this.ast.type === 'sequence') {\n      return [...this.ast.children]\n    }\n    return [this.ast]\n  }\n\n  private applyQuantifier(min: number, max: number, greedy: boolean): Pattern<T> {\n    const seq = this.getSequence()\n    if (seq.length === 0) {\n      return this\n    }\n\n    const rest = seq.slice(0, -1)\n    const quantified: PatternNode<T> = {\n      type: 'quantifier',\n      child: seq[seq.length - 1],\n      min,\n      max,\n      greedy,\n    }\n\n    return new Pattern<T>({\n      type: 'sequence',\n      children: [...rest, quantified],\n    })\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "9657E6188A58006B64756E2164756E21",
+  "names": []
+}

package/dist/matcher.d.ts

@@ -0,0 +1,13 @@
+import type { NFA } from './nfa';
+import { type MatchResult } from './engine';
+import { Scanner } from './scanner';
+export { type MatchResult } from './engine';
+export declare class Matcher<T> {
+    private nfa;
+    private greedy;
+    constructor(nfa: NFA<T>, greedy: boolean);
+    findAll(sequence: Iterable<T>): MatchResult<T>[];
+    find(sequence: Iterable<T>): MatchResult<T> | null;
+    test(sequence: Iterable<T>): boolean;
+    scanner(): Scanner<T>;
+}

package/dist/nfa.d.ts

@@ -0,0 +1,15 @@
+import type { PatternNode, Predicate } from './ast';
+export interface NFAState<T> {
+    id: number;
+    epsilons: NFAState<T>[];
+    transitions: Array<{
+        predicate: Predicate<T>;
+        target: NFAState<T>;
+    }>;
+    anchorCheck?: (index: number, length: number) => boolean;
+}
+export interface NFA<T> {
+    start: NFAState<T>;
+    accept: NFAState<T>;
+}
+export declare function compile<T>(node: PatternNode<T>): NFA<T>;

package/dist/pattern.d.ts

@@ -0,0 +1,24 @@
+import { type PatternNode, type Predicate } from './ast';
+import { Matcher } from './matcher';
+export declare class Pattern<T> {
+    private ast;
+    private constructor();
+    static where<T>(fn: Predicate<T>): Pattern<T>;
+    static any<T>(): Pattern<T>;
+    static oneOf<T>(...alternatives: (Predicate<T> | Pattern<T>)[]): Pattern<T>;
+    followedBy(fnOrPattern: Predicate<T> | Pattern<T>): Pattern<T>;
+    followedByAny(): Pattern<T>;
+    oneOrMore(greedy?: boolean): Pattern<T>;
+    zeroOrMore(greedy?: boolean): Pattern<T>;
+    optional(greedy?: boolean): Pattern<T>;
+    times(n: number): Pattern<T>;
+    between(min: number, max: number, greedy?: boolean): Pattern<T>;
+    or(fnOrPattern: Predicate<T> | Pattern<T>): Pattern<T>;
+    atStart(): Pattern<T>;
+    atEnd(): Pattern<T>;
+    compile(): Matcher<T>;
+    toAST(): PatternNode<T>;
+    private resolveNode;
+    private getSequence;
+    private applyQuantifier;
+}

package/dist/scanner.d.ts

@@ -0,0 +1,19 @@
+import type { NFA } from './nfa';
+import { type MatchResult } from './engine';
+export declare class Scanner<T> {
+    private nfa;
+    private greedy;
+    private position;
+    private scanStart;
+    private buffer;
+    private active;
+    private lastAcceptLength;
+    private simulationAlive;
+    constructor(nfa: NFA<T>, greedy: boolean);
+    push(element: T): MatchResult<T>[];
+    end(): MatchResult<T>[];
+    private initSimulation;
+    private step;
+    private drain;
+    private emitMatch;
+}