@wix/web5-core 1.56.0

package/dist/esm/patternValidator/automaton.js

@@ -0,0 +1,345 @@
+export function buildAutomaton(ast) {
+  let stateCounter = 0;
+  const states = new Map();
+  const transitions = [];
+  const acceptStates = new Set();
+  function createState(type) {
+    const id = `s${stateCounter++}`;
+    states.set(id, {
+      id,
+      type
+    });
+    return id;
+  }
+  function addTransition(from, to, condition) {
+    transitions.push({
+      from,
+      to,
+      condition
+    });
+  }
+  function buildElement(node, start, end) {
+    const q = node.quantifier;
+    // Helper to create condition with HTML comment or link attributes if present
+    const createCondition = () => ({
+      type: 'element',
+      element: node.element,
+      ...(node.element === 'html_comment' && node.htmlCommentAttrs ? {
+        htmlCommentAttrs: node.htmlCommentAttrs
+      } : {}),
+      ...(node.element === 'link' && node.linkAttrs ? {
+        linkAttrs: node.linkAttrs
+      } : {}),
+      ...(node.element === 'image' && node.imageAttrs ? {
+        imageAttrs: node.imageAttrs
+      } : {})
+    });
+    if (!q) {
+      addTransition(start, end, createCondition());
+      return;
+    }
+    if (q.type === 'star') {
+      addTransition(start, end, {
+        type: 'epsilon'
+      });
+      const loop = createState('normal');
+      addTransition(start, loop, createCondition());
+      addTransition(loop, start, {
+        type: 'epsilon'
+      });
+      addTransition(loop, end, {
+        type: 'epsilon'
+      });
+    } else if (q.type === 'plus') {
+      const loop = createState('normal');
+      addTransition(start, loop, createCondition());
+      addTransition(loop, loop, createCondition());
+      addTransition(loop, end, {
+        type: 'epsilon'
+      });
+    } else if (q.type === 'optional') {
+      addTransition(start, end, {
+        type: 'epsilon'
+      });
+      addTransition(start, end, createCondition());
+    } else if (q.type === 'exact') {
+      let current = start;
+      for (let i = 0; i < q.min; i++) {
+        const next = i === q.min - 1 ? end : createState('normal');
+        addTransition(current, next, createCondition());
+        current = next;
+      }
+    } else if (q.type === 'range') {
+      const min = q.min ?? 0;
+      const max = q.max ?? Infinity;
+      let current = start;
+      for (let i = 0; i < min; i++) {
+        const next = createState('normal');
+        addTransition(current, next, createCondition());
+        current = next;
+      }
+      if (max === Infinity) {
+        addTransition(current, current, createCondition());
+        addTransition(current, end, {
+          type: 'epsilon'
+        });
+      } else {
+        for (let i = min; i < max; i++) {
+          addTransition(current, end, {
+            type: 'epsilon'
+          });
+          const next = i === max - 1 ? end : createState('normal');
+          addTransition(current, next, createCondition());
+          current = next;
+        }
+        addTransition(current, end, {
+          type: 'epsilon'
+        });
+      }
+    }
+  }
+  function buildSequence(node, start, end) {
+    let current = start;
+    for (let i = 0; i < node.children.length; i++) {
+      const next = i === node.children.length - 1 ? end : createState('normal');
+      buildNode(node.children[i], current, next);
+      current = next;
+    }
+  }
+  function buildAlternation(node, start, end) {
+    if (!node.quantifier) {
+      for (const choice of node.choices) {
+        buildNode(choice, start, end);
+      }
+    } else {
+      const altStart = createState('normal');
+      const altEnd = createState('normal');
+      for (const choice of node.choices) {
+        buildNode(choice, altStart, altEnd);
+      }
+      const q = node.quantifier;
+      if (q.type === 'star' || q.type === 'optional' || q.type === 'range' && (q.min ?? 0) === 0) {
+        addTransition(start, end, {
+          type: 'epsilon'
+        });
+      }
+      addTransition(start, altStart, {
+        type: 'epsilon'
+      });
+      addTransition(altEnd, end, {
+        type: 'epsilon'
+      });
+      if (q.type === 'star' || q.type === 'plus' || q.type === 'range' && (q.max ?? Infinity) > 1) {
+        addTransition(altEnd, altStart, {
+          type: 'epsilon'
+        });
+      }
+    }
+  }
+  function buildGroup(node, start, end) {
+    if (!node.quantifier) {
+      buildNode(node.pattern, start, end);
+    } else {
+      const groupStart = createState('normal');
+      const groupEnd = createState('normal');
+      buildNode(node.pattern, groupStart, groupEnd);
+      const q = node.quantifier;
+      if (q.type === 'star') {
+        addTransition(start, end, {
+          type: 'epsilon'
+        });
+        addTransition(start, groupStart, {
+          type: 'epsilon'
+        });
+        addTransition(groupEnd, groupStart, {
+          type: 'epsilon'
+        });
+        addTransition(groupEnd, end, {
+          type: 'epsilon'
+        });
+      } else if (q.type === 'plus') {
+        addTransition(start, groupStart, {
+          type: 'epsilon'
+        });
+        addTransition(groupEnd, groupStart, {
+          type: 'epsilon'
+        });
+        addTransition(groupEnd, end, {
+          type: 'epsilon'
+        });
+      } else if (q.type === 'optional') {
+        addTransition(start, end, {
+          type: 'epsilon'
+        });
+        addTransition(start, groupStart, {
+          type: 'epsilon'
+        });
+        addTransition(groupEnd, end, {
+          type: 'epsilon'
+        });
+      } else if (q.type === 'exact') {
+        let current = start;
+        for (let i = 0; i < q.min; i++) {
+          const next = i === q.min - 1 ? end : createState('normal');
+          const iterationStart = createState('normal');
+          const iterationEnd = createState('normal');
+          buildNode(node.pattern, iterationStart, iterationEnd);
+          addTransition(current, iterationStart, {
+            type: 'epsilon'
+          });
+          addTransition(iterationEnd, next, {
+            type: 'epsilon'
+          });
+          current = next;
+        }
+      } else if (q.type === 'range') {
+        const min = q.min ?? 0;
+        const max = q.max ?? Infinity;
+        let current = start;
+
+        // Build minimum required repetitions
+        for (let i = 0; i < min; i++) {
+          const next = createState('normal');
+          const iterationStart = createState('normal');
+          const iterationEnd = createState('normal');
+          buildNode(node.pattern, iterationStart, iterationEnd);
+          addTransition(current, iterationStart, {
+            type: 'epsilon'
+          });
+          addTransition(iterationEnd, next, {
+            type: 'epsilon'
+          });
+          current = next;
+        }
+
+        // Build optional repetitions up to max
+        if (max === Infinity) {
+          // Unlimited repetitions
+          const loopStart = createState('normal');
+          const loopEnd = createState('normal');
+          buildNode(node.pattern, loopStart, loopEnd);
+          addTransition(current, loopStart, {
+            type: 'epsilon'
+          });
+          addTransition(loopEnd, loopStart, {
+            type: 'epsilon'
+          });
+          addTransition(loopEnd, end, {
+            type: 'epsilon'
+          });
+          addTransition(current, end, {
+            type: 'epsilon'
+          });
+        } else {
+          // Limited repetitions
+          const optionalStart = createState('normal');
+          const optionalEnd = createState('normal');
+          buildNode(node.pattern, optionalStart, optionalEnd);
+
+          // Allow 0 to (max - min) additional repetitions
+          let optionalCurrent = current;
+          for (let i = 0; i < max - min; i++) {
+            const next = i === max - min - 1 ? end : createState('normal');
+            addTransition(optionalCurrent, optionalStart, {
+              type: 'epsilon'
+            });
+            addTransition(optionalEnd, next, {
+              type: 'epsilon'
+            });
+            addTransition(optionalCurrent, next, {
+              type: 'epsilon'
+            }); // Skip this repetition
+            optionalCurrent = next;
+          }
+        }
+      } else {
+        buildNode(node.pattern, start, end);
+      }
+    }
+  }
+  function buildList(node, start, end) {
+    // For lists, we create a simple transition that matches 'list' element
+    // The actual list item validation will be done separately in the matcher
+    if (!node.quantifier) {
+      addTransition(start, end, {
+        type: 'element',
+        element: 'list'
+      });
+    } else {
+      const q = node.quantifier;
+      if (q.type === 'star') {
+        addTransition(start, end, {
+          type: 'epsilon'
+        });
+        const loop = createState('normal');
+        addTransition(start, loop, {
+          type: 'element',
+          element: 'list'
+        });
+        addTransition(loop, start, {
+          type: 'epsilon'
+        });
+        addTransition(loop, end, {
+          type: 'epsilon'
+        });
+      } else if (q.type === 'plus') {
+        const loop = createState('normal');
+        addTransition(start, loop, {
+          type: 'element',
+          element: 'list'
+        });
+        addTransition(loop, loop, {
+          type: 'element',
+          element: 'list'
+        });
+        addTransition(loop, end, {
+          type: 'epsilon'
+        });
+      } else if (q.type === 'optional') {
+        addTransition(start, end, {
+          type: 'epsilon'
+        });
+        addTransition(start, end, {
+          type: 'element',
+          element: 'list'
+        });
+      } else {
+        // exact or range - just treat as simple list match for now
+        addTransition(start, end, {
+          type: 'element',
+          element: 'list'
+        });
+      }
+    }
+  }
+  function buildNode(node, start, end) {
+    switch (node.kind) {
+      case 'element':
+        buildElement(node, start, end);
+        break;
+      case 'sequence':
+        buildSequence(node, start, end);
+        break;
+      case 'alternation':
+        buildAlternation(node, start, end);
+        break;
+      case 'group':
+        buildGroup(node, start, end);
+        break;
+      case 'list':
+        buildList(node, start, end);
+        break;
+    }
+  }
+  const startState = createState('start');
+  const finalState = createState('accept');
+  acceptStates.add(finalState);
+  buildNode(ast, startState, finalState);
+  return {
+    states,
+    transitions,
+    startState,
+    acceptStates
+  };
+}
+//# sourceMappingURL=automaton.js.map

