regex-partial-match 1.2.0 → 2.0.0

package/lib/compilePartial.js

@@ -1,397 +0,0 @@
-import escapeAtom from "./escapeAtom.js";
-const OCCURRENCES_REGEX = /\{\d+,?\d*\}/y;
-const NOT_NUMBERS_REGEX = /\D/g;
-const MAYBE_HAS_BACKREFERENCE_REGEX = /\\[1-9]|\\k</;
-const DISJUNCTION_TO_END_OF_INPUT = "|$(?![\\s\\S]))";
-const ANY_CAPTURED_TEXT = "(?:[\\s\\S]*?)";
-const isBackreference = (part) => typeof part !== "string";
-const isNumericBackreference = (part) => isBackreference(part) && typeof part.ref === "number";
-const REGEX_FEATURES = [
-    "patternCharacter",
-    "startAnchor",
-    "endAnchor",
-    "wordBoundary",
-    "nonWordBoundary",
-    "lookahead",
-    "negativeLookahead",
-    "lookbehind",
-    "negativeLookbehind",
-    "backreference",
-    "namedBackreference",
-    "namedGroup",
-    "capturingGroup",
-    "lookaroundCapture",
-    "nonCapturingGroup",
-    "modifierGroup",
-    "modifierGroupWithRemoval",
-    "characterClass",
-    "nestedCharacterClass",
-    "classIntersection",
-    "classSubtraction",
-    "disjunction",
-    "quantifier",
-    "unicodePropertyEscape",
-    "characterClassEscape",
-    "controlEscape",
-    "controlLetterEscape",
-    "hexEscapeSequence",
-    "unicodeEscapeSequence",
-    "otherEscape"
-];
-const FEATURE_BIT = {};
-for (let index = 0; index < REGEX_FEATURES.length; index++) {
-    FEATURE_BIT[REGEX_FEATURES[index]] = 1 << index;
-}
-function featureSet(mask) {
-    const features = new Set();
-    for (let index = 0; index < REGEX_FEATURES.length; index++) {
-        if (mask & (1 << index))
-            features.add(REGEX_FEATURES[index]);
-    }
-    return features;
-}
-function walk(regex) {
-    const source = regex.source;
-    const isUnicode = regex.unicode || regex.unicodeSets;
-    let i = 0;
-    let groupCount = 0;
-    let featureMask = 0;
-    function extractSlice(length) {
-        return source.slice(i, (i += length));
-    }
-    function process(withinLookaround) {
-        var _a;
-        const result = [];
-        function appendOptional(length) {
-            result.push("(?:" + extractSlice(length) + DISJUNCTION_TO_END_OF_INPUT);
-        }
-        function appendRaw(length) {
-            result.push(extractSlice(length));
-        }
-        function appendRawLookaround(prefixLength) {
-            const start = i;
-            i += prefixLength;
-            process(true);
-            result.push(source.slice(start, i));
-        }
-        while (i < source.length) {
-            switch (source[i]) {
-                case "\\":
-                    switch (source[i + 1]) {
-                        case "c":
-                            featureMask |= FEATURE_BIT.controlLetterEscape;
-                            appendOptional(3);
-                            break;
-                        case "k": {
-                            const referenceEnd = source[i + 2] === "<" ? source.indexOf(">", i) : -1;
-                            if (referenceEnd === -1) {
-                                appendOptional(2);
-                            }
-                            else {
-                                featureMask |= FEATURE_BIT.namedBackreference;
-                                const start = i;
-                                const ref = source.slice(i + 3, referenceEnd);
-                                i = referenceEnd + 1;
-                                result.push({ ref, start, end: i });
-                            }
-                            break;
-                        }
-                        case "u":
-                            featureMask |= FEATURE_BIT.unicodeEscapeSequence;
-                            if (isUnicode && source[i + 2] === "{") {
-                                appendOptional(source.indexOf("}", i) - i + 1);
-                            }
-                            else {
-                                appendOptional(6);
-                            }
-                            break;
-                        case "p":
-                        case "P":
-                            if (isUnicode) {
-                                featureMask |= FEATURE_BIT.unicodePropertyEscape;
-                                appendOptional(source.indexOf("}", i) - i + 1);
-                            }
-                            else {
-                                appendOptional(2);
-                            }
-                            break;
-                        case "x":
-                            featureMask |= FEATURE_BIT.hexEscapeSequence;
-                            appendOptional(4);
-                            break;
-                        case "b":
-                            featureMask |= FEATURE_BIT.wordBoundary;
-                            appendOptional(2);
-                            break;
-                        case "B":
-                            featureMask |= FEATURE_BIT.nonWordBoundary;
-                            appendOptional(2);
-                            break;
-                        case "f":
-                        case "n":
-                        case "r":
-                        case "t":
-                        case "v":
-                            featureMask |= FEATURE_BIT.controlEscape;
-                            appendOptional(2);
-                            break;
-                        case "1":
-                        case "2":
-                        case "3":
-                        case "4":
-                        case "5":
-                        case "6":
-                        case "7":
-                        case "8":
-                        case "9": {
-                            featureMask |= FEATURE_BIT.backreference;
-                            NOT_NUMBERS_REGEX.lastIndex = i + 1;
-                            const nextNonDigit = NOT_NUMBERS_REGEX.exec(source);
-                            const start = i;
-                            const end = nextNonDigit ? nextNonDigit.index : source.length;
-                            const ref = Number(source.slice(start + 1, end));
-                            i = end;
-                            result.push({ ref, start, end });
-                            break;
-                        }
-                        case "d":
-                        case "D":
-                        case "w":
-                        case "W":
-                        case "s":
-                        case "S":
-                            featureMask |= FEATURE_BIT.characterClassEscape;
-                            appendOptional(2);
-                            break;
-                        default:
-                            featureMask |= FEATURE_BIT.otherEscape;
-                            appendOptional(2);
-                            break;
-                    }
-                    break;
-                case "[": {
-                    featureMask |= FEATURE_BIT.characterClass;
-                    let depth = 1, j = i + 1, previousSetOperatorCharacter;
-                    while (depth) {
-                        const character = source[j];
-                        switch (character) {
-                            case "\\":
-                                j += 2;
-                                previousSetOperatorCharacter = undefined;
-                                continue;
-                            case "[":
-                                if (regex.unicodeSets) {
-                                    featureMask |= FEATURE_BIT.nestedCharacterClass;
-                                    depth++;
-                                }
-                                break;
-                            case "]":
-                                depth--;
-                                break;
-                            case "&":
-                                if (regex.unicodeSets && previousSetOperatorCharacter === "&") {
-                                    featureMask |= FEATURE_BIT.classIntersection;
-                                }
-                                break;
-                            case "-":
-                                if (regex.unicodeSets && previousSetOperatorCharacter === "-") {
-                                    featureMask |= FEATURE_BIT.classSubtraction;
-                                }
-                                break;
-                        }
-                        previousSetOperatorCharacter = character;
-                        j++;
-                    }
-                    appendOptional(j - i);
-                    break;
-                }
-                case "^":
-                    featureMask |= FEATURE_BIT.startAnchor;
-                    appendRaw(1);
-                    break;
-                case "$":
-                    featureMask |= FEATURE_BIT.endAnchor;
-                    appendRaw(1);
-                    break;
-                case "|":
-                    featureMask |= FEATURE_BIT.disjunction;
-                    appendRaw(1);
-                    break;
-                case "*":
-                case "+":
-                case "?":
-                    featureMask |= FEATURE_BIT.quantifier;
-                    appendRaw(1);
-                    break;
-                case "{": {
-                    OCCURRENCES_REGEX.lastIndex = i;
-                    const regExpExecArray = OCCURRENCES_REGEX.exec(source);
-                    if (regExpExecArray) {
-                        featureMask |= FEATURE_BIT.quantifier;
-                        appendRaw(regExpExecArray[0].length);
-                    }
-                    else {
-                        appendOptional(1);
-                    }
-                    break;
-                }
-                case "(":
-                    if (source[i + 1] == "?") {
-                        switch (source[i + 2]) {
-                            case ":":
-                                featureMask |= FEATURE_BIT.nonCapturingGroup;
-                                result.push("(?:");
-                                i += 3;
-                                result.push(...process(withinLookaround), DISJUNCTION_TO_END_OF_INPUT);
-                                break;
-                            case "=":
-                                featureMask |= FEATURE_BIT.lookahead;
-                                result.push("(?=");
-                                i += 3;
-                                result.push(...process(true), ")");
-                                break;
-                            case "-":
-                            case "i":
-                            case "s":
-                            case "m": {
-                                const flagsStart = i + 2, colonIndex = source.indexOf(":", flagsStart);
-                                const modifiers = source.slice(flagsStart, colonIndex);
-                                featureMask |= modifiers.includes("-")
-                                    ? FEATURE_BIT.modifierGroupWithRemoval
-                                    : FEATURE_BIT.modifierGroup;
-                                result.push("(?" + modifiers + ":");
-                                i = colonIndex + 1;
-                                result.push(...process(withinLookaround), ")");
-                                break;
-                            }
-                            case "!":
-                                featureMask |= FEATURE_BIT.negativeLookahead;
-                                appendRawLookaround(3);
-                                break;
-                            case "<":
-                                switch (source[i + 3]) {
-                                    case "=":
-                                        featureMask |= FEATURE_BIT.lookbehind;
-                                        appendRawLookaround(4);
-                                        break;
-                                    case "!":
-                                        featureMask |= FEATURE_BIT.negativeLookbehind;
-                                        appendRawLookaround(4);
-                                        break;
-                                    default:
-                                        featureMask |= FEATURE_BIT.namedGroup;
-                                        featureMask |= FEATURE_BIT.capturingGroup;
-                                        if (withinLookaround)
-                                            featureMask |= FEATURE_BIT.lookaroundCapture;
-                                        ++groupCount;
-                                        appendRaw(source.indexOf(">", i) - i + 1);
-                                        result.push(...process(withinLookaround), DISJUNCTION_TO_END_OF_INPUT);
-                                        break;
-                                }
-                                break;
-                        }
-                    }
-                    else {
-                        featureMask |= FEATURE_BIT.capturingGroup;
-                        if (withinLookaround)
-                            featureMask |= FEATURE_BIT.lookaroundCapture;
-                        ++groupCount;
-                        appendRaw(1);
-                        result.push(...process(withinLookaround), DISJUNCTION_TO_END_OF_INPUT);
-                    }
-                    break;
-                case ")":
-                    ++i;
-                    return result;
-                default:
-                    featureMask |= FEATURE_BIT.patternCharacter;
-                    appendOptional(isUnicode && ((_a = source.codePointAt(i)) !== null && _a !== void 0 ? _a : 0) > 0xffff ? 2 : 1);
-                    break;
-            }
-        }
-        return result;
-    }
-    return { parts: process(false), groupCount, featureMask };
-}
-function render(parts, renderBackref) {
-    let rendered = "";
-    for (const part of parts) {
-        rendered += isBackreference(part) ? renderBackref(part) : part;
-    }
-    return rendered;
-}
-function backrefToken(backref) {
-    return isNumericBackreference(backref)
-        ? "\\" + String(backref.ref)
-        : "\\k<" + backref.ref + ">";
-}
-function reclassifyOctalEscapes(parts, source, groupCount) {
-    return parts.map((part) => isNumericBackreference(part) && part.ref > groupCount
-        ? "(?:" + source.slice(part.start, part.end) + DISJUNCTION_TO_END_OF_INPUT
-        : part);
-}
-function spliceOriginalSource(source, backrefs) {
-    let result = "";
-    let cursor = 0;
-    for (const { start, end } of backrefs) {
-        result += source.slice(cursor, start) + ANY_CAPTURED_TEXT;
-        cursor = end;
-    }
-    return result + source.slice(cursor);
-}
-function expandCaptured(value, isUnicode) {
-    return (isUnicode ? Array.from(value) : value.split(""))
-        .map((atom) => "(?:" + escapeAtom(atom) + DISJUNCTION_TO_END_OF_INPUT)
-        .join("");
-}
-class Compiled {
-    constructor(_featureMask) {
-        this._featureMask = _featureMask;
-    }
-    get features() {
-        var _a;
-        return ((_a = this._features) !== null && _a !== void 0 ? _a : (this._features = featureSet(this._featureMask)));
-    }
-}
-class CompiledStatic extends Compiled {
-    constructor(regex, featureMask) {
-        super(featureMask);
-        this.regex = regex;
-        this.kind = "static";
-    }
-}
-class CompiledDynamic extends Compiled {
-    constructor(dynamic, featureMask) {
-        super(featureMask);
-        this.dynamic = dynamic;
-        this.kind = "dynamic";
-    }
-}
-export const compilePartial = (regex) => {
-    const { parts, groupCount, featureMask } = walk(regex);
-    const flags = regex.flags;
-    if (!MAYBE_HAS_BACKREFERENCE_REGEX.test(regex.source)) {
-        return new CompiledStatic(new RegExp(render(parts, backrefToken), flags), featureMask);
-    }
-    const isUnicode = regex.unicode || regex.unicodeSets;
-    const sanitisedParts = isUnicode
-        ? parts
-        : reclassifyOctalEscapes(parts, regex.source, groupCount);
-    const backreferences = sanitisedParts.filter(isBackreference);
-    if (backreferences.length === 0) {
-        return new CompiledStatic(new RegExp(render(sanitisedParts, backrefToken), flags), featureMask);
-    }
-    return new CompiledDynamic({
-        originalCaptureScan: new RegExp(spliceOriginalSource(regex.source, backreferences), flags),
-        preScan: new RegExp(render(parts, () => ANY_CAPTURED_TEXT), flags),
-        expand: (capture) => render(parts, (backref) => {
-            var _a;
-            const captured = isNumericBackreference(backref)
-                ? capture[backref.ref]
-                : (_a = capture.groups) === null || _a === void 0 ? void 0 : _a[backref.ref];
-            return captured === undefined
-                ? "(?:" + backrefToken(backref) + DISJUNCTION_TO_END_OF_INPUT
-                : expandCaptured(captured, isUnicode);
-        })
-    }, featureMask);
-};

