regex-explain 0.0.0-stage → 1.0.0

package/dist/cjs/explainer.js

@@ -0,0 +1,628 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRegexSource = isRegexSource;
+exports.explainRegex = explainRegex;
+exports.parseRegexInput = parseRegexInput;
+exports.describeCount = describeCount;
+/**
+ * Turns an ECMAScript regular expression into a tree of plain-English explanations.
+ *
+ * Parsing is done by `@eslint-community/regexpp`, character set and length analysis by
+ * `regexp-ast-analysis`, and backtracking analysis by `scslre`. This module walks the AST and words
+ * the results.
+ */
+const regexpp_1 = require("@eslint-community/regexpp");
+const regexp_ast_analysis_1 = require("regexp-ast-analysis");
+const scslre_1 = require("scslre");
+const text_1 = require("./text");
+/**
+ * Checks whether a value is a {@link RegexSource}, such as an untyped command argument.
+ *
+ * @param value The value.
+ *
+ * @returns Whether the value has string `pattern` and `flags` properties.
+ */
+function isRegexSource(value) {
+    const candidate = value;
+    return typeof candidate?.pattern === "string" && typeof candidate.flags === "string";
+}
+/** Flag letters mapped to their `RegExp` property and meaning. */
+const FLAG_INFO = {
+    d: { name: "hasIndices", description: "Record start and end indices for each capture group." },
+    g: { name: "global", description: "Find all matches instead of stopping after the first." },
+    i: { name: "ignoreCase", description: "Ignore case: letters match both upper and lower case." },
+    m: {
+        name: "multiline",
+        description: `${(0, text_1.code)("^")} and ${(0, text_1.code)("$")} match at the start and end of each line, not just the whole input.`,
+    },
+    s: { name: "dotAll", description: `${(0, text_1.code)(".")} also matches line terminators.` },
+    u: {
+        name: "unicode",
+        description: "Treat the pattern as a sequence of Unicode code points and use strict syntax.",
+    },
+    v: {
+        name: "unicodeSets",
+        description: `Unicode mode with set operations (${(0, text_1.code)("--")}, ${(0, text_1.code)("&&")}), nested classes, and string properties.`,
+    },
+    y: { name: "sticky", description: `Match only at the position given by ${(0, text_1.code)("lastIndex")}.` },
+};
+/** Friendly names for common Unicode properties and general categories. */
+const UNICODE_PROPERTY_NAMES = {
+    L: "letter",
+    Letter: "letter",
+    Lu: "uppercase letter",
+    Uppercase_Letter: "uppercase letter",
+    Ll: "lowercase letter",
+    Lowercase_Letter: "lowercase letter",
+    Lt: "titlecase letter",
+    Lm: "modifier letter",
+    Lo: "other letter",
+    M: "mark",
+    Mark: "mark",
+    N: "number",
+    Number: "number",
+    Nd: "decimal digit",
+    Decimal_Number: "decimal digit",
+    P: "punctuation character",
+    Punctuation: "punctuation character",
+    S: "symbol",
+    Symbol: "symbol",
+    Sc: "currency symbol",
+    Currency_Symbol: "currency symbol",
+    Z: "separator",
+    Separator: "separator",
+    Zs: "space separator",
+    Space_Separator: "space separator",
+    C: "control or other character",
+    Other: "control or other character",
+    Cc: "control character",
+    Control: "control character",
+    Alphabetic: "alphabetic character",
+    Alpha: "alphabetic character",
+    White_Space: "whitespace character",
+    space: "whitespace character",
+    Emoji: "emoji character",
+    ASCII: "ASCII character",
+    Any: "character",
+};
+/** Property keys whose value names a script. */
+const SCRIPT_KEYS = new Set(["Script", "sc", "Script_Extensions", "scx"]);
+/**
+ * Explains a regex pattern compiled with the given flags. Syntax errors are returned, not thrown.
+ *
+ * @param pattern The pattern without surrounding slashes, as passed to `new RegExp()`.
+ * @param flags The flags, such as `"gi"`.
+ * @param options Analysis options.
+ *
+ * @returns The explanation, or the reason the pattern is invalid.
+ */
+function explainRegex(pattern, flags = "", options = {}) {
+    const parser = new regexpp_1.RegExpParser({ ecmaVersion: 2025 });
+    let flagsAst;
+    let patternAst;
+    try {
+        flagsAst = parser.parseFlags(flags);
+        patternAst = parser.parsePattern(pattern, 0, pattern.length, {
+            unicode: flagsAst.unicode,
+            unicodeSets: flagsAst.unicodeSets,
+        });
+    }
+    catch (error) {
+        return {
+            ok: false,
+            pattern,
+            flags,
+            message: error instanceof Error ? error.message : String(error),
+            index: error instanceof regexpp_1.RegExpSyntaxError ? error.index : undefined,
+        };
+    }
+    const ctx = { flags: flagsAst };
+    const length = (0, regexp_ast_analysis_1.getLengthRange)(patternAst.alternatives, flagsAst);
+    return {
+        ok: true,
+        pattern,
+        flags,
+        nodes: explainAlternatives(patternAst.alternatives, ctx),
+        flagExplanations: [...flags].map((flag) => ({ flag, ...FLAG_INFO[flag] })),
+        length: { min: length.min, max: length.max },
+        warnings: options.checkBacktracking === false ? [] : findBacktracking(patternAst, flagsAst, pattern),
+        multiline: flagsAst.multiline || enablesMultiline(patternAst),
+    };
+}
+/**
+ * Checks whether a node, or any node inside it, is a group whose modifiers turn multiline on, as in
+ * `(?m:^a$)`.
+ *
+ * @param node The node.
+ *
+ * @returns Whether `^` and `$` match at line breaks somewhere in the node.
+ */
+function enablesMultiline(node) {
+    if (node.type === "Group" && node.modifiers?.add.multiline) {
+        return true;
+    }
+    const children = "alternatives" in node
+        ? node.alternatives
+        : node.type === "Alternative"
+            ? node.elements
+            : node.type === "Quantifier"
+                ? [node.element]
+                : [];
+    return children.some(enablesMultiline);
+}
+/**
+ * Reads typed or selected text as a regex.
+ *
+ * @param text Either a literal such as `/ab+c/gi`, optionally surrounded by whitespace, or a bare
+ *   pattern.
+ *
+ * @returns The regex; bare patterns have no flags. The pattern is not validated.
+ */
+function parseRegexInput(text) {
+    const literal = /^\/((?:\\.|\[(?:\\.|[^\]\\])*\]|[^/\\[])+)\/([a-z]*)$/s.exec(text.trim());
+    return literal ? { pattern: literal[1], flags: literal[2] } : { pattern: text, flags: "" };
+}
+/**
+ * Finds quantifiers that can backtrack catastrophically.
+ *
+ * @param pattern The parsed pattern.
+ * @param flags The parsed flags.
+ * @param source The pattern source, for slicing fixes.
+ *
+ * @returns One warning per problem found.
+ */
+function findBacktracking(pattern, flags, source) {
+    // Move reports flag ordinary patterns such as /a+b/ that are slow only on adversarial input
+    // scanned at every offset; they are too common to be useful as warnings.
+    const { reports } = (0, scslre_1.analyse)({ pattern, flags }, { reportTypes: { Move: false } });
+    return reports.map((report) => toWarning(report, source));
+}
+/**
+ * Words one backtracking report.
+ *
+ * @param report The scslre report.
+ * @param source The pattern source.
+ *
+ * @returns The warning.
+ */
+function toWarning(report, source) {
+    const quant = report.type === "Trade" ? report.startQuant : report.quant;
+    const cost = `so a failed match can take ${report.exponential ? "exponential" : "polynomial"} time`;
+    let description;
+    switch (report.type) {
+        case "Trade":
+            description = `${(0, text_1.code)(report.startQuant.raw)} and ${(0, text_1.code)(report.endQuant.raw)} can match the same text, ${cost}`;
+            break;
+        case "Self":
+            description = `${(0, text_1.code)(report.quant.raw)} is repeated by ${(0, text_1.code)(report.parentQuant.raw)} and can match the same text in many ways, ${cost}`;
+            break;
+        case "Move":
+            // Disabled in findBacktracking; worded anyway so new options cannot produce blank warnings.
+            description = `${(0, text_1.code)(report.quant.raw)} is retried at every position of a failing input, ${cost}`;
+            break;
+    }
+    const fixed = report.fix();
+    return {
+        raw: source.slice(quant.start, quant.end),
+        start: quant.start,
+        end: quant.end,
+        exponential: report.exponential,
+        attackCharacter: report.character.pick,
+        description,
+        fix: fixed ? { pattern: fixed.source, flags: fixed.flags } : undefined,
+    };
+}
+/**
+ * Builds an explanation node.
+ *
+ * @param span The source the node explains.
+ * @param description The explanation.
+ * @param children Explanations of the parts of `span`.
+ *
+ * @returns The node.
+ */
+function make(span, description, children = []) {
+    return { raw: span.raw, start: span.start, end: span.end, description, children };
+}
+/**
+ * Returns a copy of a node with a prefix added to its description.
+ *
+ * @param prefix The text to add.
+ * @param node The node.
+ *
+ * @returns The new node.
+ */
+function prefixed(prefix, node) {
+    return { ...node, description: prefix + node.description };
+}
+/**
+ * Explains a list of alternatives, as found in the pattern, groups, and lookarounds.
+ *
+ * @param alternatives The alternatives, at least one.
+ * @param ctx The walk context.
+ *
+ * @returns The steps of a single alternative, or one node that lists every alternative.
+ */
+function explainAlternatives(alternatives, ctx) {
+    if (alternatives.length === 1) {
+        return explainSequence(alternatives[0], ctx);
+    }
+    const options = alternatives.map((alt, i) => {
+        const steps = explainSequence(alt, ctx);
+        // An option with a single step reads better without an extra level.
+        if (steps.length === 1) {
+            return make(alt, `Option ${i + 1}: ${(0, text_1.lowerFirst)(steps[0].description)}`, [
+                ...steps[0].children,
+            ]);
+        }
+        return make(alt, `Option ${i + 1}:`, steps);
+    });
+    const span = {
+        raw: alternatives.map((a) => a.raw).join("|"),
+        start: alternatives[0].start,
+        end: alternatives[alternatives.length - 1].end,
+    };
+    return [make(span, `Match one of ${alternatives.length} alternatives:`, options)];
+}
+/**
+ * Explains the elements of one alternative, merging runs of literal characters.
+ *
+ * @param alt The alternative.
+ * @param ctx The walk context.
+ *
+ * @returns One node per step.
+ */
+function explainSequence(alt, ctx) {
+    if (alt.elements.length === 0) {
+        return [make(alt, "Match the empty string")];
+    }
+    // Consecutive characters become one run, so that "abc" is one step rather than three.
+    const steps = alt.elements.reduce((acc, el) => {
+        const last = acc[acc.length - 1];
+        if (el.type !== "Character") {
+            return [...acc, el];
+        }
+        return Array.isArray(last) ? [...acc.slice(0, -1), [...last, el]] : [...acc, [el]];
+    }, []);
+    return steps.map((step) => Array.isArray(step) ? explainCharacterRun(step, ctx) : explainElement(step, ctx));
+}
+/**
+ * Returns " (case-insensitive)" when ignoring case changes what the elements match.
+ *
+ * @param elements The elements to check.
+ * @param ctx The walk context.
+ *
+ * @returns The note, or an empty string.
+ */
+function caseNote(elements, ctx) {
+    if (!ctx.flags.ignoreCase) {
+        return "";
+    }
+    const sensitive = { ...ctx.flags, ignoreCase: false };
+    const changes = elements.some((el) => (0, regexp_ast_analysis_1.toUnicodeSet)(el, ctx.flags).chars.size !== (0, regexp_ast_analysis_1.toUnicodeSet)(el, sensitive).chars.size);
+    return changes ? " (case-insensitive)" : "";
+}
+/**
+ * Explains consecutive literal characters as one step.
+ *
+ * @param run The characters, at least one.
+ * @param ctx The walk context.
+ *
+ * @returns The node.
+ */
+function explainCharacterRun(run, ctx) {
+    const note = caseNote(run, ctx);
+    if (run.length === 1) {
+        return make(run[0], `Match ${(0, text_1.describeCodePoint)(run[0].value)}${note}`);
+    }
+    const text = String.fromCodePoint(...run.map((c) => c.value));
+    const span = {
+        raw: run.map((c) => c.raw).join(""),
+        start: run[0].start,
+        end: run[run.length - 1].end,
+    };
+    // Only call it text when every character is visible; otherwise name each one.
+    if (/^[^\p{C}\s](?:[^\p{C}]*[^\p{C}\s])?$/u.test(text)) {
+        return make(span, `Match the text ${(0, text_1.code)(text)}${note}`);
+    }
+    const names = run.map((c) => (0, text_1.describeCodePoint)(c.value)).join(", ");
+    return make(span, `Match the sequence ${names}${note}`);
+}
+/**
+ * Explains one element of an alternative.
+ *
+ * @param el The element.
+ * @param ctx The walk context.
+ *
+ * @returns The node.
+ */
+function explainElement(el, ctx) {
+    switch (el.type) {
+        case "Assertion":
+            return explainAssertion(el, ctx);
+        case "Quantifier":
+            return explainQuantifier(el, ctx);
+        default:
+            return explainQuantifiable(el, ctx);
+    }
+}
+/**
+ * Explains an element that a quantifier can repeat.
+ *
+ * @param el The element.
+ * @param ctx The walk context.
+ *
+ * @returns The node.
+ */
+function explainQuantifiable(el, ctx) {
+    switch (el.type) {
+        case "Character":
+            return explainCharacterRun([el], ctx);
+        case "CapturingGroup": {
+            const n = (0, regexp_ast_analysis_1.getCapturingGroupNumber)(el);
+            const label = el.name ? `Capture group #${n} named ${(0, text_1.code)(el.name)}` : `Capture group #${n}`;
+            return make(el, `${label}:`, explainAlternatives(el.alternatives, ctx));
+        }
+        case "Group": {
+            if (!el.modifiers) {
+                return make(el, "Group (non-capturing):", explainAlternatives(el.alternatives, ctx));
+            }
+            const inner = applyModifiers(el.modifiers, ctx);
+            const label = `Group with modifiers (${describeModifiers(el.modifiers)}):`;
+            return make(el, label, explainAlternatives(el.alternatives, inner));
+        }
+        case "Backreference":
+            return make(el, `Match the same text last captured by ${describeBackrefTarget(el)}`);
+        case "Assertion":
+            // Lookaheads are quantifiable in legacy (non-unicode) mode.
+            return explainAssertion(el, ctx);
+        case "CharacterClass":
+        case "ExpressionCharacterClass":
+            return explainClass(el, ctx, true);
+        case "CharacterSet":
+            return make(el, `Match ${describeCharacterSet(el, ctx)}${caseNote([el], ctx)}`);
+    }
+}
+/**
+ * Explains a quantifier by appending the repetition to its element's explanation.
+ *
+ * @param q The quantifier.
+ * @param ctx The walk context.
+ *
+ * @returns The node.
+ */
+function explainQuantifier(q, ctx) {
+    const inner = explainQuantifiable(q.element, ctx);
+    const greed = q.min === q.max ? "" : q.greedy ? " (as many as possible)" : " (as few as possible)";
+    const repetition = `${describeCount(q.min, q.max)}${greed}`;
+    if (inner.children.length === 0) {
+        return make(q, `${inner.description}, ${repetition}`);
+    }
+    const heading = inner.description.replace(/:$/, "");
+    return make(q, `${heading}, ${repetition}:`, [...inner.children]);
+}
+/**
+ * Words a repetition count.
+ *
+ * @param min The minimum count.
+ * @param max The maximum count; `Infinity` when unbounded.
+ *
+ * @returns A phrase such as "one or more times".
+ */
+function describeCount(min, max) {
+    if (min === 0 && max === 1) {
+        return "optionally";
+    }
+    if (max === Infinity) {
+        return min === 0
+            ? "zero or more times"
+            : min === 1
+                ? "one or more times"
+                : `${min} or more times`;
+    }
+    if (min === max) {
+        return min === 1 ? "exactly once" : `exactly ${min} times`;
+    }
+    return `between ${min} and ${max} times`;
+}
+/**
+ * Explains an anchor, word boundary, or lookaround.
+ *
+ * @param a The assertion.
+ * @param ctx The walk context.
+ *
+ * @returns The node.
+ */
+function explainAssertion(a, ctx) {
+    const where = ctx.flags.multiline ? "a line" : "the input";
+    switch (a.kind) {
+        case "start":
+            return make(a, `Assert position is at the start of ${where}`);
+        case "end":
+            return make(a, `Assert position is at the end of ${where}`);
+        case "word":
+            return make(a, `Assert position is ${a.negate ? "not " : ""}at a word boundary`);
+        case "lookahead":
+            return make(a, a.negate
+                ? "Negative lookahead: assert that what follows does not match:"
+                : "Lookahead: assert that what follows matches:", explainAlternatives(a.alternatives, ctx));
+        case "lookbehind":
+            return make(a, a.negate
+                ? "Negative lookbehind: assert that what precedes does not match:"
+                : "Lookbehind: assert that what precedes matches:", explainAlternatives(a.alternatives, ctx));
+    }
+}
+/**
+ * Names the group a backreference refers to.
+ *
+ * @param ref The backreference.
+ *
+ * @returns A phrase such as "group #1 (`name`)".
+ */
+function describeBackrefTarget(ref) {
+    if (ref.ambiguous) {
+        const numbers = ref.resolved.map((g) => `#${(0, regexp_ast_analysis_1.getCapturingGroupNumber)(g)}`).join(" or ");
+        return `the group named ${(0, text_1.code)(ref.ref)} (${numbers})`;
+    }
+    const n = (0, regexp_ast_analysis_1.getCapturingGroupNumber)(ref.resolved);
+    return typeof ref.ref === "string" ? `group #${n} (${(0, text_1.code)(ref.ref)})` : `group #${n}`;
+}
+/**
+ * Applies a group's inline modifiers, such as `(?i-m:...)`, to the context.
+ *
+ * @param m The modifiers.
+ * @param ctx The enclosing context.
+ *
+ * @returns The context inside the group.
+ */
+function applyModifiers(m, ctx) {
+    // A flag a group removes is off, one it adds is on, and the rest keep the enclosing value.
+    const flag = (name) => m.remove?.[name] ? false : m.add?.[name] ? true : ctx.flags[name];
+    return {
+        flags: {
+            ...ctx.flags,
+            ignoreCase: flag("ignoreCase"),
+            multiline: flag("multiline"),
+            dotAll: flag("dotAll"),
+        },
+    };
+}
+/**
+ * Words a group's inline modifiers.
+ *
+ * @param m The modifiers.
+ *
+ * @returns A phrase such as "enable ignore case; disable multiline".
+ */
+function describeModifiers(m) {
+    const names = (f) => f
+        ? [
+            f.ignoreCase ? "ignore case" : "",
+            f.multiline ? "multiline" : "",
+            f.dotAll ? "dotAll" : "",
+        ].filter(Boolean)
+        : [];
+    const on = names(m.add);
+    const off = names(m.remove);
+    return [on.length ? `enable ${on.join(", ")}` : "", off.length ? `disable ${off.join(", ")}` : ""]
+        .filter(Boolean)
+        .join("; ");
+}
+/**
+ * Explains a character class.
+ *
+ * @param cls The class.
+ * @param ctx The walk context.
+ * @param topLevel Whether the class is an element of an alternative, which adds the verb "Match".
+ *
+ * @returns The node.
+ */
+function explainClass(cls, ctx, topLevel) {
+    const verb = topLevel ? "Match " : "";
+    const note = topLevel ? caseNote([cls], ctx) : "";
+    if (cls.type === "ExpressionCharacterClass") {
+        const what = cls.negate ? "any character not in" : "a character in";
+        return make(cls, `${verb}${what} the set${note}:`, [explainClassElement(cls.expression, ctx)]);
+    }
+    if (cls.elements.length === 0) {
+        return make(cls, cls.negate ? `${verb}any character at all` : `${verb}nothing (an empty class never matches)`);
+    }
+    const what = cls.negate ? "any character except" : "one of";
+    return make(cls, `${verb}${what}${note}:`, cls.elements.map((e) => explainClassElement(e, ctx)));
+}
+/**
+ * Explains one member of a character class as a noun phrase.
+ *
+ * @param el The member.
+ * @param ctx The walk context.
+ *
+ * @returns The node.
+ */
+function explainClassElement(el, ctx) {
+    switch (el.type) {
+        case "Character":
+            return make(el, (0, text_1.describeCodePoint)(el.value));
+        case "CharacterClassRange":
+            return make(el, `a character from ${(0, text_1.describeCodePoint)(el.min.value)} to ${(0, text_1.describeCodePoint)(el.max.value)}`);
+        case "CharacterSet":
+            return make(el, describeCharacterSet(el, ctx));
+        case "CharacterClass":
+        case "ExpressionCharacterClass":
+            return explainClass(el, ctx, false);
+        case "ClassStringDisjunction": {
+            const strings = el.alternatives.map((a) => a.elements.length
+                ? (0, text_1.code)(String.fromCodePoint(...a.elements.map((c) => c.value)))
+                : "the empty string");
+            return make(el, strings.length === 1
+                ? `the string ${strings[0]}`
+                : `one of the strings ${strings.join(", ")}`);
+        }
+        case "ClassIntersection":
+            return make(el, "characters that are in all of:", flattenOperands(el).map((o) => explainClassElement(o, ctx)));
+        case "ClassSubtraction": {
+            const [first, ...rest] = flattenOperands(el);
+            return make(el, "characters that are:", [
+                prefixed("in ", explainClassElement(first, ctx)),
+                ...rest.map((o) => prefixed("but not ", explainClassElement(o, ctx))),
+            ]);
+        }
+    }
+}
+/**
+ * Flattens a left-nested set operation such as `(a&&b)&&c` into its operands.
+ *
+ * @param node The operation.
+ *
+ * @returns The operands, left to right.
+ */
+function flattenOperands(node) {
+    const left = node.left.type === node.type
+        ? flattenOperands(node.left)
+        : [node.left];
+    return [...left, node.right];
+}
+/**
+ * Describes `.`, `\d`, `\s`, `\w`, or a Unicode property escape as a noun phrase.
+ *
+ * @param set The character set.
+ * @param ctx The walk context.
+ *
+ * @returns The phrase.
+ */
+function describeCharacterSet(set, ctx) {
+    switch (set.kind) {
+        case "any":
+            return ctx.flags.dotAll ? "any character" : "any character except a line break";
+        case "digit":
+            return set.negate ? "any character that is not a digit" : "a digit (0-9)";
+        case "space":
+            return set.negate
+                ? "any character that is not whitespace"
+                : "a whitespace character (space, tab, line break, etc.)";
+        case "word":
+            return set.negate
+                ? "any character that is not a word character"
+                : "a word character (letter, digit, or underscore)";
+        case "property":
+            return describeProperty(set);
+    }
+}
+/**
+ * Describes a Unicode property escape such as `\p{Lu}` as a noun phrase.
+ *
+ * @param set The property escape.
+ *
+ * @returns The phrase.
+ */
+function describeProperty(set) {
+    const raw = set.value ? `${set.key}=${set.value}` : set.key;
+    if (set.strings) {
+        return `a string with Unicode property ${(0, text_1.code)(raw)}`;
+    }
+    const name = set.value ?? set.key;
+    const friendly = set.value && SCRIPT_KEYS.has(set.key)
+        ? `character in the ${set.value.replace(/_/g, " ")} script`
+        : (UNICODE_PROPERTY_NAMES[name] ?? `character with Unicode property ${(0, text_1.code)(raw)}`);
+    return set.negate ? `any character that is not ${(0, text_1.withArticle)(friendly)}` : (0, text_1.withArticle)(friendly);
+}
+//# sourceMappingURL=explainer.js.map

