@astrale-os/kernel-dsl 0.2.0-beta.4 → 0.2.0-beta.41

package/dist/v1/language/value/regexp/ast.d.ts

@@ -0,0 +1,21 @@
+export type ScalarRange = readonly [minimum: number, maximum: number];
+export interface Expression {
+    readonly alternatives: readonly Sequence[];
+}
+export interface Sequence {
+    readonly pieces: readonly Piece[];
+}
+export interface Piece {
+    readonly atom: Atom;
+    readonly minimum: number;
+    readonly maximum?: number;
+}
+export type Atom = {
+    readonly kind: 'ranges';
+    readonly ranges: readonly ScalarRange[];
+} | {
+    readonly kind: 'expression';
+    readonly expression: Expression;
+};
+/** Parse the complete RFC 9485 I-Regexp grammar into the one compiler AST. */
+export declare function parseIRegexp(source: string): Expression | undefined;

package/dist/v1/language/value/regexp/ast.js

@@ -0,0 +1,326 @@
+const CATEGORY = /^(?:L[lmotu]?|M[cen]?|N[dlo]?|P[cdfios]?|Z[lps]?|S[ckmo]?|C[cfno]?)$/u;
+const MAX_CODE_POINTS = 4096;
+const MAX_NESTING = 32;
+const MAX_REPEAT = 1000;
+const SCALAR_RANGES = [
+    [0, 0xd7ff],
+    [0xe000, 0x10ffff],
+];
+const DOT_RANGES = [
+    [0, 9],
+    [11, 12],
+    [14, 0xd7ff],
+    [0xe000, 0x10ffff],
+];
+/** Parse the complete RFC 9485 I-Regexp grammar into the one compiler AST. */
+export function parseIRegexp(source) {
+    if (!isUnicodeScalarString(source) || source === '[^]')
+        return undefined;
+    const characters = Array.from(source);
+    if (characters.length > MAX_CODE_POINTS)
+        return undefined;
+    const parser = new Parser(characters);
+    const expression = parser.expression(undefined, 0);
+    return expression !== undefined && parser.done ? expression : undefined;
+}
+class Parser {
+    characters;
+    index = 0;
+    constructor(characters) {
+        this.characters = characters;
+    }
+    get done() {
+        return this.index === this.characters.length;
+    }
+    expression(stop, depth) {
+        if (depth > MAX_NESTING)
+            return undefined;
+        const alternatives = [];
+        const first = this.sequence(stop, depth);
+        if (first === undefined)
+            return undefined;
+        alternatives.push(first);
+        while (this.peek() === '|') {
+            this.index++;
+            const next = this.sequence(stop, depth);
+            if (next === undefined)
+                return undefined;
+            alternatives.push(next);
+        }
+        return { alternatives };
+    }
+    sequence(stop, depth) {
+        const pieces = [];
+        while (this.index < this.characters.length) {
+            const next = this.peek();
+            if (next === '|' || next === stop)
+                return { pieces };
+            const piece = this.piece(depth);
+            if (piece === undefined)
+                return undefined;
+            pieces.push(piece);
+        }
+        return stop === undefined ? { pieces } : undefined;
+    }
+    piece(depth) {
+        const atom = this.atom(depth);
+        if (atom === undefined)
+            return undefined;
+        const next = this.peek();
+        if (next === '*') {
+            this.index++;
+            return { atom, minimum: 0 };
+        }
+        if (next === '+') {
+            this.index++;
+            return { atom, minimum: 1 };
+        }
+        if (next === '?') {
+            this.index++;
+            return { atom, minimum: 0, maximum: 1 };
+        }
+        if (next === '{') {
+            const range = this.quantifier();
+            return range === undefined ? undefined : { atom, ...range };
+        }
+        return { atom, minimum: 1, maximum: 1 };
+    }
+    atom(depth) {
+        const next = this.peek();
+        if (next === undefined)
+            return undefined;
+        if (next === '(') {
+            this.index++;
+            const expression = this.expression(')', depth + 1);
+            if (expression === undefined || this.peek() !== ')')
+                return undefined;
+            this.index++;
+            return { kind: 'expression', expression };
+        }
+        if (next === '.') {
+            this.index++;
+            return { kind: 'ranges', ranges: DOT_RANGES };
+        }
+        if (next === '[')
+            return this.characterClass();
+        if (next === '\\') {
+            const ranges = this.escape(true);
+            return ranges === undefined ? undefined : { kind: 'ranges', ranges };
+        }
+        if (!isNormalCharacter(next))
+            return undefined;
+        this.index++;
+        return { kind: 'ranges', ranges: singleton(next) };
+    }
+    quantifier() {
+        this.index++;
+        const minimum = this.integer();
+        if (minimum === undefined || minimum > MAX_REPEAT)
+            return undefined;
+        let maximum = minimum;
+        if (this.peek() === ',') {
+            this.index++;
+            maximum = this.integer();
+        }
+        if ((maximum !== undefined && (maximum > MAX_REPEAT || maximum < minimum)) ||
+            this.peek() !== '}') {
+            return undefined;
+        }
+        this.index++;
+        return maximum === undefined ? { minimum } : { minimum, maximum };
+    }
+    characterClass() {
+        this.index++;
+        const negated = this.peek() === '^';
+        if (negated)
+            this.index++;
+        if (this.peek() === undefined || this.peek() === ']')
+            return undefined;
+        const ranges = [];
+        if (this.peek() === '-') {
+            ranges.push(...singleton('-'));
+            this.index++;
+        }
+        else if (!this.classEntry(ranges))
+            return undefined;
+        while (this.peek() !== ']') {
+            if (this.peek() === undefined)
+                return undefined;
+            if (this.peek() === '-' && this.peek(1) === ']') {
+                ranges.push(...singleton('-'));
+                this.index++;
+                break;
+            }
+            if (!this.classEntry(ranges))
+                return undefined;
+        }
+        if (this.peek() !== ']')
+            return undefined;
+        this.index++;
+        const merged = mergeRanges(ranges);
+        return { kind: 'ranges', ranges: negated ? complement(merged) : merged };
+    }
+    classEntry(output) {
+        if (this.peek() === '\\' && (this.peek(1) === 'p' || this.peek(1) === 'P')) {
+            const ranges = this.categoryEscape();
+            if (ranges === undefined)
+                return false;
+            output.push(...ranges);
+            return true;
+        }
+        const start = this.classCharacter();
+        if (start === undefined)
+            return false;
+        if (this.peek() !== '-' || this.peek(1) === ']') {
+            output.push([start, start]);
+            return true;
+        }
+        this.index++;
+        const end = this.classCharacter();
+        if (end === undefined || end < start)
+            return false;
+        output.push([start, end]);
+        return true;
+    }
+    classCharacter() {
+        if (this.peek() === '\\') {
+            const ranges = this.escape(false);
+            return ranges?.length === 1 && ranges[0][0] === ranges[0][1] ? ranges[0][0] : undefined;
+        }
+        const next = this.peek();
+        if (next === undefined || next === '-' || next === '[' || next === ']' || next === '\\')
+            return undefined;
+        this.index++;
+        return next.codePointAt(0);
+    }
+    escape(allowCategory) {
+        if (allowCategory && (this.peek(1) === 'p' || this.peek(1) === 'P')) {
+            return this.categoryEscape();
+        }
+        if (this.peek() !== '\\')
+            return undefined;
+        const escaped = this.peek(1);
+        if (escaped === undefined || !'()*+-.?[\\]^nrt{}'.includes(escaped))
+            return undefined;
+        this.index += 2;
+        const value = escaped === 'n' ? '\n' : escaped === 'r' ? '\r' : escaped === 't' ? '\t' : escaped;
+        return singleton(value);
+    }
+    categoryEscape() {
+        if (this.peek() !== '\\' ||
+            (this.peek(1) !== 'p' && this.peek(1) !== 'P') ||
+            this.peek(2) !== '{')
+            return undefined;
+        const negated = this.peek(1) === 'P';
+        this.index += 3;
+        let category = '';
+        while (this.peek() !== '}' && this.peek() !== undefined) {
+            category += this.peek();
+            this.index++;
+        }
+        if (this.peek() !== '}' || !CATEGORY.test(category))
+            return undefined;
+        this.index++;
+        const ranges = categoryRanges(category);
+        return negated ? complement(ranges) : ranges;
+    }
+    integer() {
+        const start = this.index;
+        while (/^[0-9]$/u.test(this.peek() ?? ''))
+            this.index++;
+        if (this.index === start)
+            return undefined;
+        const value = Number(this.characters.slice(start, this.index).join(''));
+        return Number.isSafeInteger(value) ? value : undefined;
+    }
+    peek(offset = 0) {
+        return this.characters[this.index + offset];
+    }
+}
+const categories = new Map();
+function categoryRanges(category) {
+    const retained = categories.get(category);
+    if (retained !== undefined)
+        return retained;
+    const expression = new RegExp(`^\\p{${category}}$`, 'u');
+    const output = [];
+    let start;
+    let previous = -2;
+    for (const [minimum, maximum] of SCALAR_RANGES) {
+        for (let scalar = minimum; scalar <= maximum; scalar++) {
+            if (!expression.test(String.fromCodePoint(scalar)))
+                continue;
+            if (start === undefined)
+                start = scalar;
+            else if (scalar !== previous + 1) {
+                output.push([start, previous]);
+                start = scalar;
+            }
+            previous = scalar;
+        }
+    }
+    if (start !== undefined)
+        output.push([start, previous]);
+    const frozen = Object.freeze(output.map((range) => Object.freeze(range)));
+    categories.set(category, frozen);
+    return frozen;
+}
+function singleton(value) {
+    const scalar = value.codePointAt(0);
+    return scalar === undefined ? [] : [[scalar, scalar]];
+}
+function mergeRanges(input) {
+    const sorted = [...input].sort((left, right) => left[0] - right[0] || left[1] - right[1]);
+    const output = [];
+    for (const range of sorted) {
+        const previous = output.at(-1);
+        if (previous === undefined || range[0] > previous[1] + 1)
+            output.push([range[0], range[1]]);
+        else
+            output[output.length - 1] = [previous[0], Math.max(previous[1], range[1])];
+    }
+    return output;
+}
+function complement(input) {
+    const output = [];
+    for (const [minimum, maximum] of SCALAR_RANGES) {
+        let cursor = minimum;
+        for (const [start, end] of input) {
+            if (end < minimum || start > maximum)
+                continue;
+            if (start > cursor)
+                output.push([cursor, Math.min(start - 1, maximum)]);
+            cursor = Math.max(cursor, end + 1);
+            if (cursor > maximum)
+                break;
+        }
+        if (cursor <= maximum)
+            output.push([cursor, maximum]);
+    }
+    return output;
+}
+function isNormalCharacter(value) {
+    const code = value.codePointAt(0);
+    return (code !== undefined &&
+        ((code >= 0 && code <= 0x27) ||
+            code === 0x2c ||
+            code === 0x2d ||
+            (code >= 0x2f && code <= 0x3e) ||
+            (code >= 0x40 && code <= 0x5a) ||
+            (code >= 0x5e && code <= 0x7a) ||
+            (code >= 0x7e && code <= 0xd7ff) ||
+            (code >= 0xe000 && code <= 0x10ffff)));
+}
+function isUnicodeScalarString(value) {
+    for (let index = 0; index < value.length; index++) {
+        const unit = value.charCodeAt(index);
+        if (unit < 0xd800 || unit > 0xdfff)
+            continue;
+        if (unit > 0xdbff || index + 1 >= value.length)
+            return false;
+        const next = value.charCodeAt(++index);
+        if (next < 0xdc00 || next > 0xdfff)
+            return false;
+    }
+    return true;
+}

