@pattern-algebra/core 0.0.0

package/dist/automaton/intersect.js

@@ -0,0 +1,302 @@
+/**
+ * Automaton intersection using product construction.
+ * @packageDocumentation
+ */
+/**
+ * Compute the intersection of two automata using product construction.
+ *
+ * The resulting automaton accepts a string iff both input automata accept it.
+ * L(A ∩ B) = L(A) ∩ L(B)
+ *
+ * @param a - First automaton
+ * @param b - Second automaton
+ * @returns Intersection automaton
+ *
+ * @public
+ */
+export function intersect(a, b) {
+    return productConstruction(a, b, 'intersection');
+}
+/**
+ * Compute the union of two automata using NFA construction.
+ *
+ * The resulting automaton accepts a string iff either input automaton accepts it.
+ * L(A ∪ B) = L(A) ∪ L(B)
+ *
+ * We use NFA union: create a new initial state with epsilon transitions
+ * to both automata's initial states, then merge the states.
+ *
+ * @param a - First automaton
+ * @param b - Second automaton
+ * @returns Union automaton (NFA)
+ *
+ * @public
+ */
+export function union(a, b) {
+    // Renumber states: a's states stay as-is, b's states are shifted by a.states.length
+    const aOffset = 0;
+    const bOffset = a.states.length;
+    const newInitialState = a.states.length + b.states.length;
+    // Copy a's states
+    const states = a.states.map((state) => ({
+        id: state.id + aOffset,
+        accepting: state.accepting,
+        transitions: state.transitions.map((t) => renumberTransition(t, aOffset)),
+    }));
+    // Copy b's states with renumbered IDs
+    for (const state of b.states) {
+        states.push({
+            id: state.id + bOffset,
+            accepting: state.accepting,
+            transitions: state.transitions.map((t) => renumberTransition(t, bOffset)),
+        });
+    }
+    // Create new initial state with epsilon transitions to both original initial states
+    states.push({
+        id: newInitialState,
+        accepting: false,
+        transitions: [
+            { type: 'epsilon', target: a.initialState + aOffset },
+            { type: 'epsilon', target: b.initialState + bOffset },
+        ],
+    });
+    // Accepting states from both automata
+    const acceptingStates = [...a.acceptingStates.map((s) => s + aOffset), ...b.acceptingStates.map((s) => s + bOffset)];
+    return {
+        states,
+        initialState: newInitialState,
+        acceptingStates,
+        isDeterministic: false, // NFA union is non-deterministic
+    };
+}
+/**
+ * Renumber a transition's targets by adding an offset.
+ */
+function renumberTransition(t, offset) {
+    switch (t.type) {
+        case 'literal':
+            return { ...t, target: t.target + offset };
+        case 'wildcard':
+            return { ...t, target: t.target + offset };
+        case 'epsilon':
+            return { ...t, target: t.target + offset };
+        case 'globstar':
+            return { ...t, selfLoop: t.selfLoop + offset, exit: t.exit + offset };
+    }
+}
+/**
+ * Product construction for intersection or union.
+ */
+function productConstruction(a, b, mode) {
+    // Map from (stateA, stateB) pair to product state ID
+    const pairToState = new Map();
+    const productStates = [];
+    const getPairKey = (sa, sb) => `${sa},${sb}`;
+    const getOrCreateState = (sa, sb) => {
+        const key = getPairKey(sa, sb);
+        let stateId = pairToState.get(key);
+        if (stateId === undefined) {
+            stateId = productStates.length;
+            pairToState.set(key, stateId);
+            const acceptA = a.states[sa]?.accepting ?? false;
+            const acceptB = b.states[sb]?.accepting ?? false;
+            // For intersection: accepting iff both accept
+            // For union: accepting iff either accepts
+            const accepting = mode === 'intersection' ? acceptA && acceptB : acceptA || acceptB;
+            productStates.push({
+                id: stateId,
+                transitions: [],
+                accepting,
+            });
+        }
+        return stateId;
+    };
+    // Start with initial states
+    const initialState = getOrCreateState(a.initialState, b.initialState);
+    // Worklist of state pairs to process
+    const worklist = [
+        { stateId: initialState, sa: a.initialState, sb: b.initialState },
+    ];
+    const processed = new Set();
+    while (worklist.length > 0) {
+        const { stateId, sa, sb } = worklist.pop();
+        const key = getPairKey(sa, sb);
+        if (processed.has(key))
+            continue;
+        processed.add(key);
+        const stateA = a.states[sa];
+        const stateB = b.states[sb];
+        const transitions = [];
+        // For each pair of transitions that can fire together
+        for (const transA of stateA?.transitions ?? []) {
+            for (const transB of stateB?.transitions ?? []) {
+                const combined = combineTransitions(transA, transB);
+                if (combined) {
+                    const targetState = getOrCreateState(combined.targetA, combined.targetB);
+                    transitions.push({
+                        ...combined.transition,
+                        target: targetState,
+                    });
+                    const targetKey = getPairKey(combined.targetA, combined.targetB);
+                    if (!processed.has(targetKey)) {
+                        worklist.push({
+                            stateId: targetState,
+                            sa: combined.targetA,
+                            sb: combined.targetB,
+                        });
+                    }
+                }
+            }
+        }
+        productStates[stateId] = {
+            ...productStates[stateId],
+            transitions,
+        };
+    }
+    const acceptingStates = productStates.filter((s) => s.accepting).map((s) => s.id);
+    return {
+        states: productStates,
+        initialState,
+        acceptingStates,
+        isDeterministic: a.isDeterministic && b.isDeterministic,
+    };
+}
+/**
+ * Combine two transitions if they can fire on the same input.
+ */
+function combineTransitions(transA, transB) {
+    // Skip epsilon transitions in product (they're handled differently)
+    if (transA.type === 'epsilon' || transB.type === 'epsilon') {
+        return null;
+    }
+    // Literal + Literal: must be same literal
+    if (transA.type === 'literal' && transB.type === 'literal') {
+        if (transA.segment === transB.segment) {
+            return {
+                transition: { type: 'literal', segment: transA.segment },
+                targetA: transA.target,
+                targetB: transB.target,
+            };
+        }
+        return null;
+    }
+    // Literal + Wildcard: literal must match wildcard pattern
+    if (transA.type === 'literal' && transB.type === 'wildcard') {
+        if (transB.pattern.test(transA.segment)) {
+            return {
+                transition: { type: 'literal', segment: transA.segment },
+                targetA: transA.target,
+                targetB: transB.target,
+            };
+        }
+        return null;
+    }
+    // Wildcard + Literal: literal must match wildcard pattern
+    if (transA.type === 'wildcard' && transB.type === 'literal') {
+        if (transA.pattern.test(transB.segment)) {
+            return {
+                transition: { type: 'literal', segment: transB.segment },
+                targetA: transA.target,
+                targetB: transB.target,
+            };
+        }
+        return null;
+    }
+    // Wildcard + Wildcard: compute intersection of patterns
+    if (transA.type === 'wildcard' && transB.type === 'wildcard') {
+        // Create a combined matcher that tests both patterns
+        const combinedPattern = createIntersectionPattern(transA.pattern, transB.pattern);
+        return {
+            transition: {
+                type: 'wildcard',
+                pattern: combinedPattern,
+                patternSource: `(${transA.patternSource})∩(${transB.patternSource})`,
+            },
+            targetA: transA.target,
+            targetB: transB.target,
+        };
+    }
+    // Globstar transitions
+    if (transA.type === 'globstar' || transB.type === 'globstar') {
+        return handleGlobstarProduct(transA, transB);
+    }
+    return null;
+}
+/**
+ * Create a pattern that matches the intersection of two patterns.
+ *
+ * Since true regex intersection is complex (undecidable in general),
+ * we create a composite matcher that tests both patterns.
+ *
+ * @param patternA - First pattern to test
+ * @param patternB - Second pattern to test
+ * @returns A SegmentMatcher that matches if both patterns match
+ */
+function createIntersectionPattern(patternA, patternB) {
+    return {
+        test: (str) => patternA.test(str) && patternB.test(str),
+        source: `(${patternA.source})∩(${patternB.source})`,
+    };
+}
+/**
+ * Handle product of globstar transitions.
+ */
+function handleGlobstarProduct(transA, transB) {
+    // Globstar matches any segment, so it can combine with anything
+    if (transA.type === 'globstar' && transB.type === 'globstar') {
+        // Both globstars: product stays in globstar state for both
+        return {
+            transition: {
+                type: 'wildcard',
+                pattern: /^.+$/,
+                patternSource: '**',
+            },
+            targetA: transA.selfLoop,
+            targetB: transB.selfLoop,
+        };
+    }
+    if (transA.type === 'globstar') {
+        // A is globstar, B is something else
+        if (transB.type === 'literal') {
+            return {
+                transition: { type: 'literal', segment: transB.segment },
+                targetA: transA.selfLoop, // Stay in globstar
+                targetB: transB.target,
+            };
+        }
+        if (transB.type === 'wildcard') {
+            return {
+                transition: {
+                    type: 'wildcard',
+                    pattern: transB.pattern,
+                    patternSource: transB.patternSource,
+                },
+                targetA: transA.selfLoop,
+                targetB: transB.target,
+            };
+        }
+    }
+    if (transB.type === 'globstar') {
+        // B is globstar, A is something else
+        if (transA.type === 'literal') {
+            return {
+                transition: { type: 'literal', segment: transA.segment },
+                targetA: transA.target,
+                targetB: transB.selfLoop,
+            };
+        }
+        if (transA.type === 'wildcard') {
+            return {
+                transition: {
+                    type: 'wildcard',
+                    pattern: transA.pattern,
+                    patternSource: transA.patternSource,
+                },
+                targetA: transA.target,
+                targetB: transB.selfLoop,
+            };
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=intersect.js.map

package/dist/automaton/intersect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intersect.js","sourceRoot":"","sources":["../../src/automaton/intersect.ts"],"names":[],"mappings":"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"}

package/dist/automaton/pattern-algebra.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Pattern-level set operations (pattern algebra).
+ *
+ * These functions operate on CompiledPattern objects and return new
+ * CompiledPattern objects, providing a higher-level API than the raw
+ * automaton operations.
+ *
+ * @packageDocumentation
+ */
+import type { CompiledPattern } from '../types';
+/**
+ * Compute the intersection of two patterns.
+ *
+ * The result matches paths that match BOTH input patterns.
+ * L(result) = L(a) ∩ L(b)
+ *
+ * @param a - First pattern
+ * @param b - Second pattern
+ * @returns Pattern matching paths in both a and b
+ *
+ * @public
+ */
+export declare function patternIntersect(a: CompiledPattern, b: CompiledPattern): CompiledPattern;
+/**
+ * Compute the union of two patterns.
+ *
+ * The result matches paths that match EITHER input pattern.
+ * L(result) = L(a) ∪ L(b)
+ *
+ * @param a - First pattern
+ * @param b - Second pattern
+ * @returns Pattern matching paths in a or b (or both)
+ *
+ * @public
+ */
+export declare function patternUnion(a: CompiledPattern, b: CompiledPattern): CompiledPattern;
+/**
+ * Compute the complement of a pattern.
+ *
+ * The result matches paths that do NOT match the input pattern.
+ * L(result) = Σ* - L(a)
+ *
+ * @param a - Pattern to complement
+ * @returns Pattern matching paths not matched by a
+ *
+ * @public
+ */
+export declare function patternComplement(a: CompiledPattern): CompiledPattern;
+/**
+ * Compute the difference of two patterns.
+ *
+ * The result matches paths that match a but NOT b.
+ * L(result) = L(a) - L(b) = L(a) ∩ L(¬b)
+ *
+ * @param a - Pattern to subtract from
+ * @param b - Pattern to subtract
+ * @returns Pattern matching paths in a but not in b
+ *
+ * @public
+ */
+export declare function patternDifference(a: CompiledPattern, b: CompiledPattern): CompiledPattern;
+//# sourceMappingURL=pattern-algebra.d.ts.map

package/dist/automaton/pattern-algebra.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-algebra.d.ts","sourceRoot":"","sources":["../../src/automaton/pattern-algebra.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,eAAe,EAA+C,MAAM,UAAU,CAAA;AAS5F;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,eAAe,GAAG,eAAe,CAkBxF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,eAAe,GAAG,eAAe,CAkBpF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,eAAe,GAAG,eAAe,CAqBrE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,eAAe,GAAG,eAAe,CAyBzF"}

package/dist/automaton/pattern-algebra.js

@@ -0,0 +1,309 @@
+/**
+ * Pattern-level set operations (pattern algebra).
+ *
+ * These functions operate on CompiledPattern objects and return new
+ * CompiledPattern objects, providing a higher-level API than the raw
+ * automaton operations.
+ *
+ * @packageDocumentation
+ */
+import { intersect, union } from './intersect';
+import { complement } from './complement';
+import { determinize } from './determinize';
+// =============================================================================
+// PATTERN SET OPERATIONS
+// =============================================================================
+/**
+ * Compute the intersection of two patterns.
+ *
+ * The result matches paths that match BOTH input patterns.
+ * L(result) = L(a) ∩ L(b)
+ *
+ * @param a - First pattern
+ * @param b - Second pattern
+ * @returns Pattern matching paths in both a and b
+ *
+ * @public
+ */
+export function patternIntersect(a, b) {
+    // Determinize inputs to handle epsilon transitions properly
+    const dfaA = a.automaton.isDeterministic ? a.automaton : determinize(a.automaton);
+    const dfaB = b.automaton.isDeterministic ? b.automaton : determinize(b.automaton);
+    const automaton = intersect(dfaA, dfaB);
+    const source = `(${a.source}) ∩ (${b.source})`;
+    const ast = createSyntheticAst(source, 'intersection', [a.ast, b.ast]);
+    const quickReject = mergeQuickRejectForIntersection(a.quickReject, b.quickReject);
+    return {
+        source,
+        ast,
+        quickReject,
+        automaton,
+        isUnbounded: a.isUnbounded && b.isUnbounded,
+        minSegments: Math.max(a.minSegments, b.minSegments),
+        maxSegments: computeIntersectionMaxSegments(a.maxSegments, b.maxSegments),
+    };
+}
+/**
+ * Compute the union of two patterns.
+ *
+ * The result matches paths that match EITHER input pattern.
+ * L(result) = L(a) ∪ L(b)
+ *
+ * @param a - First pattern
+ * @param b - Second pattern
+ * @returns Pattern matching paths in a or b (or both)
+ *
+ * @public
+ */
+export function patternUnion(a, b) {
+    // Determinize inputs to handle epsilon transitions properly
+    const dfaA = a.automaton.isDeterministic ? a.automaton : determinize(a.automaton);
+    const dfaB = b.automaton.isDeterministic ? b.automaton : determinize(b.automaton);
+    const automaton = union(dfaA, dfaB);
+    const source = `(${a.source}) ∪ (${b.source})`;
+    const ast = createSyntheticAst(source, 'union', [a.ast, b.ast]);
+    const quickReject = mergeQuickRejectForUnion(a.quickReject, b.quickReject);
+    return {
+        source,
+        ast,
+        quickReject,
+        automaton,
+        isUnbounded: a.isUnbounded || b.isUnbounded,
+        minSegments: Math.min(a.minSegments, b.minSegments),
+        maxSegments: computeUnionMaxSegments(a.maxSegments, b.maxSegments, a.isUnbounded, b.isUnbounded),
+    };
+}
+/**
+ * Compute the complement of a pattern.
+ *
+ * The result matches paths that do NOT match the input pattern.
+ * L(result) = Σ* - L(a)
+ *
+ * @param a - Pattern to complement
+ * @returns Pattern matching paths not matched by a
+ *
+ * @public
+ */
+export function patternComplement(a) {
+    // Determinize input (complement already does this, but be explicit)
+    const dfa = a.automaton.isDeterministic ? a.automaton : determinize(a.automaton);
+    const automaton = complement(dfa);
+    const source = `¬(${a.source})`;
+    const ast = createSyntheticAst(source, 'complement', [a.ast]);
+    // Complement has no useful quick-reject filters
+    // (the complement of any bounded set is unbounded)
+    const quickReject = {};
+    return {
+        source,
+        ast,
+        quickReject,
+        automaton,
+        // Complement is always unbounded (matches infinite set of paths)
+        isUnbounded: true,
+        minSegments: 0,
+        maxSegments: undefined,
+    };
+}
+/**
+ * Compute the difference of two patterns.
+ *
+ * The result matches paths that match a but NOT b.
+ * L(result) = L(a) - L(b) = L(a) ∩ L(¬b)
+ *
+ * @param a - Pattern to subtract from
+ * @param b - Pattern to subtract
+ * @returns Pattern matching paths in a but not in b
+ *
+ * @public
+ */
+export function patternDifference(a, b) {
+    // A \ B = A ∩ ¬B
+    // Determinize inputs to handle epsilon transitions properly
+    const dfaA = a.automaton.isDeterministic ? a.automaton : determinize(a.automaton);
+    const dfaB = b.automaton.isDeterministic ? b.automaton : determinize(b.automaton);
+    const bComplement = complement(dfaB);
+    const automaton = intersect(dfaA, bComplement);
+    const source = `(${a.source}) \\ (${b.source})`;
+    const ast = createSyntheticAst(source, 'difference', [a.ast, b.ast]);
+    // Difference inherits quick-reject from a (paths must match a)
+    // But we can't use b's filters since we're excluding b
+    const quickReject = a.quickReject;
+    return {
+        source,
+        ast,
+        quickReject,
+        automaton,
+        // Difference of A and B has same unbounded status as A
+        // (we're only removing paths from A)
+        isUnbounded: a.isUnbounded,
+        minSegments: a.minSegments,
+        maxSegments: a.maxSegments,
+    };
+}
+/**
+ * Create a synthetic AST for algebraic pattern operations.
+ */
+function createSyntheticAst(source, _operation, operands) {
+    // For synthetic patterns, we create an alternation node containing
+    // references to the original patterns. This preserves the structure
+    // while indicating this is a computed pattern.
+    const root = {
+        type: 'alternation',
+        branches: operands.map((p) => p.root),
+    };
+    return {
+        source,
+        root,
+        // Synthetic patterns inherit absoluteness from operands
+        isAbsolute: operands.some((p) => p.isAbsolute),
+        isNegation: false,
+    };
+}
+/**
+ * Merge quick-reject filters for intersection (AND semantics).
+ *
+ * For intersection, a path must satisfy BOTH patterns, so we take
+ * the more restrictive constraint for each field.
+ */
+function mergeQuickRejectForIntersection(a, b) {
+    return {
+        requiredPrefix: mergePrefix(a.requiredPrefix, b.requiredPrefix, 'intersection'),
+        requiredSuffix: mergeSuffix(a.requiredSuffix, b.requiredSuffix, 'intersection'),
+        minLength: mergeMinLength(a.minLength, b.minLength, 'intersection'),
+        requiredLiterals: mergeLiterals(a.requiredLiterals, b.requiredLiterals, 'intersection'),
+    };
+}
+/**
+ * Merge quick-reject filters for union (OR semantics).
+ *
+ * For union, a path need only satisfy ONE pattern, so we take
+ * the less restrictive (common) constraint for each field.
+ */
+function mergeQuickRejectForUnion(a, b) {
+    return {
+        requiredPrefix: mergePrefix(a.requiredPrefix, b.requiredPrefix, 'union'),
+        requiredSuffix: mergeSuffix(a.requiredSuffix, b.requiredSuffix, 'union'),
+        minLength: mergeMinLength(a.minLength, b.minLength, 'union'),
+        requiredLiterals: mergeLiterals(a.requiredLiterals, b.requiredLiterals, 'union'),
+    };
+}
+/**
+ * Merge prefix constraints.
+ */
+function mergePrefix(a, b, mode) {
+    if (a === undefined)
+        return mode === 'intersection' ? b : undefined;
+    if (b === undefined)
+        return mode === 'intersection' ? a : undefined;
+    if (mode === 'intersection') {
+        // For intersection, take longer prefix if one is substring of other
+        if (a.startsWith(b))
+            return a;
+        if (b.startsWith(a))
+            return b;
+        // Incompatible prefixes - keep the longer one (will likely reject more)
+        return a.length >= b.length ? a : b;
+    }
+    else {
+        // For union, take common prefix only
+        let common = '';
+        for (let i = 0; i < Math.min(a.length, b.length); i++) {
+            if (a[i] === b[i]) {
+                common += a[i];
+            }
+            else {
+                break;
+            }
+        }
+        return common || undefined;
+    }
+}
+/**
+ * Merge suffix constraints.
+ */
+function mergeSuffix(a, b, mode) {
+    if (a === undefined)
+        return mode === 'intersection' ? b : undefined;
+    if (b === undefined)
+        return mode === 'intersection' ? a : undefined;
+    if (mode === 'intersection') {
+        // For intersection, take longer suffix if one is substring of other
+        if (a.endsWith(b))
+            return a;
+        if (b.endsWith(a))
+            return b;
+        // Incompatible suffixes - keep the longer one
+        return a.length >= b.length ? a : b;
+    }
+    else {
+        // For union, take common suffix only
+        let common = '';
+        for (let i = 0; i < Math.min(a.length, b.length); i++) {
+            if (a[a.length - 1 - i] === b[b.length - 1 - i]) {
+                common = a[a.length - 1 - i] + common;
+            }
+            else {
+                break;
+            }
+        }
+        return common || undefined;
+    }
+}
+/**
+ * Merge minLength constraints.
+ */
+function mergeMinLength(a, b, mode) {
+    if (a === undefined)
+        return mode === 'intersection' ? b : undefined;
+    if (b === undefined)
+        return mode === 'intersection' ? a : undefined;
+    if (mode === 'intersection') {
+        // For intersection, take max (more restrictive)
+        return Math.max(a, b);
+    }
+    else {
+        // For union, take min (less restrictive)
+        return Math.min(a, b);
+    }
+}
+/**
+ * Merge requiredLiterals constraints.
+ */
+function mergeLiterals(a, b, mode) {
+    if (a === undefined)
+        return mode === 'intersection' ? b : undefined;
+    if (b === undefined)
+        return mode === 'intersection' ? a : undefined;
+    if (mode === 'intersection') {
+        // For intersection, union of sets (all must be present)
+        const combined = new Set([...a, ...b]);
+        return combined.size > 0 ? [...combined] : undefined;
+    }
+    else {
+        // For union, intersection of sets (must be in all branches)
+        const bSet = new Set(b);
+        const common = a.filter((lit) => bSet.has(lit));
+        return common.length > 0 ? common : undefined;
+    }
+}
+/**
+ * Compute maxSegments for intersection.
+ */
+function computeIntersectionMaxSegments(a, b) {
+    if (a === undefined)
+        return b;
+    if (b === undefined)
+        return a;
+    return Math.min(a, b);
+}
+/**
+ * Compute maxSegments for union.
+ */
+function computeUnionMaxSegments(a, b, aUnbounded, bUnbounded) {
+    if (aUnbounded || bUnbounded)
+        return undefined;
+    if (a === undefined || b === undefined)
+        return undefined;
+    return Math.max(a, b);
+}
+//# sourceMappingURL=pattern-algebra.js.map