@discretion/core 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,117 @@
+# Changelog
+
+All notable changes to `@discretion/core`.
+
+Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+Versioning follows [VERSIONING.md](https://github.com/horozbabasi/discretion/blob/main/VERSIONING.md),
+which is stricter than 0.x requires: **in 0.x, a minor bump is the breaking
+one.**
+
+## [Unreleased]
+
+Nothing yet.
+
+## [0.1.0] — first published release
+
+The engine has existed and been evaluated since well before this version; what
+0.1.0 marks is the point at which it became usable as a standalone package
+rather than as the extension's internals.
+
+### Added
+
+- **`protect(text, options)`** — the supported entry point. Runs Stages 0–4 in
+  the one order that is correct and returns the masked text, the findings,
+  an exposure score, and the vault needed to reverse it.
+
+  It exists because composing the pipeline by hand meant eight calls in a
+  specific order, an identity map held between two of them, and the fitted
+  calibration model imported from a second package through an unchecked cast.
+  Two of those orderings were bugs fixed in earlier milestones — resolving
+  overlaps *before* scoring exposure, and taking surrogates from the masker
+  rather than from `chooseSurrogate`, so that what is displayed is what is
+  substituted.
+
+- **`ALL_ENTITY_TYPES`, `NER_ENTITY_TYPES`, `detectableEntityTypes()`** — a
+  runtime enumeration of the entity types, which a TypeScript union does not
+  have. `detectableEntityTypes()` is derived from the detector registry rather
+  than declared, so it cannot go stale: a type appears the moment something can
+  produce it.
+
+- **`toCalibrationModel()`** — converts a fitted model to core's typed shape and
+  **reports** keys that are not entity types, replacing an
+  `as unknown as CalibrationModel` cast that would have hidden a stale key
+  while calibration silently fell back to the pooled curve.
+
+- `exposureBand()`, `PersonPool`, `SeverityCategory` and
+  `GeneratedCalibrationModel` are now exported. The last three were named in
+  public signatures without being exported, so a consumer could receive one and
+  had no way to name its type.
+
+- Runnable examples under `examples/`, executed against the packed tarball by
+  `scripts/verify-standalone-consumer.sh`, so the documentation cannot drift
+  from the package.
+
+### Changed
+
+- **`@huggingface/transformers` is now an optional peer dependency** rather
+  than a dependency. It is needed only for Stage 2, which is reached through
+  the separate `./ner-transformers` entry point, and it pulls in
+  `onnxruntime-node`. Installing the package in an empty project now produces
+  **20 MB of `node_modules`** instead of a little over 220 MB.
+
+  If you use Stage 2, add `@huggingface/transformers` to your own
+  dependencies.
+
+- `@discretion/data` is pinned to an exact version instead of `*`, so core
+  and its data tables cannot drift apart across releases.
+
+### Fixed
+
+- **API_KEY matches no longer swallow a trailing full stop.** The body charset
+  legitimately includes `.`, and the match ran on into sentence punctuation, so
+  a key at the end of a sentence and the same key mid-sentence were two
+  different values — which quietly broke the guarantee that a value seen twice
+  gets the same stand-in, and left the masked text missing its punctuation.
+
+  Measured, Stage 1 + Stage 2 over 2,611 documents and 6,645 ground-truth
+  entities:
+
+  | | before | after |
+  | --- | --- | --- |
+  | API_KEY recall | 99.6% | **100.0%** |
+  | API_KEY F1 | 97.6% | **97.9%** |
+  | API_KEY false negatives | 2 | **0** |
+  | API_KEY false positives | 20 | 20 |
+  | GENERIC_SECRET false positives | 2,075 | 2,077 |
+
+  Two keys previously missed are now found. Two additional GENERIC_SECRET
+  false positives appear alongside them, in the same two Dutch documents.
+  GENERIC_SECRET's published precision, recall and F1 (2.0% / 56.8% / 3.8%)
+  are unchanged at one decimal place, and no other entity type moved at all.
+
+  **The mechanism behind those two extra false positives was not isolated.**
+  The direction is consistent with the shorter API_KEY span leaving text that
+  the generic high-entropy detector then matches, but that was not confirmed,
+  and it is recorded as unexplained rather than given a tidy reason.
+
+### Removed
+
+- `DetectionResult` and `StageTiming`. Both were declared as shapes for "later
+  milestones" and never implemented — no function returned one and nothing
+  referenced them. A type in a published API is a promise that something
+  produces it. Use `ProtectResult`, whose `stagesRun` is derived from what
+  actually ran.
+
+### Known limitations
+
+Published rather than smoothed; the full table is in
+[BENCHMARKS.md](https://github.com/horozbabasi/discretion/blob/main/BENCHMARKS.md).
+
+- `GENERIC_SECRET` recall is 56.8% and its precision is 2.0% before Stage 4
+  overlap resolution reassigns most of those matches to a specific type.
+- `TAX_ID` precision is 46.0%; `DRIVERS_LICENSE`, `POSTAL_CODE`,
+  `US_ROUTING_NUMBER` and `URL_WITH_CREDENTIALS` are all below 40% precision.
+- Stage 2 recognises `PERSON`, `ORG` and `LOCATION` only, and needs a model
+  this package does not ship.
+- `DATE_OF_BIRTH` is in the `EntityType` union but nothing produces it; it is
+  correctly absent from `detectableEntityTypes()`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 horozbabasi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,319 @@
+# @discretion/core
+
+Finds sensitive values in text — credentials, card and bank numbers, national
+and tax IDs, contact details, names — and replaces them with realistic
+stand-ins you can reverse later.
+
+It runs entirely in-process. **The package makes no network requests**, has no
+DOM dependency and no Node built-in dependency, so the same code runs in
+Node, a browser, a worker, Deno or Bun.
+
+```bash
+npm install @discretion/core
+```
+
+---
+
+## Quick start
+
+```js
+import { protect, restore } from '@discretion/core';
+
+const message = 'Wire it to DE44500105175407324931 and use key sk_live_7f3Kq2mNpX8vC1bWzR4tY6.';
+
+const result = await protect(message, { seed: 42 });
+
+console.log(result.maskedText);
+// Wire it to DE47770612720573428586 and use key AIzauyqgh8Oh57cbKOykXCGFCF3tvgjsKhc_kVd.
+
+console.log(result.entities.map((e) => `${e.type} -> ${e.surrogate}`));
+// [ 'IBAN -> DE47770612720573428586', 'API_KEY -> AIzauyqgh8Oh57cbKOykXCGFCF3tvgjsKhc_kVd' ]
+
+// Send result.maskedText wherever it needs to go. When the reply comes back:
+console.log(restore(result.maskedText, result.vault).restoredText === message);
+// true
+```
+
+The surrogates are **format-preserving**: an IBAN is replaced by a different
+IBAN that passes the same checksum, a card number by a card number that passes
+Luhn. Text that had to look like an IBAN downstream still does.
+
+The output above is what this actually prints with `seed: 42`. Drop the seed
+and the stand-ins differ every run.
+
+---
+
+## What it detects
+
+113 detectors across 34 entity types, in ten families: secrets, financial,
+identity, health, document, contact, person, location, network, other.
+
+Identifiers are **validated, not pattern-matched**. A card number must pass
+Luhn, an IBAN must pass mod-97, a national ID must pass its own country's
+check digit, a phone number must parse as a real number in some region. Then
+the surrounding text is scored, so `sk_test_...` in a code fence is treated
+differently from the same shape in a sentence about production.
+
+```js
+import { detectableEntityTypes } from '@discretion/core';
+
+console.log(detectableEntityTypes().length); // 34
+```
+
+Confidence is **calibrated against a held-out set**, so 0.8 means roughly 80%
+— expected calibration error 2.63%, against 12.33% for the raw scores. Full
+per-type precision and recall are in
+[BENCHMARKS.md](https://github.com/horozbabasi/discretion/blob/main/BENCHMARKS.md),
+including the types that do badly.
+
+---
+
+## It fails closed, and that is your contract too
+
+If a detector throws or detection times out, `protect()` **rejects**. It does
+not return an empty result.
+
+That is deliberate and it is the single most important thing to get right when
+you integrate it:
+
+```js
+// WRONG. This turns every failure into "nothing sensitive here".
+let result;
+try {
+  result = await protect(message);
+} catch {
+  result = { maskedText: message, entities: [] }; // ← now you send the original
+}
+
+// RIGHT. Not being able to check is not the same as having checked.
+const result = await protect(message); // let it throw, and stop
+```
+
+Being unable to look is not evidence that there was nothing to find. If you
+cannot mask, do not send.
+
+---
+
+## Reversing it
+
+`protect()` returns the `vault` that holds the originals. `restore()` needs it.
+
+```js
+import { protect, restore, Vault } from '@discretion/core';
+
+// One vault across a whole conversation, so a value seen twice gets the same
+// stand-in and a reply mentioning it can still be restored.
+const vault = new Vault();
+
+const first = await protect('My IBAN is DE44500105175407324931.', { vault });
+const second = await protect('Again: DE44500105175407324931', { vault });
+console.log(first.entities[0].surrogate === second.entities[0].surrogate); // true
+
+const reply = `Received ${first.entities[0].surrogate}, thanks.`;
+console.log(restore(reply, vault).restoredText);
+// Received DE44500105175407324931, thanks.
+```
+
+The vault holds plaintext originals **in memory**. Do not serialise it to
+disk, a database, or a log. If you keep one per user session, clear it when
+the session ends.
+
+For streamed responses use the `Restorer` class, which buffers across chunk
+boundaries so a surrogate split between two chunks is still replaced:
+
+```js
+import { Restorer } from '@discretion/core';
+
+const restorer = new Restorer(vault);
+for await (const chunk of stream) process.stdout.write(restorer.push(chunk));
+process.stdout.write(restorer.finish()); // the tail - do not drop it
+```
+
+---
+
+## Choosing what gets reported
+
+Three profiles, differing in which families they cover and how much confidence
+they demand:
+
+```js
+await protect(message, { profile: 'minimal' });  // secrets and financial only
+await protect(message, { profile: 'balanced' }); // default
+await protect(message, { profile: 'strict' });   // adds health, location, orgs, dates
+```
+
+Finer control:
+
+```js
+await protect(message, {
+  // Never report these exact values; always report those.
+  lists: { allow: ['support@example.com'], deny: ['Project Gemstone'] },
+
+  // Turn individual types off.
+  typeAllowed: (type) => type !== 'PERSON',
+
+  // Needed for identifiers that are ambiguous without a country. A phone
+  // number in national form cannot be validated at all without this - it is
+  // not a confidence penalty, the detector reports nothing.
+  defaultRegion: 'DE',
+
+  // '[EMAIL_1]' style instead of realistic stand-ins.
+  mode: 'token',
+
+  // Fixed seed makes the run reproducible.
+  seed: 42,
+});
+```
+
+A type excluded by `typeAllowed` is **not masked** — it is not reported and
+not replaced. That is the honest consequence of switching it off.
+
+---
+
+## Names, organisations and places (optional)
+
+Stages 0, 1, 3 and 4 run with no model. Recognising *names* needs Stage 2, a
+multilingual transformer that this package does **not** depend on, because it
+pulls in the ONNX runtime — over 200 MB — and most callers do not need it.
+
+```bash
+npm install @huggingface/transformers   # only if you want Stage 2
+```
+
+```js
+import { protect, NerEngine } from '@discretion/core';
+import { createTransformersClassifier } from '@discretion/core/ner-transformers';
+
+const classifier = await createTransformersClassifier({
+  model: 'jiting/xlm-roberta-base-ner-hrl_onnx',
+  dtype: 'q8',
+  cacheDir: './models',
+  // Leave false in production and bundle the weights yourself. `protect()`
+  // never reaches the network; this flag is the one place the TOOLING can.
+  allowRemoteModels: false,
+});
+
+const ner = new NerEngine(classifier, { timeBudgetMs: 5_000 });
+await ner.warmup();
+
+const result = await protect(message, { ner });
+console.log(result.stagesRun.includes('stage2-ner')); // true
+```
+
+`stagesRun` is derived from what actually ran, not declared. If it does not
+contain `'stage2-ner'`, names were not looked for — check it rather than
+assuming.
+
+Per-language F1 ranges from 82.0 (Japanese) to 96.4 (Ukrainian) across 25
+languages; the model weights are not shipped in this package.
+
+---
+
+## Adding your own detector
+
+Adding one is a single object. It joins the same validation, context scoring
+and fusion as the built-ins.
+
+```js
+import { registerDetector, CONFIDENCE, GLOBAL_REGION, valid, invalid } from '@discretion/core';
+
+registerDetector({
+  id: 'acme-employee-id',
+  entityType: 'NATIONAL_ID',
+  regions: [GLOBAL_REGION],
+  pattern: /\bACME-\d{7}\b/gu,
+  baseConfidence: CONFIDENCE.MEDIUM,
+  description: 'Acme internal employee number.',
+  validate: ({ match }) => {
+    const digits = match[0].slice('ACME-'.length);
+    const sum = [...digits].reduce((acc, d) => acc + Number(d), 0);
+    return sum % 7 === 0 ? valid({ confidence: CONFIDENCE.MAXIMUM }) : invalid('checksum');
+  },
+});
+```
+
+**`ctx.text` is the whole normalized document, not the matched substring.** The
+match is `ctx.match[0]`, or `ctx.text.slice(ctx.start, ctx.end)`. Slicing
+`ctx.text` as though it were the match is the easiest mistake to make here, and
+it fails quietly: the validator rejects everything and the detector simply
+never reports.
+
+`entityType` must be an existing `EntityType`; the union is closed so that
+profiles, severity weights and surrogate strategies stay total. Values of a
+type with no format-preserving generator fall back to a bracket token
+(`[NATIONAL_ID_1]`) rather than an invented stand-in.
+
+---
+
+## Working with offsets
+
+`protect()` handles this for you. If you use the lower-level stages, the rule
+matters: detection runs on **normalized** text (invisible characters stripped,
+NFKC applied, homoglyphs folded), and offsets into it are not offsets into
+your original string.
+
+```js
+import { normalize, runStage1, mapNormalizedSpan } from '@discretion/core';
+
+const normalization = normalize(original);
+for (const candidate of runStage1(normalization, {})) {
+  // Widens correctly when a span lands inside an NFKC expansion. Never index
+  // the offset map directly for a range.
+  const [start, end] = mapNormalizedSpan(normalization, candidate.start, candidate.end);
+  console.log(original.slice(start, end));
+}
+```
+
+`ProtectedEntity.originalStart` / `originalEnd` are already in the original
+string's coordinates.
+
+---
+
+## What it will not do
+
+- **It misses things.** `GENERIC_SECRET` recall is 55.4%; `TAX_ID` is 91.2%.
+  It is a safety net, not a guarantee, and it is not a compliance control.
+- **It flags harmless things.** Review before acting on it in anything
+  automated.
+- **It does not read files, images or PDFs.** Text in, text out.
+- **It does not do structured redaction of documents** — no PDF or DOCX
+  rewriting, no bounding boxes.
+- **It has no server component and never will.** There is nothing to
+  configure, no key, no account, and no request to block at your firewall.
+
+The measured numbers behind all of this, including where it does badly, are
+published in
+[BENCHMARKS.md](https://github.com/horozbabasi/discretion/blob/main/BENCHMARKS.md).
+Nothing above is asserted without a measurement behind it.
+
+---
+
+## Performance
+
+On the reference machine, Stages 0–3 over a 2 KB document: **p50 10.6 ms**.
+With Stage 2 enabled: **p50 255.8 ms**, almost all of it inference.
+
+Measured with a machine-health canary that marks a run degraded when the
+machine itself is slow, so published figures are not compared against numbers
+taken under load. See
+[BENCHMARKS.md](https://github.com/horozbabasi/discretion/blob/main/BENCHMARKS.md).
+
+---
+
+## API surface and stability
+
+`protect()` is the supported entry point. Every pipeline stage is also
+exported for callers who want one — `normalize`, `runStage1`, `detect`,
+`resolveOverlaps`, `calibrate`, `decide`, `maskOriginal`, `computeExposure`.
+
+`mask()` is **not** a smaller `protect()`. It runs Stage 1 only, with no
+context scoring, calibration or profile decision. It exists for the Stage-1
+baseline in the evaluation harness.
+
+Versioning policy, including what 0.x means here:
+[VERSIONING.md](https://github.com/horozbabasi/discretion/blob/main/VERSIONING.md).
+
+## Licence
+
+MIT. Unicode data under the Unicode licence — see `THIRD_PARTY_NOTICES.md` in
+`@discretion/data`.

package/dist/src/checksums/aba.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The ABA routing transit number checksum (US_ROUTING_NUMBER).
+ *
+ * A nine-digit number whose positional weights cycle 3, 7, 1. The number is
+ * valid when the weighted sum is divisible by 10.
+ *
+ * Kept in its own module rather than inlined in the detector because the same
+ * 3-7-1 pattern appears in other North American banking identifiers, and
+ * because "which weight goes first" is exactly the kind of detail that is
+ * worth pinning with its own tests.
+ */
+/**
+ * Validate a nine-digit ABA routing number.
+ *
+ * Length is enforced here because the checksum alone is weak — a shorter or
+ * longer digit run can satisfy it by chance, and every real routing number is
+ * exactly nine digits.
+ */
+export declare function abaValid(value: string): boolean;
+/**
+ * The final ABA check digit for the first eight digits of a routing number.
+ * Returns `null` if the payload is not exactly eight digits.
+ */
+export declare function abaCheckDigit(payload: string): number | null;
+//# sourceMappingURL=aba.d.ts.map

package/dist/src/checksums/aba.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aba.d.ts","sourceRoot":"","sources":["../../../src/checksums/aba.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAQH;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAK/C;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQ5D"}

package/dist/src/checksums/aba.js

@@ -0,0 +1,47 @@
+/**
+ * The ABA routing transit number checksum (US_ROUTING_NUMBER).
+ *
+ * A nine-digit number whose positional weights cycle 3, 7, 1. The number is
+ * valid when the weighted sum is divisible by 10.
+ *
+ * Kept in its own module rather than inlined in the detector because the same
+ * 3-7-1 pattern appears in other North American banking identifiers, and
+ * because "which weight goes first" is exactly the kind of detail that is
+ * worth pinning with its own tests.
+ */
+import { toDigits } from './digits.js';
+import { cyclicWeightedMod } from './weighted.js';
+/** ABA positional weights, cycling across the nine digits. */
+const ABA_WEIGHTS = [3, 7, 1];
+/**
+ * Validate a nine-digit ABA routing number.
+ *
+ * Length is enforced here because the checksum alone is weak — a shorter or
+ * longer digit run can satisfy it by chance, and every real routing number is
+ * exactly nine digits.
+ */
+export function abaValid(value) {
+    if (value.length !== 9)
+        return false;
+    const digits = toDigits(value);
+    if (digits === null)
+        return false;
+    return cyclicWeightedMod(digits, ABA_WEIGHTS, 10) === 0;
+}
+/**
+ * The final ABA check digit for the first eight digits of a routing number.
+ * Returns `null` if the payload is not exactly eight digits.
+ */
+export function abaCheckDigit(payload) {
+    if (payload.length !== 8)
+        return null;
+    const digits = toDigits(payload);
+    if (digits === null)
+        return null;
+    const partial = cyclicWeightedMod(digits, ABA_WEIGHTS, 10);
+    if (partial === null)
+        return null;
+    // The ninth position carries weight 1 (index 8 → 8 % 3 === 2 → weight 1).
+    return (10 - partial) % 10;
+}
+//# sourceMappingURL=aba.js.map

package/dist/src/checksums/aba.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aba.js","sourceRoot":"","sources":["../../../src/checksums/aba.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAElD,8DAA8D;AAC9D,MAAM,WAAW,GAAsB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAa;IACpC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACrC,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC/B,IAAI,MAAM,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAClC,OAAO,iBAAiB,CAAC,MAAM,EAAE,WAAW,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC;AAC1D,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,OAAe;IAC3C,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACtC,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;IACjC,IAAI,MAAM,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IACjC,MAAM,OAAO,GAAG,iBAAiB,CAAC,MAAM,EAAE,WAAW,EAAE,EAAE,CAAC,CAAC;IAC3D,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAClC,0EAA0E;IAC1E,OAAO,CAAC,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;AAC7B,CAAC"}

package/dist/src/checksums/digits.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Digit and character helpers shared by every checksum implementation.
+ *
+ * These exist so that the algorithm modules (luhn, mod97, verhoeff, …) deal
+ * only in `number[]` and never re-implement parsing. Every function here is
+ * total: it returns `null` on malformed input rather than throwing, because
+ * checksum code runs on arbitrary user text where malformed input is the
+ * common case, not an exceptional one.
+ */
+/**
+ * Parse a string of ASCII digits into numeric digit values.
+ *
+ * Returns `null` if the string is empty or contains any non-digit character.
+ * Deliberately rejects non-ASCII digits (Arabic-Indic ٤, fullwidth ４, …):
+ * Stage 0 normalization already folds fullwidth forms to ASCII, and a
+ * genuinely non-ASCII digit run is not an identifier in any scheme we
+ * validate.
+ */
+export declare function toDigits(value: string): number[] | null;
+/**
+ * Remove every character in `separators` from `value`.
+ *
+ * Identifiers are routinely written with grouping punctuation (`4111 1111
+ * 1111 1111`, `123-45-6789`, `AB-12-CD`). Detectors strip before validating
+ * and keep the raw span for offset reporting.
+ */
+export declare function stripSeparators(value: string, separators?: string): string;
+/**
+ * Value of an alphanumeric character in base 36: '0'–'9' → 0–9,
+ * 'A'/'a'–'Z'/'z' → 10–35. Returns `null` for anything else.
+ *
+ * This is the mapping IBAN's mod-97 and several VAT schemes use to fold
+ * letters into the numeric checksum.
+ */
+export declare function alphanumericValue(ch: string): number | null;
+/**
+ * Expand every character of `value` to its base-36 value and concatenate the
+ * decimal representations, the transformation IBAN mod-97 requires.
+ *
+ * "GB82" → "161182"  (G=16, B=11, 8, 2)
+ *
+ * Returns `null` if any character is not alphanumeric.
+ */
+export declare function toNumericString(value: string): string | null;
+/** True when every character is an ASCII digit and the string is non-empty. */
+export declare function isAllDigits(value: string): boolean;
+/**
+ * True when every digit is identical ("0000000000", "1111111111").
+ *
+ * Repdigits pass several national checksums by construction (a weighted sum
+ * of identical digits often lands on a valid remainder) yet are never issued.
+ * Schemes that exclude them say so in their own validator.
+ */
+export declare function isRepdigit(digits: readonly number[]): boolean;
+//# sourceMappingURL=digits.d.ts.map

package/dist/src/checksums/digits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"digits.d.ts","sourceRoot":"","sources":["../../../src/checksums/digits.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,CASvD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,SAAa,GAAG,MAAM,CAM9E;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAO3D;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQ5D;AAED,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAOlD;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAO7D"}