package/dist/esm/patternValidator/automaton.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["buildAutomaton","ast","stateCounter","states","Map","transitions","acceptStates","Set","createState","type","id","set","addTransition","from","to","condition","push","buildElement","node","start","end","q","quantifier","createCondition","element","htmlCommentAttrs","linkAttrs","imageAttrs","loop","current","i","min","next","max","Infinity","buildSequence","children","length","buildNode","buildAlternation","choice","choices","altStart","altEnd","buildGroup","pattern","groupStart","groupEnd","iterationStart","iterationEnd","loopStart","loopEnd","optionalStart","optionalEnd","optionalCurrent","buildList","kind","startState","finalState","add"],"sources":["../../../src/patternValidator/automaton.ts"],"sourcesContent":["import type { PatternNode, Automaton, State, Transition } from './types';\n\nexport function buildAutomaton(ast: PatternNode): Automaton {\n  let stateCounter = 0;\n  const states = new Map<string, State>();\n  const transitions: Transition[] = [];\n  const acceptStates = new Set<string>();\n\n  function createState(type: State['type']): string {\n    const id = `s${stateCounter++}`;\n    states.set(id, { id, type });\n    return id;\n  }\n\n  function addTransition(\n    from: string,\n    to: string,\n    condition: Transition['condition'],\n  ): void {\n    transitions.push({ from, to, condition });\n  }\n\n  function buildElement(\n    node: PatternNode & { kind: 'element' },\n    start: string,\n    end: string,\n  ): void {\n    const q = node.quantifier;\n    // Helper to create condition with HTML comment or link attributes if present\n    const createCondition = () => ({\n      type: 'element' as const,\n      element: node.element,\n      ...(node.element === 'html_comment' && node.htmlCommentAttrs\n        ? { htmlCommentAttrs: node.htmlCommentAttrs }\n        : {}),\n      ...(node.element === 'link' && node.linkAttrs\n        ? { linkAttrs: node.linkAttrs }\n        : {}),\n      ...(node.element === 'image' && node.imageAttrs\n        ? { imageAttrs: node.imageAttrs }\n        : {}),\n    });\n\n    if (!q) {\n      addTransition(start, end, createCondition());\n      return;\n    }\n\n    if (q.type === 'star') {\n      addTransition(start, end, { type: 'epsilon' });\n      const loop = createState('normal');\n      addTransition(start, loop, createCondition());\n      addTransition(loop, start, { type: 'epsilon' });\n      addTransition(loop, end, { type: 'epsilon' });\n    } else if (q.type === 'plus') {\n      const loop = createState('normal');\n      addTransition(start, loop, createCondition());\n      addTransition(loop, loop, createCondition());\n      addTransition(loop, end, { type: 'epsilon' });\n    } else if (q.type === 'optional') {\n      addTransition(start, end, { type: 'epsilon' });\n      addTransition(start, end, createCondition());\n    } else if (q.type === 'exact') {\n      let current = start;\n      for (let i = 0; i < q.min!; i++) {\n        const next = i === q.min! - 1 ? end : createState('normal');\n        addTransition(current, next, createCondition());\n        current = next;\n      }\n    } else if (q.type === 'range') {\n      const min = q.min ?? 0;\n      const max = q.max ?? Infinity;\n      let current = start;\n\n      for (let i = 0; i < min; i++) {\n        const next = createState('normal');\n        addTransition(current, next, createCondition());\n        current = next;\n      }\n\n      if (max === Infinity) {\n        addTransition(current, current, createCondition());\n        addTransition(current, end, { type: 'epsilon' });\n      } else {\n        for (let i = min; i < max; i++) {\n          addTransition(current, end, { type: 'epsilon' });\n          const next = i === max - 1 ? end : createState('normal');\n          addTransition(current, next, createCondition());\n          current = next;\n        }\n        addTransition(current, end, { type: 'epsilon' });\n      }\n    }\n  }\n\n  function buildSequence(\n    node: PatternNode & { kind: 'sequence' },\n    start: string,\n    end: string,\n  ): void {\n    let current = start;\n    for (let i = 0; i < node.children.length; i++) {\n      const next = i === node.children.length - 1 ? end : createState('normal');\n      buildNode(node.children[i], current, next);\n      current = next;\n    }\n  }\n\n  function buildAlternation(\n    node: PatternNode & { kind: 'alternation' },\n    start: string,\n    end: string,\n  ): void {\n    if (!node.quantifier) {\n      for (const choice of node.choices) {\n        buildNode(choice, start, end);\n      }\n    } else {\n      const altStart = createState('normal');\n      const altEnd = createState('normal');\n      for (const choice of node.choices) {\n        buildNode(choice, altStart, altEnd);\n      }\n      const q = node.quantifier;\n      if (\n        q.type === 'star' ||\n        q.type === 'optional' ||\n        (q.type === 'range' && (q.min ?? 0) === 0)\n      ) {\n        addTransition(start, end, { type: 'epsilon' });\n      }\n      addTransition(start, altStart, { type: 'epsilon' });\n      addTransition(altEnd, end, { type: 'epsilon' });\n      if (\n        q.type === 'star' ||\n        q.type === 'plus' ||\n        (q.type === 'range' && (q.max ?? Infinity) > 1)\n      ) {\n        addTransition(altEnd, altStart, { type: 'epsilon' });\n      }\n    }\n  }\n\n  function buildGroup(\n    node: PatternNode & { kind: 'group' },\n    start: string,\n    end: string,\n  ): void {\n    if (!node.quantifier) {\n      buildNode(node.pattern, start, end);\n    } else {\n      const groupStart = createState('normal');\n      const groupEnd = createState('normal');\n      buildNode(node.pattern, groupStart, groupEnd);\n      const q = node.quantifier;\n\n      if (q.type === 'star') {\n        addTransition(start, end, { type: 'epsilon' });\n        addTransition(start, groupStart, { type: 'epsilon' });\n        addTransition(groupEnd, groupStart, { type: 'epsilon' });\n        addTransition(groupEnd, end, { type: 'epsilon' });\n      } else if (q.type === 'plus') {\n        addTransition(start, groupStart, { type: 'epsilon' });\n        addTransition(groupEnd, groupStart, { type: 'epsilon' });\n        addTransition(groupEnd, end, { type: 'epsilon' });\n      } else if (q.type === 'optional') {\n        addTransition(start, end, { type: 'epsilon' });\n        addTransition(start, groupStart, { type: 'epsilon' });\n        addTransition(groupEnd, end, { type: 'epsilon' });\n      } else if (q.type === 'exact') {\n        let current = start;\n        for (let i = 0; i < q.min!; i++) {\n          const next = i === q.min! - 1 ? end : createState('normal');\n          const iterationStart = createState('normal');\n          const iterationEnd = createState('normal');\n          buildNode(node.pattern, iterationStart, iterationEnd);\n          addTransition(current, iterationStart, { type: 'epsilon' });\n          addTransition(iterationEnd, next, { type: 'epsilon' });\n          current = next;\n        }\n      } else if (q.type === 'range') {\n        const min = q.min ?? 0;\n        const max = q.max ?? Infinity;\n        let current = start;\n\n        // Build minimum required repetitions\n        for (let i = 0; i < min; i++) {\n          const next = createState('normal');\n          const iterationStart = createState('normal');\n          const iterationEnd = createState('normal');\n          buildNode(node.pattern, iterationStart, iterationEnd);\n          addTransition(current, iterationStart, { type: 'epsilon' });\n          addTransition(iterationEnd, next, { type: 'epsilon' });\n          current = next;\n        }\n\n        // Build optional repetitions up to max\n        if (max === Infinity) {\n          // Unlimited repetitions\n          const loopStart = createState('normal');\n          const loopEnd = createState('normal');\n          buildNode(node.pattern, loopStart, loopEnd);\n          addTransition(current, loopStart, { type: 'epsilon' });\n          addTransition(loopEnd, loopStart, { type: 'epsilon' });\n          addTransition(loopEnd, end, { type: 'epsilon' });\n          addTransition(current, end, { type: 'epsilon' });\n        } else {\n          // Limited repetitions\n          const optionalStart = createState('normal');\n          const optionalEnd = createState('normal');\n          buildNode(node.pattern, optionalStart, optionalEnd);\n\n          // Allow 0 to (max - min) additional repetitions\n          let optionalCurrent = current;\n          for (let i = 0; i < max - min; i++) {\n            const next = i === max - min - 1 ? end : createState('normal');\n            addTransition(optionalCurrent, optionalStart, { type: 'epsilon' });\n            addTransition(optionalEnd, next, { type: 'epsilon' });\n            addTransition(optionalCurrent, next, { type: 'epsilon' }); // Skip this repetition\n            optionalCurrent = next;\n          }\n        }\n      } else {\n        buildNode(node.pattern, start, end);\n      }\n    }\n  }\n\n  function buildList(\n    node: PatternNode & { kind: 'list' },\n    start: string,\n    end: string,\n  ): void {\n    // For lists, we create a simple transition that matches 'list' element\n    // The actual list item validation will be done separately in the matcher\n    if (!node.quantifier) {\n      addTransition(start, end, { type: 'element', element: 'list' });\n    } else {\n      const q = node.quantifier;\n      if (q.type === 'star') {\n        addTransition(start, end, { type: 'epsilon' });\n        const loop = createState('normal');\n        addTransition(start, loop, { type: 'element', element: 'list' });\n        addTransition(loop, start, { type: 'epsilon' });\n        addTransition(loop, end, { type: 'epsilon' });\n      } else if (q.type === 'plus') {\n        const loop = createState('normal');\n        addTransition(start, loop, { type: 'element', element: 'list' });\n        addTransition(loop, loop, { type: 'element', element: 'list' });\n        addTransition(loop, end, { type: 'epsilon' });\n      } else if (q.type === 'optional') {\n        addTransition(start, end, { type: 'epsilon' });\n        addTransition(start, end, { type: 'element', element: 'list' });\n      } else {\n        // exact or range - just treat as simple list match for now\n        addTransition(start, end, { type: 'element', element: 'list' });\n      }\n    }\n  }\n\n  function buildNode(node: PatternNode, start: string, end: string): void {\n    switch (node.kind) {\n      case 'element':\n        buildElement(node, start, end);\n        break;\n      case 'sequence':\n        buildSequence(node, start, end);\n        break;\n      case 'alternation':\n        buildAlternation(node, start, end);\n        break;\n      case 'group':\n        buildGroup(node, start, end);\n        break;\n      case 'list':\n        buildList(node, start, end);\n        break;\n    }\n  }\n\n  const startState = createState('start');\n  const finalState = createState('accept');\n  acceptStates.add(finalState);\n\n  buildNode(ast, startState, finalState);\n\n  return { states, transitions, startState, acceptStates };\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/patternValidator/index.js

@@ -0,0 +1,190 @@
+import { tokenize } from './lexer.js';
+import { parseWithStop } from './parser.js';
+import { buildAutomaton } from './automaton.js';
+import { match, elementMatchesStop } from './matcher.js';
+import { convertToBlockElements } from '../markdownBlocks.js';
+/**
+ * Validates if a pattern rule syntax is correct
+ *
+ * @param patternRule - Pattern string to validate
+ * @returns Object with validation result and optional error message
+ *
+ * @example
+ * validatePatternSyntax('h2 > t') // { valid: true }
+ * validatePatternSyntax('h2 > invalid') // { valid: false, error: '...' }
+ */
+export function validatePatternSyntax(patternRule) {
+  if (!patternRule || patternRule.trim() === '') {
+    return {
+      valid: false,
+      error: 'Pattern rule is empty',
+      startIndex: 0,
+      endIndex: -1,
+      astStartIndex: -1,
+      astEndIndex: -1
+    };
+  }
+  try {
+    const tokens = tokenize(patternRule);
+    const {
+      pattern
+    } = parseWithStop(tokens);
+    buildAutomaton(pattern);
+    return {
+      valid: true,
+      startIndex: 0,
+      endIndex: -1,
+      astStartIndex: -1,
+      astEndIndex: -1
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      valid: false,
+      error: errorMessage,
+      startIndex: 0,
+      endIndex: -1,
+      astStartIndex: -1,
+      astEndIndex: -1
+    };
+  }
+}
+
+/**
+ * Runs the matcher for a pattern over enriched block elements, honoring an
+ * optional `~` stop clause.
+ *
+ * Stop-clause semantics:
+ * - Elements matching the stop condition act as walls: the pattern is matched
+ *   against the prefix before each candidate (in order) and the first valid,
+ *   non-empty prefix wins. The marker itself is never consumed.
+ * - If candidates exist but no prefix matches, the pattern fails — it never
+ *   matches "through" a marker.
+ * - If no element matches the stop condition (e.g. streamed markdown where
+ *   the end marker hasn't arrived yet), matching behaves as if the pattern
+ *   had no stop clause.
+ */
+function runMatch(enrichedBlocks, pattern, stopAt) {
+  const automaton = buildAutomaton(pattern);
+  if (stopAt) {
+    const candidates = [];
+    for (let i = 0; i < enrichedBlocks.length; i++) {
+      if (elementMatchesStop(enrichedBlocks[i], stopAt)) {
+        candidates.push(i);
+      }
+    }
+    if (candidates.length > 0) {
+      for (const cut of candidates) {
+        const attempt = match(automaton, enrichedBlocks.slice(0, cut), pattern);
+        // Reject empty-prefix matches (endIndex < 0) — a match that consumes
+        // nothing before the marker is never useful
+        if (attempt.valid && attempt.endIndex >= 0) {
+          return attempt;
+        }
+      }
+      return {
+        valid: false,
+        error: `Pattern did not match before stop marker at position ${candidates[0] + 1}`,
+        startIndex: 0,
+        endIndex: -1
+      };
+    }
+  }
+  return match(automaton, enrichedBlocks, pattern);
+}
+function runValidation(enrichedBlocks, patternRule) {
+  try {
+    const tokens = tokenize(patternRule);
+    const {
+      pattern,
+      stopAt
+    } = parseWithStop(tokens);
+    const result = runMatch(enrichedBlocks, pattern, stopAt);
+
+    // valid is true if:
+    // 1. result.valid is true (complete match, including cases with extra elements after)
+    // valid is false if:
+    // - result.valid is false (incomplete match, validation error, or no match)
+    //   This includes cases where required elements are missing (e.g., pattern requires image but it's not found)
+    //   We should NOT accept partial matches when the pattern is incomplete
+    const isValid = result.valid;
+
+    // Extract AST node indices from enriched blocks
+    let astStartIndex = -1;
+    let astEndIndex = -1;
+    if (result.endIndex >= 0 && enrichedBlocks.length > 0) {
+      // Get AST node indices from the matched enriched blocks
+      if (result.startIndex >= 0 && result.startIndex < enrichedBlocks.length) {
+        astStartIndex = enrichedBlocks[result.startIndex].astNodeIndex;
+      }
+      if (result.endIndex >= 0 && result.endIndex < enrichedBlocks.length) {
+        astEndIndex = enrichedBlocks[result.endIndex].astNodeIndex;
+      }
+    }
+    return {
+      valid: isValid,
+      error: result.error,
+      startIndex: result.startIndex,
+      endIndex: result.endIndex,
+      astStartIndex,
+      astEndIndex
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      valid: false,
+      error: `Pattern parsing error: ${errorMessage}`,
+      startIndex: 0,
+      endIndex: -1,
+      astStartIndex: -1,
+      astEndIndex: -1
+    };
+  }
+}
+
+/**
+ * Validates if AST nodes match a pattern rule
+ *
+ * @param nodes - Array of markdown AST nodes (RootContent[])
+ * @param patternRule - Pattern string (e.g., 'h2 > t > link')
+ * @returns PatternValidationResult with validation status, indices, and optional error
+ *
+ * @example
+ * const nodes = parseMarkdownToAst('## Title\n\nText');
+ * validatePattern(nodes, 'h2 > t') // { valid: true, startIndex: 0, endIndex: 1, astStartIndex: 0, astEndIndex: 1 }
+ */
+export function validatePattern(nodes, patternRule) {
+  let enrichedBlocks;
+  try {
+    // Convert AST nodes to enriched block elements
+    enrichedBlocks = convertToBlockElements(nodes);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      valid: false,
+      error: `Pattern parsing error: ${errorMessage}`,
+      startIndex: 0,
+      endIndex: -1,
+      astStartIndex: -1,
+      astEndIndex: -1
+    };
+  }
+  return runValidation(enrichedBlocks, patternRule);
+}
+
+/**
+ * Validates if enriched block elements match a pattern rule
+ * This is useful for testing/debugging when you have block elements but not AST nodes
+ *
+ * @param enrichedBlocks - Array of enriched block elements with AST node indices
+ * @param patternRule - Pattern string (e.g., 'h2 > t > link')
+ * @returns PatternValidationResult with validation status, indices, and optional error
+ *
+ * @example
+ * const blocks = [{ element: 'h2', astNodeIndex: 0 }, { element: 't', astNodeIndex: 1 }];
+ * validatePatternWithBlocks(blocks, 'h2 > t') // { valid: true, startIndex: 0, endIndex: 1 }
+ */
+export function validatePatternWithBlocks(enrichedBlocks, patternRule) {
+  return runValidation(enrichedBlocks, patternRule);
+}
+//# sourceMappingURL=index.js.map