package/lib/partialMatchRegExp.d.ts

@@ -1,52 +0,0 @@
-import { type RegexFeature } from "./compilePartial.ts";
-export type { RegexFeature };
-declare const compiledPartial: unique symbol;
-/**
- * A `RegExp` subclass that supports partial (prefix) matching.
- *
- * An instance behaves like a normal `RegExp` but also matches any input string
- * that is a valid prefix of the original pattern — i.e. strings that could still
- * lead to a full match with more input. This enables validation of incomplete
- * input strings.
- *
- * @example
- * ```typescript
- * const pattern = /^hello world/;
- * const partial = new PartialMatchRegExp(pattern);
- *
- * partial.test('h');           // true - could match
- * partial.test('hello');       // true - could match
- * partial.test('hello world'); // true - full match
- * partial.test('goodbye');     // false - cannot match
- * ```
- *
- * @remarks
- * - The transformed pattern always matches an empty string at the end of input;
- *   use a start anchor (`^`) to prevent false positives from empty string matches
- * - The `y` (sticky) flag may not behave as expected in partial matching scenarios
- *
- * @see {@link https://github.com/TomStrepsil/regex-partial-match#readme | Documentation}
- */
-declare class PartialMatchRegExp extends RegExp {
-    private [compiledPartial];
-    constructor(pattern: RegExp | string, flags?: string);
-    /**
-     * The syntactic constructs the original pattern uses, recorded as a side
-     * effect of the single walk that builds the partial-match regex.
-     *
-     * The set is built on first read and cached, so patterns that are only ever
-     * matched against never pay for it. It iterates in `RegexFeature` declaration
-     * order, not the order the constructs appear in the pattern.
-     *
-     * @returns The features the original pattern contains
-     *
-     * @example
-     * ```typescript
-     * new PartialMatchRegExp(/^[a-z]+/).features.has("startAnchor"); // true
-     * ```
-     */
-    get features(): ReadonlySet<RegexFeature>;
-    exec(input: string): RegExpExecArray | null;
-    private _execDynamic;
-}
-export default PartialMatchRegExp;