package/dist/v1/language/value/regexp/compile.d.ts

@@ -0,0 +1,3 @@
+import type { Pattern, RunPattern } from '../compile/model.js';
+/** Compile scalar sequences as counted runs; preserve the NFA for branching expressions. */
+export declare function compilePattern(source: string): Pattern | RunPattern;

package/dist/v1/language/value/regexp/compile.js

@@ -0,0 +1,138 @@
+import { parseIRegexp } from './ast.js';
+/** Compile scalar sequences as counted runs; preserve the NFA for branching expressions. */
+export function compilePattern(source) {
+    const expression = parseIRegexp(source);
+    if (expression === undefined)
+        throw new TypeError('Cannot compile an invalid I-Regexp source.');
+    const runs = scalarRuns(expression);
+    if (runs !== undefined)
+        return Object.freeze({ source, runs });
+    const builder = new Builder();
+    const fragment = builder.expression(expression);
+    builder.states[fragment.end].accepting = true;
+    return Object.freeze({
+        source,
+        start: fragment.start,
+        states: Object.freeze(builder.states.map(freezeState)),
+    });
+}
+function scalarRuns(expression) {
+    if (expression.alternatives.length !== 1)
+        return undefined;
+    const pieces = expression.alternatives[0].pieces;
+    let counted = false;
+    for (let index = 0; index < pieces.length; index++) {
+        const piece = pieces[index];
+        if (piece.atom.kind !== 'ranges' ||
+            (index !== pieces.length - 1 && piece.minimum !== piece.maximum))
+            return undefined;
+        if (piece.maximum !== undefined && piece.maximum > 1)
+            counted = true;
+    }
+    if (!counted)
+        return undefined;
+    const runs = [];
+    for (const piece of pieces) {
+        if (piece.atom.kind !== 'ranges')
+            return undefined;
+        runs.push(Object.freeze({
+            ranges: freezeRanges(piece.atom.ranges),
+            minimum: piece.minimum,
+            ...(piece.maximum === undefined ? {} : { maximum: piece.maximum }),
+        }));
+    }
+    return Object.freeze(runs);
+}
+function freezeRanges(ranges) {
+    if (Object.isFrozen(ranges))
+        return ranges;
+    for (const range of ranges)
+        Object.freeze(range);
+    return Object.freeze(ranges);
+}
+class Builder {
+    states = [];
+    expression(expression) {
+        if (expression.alternatives.length === 1)
+            return this.sequence(expression.alternatives[0]);
+        const start = this.state();
+        const end = this.state();
+        for (const alternative of expression.alternatives) {
+            const branch = this.sequence(alternative);
+            this.epsilon(start, branch.start);
+            this.epsilon(branch.end, end);
+        }
+        return { start, end };
+    }
+    sequence(sequence) {
+        let output;
+        for (const piece of sequence.pieces) {
+            const fragment = this.piece(piece);
+            output = output === undefined ? fragment : this.concat(output, fragment);
+        }
+        return output ?? this.empty();
+    }
+    piece(piece) {
+        let output;
+        for (let index = 0; index < piece.minimum; index++) {
+            const fragment = this.atom(piece.atom);
+            output = output === undefined ? fragment : this.concat(output, fragment);
+        }
+        if (piece.maximum === undefined) {
+            const repeated = this.star(piece.atom);
+            return output === undefined ? repeated : this.concat(output, repeated);
+        }
+        if (piece.maximum === piece.minimum)
+            return output ?? this.empty();
+        output ??= this.empty();
+        const end = this.state();
+        for (let index = piece.minimum; index < piece.maximum; index++) {
+            // A shorter repetition exits the whole suffix, rather than skipping arbitrary copies.
+            this.epsilon(output.end, end);
+            output = this.concat(output, this.atom(piece.atom));
+        }
+        this.epsilon(output.end, end);
+        return { start: output.start, end };
+    }
+    atom(atom) {
+        if (atom.kind === 'expression')
+            return this.expression(atom.expression);
+        const start = this.state();
+        const end = this.state();
+        this.states[start].transitions.push({ to: end, ranges: atom.ranges });
+        return { start, end };
+    }
+    star(atom) {
+        const start = this.state();
+        const end = this.state();
+        const child = this.atom(atom);
+        this.epsilon(start, end);
+        this.epsilon(start, child.start);
+        this.epsilon(child.end, child.start);
+        this.epsilon(child.end, end);
+        return { start, end };
+    }
+    empty() {
+        const start = this.state();
+        const end = this.state();
+        this.epsilon(start, end);
+        return { start, end };
+    }
+    concat(left, right) {
+        this.epsilon(left.end, right.start);
+        return { start: left.start, end: right.end };
+    }
+    state() {
+        return this.states.push({ epsilon: [], transitions: [] }) - 1;
+    }
+    epsilon(from, to) {
+        this.states[from].epsilon.push(to);
+    }
+}
+function freezeState(state) {
+    return Object.freeze({
+        epsilon: Object.freeze(state.epsilon),
+        transitions: Object.freeze(state.transitions.map((transition) => Object.freeze({ to: transition.to, ranges: freezeRanges(transition.ranges) }))),
+        ...(state.accepting === true ? { accepting: true } : {}),
+    });
+}