package/dist/esm/patternValidator/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["tokenize","parseWithStop","buildAutomaton","match","elementMatchesStop","convertToBlockElements","validatePatternSyntax","patternRule","trim","valid","error","startIndex","endIndex","astStartIndex","astEndIndex","tokens","pattern","errorMessage","Error","message","String","runMatch","enrichedBlocks","stopAt","automaton","candidates","i","length","push","cut","attempt","slice","runValidation","result","isValid","astNodeIndex","validatePattern","nodes","validatePatternWithBlocks"],"sources":["../../../src/patternValidator/index.ts"],"sourcesContent":["import { tokenize } from './lexer';\nimport { parseWithStop } from './parser';\nimport { buildAutomaton } from './automaton';\nimport { match, elementMatchesStop, type MatchResult } from './matcher';\nimport type { RootContent } from 'mdast';\nimport { convertToBlockElements } from '../markdownBlocks';\nimport type { EnrichedBlockElement, PatternNode, StopCondition } from './types';\n\nexport type PatternValidationResult = {\n  valid: boolean;\n  error?: string;\n  startIndex: number;\n  endIndex: number;\n  astStartIndex: number; // AST node index for the first matched block element (defaults to -1 if not matched)\n  astEndIndex: number; // AST node index for the last matched block element (defaults to -1 if not matched)\n};\n\n/**\n * Validates if a pattern rule syntax is correct\n *\n * @param patternRule - Pattern string to validate\n * @returns Object with validation result and optional error message\n *\n * @example\n * validatePatternSyntax('h2 > t') // { valid: true }\n * validatePatternSyntax('h2 > invalid') // { valid: false, error: '...' }\n */\nexport function validatePatternSyntax(\n  patternRule: string,\n): PatternValidationResult {\n  if (!patternRule || patternRule.trim() === '') {\n    return {\n      valid: false,\n      error: 'Pattern rule is empty',\n      startIndex: 0,\n      endIndex: -1,\n      astStartIndex: -1,\n      astEndIndex: -1,\n    };\n  }\n\n  try {\n    const tokens = tokenize(patternRule);\n    const { pattern } = parseWithStop(tokens);\n    buildAutomaton(pattern);\n    return {\n      valid: true,\n      startIndex: 0,\n      endIndex: -1,\n      astStartIndex: -1,\n      astEndIndex: -1,\n    };\n  } catch (error) {\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    return {\n      valid: false,\n      error: errorMessage,\n      startIndex: 0,\n      endIndex: -1,\n      astStartIndex: -1,\n      astEndIndex: -1,\n    };\n  }\n}\n\n/**\n * Runs the matcher for a pattern over enriched block elements, honoring an\n * optional `~` stop clause.\n *\n * Stop-clause semantics:\n * - Elements matching the stop condition act as walls: the pattern is matched\n *   against the prefix before each candidate (in order) and the first valid,\n *   non-empty prefix wins. The marker itself is never consumed.\n * - If candidates exist but no prefix matches, the pattern fails — it never\n *   matches \"through\" a marker.\n * - If no element matches the stop condition (e.g. streamed markdown where\n *   the end marker hasn't arrived yet), matching behaves as if the pattern\n *   had no stop clause.\n */\nfunction runMatch(\n  enrichedBlocks: EnrichedBlockElement[],\n  pattern: PatternNode,\n  stopAt: StopCondition | undefined,\n): MatchResult {\n  const automaton = buildAutomaton(pattern);\n\n  if (stopAt) {\n    const candidates: number[] = [];\n    for (let i = 0; i < enrichedBlocks.length; i++) {\n      if (elementMatchesStop(enrichedBlocks[i], stopAt)) {\n        candidates.push(i);\n      }\n    }\n\n    if (candidates.length > 0) {\n      for (const cut of candidates) {\n        const attempt = match(automaton, enrichedBlocks.slice(0, cut), pattern);\n        // Reject empty-prefix matches (endIndex < 0) — a match that consumes\n        // nothing before the marker is never useful\n        if (attempt.valid && attempt.endIndex >= 0) {\n          return attempt;\n        }\n      }\n      return {\n        valid: false,\n        error: `Pattern did not match before stop marker at position ${\n          candidates[0] + 1\n        }`,\n        startIndex: 0,\n        endIndex: -1,\n      };\n    }\n  }\n\n  return match(automaton, enrichedBlocks, pattern);\n}\n\nfunction runValidation(\n  enrichedBlocks: EnrichedBlockElement[],\n  patternRule: string,\n): PatternValidationResult {\n  try {\n    const tokens = tokenize(patternRule);\n    const { pattern, stopAt } = parseWithStop(tokens);\n\n    const result = runMatch(enrichedBlocks, pattern, stopAt);\n\n    // valid is true if:\n    // 1. result.valid is true (complete match, including cases with extra elements after)\n    // valid is false if:\n    // - result.valid is false (incomplete match, validation error, or no match)\n    //   This includes cases where required elements are missing (e.g., pattern requires image but it's not found)\n    //   We should NOT accept partial matches when the pattern is incomplete\n    const isValid = result.valid;\n\n    // Extract AST node indices from enriched blocks\n    let astStartIndex = -1;\n    let astEndIndex = -1;\n\n    if (result.endIndex >= 0 && enrichedBlocks.length > 0) {\n      // Get AST node indices from the matched enriched blocks\n      if (result.startIndex >= 0 && result.startIndex < enrichedBlocks.length) {\n        astStartIndex = enrichedBlocks[result.startIndex].astNodeIndex;\n      }\n      if (result.endIndex >= 0 && result.endIndex < enrichedBlocks.length) {\n        astEndIndex = enrichedBlocks[result.endIndex].astNodeIndex;\n      }\n    }\n\n    return {\n      valid: isValid,\n      error: result.error,\n      startIndex: result.startIndex,\n      endIndex: result.endIndex,\n      astStartIndex,\n      astEndIndex,\n    };\n  } catch (error) {\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    return {\n      valid: false,\n      error: `Pattern parsing error: ${errorMessage}`,\n      startIndex: 0,\n      endIndex: -1,\n      astStartIndex: -1,\n      astEndIndex: -1,\n    };\n  }\n}\n\n/**\n * Validates if AST nodes match a pattern rule\n *\n * @param nodes - Array of markdown AST nodes (RootContent[])\n * @param patternRule - Pattern string (e.g., 'h2 > t > link')\n * @returns PatternValidationResult with validation status, indices, and optional error\n *\n * @example\n * const nodes = parseMarkdownToAst('## Title\\n\\nText');\n * validatePattern(nodes, 'h2 > t') // { valid: true, startIndex: 0, endIndex: 1, astStartIndex: 0, astEndIndex: 1 }\n */\nexport function validatePattern(\n  nodes: RootContent[],\n  patternRule: string,\n): PatternValidationResult {\n  let enrichedBlocks: EnrichedBlockElement[];\n  try {\n    // Convert AST nodes to enriched block elements\n    enrichedBlocks = convertToBlockElements(nodes);\n  } catch (error) {\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    return {\n      valid: false,\n      error: `Pattern parsing error: ${errorMessage}`,\n      startIndex: 0,\n      endIndex: -1,\n      astStartIndex: -1,\n      astEndIndex: -1,\n    };\n  }\n  return runValidation(enrichedBlocks, patternRule);\n}\n\n/**\n * Validates if enriched block elements match a pattern rule\n * This is useful for testing/debugging when you have block elements but not AST nodes\n *\n * @param enrichedBlocks - Array of enriched block elements with AST node indices\n * @param patternRule - Pattern string (e.g., 'h2 > t > link')\n * @returns PatternValidationResult with validation status, indices, and optional error\n *\n * @example\n * const blocks = [{ element: 'h2', astNodeIndex: 0 }, { element: 't', astNodeIndex: 1 }];\n * validatePatternWithBlocks(blocks, 'h2 > t') // { valid: true, startIndex: 0, endIndex: 1 }\n */\nexport function validatePatternWithBlocks(\n  enrichedBlocks: EnrichedBlockElement[],\n  patternRule: string,\n): PatternValidationResult {\n  return runValidation(enrichedBlocks, patternRule);\n}\n\nexport type {\n  BlockElement,\n  EnrichedBlockElement,\n  LinkMetadata,\n  LinkAttribute,\n  ImageMetadata,\n  ImageAttribute,\n  StopCondition,\n} from './types';\n"],"mappings":"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","ignoreList":[]}