regex-partial-match 1.1.2 → 1.3.0

package/lib/compilePartial.js

@@ -1,334 +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 isBackreference = (part) => typeof part !== "string";
-const isNumericBackreference = (part) => isBackreference(part) && typeof part.ref === "number";
-function walk(regex) {
-    const source = regex.source;
-    const isUnicode = regex.unicode || regex.unicodeSets;
-    let i = 0;
-    let groupCount = 0;
-    const features = new Set();
-    function extractSlice(length) {
-        return source.slice(i, (i += length));
-    }
-    function process() {
-        var _a;
-        const result = [];
-        function appendOptional(length) {
-            result.push("(?:" + extractSlice(length) + DISJUNCTION_TO_END_OF_INPUT);
-        }
-        function appendRaw(length) {
-            result.push(extractSlice(length));
-        }
-        function appendRawGroup(prefixLength) {
-            const start = i;
-            i += prefixLength;
-            process();
-            result.push(source.slice(start, i));
-        }
-        while (i < source.length) {
-            switch (source[i]) {
-                case "\\":
-                    switch (source[i + 1]) {
-                        case "c":
-                            features.add("controlLetterEscape");
-                            appendOptional(3);
-                            break;
-                        case "k": {
-                            const referenceEnd = source[i + 2] === "<" ? source.indexOf(">", i) : -1;
-                            if (referenceEnd === -1) {
-                                appendOptional(2);
-                            }
-                            else {
-                                features.add("namedBackreference");
-                                const start = i;
-                                const ref = source.slice(i + 3, referenceEnd);
-                                i = referenceEnd + 1;
-                                result.push({ ref, start, end: i });
-                            }
-                            break;
-                        }
-                        case "u":
-                            features.add("unicodeEscapeSequence");
-                            if (isUnicode && source[i + 2] === "{") {
-                                appendOptional(source.indexOf("}", i) - i + 1);
-                            }
-                            else {
-                                appendOptional(6);
-                            }
-                            break;
-                        case "p":
-                        case "P":
-                            if (isUnicode) {
-                                features.add("unicodePropertyEscape");
-                                appendOptional(source.indexOf("}", i) - i + 1);
-                            }
-                            else {
-                                appendOptional(2);
-                            }
-                            break;
-                        case "x":
-                            features.add("hexEscapeSequence");
-                            appendOptional(4);
-                            break;
-                        case "b":
-                            features.add("wordBoundary");
-                            appendOptional(2);
-                            break;
-                        case "B":
-                            features.add("nonWordBoundary");
-                            appendOptional(2);
-                            break;
-                        case "f":
-                        case "n":
-                        case "r":
-                        case "t":
-                        case "v":
-                            features.add("controlEscape");
-                            appendOptional(2);
-                            break;
-                        case "1":
-                        case "2":
-                        case "3":
-                        case "4":
-                        case "5":
-                        case "6":
-                        case "7":
-                        case "8":
-                        case "9": {
-                            features.add("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":
-                            features.add("characterClassEscape");
-                            appendOptional(2);
-                            break;
-                        default:
-                            features.add("otherEscape");
-                            appendOptional(2);
-                            break;
-                    }
-                    break;
-                case "[": {
-                    features.add("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) {
-                                    features.add("nestedCharacterClass");
-                                    depth++;
-                                }
-                                break;
-                            case "]":
-                                depth--;
-                                break;
-                            case "&":
-                                if (regex.unicodeSets && previousSetOperatorCharacter === "&") {
-                                    features.add("classIntersection");
-                                }
-                                break;
-                            case "-":
-                                if (regex.unicodeSets && previousSetOperatorCharacter === "-") {
-                                    features.add("classSubtraction");
-                                }
-                                break;
-                        }
-                        previousSetOperatorCharacter = character;
-                        j++;
-                    }
-                    appendOptional(j - i);
-                    break;
-                }
-                case "^":
-                    features.add("startAnchor");
-                    appendRaw(1);
-                    break;
-                case "$":
-                    features.add("endAnchor");
-                    appendRaw(1);
-                    break;
-                case "|":
-                    features.add("disjunction");
-                    appendRaw(1);
-                    break;
-                case "*":
-                case "+":
-                case "?":
-                    features.add("quantifier");
-                    appendRaw(1);
-                    break;
-                case "{": {
-                    OCCURRENCES_REGEX.lastIndex = i;
-                    const regExpExecArray = OCCURRENCES_REGEX.exec(source);
-                    if (regExpExecArray) {
-                        features.add("quantifier");
-                        appendRaw(regExpExecArray[0].length);
-                    }
-                    else {
-                        appendOptional(1);
-                    }
-                    break;
-                }
-                case "(":
-                    if (source[i + 1] == "?") {
-                        switch (source[i + 2]) {
-                            case ":":
-                                features.add("nonCapturingGroup");
-                                result.push("(?:");
-                                i += 3;
-                                result.push(...process(), DISJUNCTION_TO_END_OF_INPUT);
-                                break;
-                            case "=":
-                                features.add("lookahead");
-                                result.push("(?=");
-                                i += 3;
-                                result.push(...process(), ")");
-                                break;
-                            case "-":
-                            case "i":
-                            case "s":
-                            case "m": {
-                                const flagsStart = i + 2, colonIndex = source.indexOf(":", flagsStart);
-                                const modifiers = source.slice(flagsStart, colonIndex);
-                                features.add(modifiers.includes("-")
-                                    ? "modifierGroupWithRemoval"
-                                    : "modifierGroup");
-                                result.push("(?" + modifiers + ":");
-                                i = colonIndex + 1;
-                                result.push(...process(), ")");
-                                break;
-                            }
-                            case "!":
-                                features.add("negativeLookahead");
-                                appendRawGroup(3);
-                                break;
-                            case "<":
-                                switch (source[i + 3]) {
-                                    case "=":
-                                        features.add("lookbehind");
-                                        appendRawGroup(4);
-                                        break;
-                                    case "!":
-                                        features.add("negativeLookbehind");
-                                        appendRawGroup(4);
-                                        break;
-                                    default:
-                                        features.add("namedGroup");
-                                        features.add("capturingGroup");
-                                        ++groupCount;
-                                        appendRaw(source.indexOf(">", i) - i + 1);
-                                        result.push(...process(), DISJUNCTION_TO_END_OF_INPUT);
-                                        break;
-                                }
-                                break;
-                        }
-                    }
-                    else {
-                        features.add("capturingGroup");
-                        ++groupCount;
-                        appendRaw(1);
-                        result.push(...process(), DISJUNCTION_TO_END_OF_INPUT);
-                    }
-                    break;
-                case ")":
-                    ++i;
-                    return result;
-                default:
-                    features.add("patternCharacter");
-                    appendOptional(isUnicode && ((_a = source.codePointAt(i)) !== null && _a !== void 0 ? _a : 0) > 0xffff ? 2 : 1);
-                    break;
-            }
-        }
-        return result;
-    }
-    return { parts: process(), groupCount, features };
-}
-function render(parts, renderBackref) {
-    return parts
-        .map((part) => (isBackreference(part) ? renderBackref(part) : part))
-        .join("");
-}
-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) + "(?:[\\s\\S]*?)";
-        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("");
-}
-export const compilePartial = (regex) => {
-    const { parts, groupCount, features } = walk(regex);
-    if (!MAYBE_HAS_BACKREFERENCE_REGEX.test(regex.source)) {
-        return {
-            kind: "static",
-            regex: new RegExp(render(parts, backrefToken), regex.flags),
-            features
-        };
-    }
-    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 {
-            kind: "static",
-            regex: new RegExp(render(sanitisedParts, backrefToken), regex.flags),
-            features
-        };
-    }
-    return {
-        kind: "dynamic",
-        features,
-        dynamic: {
-            originalCaptureScan: new RegExp(spliceOriginalSource(regex.source, backreferences), regex.flags),
-            preScan: new RegExp(render(parts, () => "(?:[\\s\\S]*?)"), regex.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);
-            })
-        }
-    };
-};

package/lib/partialMatchRegExp.js

@@ -1,122 +0,0 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _PartialMatchRegExp_compiledPartial;
-import { compilePartial } from "./compilePartial.js";
-/**
- * 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);
-        _PartialMatchRegExp_compiledPartial.set(this, void 0);
-        __classPrivateFieldSet(this, _PartialMatchRegExp_compiledPartial, compilePartial(this), "f");
-        this.features = __classPrivateFieldGet(this, _PartialMatchRegExp_compiledPartial, "f").features;
-    }
-    exec(input) {
-        const compiled = __classPrivateFieldGet(this, _PartialMatchRegExp_compiledPartial, "f");
-        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;
-    }
-}
-_PartialMatchRegExp_compiledPartial = new WeakMap();
-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;