package/dist/v1/language/value/regexp/lower.d.ts

@@ -0,0 +1,3 @@
+import type { JsonSchema } from '../model/schema.js';
+/** Creates an Ajv-private schema copy with only checked I-Regexp sources lowered. */
+export declare function lowerIRegexpSchemas(schema: JsonSchema): JsonSchema;

package/dist/v1/language/value/regexp/lower.js

@@ -0,0 +1,26 @@
+import { accept as acceptJsonValue } from '@astrale-os/kernel-dsl/value';
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { walkSchema } from '../syntax/walk.js';
+import { lowerIRegexpPattern } from './pattern.js';
+/** Creates an Ajv-private schema copy with only checked I-Regexp sources lowered. */
+export function lowerIRegexpSchemas(schema) {
+    const lowered = acceptJsonValue(schema);
+    walkSchema(lowered, ({ schema: current }) => {
+        if (!isJsonObject(current))
+            return;
+        const mutable = current;
+        if (typeof current.pattern === 'string') {
+            mutable.pattern = lowerIRegexpPattern(current.pattern);
+        }
+        if (isJsonObject(current.patternProperties)) {
+            const patterns = current.patternProperties;
+            const entries = Object.entries(current.patternProperties);
+            for (const key of Object.keys(patterns))
+                delete patterns[key];
+            for (const [pattern, child] of entries) {
+                patterns[lowerIRegexpPattern(pattern)] = child;
+            }
+        }
+    });
+    return lowered;
+}

package/dist/v1/language/value/regexp/matcher.d.ts

@@ -0,0 +1,10 @@
+import type { Pattern, RunPattern } from '../compile/model.js';
+export interface IRegexpMatcher {
+    test(value: string): boolean;
+    matches(value: string): boolean;
+}
+/**
+ * Load the portable counted-run or Thompson NFA executor for search and whole-string matching.
+ * Scratch belongs to one invocation: no match-result cache, shared mutable cursor or DFA expansion.
+ */
+export declare function loadPattern(pattern: Pattern | RunPattern): IRegexpMatcher;