package/lib/partialMatchRegExp.js

@@ -1,126 +0,0 @@
-import { compilePartial } from "./compilePartial.js";
-const compiledPartial = Symbol("compiledPartial");
-/**
- * A `RegExp` subclass that supports partial (prefix) matching.
- *
- * An instance behaves like a normal `RegExp` but also matches any input string
- * that is a valid prefix of the original pattern — i.e. strings that could still
- * lead to a full match with more input. This enables validation of incomplete
- * input strings.
- *
- * @example
- * ```typescript
- * const pattern = /^hello world/;
- * const partial = new PartialMatchRegExp(pattern);
- *
- * partial.test('h');           // true - could match
- * partial.test('hello');       // true - could match
- * partial.test('hello world'); // true - full match
- * partial.test('goodbye');     // false - cannot match
- * ```
- *
- * @remarks
- * - The transformed pattern always matches an empty string at the end of input;
- *   use a start anchor (`^`) to prevent false positives from empty string matches
- * - The `y` (sticky) flag may not behave as expected in partial matching scenarios
- *
- * @see {@link https://github.com/TomStrepsil/regex-partial-match#readme | Documentation}
- */
-class PartialMatchRegExp extends RegExp {
-    constructor(pattern, flags) {
-        super(pattern, flags);
-        this[compiledPartial] = compilePartial(this);
-    }
-    /**
-     * The syntactic constructs the original pattern uses, recorded as a side
-     * effect of the single walk that builds the partial-match regex.
-     *
-     * The set is built on first read and cached, so patterns that are only ever
-     * matched against never pay for it. It iterates in `RegexFeature` declaration
-     * order, not the order the constructs appear in the pattern.
-     *
-     * @returns The features the original pattern contains
-     *
-     * @example
-     * ```typescript
-     * new PartialMatchRegExp(/^[a-z]+/).features.has("startAnchor"); // true
-     * ```
-     */
-    get features() {
-        return this[compiledPartial].features;
-    }
-    exec(input) {
-        const compiled = this[compiledPartial];
-        if (compiled.kind === "dynamic")
-            return this._execDynamic(compiled.dynamic, input);
-        const { regex } = compiled;
-        const match = execFrom(regex, input, this.lastIndex);
-        this.lastIndex = regex.lastIndex;
-        return match;
-    }
-    _execDynamic(dynamic, input) {
-        var _a, _b;
-        const { originalCaptureScan, preScan, expand } = dynamic;
-        const honoursLastIndex = this.global || this.sticky;
-        const start = honoursLastIndex ? this.lastIndex : 0;
-        const originalMatch = super.exec(input);
-        if (isAtOrBefore(originalMatch, start))
-            return originalMatch;
-        let preScanMatch = null;
-        if (originalMatch) {
-            preScanMatch = execFrom(preScan, input, start);
-            const noEarlierPartialPossible = preScanMatch === null || preScanMatch.index >= originalMatch.index;
-            if (noEarlierPartialPossible)
-                return originalMatch;
-        }
-        const capture = (_b = (_a = execFrom(originalCaptureScan, input, start)) !== null && _a !== void 0 ? _a : preScanMatch) !== null && _b !== void 0 ? _b : execFrom(preScan, input, start);
-        if (capture === null)
-            return originalMatch;
-        const expanded = new RegExp(expand(capture), this.flags);
-        const match = execFrom(expanded, input, start);
-        if (match === null || isAtOrBefore(originalMatch, match.index))
-            return originalMatch;
-        preferLongerCaptures(match, capture);
-        if (honoursLastIndex)
-            this.lastIndex = expanded.lastIndex;
-        return match;
-    }
-}
-function execFrom(regex, input, start) {
-    regex.lastIndex = start;
-    return regex.exec(input);
-}
-function isAtOrBefore(match, index) {
-    return match !== null && match.index <= index;
-}
-function pickLonger(scanned, matched) {
-    return scanned !== undefined &&
-        matched !== undefined &&
-        scanned.length > matched.length
-        ? scanned
-        : undefined;
-}
-function preferLongerCaptures(match, scanned) {
-    var _a, _b, _c, _d;
-    for (let index = 1; index < match.length; index++) {
-        const longer = pickLonger(scanned[index], match[index]);
-        if (longer === undefined)
-            continue;
-        match[index] = longer;
-        if (match.indices && ((_a = scanned.indices) === null || _a === void 0 ? void 0 : _a[index])) {
-            match.indices[index] = scanned.indices[index];
-        }
-    }
-    if (match.groups && scanned.groups) {
-        for (const name of Object.keys(match.groups)) {
-            const longer = pickLonger(scanned.groups[name], match.groups[name]);
-            if (longer === undefined)
-                continue;
-            match.groups[name] = longer;
-            if ((_b = match.indices) === null || _b === void 0 ? void 0 : _b.groups) {
-                match.indices.groups[name] = (_d = (_c = scanned.indices) === null || _c === void 0 ? void 0 : _c.groups) === null || _d === void 0 ? void 0 : _d[name];
-            }
-        }
-    }
-}
-export default PartialMatchRegExp;