disarm 0.15.0 → 0.17.0

package/index.js

@@ -38,6 +38,7 @@ exports.transliterate = transliterate;
 exports.reverseTransliterate = reverseTransliterate;
 exports.findUntranslatable = findUntranslatable;
 exports.normalizeConfusables = normalizeConfusables;
+exports.isCanonical = isCanonical;
 exports.isConfusable = isConfusable;
 exports.unmappedConfusables = unmappedConfusables;
 exports.findUnmappedConfusables = findUnmappedConfusables;
@@ -47,6 +48,7 @@ exports.foldCase = foldCase;
 exports.isCaseFoldStable = isCaseFoldStable;
 exports.findKeyCollisions = findKeyCollisions;
 exports.demojize = demojize;
+exports.replaceEmoji = replaceEmoji;
 exports.normalize = normalize;
 exports.isNormalized = isNormalized;
 exports.collapseWhitespace = collapseWhitespace;
@@ -69,6 +71,9 @@ exports.sanitizeFilename = sanitizeFilename;
 exports.searchKey = searchKey;
 exports.sortKey = sortKey;
 exports.catalogKey = catalogKey;
+exports.skeletonKey = skeletonKey;
+exports.editDistance = editDistance;
+exports.nearestMatch = nearestMatch;
 exports.mlNormalize = mlNormalize;
 exports.graphemeLen = graphemeLen;
 exports.graphemeSplit = graphemeSplit;
@@ -84,6 +89,7 @@ exports.hasBidiConflict = hasBidiConflict;
 exports.inspectAutoLang = inspectAutoLang;
 exports.langInfo = langInfo;
 exports.scriptInfo = scriptInfo;
+exports.confusableCoverage = confusableCoverage;
 exports.unicodeVersion = unicodeVersion;
 exports.keySchemaVersion = keySchemaVersion;
 exports.confusablesVersion = confusablesVersion;
@@ -102,8 +108,40 @@ exports.inspectAnomalies = inspectAnomalies;
  */
 const native = __importStar(require("./binding"));
 const binding_1 = require("./binding");
-Object.defineProperty(exports, "Lexicon", { enumerable: true, get: function () { return binding_1.Lexicon; } });
 Object.defineProperty(exports, "Pipeline", { enumerable: true, get: function () { return binding_1.Pipeline; } });