package/dist/cjs/extlinks.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Links that open a regex in external tools, with their fields prefilled. Each tool has one builder
+ * function here.
+ *
+ * - [regex101](https://regex101.com) tests and debugs regexes interactively. Its fields are prefilled
+ *   from the query string, as its FAQ describes:
+ *   https://github.com/firasdib/Regex101/wiki/FAQ#how-to-prefill-the-fields-on-the-interface-via-url
+ *   The FAQ does not list `flavor`, but regex101 reads it: `javascript` selects the JavaScript
+ *   flavor.
+ */
+import type { RegexSource } from "./explainer";
+/**
+ * Builds a regex101 link that opens a regex in the JavaScript flavor, which is the engine this
+ * library explains and matches with.
+ *
+ * @param source The regex.
+ * @param testString Text to match against; left out when empty.
+ *
+ * @returns The link, with each value percent-encoded so that `+` and spaces survive.
+ */
+export declare function regex101Url(source: RegexSource, testString?: string): string;

package/dist/cjs/extlinks.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.regex101Url = regex101Url;
+/** The regex101 page the fields are prefilled on. */
+const REGEX101 = "https://regex101.com/";
+/**
+ * Builds a regex101 link that opens a regex in the JavaScript flavor, which is the engine this
+ * library explains and matches with.
+ *
+ * @param source The regex.
+ * @param testString Text to match against; left out when empty.
+ *
+ * @returns The link, with each value percent-encoded so that `+` and spaces survive.
+ */
+function regex101Url(source, testString = "") {
+    const params = [
+        ["regex", source.pattern],
+        ["flags", source.flags],
+        ["flavor", "javascript"],
+        ...(testString === "" ? [] : [["testString", testString]]),
+    ];
+    const query = params.map(([key, value]) => `${key}=${encodeURIComponent(value)}`).join("&");
+    return `${REGEX101}?${query}`;
+}
+//# sourceMappingURL=extlinks.js.map

package/dist/cjs/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Explains ECMAScript regular expressions in plain English, finds regexes in source code, and runs
+ * them over text.
+ *
+ * ```ts
+ * import { ExplanationRenderer, explainRegex } from "regex-explain";
+ *
+ * const result = explainRegex("^\\d{3}-\\d{4}$");
+ * console.log(new ExplanationRenderer(result).markdownList());
+ * ```
+ */
+export type { BacktrackingWarning, ExplainOptions, ExplainResult, ExplanationNode, FlagExplanation, LengthSummary, RegexExplanation, RegexExplanationError, RegexSource, } from "./explainer";
+export { describeCount, explainRegex, isRegexSource, parseRegexInput } from "./explainer";
+export { GRAMMARS, SUPPORTED_LANGUAGE_IDS } from "./compiler";
+export type { LocatedRegex } from "./locator";
+export { findRegexAt, RegexFinder } from "./locator";
+export type { FoundMatch, MatchesModel, EntryModel, MatchEntry, MatchGroupModel, MatchModel, MatchRequest, MatchResponse, } from "./matches";
+export { describeMatches, findMatches } from "./matches";
+export { regex101Url } from "./extlinks";
+export type { ErrorModel, ExplanationModel, ExplanationRow, FlagModel, RenderOptions, WarningModel, } from "./render";
+export { ExplanationRenderer } from "./render";
+export type { TextPart } from "./text";