@crewhaus/tool-secure 0.7.0 → 0.8.0

package/dist/lib/injection.js

@@ -28,8 +28,117 @@
  * attacker-controlled text. Show it to a person; do not paste it into a
  * prompt as if it were instructions.
  */
-import { compareStrings, matchAll, withPositions } from "./text";
+import { compareStrings, matchAll, matchAllSkipping, withPositions } from "./text";
 import { scanInvisible } from "./unicode";
+/** A code unit `\s` matches: WhiteSpace or LineTerminator. */
+function isRegExpSpace(c) {
+    return ((c >= 0x09 && c <= 0x0d) ||
+        c === 0x20 ||
+        c === 0xa0 ||
+        c === 0x1680 ||
+        (c >= 0x2000 && c <= 0x200a) ||
+        c === 0x2028 ||
+        c === 0x2029 ||
+        c === 0x202f ||
+        c === 0x205f ||
+        c === 0x3000 ||
+        c === 0xfeff);
+}
+/** Where `^` matches under the `m` flag. */
+function isLineStart(text, at) {
+    if (at === 0)
+        return true;
+    const c = text.charCodeAt(at - 1);
+    return c === 0x0a || c === 0x0d || c === 0x2028 || c === 0x2029;
+}
+const CHAT_MARKUP = /<\/?(?:system|assistant|human|user)>|\[\/?INST\]|<\|im_(?:start|end)\|>|^\s*###\s*(?:instruction|system)/gim;
+/**
+ * CHAT_MARKUP's matches. Its `^\s*###` branch starts at every line and runs
+ * its `\s*` on across blank lines, so a run of blank lines was rescanned from
+ * each line start in it: quadratic in the run's length. The other branches
+ * start at `<` or `[`, which no whitespace is, so a try at a line start that
+ * fails rules out every start up to the end of its whitespace.
+ */
+function chatMarkupMatches(text) {
+    return matchAllSkipping(text, CHAT_MARKUP, (t, at) => {
+        const c = t.charCodeAt(at);
+        return c === 0x3c || c === 0x5b || isLineStart(t, at);
+    }, (t, at) => {
+        if (!isLineStart(t, at))
+            return at + 1;
+        let i = at;
+        while (i < t.length && isRegExpSpace(t.charCodeAt(i)))
+            i++;
+        return i;
+    });
+}
+const PIPE_TO_SHELL = /\b(?:curl|wget)\s+[^\n|]{1,200}\|\s*(?:sudo\s+)?(?:ba|z|d|fi)?sh\b/gi;
+/** What PIPE_TO_SHELL reads after its `|`, tried at one place. */
+const PIPE_TO_SHELL_TAIL = /\s*(?:sudo\s+)?(?:ba|z|d|fi)?sh\b/iy;
+/** A code unit `\w` matches. */
+function isWordUnit(c) {
+    return ((c >= 0x30 && c <= 0x39) || (c >= 0x41 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a) || c === 0x5f);
+}
+/** `word` (lowercase ASCII) at `at`, in either case, as the `i` flag reads it. */
+function asciiWordAt(text, at, word) {
+    for (let i = 0; i < word.length; i++) {
+        const c = text.charCodeAt(at + i);
+        if (c !== word.charCodeAt(i) && c !== word.charCodeAt(i) - 0x20)
+            return false;
+    }
+    return true;
+}
+/**
+ * PIPE_TO_SHELL's matches. Its blanks after `curl` and the up to 200
+ * characters before `|` overlap on blanks, so a try that fails gave the
+ * blanks back one at a time and read up to 200 characters again after each,
+ * and every `curl` in a stretch did it again: hundreds of steps a character
+ * over text of up to 2M characters. A try is made only where it matches:
+ * after `curl` or `wget` and its blanks, the first `|` or `\n` must be a `|`
+ * that some split of the blanks leaves 1 to 200 characters before, with no
+ * `\n` among them, and the shell must follow it. Those ends only move
+ * forward, so each is found once.
+ */
+function pipeToShellMatches(text) {
+    let stop = -1;
+    let tailAt = -1;
+    let tailMatches = false;
+    return matchAllSkipping(text, PIPE_TO_SHELL, (t, at) => {
+        if (!(asciiWordAt(t, at, "curl") || asciiWordAt(t, at, "wget")))
+            return false;
+        if (at > 0 && isWordUnit(t.charCodeAt(at - 1)))
+            return false;
+        const from = at + 4;
+        let blanksEnd = from;
+        let lastBreak = -1;
+        while (blanksEnd < t.length && isRegExpSpace(t.charCodeAt(blanksEnd))) {
+            if (t.charCodeAt(blanksEnd) === 0x0a)
+                lastBreak = blanksEnd;
+            blanksEnd++;
+        }
+        if (blanksEnd === from)
+            return false;
+        if (stop < blanksEnd) {
+            stop = blanksEnd;
+            while (stop < t.length && t.charCodeAt(stop) !== 0x7c && t.charCodeAt(stop) !== 0x0a)
+                stop++;
+        }
+        if (t.charCodeAt(stop) !== 0x7c)
+            return false;
+        // The blanks the `\s+` keeps, `w`: at least one, no `\n` left after
+        // them, and 1 to 200 characters from them to the `|`.
+        const lo = Math.max(1, stop - from - 200, lastBreak - from + 1);
+        const hi = Math.min(blanksEnd - from, stop - from - 1);
+        if (lo > hi)
+            return false;
+        if (tailAt !== stop + 1) {
+            tailAt = stop + 1;
+            PIPE_TO_SHELL_TAIL.lastIndex = tailAt;
+            tailMatches = PIPE_TO_SHELL_TAIL.test(t);
+        }
+        return tailMatches;
+    }, (_, at) => at + 1);
+}
 /** The phrase rules. Also run against decoded base64, once, no recursion. */
 export const INJECTION_RULES = [
     {
@@ -65,7 +174,8 @@ export const INJECTION_RULES = [
         category: "override",
         weight: 30,
         description: "embeds chat-template or role markup, trying to close the current turn",
-        pattern: /<\/?(?:system|assistant|human|user)>|\[\/?INST\]|<\|im_(?:start|end)\|>|^\s*###\s*(?:instruction|system)/gim,
+        pattern: CHAT_MARKUP,
+        matches: chatMarkupMatches,
     },
     {
         id: "role.you-are-now",
@@ -121,7 +231,8 @@ export const INJECTION_RULES = [
         category: "tool-coercion",
         weight: 35,
         description: "a download-and-execute one-liner",
-        pattern: /\b(?:curl|wget)\s+[^\n|]{1,200}\|\s*(?:sudo\s+)?(?:ba|z|d|fi)?sh\b/gi,
+        pattern: PIPE_TO_SHELL,
+        matches: pipeToShellMatches,
     },
     {
         id: "tool.credential-request",
@@ -171,6 +282,65 @@ const HIDDEN_STYLE = /style\s*=\s*["'][^"']{0,200}(?:display\s*:\s*none|visibili
 const MARKDOWN_LINK = /\[([^\]\n]{1,200})\]\(([^)\s]{1,500})\)/g;
 const BASE64_BLOB = /[A-Za-z0-9+/]{40,}={0,2}/g;
 const DOMAIN_IN_TEXT = /\b(?:https?:\/\/)?([a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+)/i;
+/**
+ * HTML_COMMENT's matches. From each `<!--` it reads up to 4,000 characters
+ * for a `-->`, so a text of `<!--` with none read 4,000 characters again
+ * from every one: thousands of steps a character, seconds over 2M. A try is
+ * made only where the first `-->` after the opener lies within reach; that
+ * `-->` only moves forward, so it is searched for once.
+ */
+export function htmlCommentMatches(text) {
+    let close = -2;
+    return matchAllSkipping(text, HTML_COMMENT, (t, at) => {
+        if (!t.startsWith("<!--", at))
+            return false;
+        const from = at + 4;
+        if (close !== -1 && close < from)
+            close = t.indexOf("-->", from);
+        return close !== -1 && close - from <= 4_000;
+    }, (_, at) => at + 1);
+}
+/**
+ * MARKDOWN_LINK's matches. From each `[` it reads up to 200 label and 500
+ * target characters, so a run of `[` read 200 again from every one. A try
+ * is made only where it matches: the label runs from the `[` to the first
+ * `]` or `\n` (1 to 200 characters, ending at `]`), `(` follows, and the
+ * target runs to the first `)` or blank (1 to 500, ending at `)`). Both ends
+ * only move forward, so each is found once.
+ */
+export function markdownLinkMatches(text) {
+    let labelEnd = -1;
+    let targetEnd = -1;
+    return matchAllSkipping(text, MARKDOWN_LINK, (t, at) => {
+        if (t.charCodeAt(at) !== 0x5b)
+            return false;
+        const label = at + 1;
+        if (labelEnd < label) {
+            labelEnd = label;
+            while (labelEnd < t.length &&
+                t.charCodeAt(labelEnd) !== 0x5d &&
+                t.charCodeAt(labelEnd) !== 0x0a) {
+                labelEnd++;
+            }
+        }
+        const labelLength = labelEnd - label;
+        if (labelLength < 1 || labelLength > 200 || t.charCodeAt(labelEnd) !== 0x5d)
+            return false;
+        if (t.charCodeAt(labelEnd + 1) !== 0x28)
+            return false;
+        const target = labelEnd + 2;
+        if (targetEnd < target) {
+            targetEnd = target;
+            while (targetEnd < t.length &&
+                t.charCodeAt(targetEnd) !== 0x29 &&
+                !isRegExpSpace(t.charCodeAt(targetEnd))) {
+                targetEnd++;
+            }
+        }
+        const targetLength = targetEnd - target;
+        return targetLength >= 1 && targetLength <= 500 && t.charCodeAt(targetEnd) === 0x29;
+    }, (_, at) => at + 1);
+}
 /** Decoded blobs are bounded so one base64 wall cannot blow up memory. */
 export const MAX_BASE64_CANDIDATE_CHARS = 100_000;
 /** Decoding happens once. Content inside a decoded blob is never decoded again. */
@@ -220,7 +390,7 @@ export function decodeBase64Text(candidate) {
 function phraseHits(text, source) {
     const raw = [];
     for (const rule of INJECTION_RULES) {
-        for (const { index, match } of matchAll(text, rule.pattern)) {
+        for (const { index, match } of rule.matches?.(text) ?? matchAll(text, rule.pattern)) {
             raw.push({
                 type: rule.category,
                 rule: rule.id,
@@ -295,7 +465,7 @@ export function scanInjection(text) {
         });
     }
     // Concealment: instruction text inside an HTML comment.
-    for (const { index, match } of matchAll(text, HTML_COMMENT)) {
+    for (const { index, match } of htmlCommentMatches(text)) {
         const inner = match[1] ?? "";
         if (phraseHits(inner, "text").length === 0)
             continue;
@@ -321,7 +491,7 @@ export function scanInjection(text) {
         });
     }
     // Concealment: a link whose label names a different host than its target.
-    for (const { index, match } of matchAll(text, MARKDOWN_LINK)) {
+    for (const { index, match } of markdownLinkMatches(text)) {
         const label = match[1] ?? "";
         const href = match[2] ?? "";
         const labelDomain = DOMAIN_IN_TEXT.exec(label)?.[1]?.toLowerCase();

package/dist/lib/ipv6-scan.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The matches of the IPv6 candidate pattern
+ * `/\b(?=[0-9A-Fa-f:]*::|(?:[0-9A-Fa-f]{1,4}:){7})[0-9A-Fa-f:]{2,39}(?:\.\d{1,3}){0,3}/g`,
+ * in order, start for start.
+ *
+ * The lookahead's `[0-9A-Fa-f:]*::` read on to the end of a run of hex
+ * digits and colons from every word boundary in it, and a run like
+ * `a:a:a:…` has one every second character and matches every 39: quadratic
+ * in the run, minutes over the 2M characters `PiiScan` accepts. Here the run
+ * is read once: a start sees `::` ahead exactly when the run's last `::`
+ * begins at or after it.
+ */
+export declare function ipv6Candidates(text: string): Array<{
+    index: number;
+    value: string;
+}>;

package/dist/lib/ipv6-scan.js

@@ -0,0 +1,73 @@
+const isHexDigit = (c) => (c >= 0x30 && c <= 0x39) || (c >= 0x41 && c <= 0x46) || (c >= 0x61 && c <= 0x66);
+const isHexOrColon = (c) => isHexDigit(c) || c === 0x3a;
+const isDigit = (c) => c >= 0x30 && c <= 0x39;
+/** A code unit `\w` matches, which is what `\b` looks at. */
+const isWordUnit = (c) => isDigit(c) || (c >= 0x41 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a) || c === 0x5f;
+/** `(?:[0-9A-Fa-f]{1,4}:){7}` at `at`. */
+function sevenGroups(text, at) {
+    let p = at;
+    for (let g = 0; g < 7; g++) {
+        let d = p;
+        while (d < p + 4 && isHexDigit(text.charCodeAt(d)))
+            d++;
+        if (d === p || text.charCodeAt(d) !== 0x3a)
+            return false;
+        p = d + 1;
+    }
+    return true;
+}
+/**
+ * The matches of the IPv6 candidate pattern
+ * `/\b(?=[0-9A-Fa-f:]*::|(?:[0-9A-Fa-f]{1,4}:){7})[0-9A-Fa-f:]{2,39}(?:\.\d{1,3}){0,3}/g`,
+ * in order, start for start.
+ *
+ * The lookahead's `[0-9A-Fa-f:]*::` read on to the end of a run of hex
+ * digits and colons from every word boundary in it, and a run like
+ * `a:a:a:…` has one every second character and matches every 39: quadratic
+ * in the run, minutes over the 2M characters `PiiScan` accepts. Here the run
+ * is read once: a start sees `::` ahead exactly when the run's last `::`
+ * begins at or after it.
+ */
+export function ipv6Candidates(text) {
+    const out = [];
+    // The run of hex digits and colons the current start is in, and where its
+    // last `::` begins (-1 for none).
+    let runEnd = -1;
+    let lastPair = -1;
+    let at = 0;
+    while (at < text.length) {
+        if (!isHexOrColon(text.charCodeAt(at))) {
+            at++;
+            continue;
+        }
+        if (at >= runEnd) {
+            runEnd = at;
+            lastPair = -1;
+            while (runEnd < text.length && isHexOrColon(text.charCodeAt(runEnd))) {
+                if (runEnd > at &&
+                    text.charCodeAt(runEnd) === 0x3a &&
+                    text.charCodeAt(runEnd - 1) === 0x3a) {
+                    lastPair = runEnd - 1;
+                }
+                runEnd++;
+            }
+        }
+        const boundary = (at > 0 && isWordUnit(text.charCodeAt(at - 1))) !== isWordUnit(text.charCodeAt(at));
+        if (boundary && runEnd - at >= 2 && (lastPair >= at || sevenGroups(text, at))) {
+            let end = at + Math.min(39, runEnd - at);
+            for (let g = 0; g < 3; g++) {
+                if (text.charCodeAt(end) !== 0x2e || !isDigit(text.charCodeAt(end + 1)))
+                    break;
+                let d = end + 1;
+                while (d < end + 4 && isDigit(text.charCodeAt(d)))
+                    d++;
+                end = d;
+            }
+            out.push({ index: at, value: text.slice(at, end) });
+            at = end;
+            continue;
+        }
+        at++;
+    }
+    return out;
+}

package/dist/lib/literal.d.ts

@@ -0,0 +1,55 @@
+/**
+ * A literal phrase, found in linear time, exactly where
+ * `new RegExp(escaped, "g")` or `"gi"` finds it.
+ *
+ * ContentPolicyCheck's `*_phrase` rules ran as an escaped regex on the
+ * caller's thread. Case-sensitive, JavaScriptCore finds a literal quickly;
+ * case-insensitive (the default) it tries the whole phrase at every position,
+ * so the scan costs the text's length times the phrase's. Neither is capped:
+ * four rules of `a`×50 000 then `b` over 2 000 000 `a`s held the process for
+ * 16.6 s without one event-loop turn (C073's residual, bounds review).
+ *
+ * Here the text and the phrase are folded to one code unit per character the
+ * way the regex `i` flag compares them, and searched with Knuth-Morris-Pratt:
+ * each text position is passed once, whatever the phrase. Matches are what a
+ * global regex reports: leftmost, not overlapping, at UTF-16 code-unit
+ * offsets.
+ */
+/** Where one match starts, and the text it covers (the text's own spelling). */
+export type LiteralMatch = {
+    readonly index: number;
+    readonly match: string;
+};
+/** Every match counted, the first few located. */
+export type LiteralFound = {
+    readonly matches: ReadonlyArray<LiteralMatch>;
+    readonly count: number;
+};
+/**
+ * The code unit the regex `i` flag (without `u`) compares `c` as: the
+ * ECMAScript Canonicalize — its upper case when that is one code unit, and not
+ * ASCII for a non-ASCII `c` — as this engine's own tables have it. The
+ * engine's case tables can be older than `toUpperCase`'s (Bun 1.3's upper-cases
+ * U+019B to U+A7DC, which its regex does not match), so a pairing the regex
+ * does not make is not made here either.
+ */
+export declare function canonicalUnit(c: number): number;
+/**
+ * Searches one text for many phrases. The case-folded text is prepared once,
+ * on first need, and shared by every case-insensitive phrase.
+ */
+export declare class LiteralSearch {
+    #private;
+    private readonly text;
+    constructor(text: string);
+    /**
+     * Every match of `phrase`, counted in full, with the first `keep` located.
+     * An empty phrase matches at every position, as an empty regex does.
+     *
+     * Knuth-Morris-Pratt, except that from a standing start it jumps to the
+     * next place the phrase's first two code units occur: no match can start
+     * anywhere else, and a two-unit search passes each position once, so the
+     * whole search still does. On prose that jump is most of the text.
+     */
+    find(phrase: string, caseSensitive: boolean, keep: number): LiteralFound;
+}

package/dist/lib/literal.js

@@ -0,0 +1,146 @@
+/**
+ * A literal phrase, found in linear time, exactly where
+ * `new RegExp(escaped, "g")` or `"gi"` finds it.
+ *
+ * ContentPolicyCheck's `*_phrase` rules ran as an escaped regex on the
+ * caller's thread. Case-sensitive, JavaScriptCore finds a literal quickly;
+ * case-insensitive (the default) it tries the whole phrase at every position,
+ * so the scan costs the text's length times the phrase's. Neither is capped:
+ * four rules of `a`×50 000 then `b` over 2 000 000 `a`s held the process for
+ * 16.6 s without one event-loop turn (C073's residual, bounds review).
+ *
+ * Here the text and the phrase are folded to one code unit per character the
+ * way the regex `i` flag compares them, and searched with Knuth-Morris-Pratt:
+ * each text position is passed once, whatever the phrase. Matches are what a
+ * global regex reports: leftmost, not overlapping, at UTF-16 code-unit
+ * offsets.
+ */
+/** Canonical code unit per code unit, filled on first use; -1 is "not yet". */
+const CANONICAL = new Int32Array(0x10000).fill(-1);
+/**
+ * The code unit the regex `i` flag (without `u`) compares `c` as: the
+ * ECMAScript Canonicalize — its upper case when that is one code unit, and not
+ * ASCII for a non-ASCII `c` — as this engine's own tables have it. The
+ * engine's case tables can be older than `toUpperCase`'s (Bun 1.3's upper-cases
+ * U+019B to U+A7DC, which its regex does not match), so a pairing the regex
+ * does not make is not made here either.
+ */
+export function canonicalUnit(c) {
+    const known = CANONICAL[c];
+    if (known !== -1)
+        return known;
+    let out = c;
+    if (c < 0x80) {
+        if (c >= 0x61 && c <= 0x7a)
+            out = c - 0x20;
+    }
+    else {
+        const upper = String.fromCharCode(c).toUpperCase();
+        if (upper.length === 1) {
+            const u = upper.charCodeAt(0);
+            if (u >= 0x80 && u !== c && regexFolds(c, u))
+                out = u;
+        }
+    }
+    CANONICAL[c] = out;
+    return out;
+}
+function regexFolds(a, b) {
+    return new RegExp(`^\\u${a.toString(16).padStart(4, "0")}$`, "i").test(String.fromCharCode(b));
+}
+/** `text`'s code units, each folded as the regex `i` flag compares it. */
+function foldUnits(text) {
+    const out = new Uint16Array(text.length);
+    for (let i = 0; i < text.length; i++)
+        out[i] = canonicalUnit(text.charCodeAt(i));
+    return out;
+}
+function rawUnits(text) {
+    const out = new Uint16Array(text.length);
+    for (let i = 0; i < text.length; i++)
+        out[i] = text.charCodeAt(i);
+    return out;
+}
+/** KMP's failure function: for each prefix, its longest proper border. */
+function borders(p) {
+    const f = new Int32Array(p.length);
+    let k = 0;
+    for (let i = 1; i < p.length; i++) {
+        while (k > 0 && p[i] !== p[k])
+            k = f[k - 1];
+        if (p[i] === p[k])
+            k += 1;
+        f[i] = k;
+    }
+    return f;
+}
+/**
+ * Searches one text for many phrases. The case-folded text is prepared once,
+ * on first need, and shared by every case-insensitive phrase.
+ */
+export class LiteralSearch {
+    text;
+    #folded;
+    constructor(text) {
+        this.text = text;
+    }
+    #hay(caseSensitive) {
+        if (caseSensitive)
+            return this.text;
+        if (this.#folded === undefined) {
+            this.#folded = Buffer.from(foldUnits(this.text).buffer).toString("utf16le");
+        }
+        return this.#folded;
+    }
+    /**
+     * Every match of `phrase`, counted in full, with the first `keep` located.
+     * An empty phrase matches at every position, as an empty regex does.
+     *
+     * Knuth-Morris-Pratt, except that from a standing start it jumps to the
+     * next place the phrase's first two code units occur: no match can start
+     * anywhere else, and a two-unit search passes each position once, so the
+     * whole search still does. On prose that jump is most of the text.
+     */
+    find(phrase, caseSensitive, keep) {
+        const text = this.text;
+        const length = phrase.length;
+        const matches = [];
+        if (length === 0) {
+            for (let i = 0; i <= text.length && matches.length < keep; i++) {
+                matches.push({ index: i, match: "" });
+            }
+            return { matches, count: text.length + 1 };
+        }
+        if (length > text.length)
+            return { matches, count: 0 };
+        const hay = this.#hay(caseSensitive);
+        const p = caseSensitive ? rawUnits(phrase) : foldUnits(phrase);
+        const head = String.fromCharCode(...p.subarray(0, 2));
+        const f = borders(p);
+        let k = 0;
+        let count = 0;
+        for (let i = 0; i < hay.length; i++) {
+            if (k === 0) {
+                const next = hay.indexOf(head, i);
+                if (next === -1)
+                    break;
+                i = next;
+            }
+            const ch = hay.charCodeAt(i);
+            while (k > 0 && ch !== p[k])
+                k = f[k - 1];
+            if (ch === p[k])
+                k += 1;
+            if (k === length) {
+                count += 1;
+                if (matches.length < keep) {
+                    const at = i + 1 - length;
+                    matches.push({ index: at, match: text.slice(at, i + 1) });
+                }
+                // Not overlapping: the next match starts after this one ends.
+                k = 0;
+            }
+        }
+        return { matches, count };
+    }
+}

package/dist/lib/pii.d.ts

@@ -1,33 +1,3 @@
-/**
- * Personal-data detectors.
- *
- * ## Read this before you trust a result
- *
- * Every rule here is a pattern over bytes. A pattern can prove that a string
- * has the SHAPE of an identifier, and for two formats it can prove a check
- * digit is consistent. It can never prove that a string IS somebody's
- * personal data, and — far more dangerous — an empty result can never prove
- * a document has none. A name, a free-text medical detail, an employee
- * number with a local format, an address that does not end in "Street": all
- * invisible here.
- *
- * So `PiiScan` reports what it LOOKED for, not what a document contains, and
- * nothing downstream should read "0 findings" as "safe to publish".
- *
- * ## The rules, and exactly what each one proves
- *
- * | rule | proves |
- * |---|---|
- * | `email.addr-spec-subset` | dot-atom local part, dotted domain, TLD of 2+ letters. Not quoted local parts, not IP-literal domains, not internationalized addresses. |
- * | `phone.e164` | `+` then 8–15 digits with common separators, taken as the longest whole-group run within that range. Where the next number is grouped the same way the two cannot be told apart, and the span runs long; `dedupeOverlaps` lets a verified card win that overlap. |
- * | `phone.national.XX` | a national dialling shape for one of the seven supported countries. |
- * | `ssn.us-format` | `NNN-NN-NNNN` with a group the SSA has never issued (000/666/900+ area, 00 group, 0000 serial) excluded. NOT validity: there is no public checksum for an SSN, and this package does not pretend otherwise. |
- * | `iban.iso7064-mod97` | the ISO 7064 mod-97-10 check digits are correct, and where the country is known, the length matches. A real check, verifiable offline. |
- * | `card.luhn` | the Luhn check digit is correct over 12–19 digits taken as whole digit groups. A real check. It does not mean the card exists or is live. |
- * | `ip.v4-dotted` / `ip.v6-parsed` | a parseable address literal. Private, loopback and documentation ranges are labelled, because those are usually not personal data. |
- * | `dob.labelled` / `date.calendar` | a calendar date. Only a nearby "date of birth"-style label, or a caller-supplied `referenceDate` that makes the age plausible, raises it above `possible`. |
- * | `address.us-street-suffix` / `address.us-city-state-zip` | a US-style street line or city/state/ZIP tail. US conventions only. |
- */
 import { type Finding } from "./text";
 export declare const PII_TYPES: readonly ["credit_card", "date_of_birth", "email", "iban", "ip_address", "phone", "postal_address", "us_ssn"];
 export type PiiType = (typeof PII_TYPES)[number];
@@ -70,6 +40,25 @@ export declare function parseIpv4(value: string): number[] | undefined;
  * guessing which is a good way to be confidently wrong.
  */
 export declare function parseIpv6(value: string): number[] | undefined;
+export declare const EMAIL: RegExp;
+/**
+ * EMAIL's matches. It opens with an unbounded local-part run, so it is tried
+ * only where one starts, and a failed try skips the rest of that run (see
+ * matchAllSkipping): 100K of base64 cost seconds as a global search.
+ */
+export declare function emailMatches(text: string): Iterable<{
+    index: number;
+    match: RegExpExecArray;
+}>;
+/**
+ * ADDRESS_CITY_STATE_ZIP's matches, tried where a capitalised word starts; a
+ * failed try skips the rest of its `[A-Za-z.'-]` run.
+ */
+export declare function cityStateZipMatches(text: string): Iterable<{
+    index: number;
+    match: RegExpExecArray;
+}>;
+export declare const ADDRESS_CITY_STATE_ZIP: RegExp;
 /**
  * Days since 1970-01-01 for a valid proleptic Gregorian Y-M-D, or undefined.
  *