regex-partial-match 1.3.0 → 2.0.0

package/lib/partialMatchRegExp/partialMatchRegExp.d.ts

@@ -1,55 +0,0 @@
-import type { CompiledPartial } from "./compilePartial/compiled.ts";
-import { compiledPartial, truncationProbeCache } from "./partialMatchInternals.ts";
-import type { TruncationProbeCache } from "./isComplete/truncationProbeCache.ts";
-import type { RegexFeature } from "./regexFeatures.ts";
-export type { RegexFeature };
-/**
- * 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 {
-    [compiledPartial]: CompiledPartial;
-    [truncationProbeCache]: TruncationProbeCache;
-    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/partialMatchRegExp.js

@@ -1,114 +0,0 @@
-import compilePartial from "./compilePartial/index.js";
-import renderParts from "./compilePartial/renderParts.js";
-import { backreferenceExpansion } from "./backreferenceExpansion.js";
-import { compiledPartial, truncationProbeCache } from "./partialMatchInternals.js";
-import { preferLongerCaptures } from "./preferLongerCaptures.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);
-        this[compiledPartial] = compilePartial(this);
-        this[truncationProbeCache] = { probe: undefined };
-    }
-    /**
-     * 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, expansionFitsCaptures } = 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;
-        let expandedFrom = capture;
-        let expandedParts = expand(expandedFrom);
-        let expanded = new RegExp(renderParts(expandedParts), this.flags);
-        let match = execFrom(expanded, input, start);
-        if (match !== null && !expansionFitsCaptures(expandedFrom, match, input)) {
-            expandedFrom = match;
-            expandedParts = expand(expandedFrom);
-            expanded = new RegExp(renderParts(expandedParts), this.flags);
-            match = execFrom(expanded, input, start);
-            if (match !== null && !expansionFitsCaptures(expandedFrom, match, input))
-                match = null;
-        }
-        if (match === null || isAtOrBefore(originalMatch, match.index))
-            return originalMatch;
-        preferLongerCaptures(match, capture);
-        if (honoursLastIndex)
-            this.lastIndex = expanded.lastIndex;
-        match[backreferenceExpansion] = {
-            parts: expandedParts,
-            probe: undefined
-        };
-        return match;
-    }
-}
-function execFrom(regex, input, start) {
-    regex.lastIndex = start;
-    return regex.exec(input);
-}
-function isAtOrBefore(match, index) {
-    return match !== null && match.index <= index;
-}
-export default PartialMatchRegExp;

package/lib/partialMatchRegExp/preferLongerCaptures.d.ts

@@ -1 +0,0 @@
-export declare function preferLongerCaptures(match: RegExpExecArray, scanned: RegExpExecArray): void;

package/lib/partialMatchRegExp/preferLongerCaptures.js

@@ -1,30 +0,0 @@
-function pickLonger(scanned, matched) {
-    return scanned !== undefined &&
-        matched !== undefined &&
-        scanned.length > matched.length
-        ? scanned
-        : undefined;
-}
-export 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];
-            }
-        }
-    }
-}