+/**
+ * A reusable, opaque lexicon handle (HAI-SDLC 6.1). `hasAnomalies` /
+ * `inspectAnomalies` rebuild an internal set from the caller's word array on
+ * every call; constructing a `Lexicon` once (`new Lexicon([...])`) and passing
+ * it instead builds that set a single time and reuses it across calls.
+ *
+ * A thin subclass of the native handle, so a bad argument to the constructor throws a
+ * {@link DisarmError} like every other entry point (`formal/bindings`, N2).
+ */
+class Lexicon extends binding_1.Lexicon {
+    constructor(words) {
+        try {
+            super(words);
+        }
+        catch (e) {
+            throw translate(e);
+        }
+    }
+}
+exports.Lexicon = Lexicon;
+// The handle's methods are native; route them through `call()` as every function is, so a
+// wrong argument or a refused digit policy throws a `DisarmError` rather than a bare
+// `Error` whose message still carries the shim's tag (`formal/bindings`, N2). Patched on
+// the prototype, so `getPipeline`'s native instances and `instanceof Pipeline` are
+// unchanged.
+const nativeProcess = binding_1.Pipeline.prototype.process;
+const nativeWithDigitPolicy = binding_1.Pipeline.prototype.withDigitPolicy;
+binding_1.Pipeline.prototype.process = function process(text) {
+    return call(() => nativeProcess.call(this, text));
+};
+binding_1.Pipeline.prototype.withDigitPolicy = function withDigitPolicy(digitPolicy) {
+    return call(() => nativeWithDigitPolicy.call(this, digitPolicy));
+};
 // ── Errors ──────────────────────────────────────────────────────────────────
 /** Base class for every error disarm raises, so callers can `catch (e) { if (e instanceof DisarmError) … }`. */
 class DisarmError extends Error {
@@ -123,33 +161,83 @@ class DisarmInvalidArgument extends DisarmError {
 exports.DisarmInvalidArgument = DisarmInvalidArgument;
 const INVALID_ARG_TAG = 'DisarmInvalidArgument: ';
 const ERROR_TAG = 'DisarmError: ';
+/**
+ * The napi statuses an argument conversion fails with: a value of the wrong JS type
+ * (`transliterate(123)`, `stripAccents(undefined)`). They are invalid arguments, as a
+ * `TypeError` is in the Ruby binding.
+ */
+const NAPI_ARGUMENT_STATUSES = new Set([
+    'InvalidArg',
+    'ObjectExpected',
+    'StringExpected',
+    'NameExpected',
+    'FunctionExpected',
+    'NumberExpected',
+    'BooleanExpected',
+    'ArrayExpected',
+    'BigintExpected',
+]);
 /**
  * Run a native call, re-raising its tagged napi error as the matching
  * `DisarmError` subclass. The native shim prefixes fallible messages with
  * `"DisarmInvalidArgument: "` or `"DisarmError: "`; we strip the matched tag
- * cleanly. Any other throw — an untagged `Error`, or a non-`Error` value — is
- * still wrapped as a `DisarmError` so nothing leaks out unwrapped.
+ * cleanly. An argument napi could not convert is a `DisarmInvalidArgument`. Any
+ * other throw — an untagged `Error`, or a non-`Error` value — is still wrapped as a
+ * `DisarmError` so nothing leaks out unwrapped.
+ *
+ * Every export goes through here, the infallible ones included: they throw on an
+ * argument of the wrong type, and "everything disarm throws is a `DisarmError`" was
+ * false for them while they called the native function directly (`formal/bindings`,
+ * N2).
  */
 function call(fn) {
     try {
         return fn();
     }
     catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        if (msg.startsWith(INVALID_ARG_TAG)) {
-            throw new DisarmInvalidArgument(msg.slice(INVALID_ARG_TAG.length));
-        }
-        if (msg.startsWith(ERROR_TAG)) {
-            throw new DisarmError(msg.slice(ERROR_TAG.length));
-        }
-        throw new DisarmError(msg);
+        throw translate(e);
+    }
+}
+/** The {@link DisarmError} a thrown value becomes; see {@link call}. */
+function translate(e) {
+    if (e instanceof DisarmError) {
+        return e;
     }
+    const msg = e instanceof Error ? e.message : String(e);
+    if (msg.startsWith(INVALID_ARG_TAG)) {
+        return new DisarmInvalidArgument(msg.slice(INVALID_ARG_TAG.length));
+    }
+    if (msg.startsWith(ERROR_TAG)) {
+        return new DisarmError(msg.slice(ERROR_TAG.length));
+    }
+    const code = e?.code;
+    if (typeof code === 'string' && NAPI_ARGUMENT_STATUSES.has(code)) {
+        return new DisarmInvalidArgument(msg);
+    }
+    return new DisarmError(msg);
+}
+/**
+ * Check a size or threshold option before it reaches napi, which converts any JS
+ * number to an integer: `NaN` and `0.9` became 0, `2 ** 64` saturated, so
+ * `stripZalgo('caf\u00e9', { maxMarks: NaN })` stripped the accent (`formal/bindings`, N1).
+ * A size is a non-negative safe integer; anything else throws
+ * {@link DisarmInvalidArgument}.
+ */
+function size(name, value) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
+        throw new DisarmInvalidArgument(`${name} must be a non-negative integer (got ${String(value)})`);
+    }
+    return value;
+}
+/** {@link size} for an optional option: `undefined` or `null` stays absent. */
+function optionalSize(name, value) {
+    return value == null ? undefined : size(name, value);
 }
-/** Romanize Unicode text to ASCII. */
+/** Romanize Unicode text to ASCII. An unknown `lang` throws {@link DisarmInvalidArgument}. */
 function transliterate(text, options = {}) {
     const { scheme = 'default', lang } = options;
     if (scheme === 'default' && lang == null) {
-        return native.transliterate(text);
+        return call(() => native.transliterate(text));
     }
     return call(() => native.transliterateOpts(text, scheme, lang ?? undefined));
 }
@@ -157,7 +245,10 @@ function transliterate(text, options = {}) {
 function reverseTransliterate(text, options) {
     return call(() => native.reverseTransliterate(text, options.lang));
 }
-/** Every character in `text` with no romanization, as `{ char, offset }` (byte offset), in order. */
+/**
+ * Every character in `text` with no romanization, as `{ char, offset }` (byte offset), in
+ * order. An unknown `lang` throws {@link DisarmInvalidArgument}.
+ */
 function findUntranslatable(text, options = {}) {
     const { scheme = 'default', lang } = options;
     return call(() => native.findUntranslatable(text, scheme, lang ?? undefined));
@@ -167,6 +258,20 @@ function findUntranslatable(text, options = {}) {
 function normalizeConfusables(text, options = {}) {
     return call(() => native.normalizeConfusables(text, options.target ?? 'latin', options.digitPolicy ?? 'numeric'));
 }
+/**
+ * Whether `text` is already its own canonical form under `preset` (#730).
+ *
+ * The verification-path counterpart to the presets: text in, normalized text out is the
+ * generation path, and this is the question a caller asks about bytes that arrive already
+ * bound. `hasAnomalies` is not this predicate — 142,760 assigned code points are reported
+ * clean by the detector and are not their own canonical form.
+ *
+ * `preset` is any name in the preset registry or any profile, defaulting to
+ * `'canonicalize'`. An unknown one throws {@link DisarmInvalidArgument}.
+ */
+function isCanonical(text, options = {}) {
+    return call(() => native.isCanonical(text, options.preset ?? 'canonicalize'));
+}
 /** Whether `text` contains a character confusable with `target` (default `'latin'`). */
 function isConfusable(text, options = {}) {
     return call(() => native.isConfusable(text, options.target ?? 'latin'));
@@ -190,12 +295,15 @@ function unmappedConfusables(options = {}) {
 function findUnmappedConfusables(text, options = {}) {
     return call(() => native.findUnmappedConfusables(text, options.target ?? 'latin'));
 }
-/** Generate a URL-safe slug. Mirrors the core's `SlugConfig` defaults. */
+/**
+ * Generate a URL-safe slug. Mirrors the core's `SlugConfig` defaults. An unknown `lang`
+ * throws {@link DisarmInvalidArgument}.
+ */
 function slugify(text, options = {}) {
     return call(() => native.slugify(text, {
         separator: options.separator ?? '-',
         lowercase: options.lowercase ?? true,
-        maxLength: options.maxLength ?? 0,
+        maxLength: optionalSize('maxLength', options.maxLength) ?? 0,
         wordBoundary: options.wordBoundary ?? false,
         saveOrder: options.saveOrder ?? false,
         stopwords: options.stopwords ?? [],
@@ -210,11 +318,11 @@ function slugify(text, options = {}) {
 // ── Canonicalization primitives ─────────────────────────────────────────────
 /** Strip diacritics (`"café"` → `"cafe"`). */
 function stripAccents(text) {
-    return native.stripAccents(text);
+    return call(() => native.stripAccents(text));
 }
 /** Full Unicode case fold — more aggressive than `String.toLowerCase()`. */
 function foldCase(text) {
-    return native.foldCase(text);
+    return call(() => native.foldCase(text));
 }
 /**
  * Whether `text` is a stable identity key under case folding — that is, whether
@@ -227,7 +335,7 @@ function foldCase(text) {
  * folded into {@link hasAnomalies}.
  */
 function isCaseFoldStable(text) {
-    return native.isCaseFoldStable(text);
+    return call(() => native.isCaseFoldStable(text));
 }
 /**
  * Which of `values` are the same name under `key` (#620).
@@ -248,9 +356,30 @@ function isCaseFoldStable(text) {
 function findKeyCollisions(values, key, options = {}) {
     return call(() => native.findKeyCollisions(values, key, options.lang));
 }
-/** Replace emoji with their plain names. `stripModifiers` drops skin-tone/variation marks. */
+/**
+ * Replace emoji with their plain names. `stripModifiers` drops skin-tone/variation marks.
+ * An emoji CLDR cannot name — a regional indicator or a Plane 14 tag character standing
+ * alone — becomes `'[?]'`, the sentinel {@link transliterate} writes, and the default in
+ * every binding.
+ */
 function demojize(text, options = {}) {
-    return native.demojize(text, options.stripModifiers ?? false);
+    return call(() => native.demojize(text, options.stripModifiers ?? false));
+}
+/** Replace every emoji with `replacement`, verbatim (#972).
+ *
+ * The counterpart to {@link demojize}, and a different question of a different table.
+ * `demojize` asks *what does CLDR call this?*, so its domain is the CLDR name table,
+ * which is wider than the emoji: `demojize('x™y')` is `'x trade mark y'`. This asks *is
+ * this an emoji by the UCD's properties?* — `Emoji_Presentation=Yes`, an `Emoji=Yes`
+ * base carrying `U+FE0F` (not an `Extended_Pictographic` one, so `★` + `U+FE0F` stays),
+ * and the ZWJ, modifier, keycap and flag sequences on those. Nothing
+ * else moves.
+ *
+ * `replacement` is inserted exactly as given, with no padding and no whitespace collapse:
+ * `''` closes an intra-word split (`aa🔥bb` → `aabb`) and `' '` keeps two words apart
+ * (`stop🛑now` → `stop now`), and no rule serves both. */
+function replaceEmoji(text, replacement = '') {
+    return call(() => native.replaceEmoji(text, replacement));
 }
 // ── Normalization ───────────────────────────────────────────────────────────
 /** Apply a Unicode normalization `form` (default `'NFC'`). */
@@ -273,43 +402,52 @@ function isNormalized(text, options = {}) {
  * deleting them) means `a\rb` → `a b`, never `ab`.
  */
 function collapseWhitespace(text) {
-    return native.collapseWhitespace(text);
+    return call(() => native.collapseWhitespace(text));
 }
 /** Remove C0/C1 control characters (except tab/newline). */
 function stripControlChars(text) {
-    return native.stripControlChars(text);
+    return call(() => native.stripControlChars(text));
 }
 /** Remove zero-width characters (ZWSP/ZWNJ/ZWJ/word-joiner). */
 function stripZeroWidthChars(text) {
-    return native.stripZeroWidthChars(text);
+    return call(() => native.stripZeroWidthChars(text));
 }
 /** Remove Unicode bidirectional control characters. */
 function stripBidi(text) {
-    return native.stripBidi(text);
+    return call(() => native.stripBidi(text));
 }
 /** Strip the Unicode Tags block (U+E0000–U+E007F), preserving valid emoji flag sequences (#413). */
 function stripTags(text) {
-    return native.stripTags(text);
+    return call(() => native.stripTags(text));
 }
 /** Strip every variation selector (VS1–VS256) (#413). */
 function stripVariationSelectors(text) {
-    return native.stripVariationSelectors(text);
+    return call(() => native.stripVariationSelectors(text));
 }
 /** Strip every Unicode noncharacter (#413). */
 function stripNoncharacters(text) {
-    return native.stripNoncharacters(text);
+    return call(() => native.stripNoncharacters(text));
 }
 /** Strip every Private Use Area code point (#413). */
 function stripPua(text) {
-    return native.stripPua(text);
+    return call(() => native.stripPua(text));
 }
-/** Cap combining marks per base character at `maxMarks` (default `2`). */
+/**
+ * Cap the marks of each combining class on one base character at `maxMarks`, a
+ * non-negative integer. The default is the core's, 3 — equal to {@link isZalgo}'s
+ * threshold (#788), so this never strips from text `isZalgo` declines to flag. It is read
+ * from the core rather than restated here: this layer had kept the old cap of 2
+ * (`formal/bindings`, B1).
+ */
 function stripZalgo(text, options = {}) {
-    return call(() => native.stripZalgo(text, options.maxMarks ?? 2));
+    return call(() => native.stripZalgo(text, optionalSize('maxMarks', options.maxMarks)));
 }
-/** Whether any base character carries more than `threshold` (default `3`) combining marks. */
+/**
+ * Whether any base character carries more than `threshold` marks of one combining class.
+ * The default is the core's, 3.
+ */
 function isZalgo(text, options = {}) {
-    return call(() => native.isZalgo(text, options.threshold ?? 3));
+    return call(() => native.isZalgo(text, optionalSize('threshold', options.threshold)));
 }
 // ── Deobfuscation & security presets ────────────────────────────────────────
 /**
@@ -317,8 +455,8 @@ function isZalgo(text, options = {}) {
  * the half of the pair that lets a caller reject input instead of comparing a value the
  * sender never wrote.
  */
-function canonicalizeStrict(text) {
-    return call(() => native.canonicalizeStrict(text));
+function canonicalizeStrict(text, options = {}) {
+    return call(() => native.canonicalizeStrict(text, options.digitPolicy ?? 'numeric'));
 }
 /**
  * Strip the non-interchange and invisible classes while KEEPING the script.
@@ -330,23 +468,24 @@ function canonicalizeStrict(text) {
  * it collapses TAB/LF to a space, which the primitives leave alone. Infallible.
  */
 function stripFormat(text) {
-    return native.stripFormat(text);
+    return call(() => native.stripFormat(text));
 }
 /** Remove obfuscation (zero-width, bidi, combining-mark abuse, homoglyphs) while keeping legible content. */
-function stripObfuscation(text) {
-    return call(() => native.stripObfuscation(text));
+function stripObfuscation(text, options = {}) {
+    return call(() => native.stripObfuscation(text, options.digitPolicy ?? 'numeric'));
 }
 /**
- * Canonicalize text for security-sensitive comparison: NFKC → strip bidi/format
- * → strip invisible classes (#413) → strip control → strip zero-width → collapse
- * whitespace → cap combining marks (anti-zalgo) → NFC → confusables → NFC
- * (confusables sandwiched between NFC passes for idempotency).
+ * Canonicalize text for security-sensitive comparison: resolve deletions → NFKC →
+ * strip bidi/format → strip invisible classes (#413) → strip control → strip
+ * zero-width → collapse whitespace → drop repeated marks → cap combining marks
+ * (anti-zalgo) → NFC → confusables and NFC to a fixed point → drop repeated marks
+ * → cap combining marks again (the fold is iterated with NFC for idempotency).
  *
  * The name describes the mechanism (Unicode canonicalization for matching), not
  * a safety guarantee — this is not an output sanitizer; encode at the sink.
  */
-function canonicalize(text) {
-    return call(() => native.canonicalize(text));
+function canonicalize(text, options = {}) {
+    return call(() => native.canonicalize(text, options.digitPolicy ?? 'numeric'));
 }
 /**
  * @deprecated Renamed to {@link canonicalize} in 0.11 (the `*Clean` name
@@ -367,9 +506,15 @@ function securityClean(text) {
 function getPipeline(profile) {
     return call(() => native.getPipeline(profile));
 }
-/** Turn arbitrary text into a filesystem-safe filename. */
+/**
+ * Turn arbitrary text into a filesystem-safe filename.
+ *
+ * `separator` must be printable, non-space ASCII with no character illegal on
+ * `platform` and no path separator (`/`, `\`); anything else throws
+ * {@link DisarmInvalidArgument}. `''` is allowed.
+ */
 function sanitizeFilename(text, options = {}) {
-    return call(() => native.sanitizeFilename(text, options.separator ?? '_', options.maxLength ?? 255, options.platform ?? 'universal', options.lang ?? undefined, options.preserveExtension ?? true));
+    return call(() => native.sanitizeFilename(text, options.separator ?? '_', optionalSize('maxLength', options.maxLength) ?? 255, options.platform ?? 'universal', options.lang ?? undefined, options.preserveExtension ?? true));
 }
 // ── Key-derivation presets ──────────────────────────────────────────────────
 /**
@@ -377,14 +522,14 @@ function sanitizeFilename(text, options = {}) {
  * without confusable folding). `lang` selects the transliteration table.
  */
 function searchKey(text, options = {}) {
-    return call(() => native.searchKey(text, options.lang ?? undefined));
+    return call(() => native.searchKey(text, options.lang ?? undefined, options.digitPolicy ?? 'numeric'));
 }
 /**
  * Collation sort key — like {@link searchKey} but preserves base accented
  * characters for correct ordering. `lang` selects the transliteration table.
  */
 function sortKey(text, options = {}) {
-    return call(() => native.sortKey(text, options.lang ?? undefined));
+    return call(() => native.sortKey(text, options.lang ?? undefined, options.digitPolicy ?? 'numeric'));
 }
 /**
  * Library catalog deduplication key — like {@link searchKey} plus confusable
@@ -392,11 +537,39 @@ function sortKey(text, options = {}) {
  * `false`) picks the ISO 9:1995 Cyrillic scheme.
  */
 function catalogKey(text, options = {}) {
-    return call(() => native.catalogKey(text, options.lang ?? undefined, options.strictIso9 ?? false));
+    return call(() => native.catalogKey(text, options.lang ?? undefined, options.strictIso9 ?? false, options.digitPolicy ?? 'numeric'));
+}
+/**
+ * The TR39 identifier skeleton plus the two prototype classes disarm's table keeps
+ * apart (#650). A spoof key: its only job is to make confusable identifiers collide,
+ * and its output is never for display. `digitPolicy` `'numeric'` (default) applies the
+ * letter half only; `'tr39'` adds `1 ≡ l` and `0 ≡ O`; `'preserve'` keeps a non-Latin
+ * numeral in its script.
+ */
+function skeletonKey(text, options = {}) {
+    return call(() => native.skeletonKey(text, options.digitPolicy ?? 'numeric'));
+}
+/**
+ * Levenshtein edit distance between `a` and `b`, in characters (#894) — the one class of
+ * registry spoofing the confusable tables deliberately do not model (`paypa1`, `adm1n`).
+ * Canonicalize both sides first when composed and decomposed spellings should compare
+ * equal.
+ */
+function editDistance(a, b) {
+    return call(() => native.editDistance(a, b));
+}
+/**
+ * The candidate closest to `value`, with its distance, or `null` beyond `maxDistance`
+ * (default 1). Reports; it does not decide. An exact match is reported with distance 0,
+ * and ties go to the first candidate at the lowest distance (#894).
+ */
+function nearestMatch(value, candidates, options = {}) {
+    return (call(() => native.nearestMatch(value, candidates, optionalSize('maxDistance', options.maxDistance) ?? 1)) ?? null);
 }
 /**
- * ML/NLP normalization: NFKC → emoji→text → transliterate → strip accents →
- * [case fold] → strip control → strip zero-width → collapse whitespace.
+ * ML/NLP normalization: resolve deletions → NFKC → emoji→text → transliterate →
+ * strip accents → emoji→text → [case fold] → strip control → strip zero-width →
+ * collapse whitespace → NFC.
  *
  * Note this folds no confusables — it is not a homoglyph defence at any setting. Put
  * {@link normalizeConfusables} in front of it when a model needs both.
@@ -407,28 +580,28 @@ function mlNormalize(text, options = {}) {
 // ── Grapheme clusters ───────────────────────────────────────────────────────
 /** Number of grapheme clusters (user-perceived characters). */
 function graphemeLen(text) {
-    return native.graphemeLen(text);
+    return call(() => native.graphemeLen(text));
 }
 /** Split `text` into grapheme-cluster strings. */
 function graphemeSplit(text) {
-    return native.graphemeSplit(text);
+    return call(() => native.graphemeSplit(text));
 }
 /** Truncate to at most `maxGraphemes` clusters, never cutting through one. */
 function graphemeTruncate(text, maxGraphemes) {
-    return call(() => native.graphemeTruncate(text, maxGraphemes));
+    return call(() => native.graphemeTruncate(text, size('maxGraphemes', maxGraphemes)));
 }
 /** Display width (terminal columns) of a single grapheme `cluster` by East Asian Width. */
 function graphemeWidth(cluster, options = {}) {
-    return native.graphemeWidth(cluster, options.ambiguousWide ?? false);
+    return call(() => native.graphemeWidth(cluster, options.ambiguousWide ?? false));
 }
 /** Total display width (terminal columns) of `text`. */
 function terminalWidth(text, options = {}) {
-    return native.terminalWidth(text, options.ambiguousWide ?? false);
+    return call(() => native.terminalWidth(text, options.ambiguousWide ?? false));
 }
 // ── Hostname / script analysis ──────────────────────────────────────────────
 /** Whether the hostname looks like a mixed-script / confusable IDN spoof (a `false` is not a safety guarantee). */
 function isSuspiciousHostname(host) {
-    return native.isSuspiciousHostname(host);
+    return call(() => native.isSuspiciousHostname(host));
 }
 /**
  * Analyze a hostname for Unicode homoglyph spoofing, returning the full
@@ -440,11 +613,11 @@ function analyzeHostname(host, options = {}) {
 }
 /** The Unicode scripts present, in first-appearance order (Common/Inherited excluded). */
 function detectScripts(text) {
-    return native.detectScripts(text);
+    return call(() => native.detectScripts(text));
 }
 /** Whether `text` mixes characters from more than one script. */
 function isMixedScript(text) {
-    return native.isMixedScript(text);
+    return call(() => native.isMixedScript(text));
 }
 /**
  * All twelve UAX #9 explicit formatting characters, uncontexted.
@@ -455,7 +628,7 @@ function isMixedScript(text) {
  * right-to-left text.
  */
 function hasBidiControl(text) {
-    return native.hasBidiControl(text);
+    return call(() => native.hasBidiControl(text));
 }
 /**
  * Whether `text` mixes strong left-to-right and strong right-to-left characters
@@ -464,11 +637,11 @@ function hasBidiControl(text) {
  * guarantee.
  */
 function hasBidiConflict(text) {
-    return native.hasBidiConflict(text);
+    return call(() => native.hasBidiConflict(text));
 }
 /** Explain how `lang: 'auto'` detection resolves `text`. */
 function inspectAutoLang(text) {
-    return native.inspectAutoLang(text);
+    return call(() => native.inspectAutoLang(text));
 }
 // ── Metadata introspection (#404) ───────────────────────────────────────────
 /**
@@ -487,13 +660,30 @@ function langInfo(code) {
 function scriptInfo(name) {
     return call(() => native.scriptInfo(name));
 }
+/** TR39 sources whose prototype is in `script`, and how many of those disarm's bundled
+ * tables fold (#963).
+ *
+ * The denominator {@link unmappedConfusables} does not have. That function measures one
+ * bundled table against the whole 6,565-source population, which is the right question
+ * for a target disarm ships and a misleading one for a script it does not: Greek reports
+ * almost the entire population unmapped, and the number means only "there is no Greek
+ * table".
+ *
+ * `folded` counts sources any bundled table reaches, not sources folded *toward* this
+ * script — Greek is 71 of 159 because the Latin table folds Greek letters that look
+ * Latin. The grouping uses the UCD's script property, so `"Yi"` and 18 other scripts
+ * disarm's own enum does not name are addressable here. A script disarm knows that TR39
+ * never uses as a prototype returns 0 of 0. */
+function confusableCoverage(script) {
+    return call(() => native.confusableCoverage(script));
+}
 /**
  * The UCD release disarm's normalizer implements. Not a library-wide Unicode version —
  * the bundled tables track different releases. This is the one integrators ask about,
  * because it decides whether disarm's normalization agrees with the host platform's.
  */
 function unicodeVersion() {
-    return native.unicodeVersion();
+    return call(() => native.unicodeVersion());
 }
 /**
  * Whether a key stored under an earlier release still compares equal. A monotonic
@@ -501,7 +691,7 @@ function unicodeVersion() {
  * for the same input. Meaningless in isolation, by design.
  */
 function keySchemaVersion() {
-    return native.keySchemaVersion();
+    return call(() => native.keySchemaVersion());
 }
 /**
  * The Unicode `confusables.txt` release the bundled confusable tables were folded
@@ -512,15 +702,15 @@ function keySchemaVersion() {
  * confusables fold stale?" without inferring it from behaviour.
  */
 function confusablesVersion() {
-    return native.confusablesVersion();
+    return call(() => native.confusablesVersion());
 }
 /** Every Unicode script name known to the transliteration tables. */
 function listScripts() {
-    return native.listScripts();
+    return call(() => native.listScripts());
 }
 /** Every language code that has a context-aware transliteration profile. */
 function listContextLangs() {
-    return native.listContextLangs();
+    return call(() => native.listContextLangs());
 }
 // ── Anomaly detection ───────────────────────────────────────────────────────
 /**
@@ -532,10 +722,10 @@ function listContextLangs() {
  * internal set on every call — used only by the leet and segmentation branches.
  */
 function hasAnomalies(text, lexicon = []) {
-    if (lexicon instanceof binding_1.Lexicon) {
-        return native.hasAnomalies(text, lexicon);
+    if (lexicon instanceof Lexicon) {
+        return call(() => native.hasAnomalies(text, lexicon));
     }
-    return native.hasAnomalies(text, Array.isArray(lexicon) ? lexicon : [...lexicon]);
+    return call(() => native.hasAnomalies(text, Array.isArray(lexicon) ? lexicon : [...lexicon]));
 }
 /**
  * Full anomaly analysis: an `AnomalyReport` with `anomalous`, `kinds` (in
@@ -544,9 +734,8 @@ function hasAnomalies(text, lexicon = []) {
  * `lexicon` may be a `Set`/array of words or a prebuilt {@link Lexicon} handle.
  */
 function inspectAnomalies(text, lexicon = []) {
-    if (lexicon instanceof binding_1.Lexicon) {
-        return native.inspectAnomalies(text, lexicon);
+    if (lexicon instanceof Lexicon) {
+        return call(() => native.inspectAnomalies(text, lexicon));
     }
-    const words = Array.isArray(lexicon) ? lexicon : [...lexicon];
-    return native.inspectAnomalies(text, words);
+    return call(() => native.inspectAnomalies(text, Array.isArray(lexicon) ? lexicon : [...lexicon]));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "disarm",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "description": "Unicode confusable/text-security building blocks, powered by Rust",
   "main": "index.js",
   "types": "index.d.ts",
@@ -22,7 +22,7 @@
     "napi-rs"
   ],
   "engines": {
-    "node": ">= 14"
+    "node": ">= 22"
   },
   "napi": {
     "binaryName": "disarm",
@@ -50,7 +50,7 @@
   "devDependencies": {
     "@biomejs/biome": "^2.5.0",
     "@napi-rs/cli": "^3.7.2",
-    "typescript": "^6.0.3",
-    "vitest": "^4.1.9"
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.0"
   }
 }