@stll/anonymize-wasm 1.4.0 → 1.4.3

package/dist/wasm.mjs

@@ -1,6 +1,8 @@
 import { DEFAULT_ENTITY_LABELS, DETECTION_SOURCES, DETECTOR_PRIORITY, OPERATOR_TYPES } from "./constants.mjs";
+import { t as amount_words_default } from "./amount-words.mjs";
+import { t as address_street_types_default } from "./address-street-types.mjs";
 import { TextSearch } from "@stll/text-search-wasm";
-import { at, be, bg, br, cy, cz, de, dk, ee, es, fi, fr, gb, gr, hr, hu, ie, it, lt, lu, lv, mt, nl, pl, pt, ro, se, si, sk } from "@stll/stdnum";
+import { at, au, be, bg, br, ch, cy, cz, de, dk, ee, es, fi, fr, gb, gr, hr, hu, ie, it, lt, lu, lv, mt, nl, no, pl, pt, ro, se, si, sk, us } from "@stll/stdnum";
 import { toRegex } from "@stll/stdnum/patterns";
 //#region src/search-engine.ts
 let _TextSearch;
@@ -29,6 +31,7 @@ const createPipelineContext = () => ({
 	searchKey: "",
 	searchPromise: null,
 	nameCorpus: null,
+	nameCorpusKey: "",
 	nameCorpusPromise: null,
 	stopwords: null,
 	stopwordsPromise: null,
@@ -885,8 +888,46 @@ const getSentenceVerbIndicatorsSync = () => sentenceVerbIndicatorsCache ?? SENTE
 const UPPER = "A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽÄÖÜÀÂÆÇÈÊËÎÏÔÙÛŸÑĄĆĘŁŃŚŹŻ\\u0130";
 const LOWER = "a-záčďéěíňóřšťúůýžäöüßàâæçèêëîïôùûÿñąćęłńśźż\\u0131";
 const CAP_WORD = `(?:[${UPPER}]{2,}|[${UPPER}][${LOWER}${UPPER}]+)`;
+const SINGLE_CAP = `[${UPPER}](?![${LOWER}${UPPER}])`;
 const ALLCAP_WORD = `[${UPPER}]{2,}`;
+const HSPACE = "(?:[^\\S\\n]|[\xA0 ])";
+const LEGAL_LIST_BOUNDARY_RE = new RegExp(`^[,;]${HSPACE}+(?=\\p{Lu}|(?:\\p{Lu}\\.${HSPACE}?){2,})`, "u");
 const ROMAN_NUMERAL_RE = /^(?=[IVXLCDM])M{0,3}(?:CM|CD|D?C{0,3})(?:XC|XL|L?X{0,3})(?:IX|IV|V?I{0,3})$/;
+const EMPTY_LEADING_CLAUSE_TRIMS = {
+	phrases: [],
+	directPrefixes: []
+};
+let leadingClauseTrimsCache = null;
+let leadingClauseTrimsPromise = null;
+const loadLeadingClauseTrims = async () => {
+	if (leadingClauseTrimsCache) return leadingClauseTrimsCache;
+	if (leadingClauseTrimsPromise) return leadingClauseTrimsPromise;
+	leadingClauseTrimsPromise = (async () => {
+		let data = {};
+		try {
+			const mod = await import("./legal-form-leading-clauses.mjs");
+			data = mod.default ?? mod;
+		} catch (err) {
+			console.warn("[anonymize] legal-forms: failed to load legal-form-leading-clauses.json:", err);
+		}
+		const phrases = /* @__PURE__ */ new Set();
+		const directPrefixes = /* @__PURE__ */ new Set();
+		for (const [key, value] of Object.entries(data)) {
+			if (key.startsWith("_") || typeof value !== "object" || value === null) continue;
+			const config = value;
+			for (const phrase of config.phrases ?? []) if (typeof phrase === "string" && phrase.length > 0) phrases.add(phrase);
+			for (const prefix of config.directPrefixes ?? []) if (typeof prefix === "string" && prefix.length > 0) directPrefixes.add(prefix);
+		}
+		const result = {
+			phrases: [...phrases],
+			directPrefixes: [...directPrefixes]
+		};
+		leadingClauseTrimsCache = result;
+		return result;
+	})();
+	return leadingClauseTrimsPromise;
+};
+const getLeadingClauseTrimsSync = () => leadingClauseTrimsCache ?? EMPTY_LEADING_CLAUSE_TRIMS;
 let legalRoleHeadsCache = null;
 let legalRoleHeadsPromise = null;
 const loadLegalRoleHeads = async () => {
@@ -912,11 +953,23 @@ const warmLegalRoleHeads = async () => {
 		loadLegalRoleHeads(),
 		loadAllLegalSuffixes(),
 		loadSentenceVerbIndicators(),
-		loadClauseNounHeads()
+		loadClauseNounHeads(),
+		loadConnectorProseHeads(),
+		loadStructuralSingleCapPrefixes(),
+		loadLeadingClauseTrims()
 	]);
 };
 let allLegalSuffixesCache = null;
 let allLegalSuffixesPromise = null;
+let normalizedLegalBoundarySuffixesCache = null;
+let normalizedInNameLegalFormWordsCache = null;
+const normalizeLegalSuffixToken = (suffix) => suffix.replace(/[.,\s]/g, "");
+const isBoundaryLegalSuffixForm = (form) => {
+	const normalized = normalizeLegalSuffixToken(form);
+	if (normalized.length === 0) return false;
+	if (LEGAL_SUFFIXES.includes(form)) return true;
+	return /[.]/u.test(form) || normalized === normalized.toUpperCase();
+};
 const loadAllLegalSuffixes = async () => {
 	if (allLegalSuffixesCache) return allLegalSuffixesCache;
 	if (allLegalSuffixesPromise) return allLegalSuffixesPromise;
@@ -941,11 +994,15 @@ const loadAllLegalSuffixes = async () => {
 		}
 		out.sort((a, b) => b.length - a.length);
 		allLegalSuffixesCache = out;
+		normalizedLegalBoundarySuffixesCache = new Set(out.filter(isBoundaryLegalSuffixForm).map(normalizeLegalSuffixToken).filter((suffix) => suffix.length > 0));
+		normalizedInNameLegalFormWordsCache = new Set(out.filter((form) => !isBoundaryLegalSuffixForm(form) && !/\s/u.test(form)).map(normalizeLegalSuffixToken).filter((suffix) => suffix.length > 0));
 		return out;
 	})();
 	return allLegalSuffixesPromise;
 };
 const getAllLegalSuffixesSync = () => allLegalSuffixesCache ?? LEGAL_SUFFIXES;
+const getNormalizedLegalBoundarySuffixesSync = () => normalizedLegalBoundarySuffixesCache ?? new Set(LEGAL_SUFFIXES.map(normalizeLegalSuffixToken).filter((suffix) => suffix.length > 0));
+const getNormalizedInNameLegalFormWordsSync = () => normalizedInNameLegalFormWordsCache ?? /* @__PURE__ */ new Set();
 /**
 * Sync accessor for the full legal-form vocabulary
 * (`data/legal-forms.json` plus `LEGAL_SUFFIXES`,
@@ -985,18 +1042,71 @@ const loadClauseNounHeads = async () => {
 	return clauseNounHeadsPromise;
 };
 const getClauseNounHeadsSync = () => clauseNounHeadsCache ?? CLAUSE_NOUN_HEADS_SEED;
-const escapeForRegex = (form) => form.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\s+/g, "\\s+").replace(/\\\./g, "\\.[^\\S\\n]?");
+let connectorProseHeadsCache = null;
+let connectorProseHeadsPromise = null;
+const loadConnectorProseHeads = async () => {
+	if (connectorProseHeadsCache) return connectorProseHeadsCache;
+	if (connectorProseHeadsPromise) return connectorProseHeadsPromise;
+	connectorProseHeadsPromise = (async () => {
+		let data = {};
+		try {
+			const mod = await import("./generic-roles.mjs");
+			data = mod.default ?? mod;
+		} catch (err) {
+			console.warn("[anonymize] legal-forms: failed to load generic-roles.json:", err);
+		}
+		const all = /* @__PURE__ */ new Set();
+		if (Array.isArray(data.roles)) {
+			for (const role of data.roles) if (typeof role === "string" && role.length > 0) all.add(role.toLowerCase());
+		}
+		connectorProseHeadsCache = all;
+		return all;
+	})();
+	return connectorProseHeadsPromise;
+};
+const getConnectorProseHeadsSync = () => connectorProseHeadsCache ?? /* @__PURE__ */ new Set();
+let structuralSingleCapPrefixesCache = null;
+let structuralSingleCapPrefixesPromise = null;
+const loadStructuralSingleCapPrefixes = async () => {
+	if (structuralSingleCapPrefixesCache) return structuralSingleCapPrefixesCache;
+	if (structuralSingleCapPrefixesPromise) return structuralSingleCapPrefixesPromise;
+	structuralSingleCapPrefixesPromise = (async () => {
+		let data = {};
+		try {
+			const mod = await import("./structural-single-cap-prefixes.mjs");
+			data = mod.default ?? mod;
+		} catch (err) {
+			console.warn("[anonymize] legal-forms: failed to load structural-single-cap-prefixes.json:", err);
+		}
+		const all = /* @__PURE__ */ new Set();
+		for (const [key, value] of Object.entries(data)) {
+			if (key.startsWith("_")) continue;
+			if (!Array.isArray(value)) continue;
+			for (const prefix of value) {
+				if (typeof prefix !== "string" || prefix.length === 0) continue;
+				all.add(prefix.toLowerCase());
+			}
+		}
+		structuralSingleCapPrefixesCache = all;
+		return all;
+	})();
+	return structuralSingleCapPrefixesPromise;
+};
+const getStructuralSingleCapPrefixesSync = () => structuralSingleCapPrefixesCache ?? /* @__PURE__ */ new Set();
+const escapeForRegex = (form) => form.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\s+/g, `${HSPACE}+`).replace(/\\\./g, `\\.${HSPACE}?`);
 const isShortForm = (form) => form.replace(/[.\s]/g, "").length <= 3 && !form.includes(" ");
+const buildDottedAbbreviationAlternation = (forms) => [...new Set(forms.filter((form) => /^[\p{Lu}][\p{L}\p{M}]{0,5}\.$/u.test(form)).map((form) => form.slice(0, -1)).filter((form) => form.length > 0))].toSorted((a, b) => b.length - a.length).map(escapeForRegex).join("|");
 const buildPatternString = (forms) => {
 	if (forms.length === 0) return null;
 	const alt = forms.toSorted((a, b) => b.length - a.length).map(escapeForRegex).join("|");
-	const HSPACE = "[^\\S\\n]";
 	const LOWER_CONNECTOR = `${HSPACE}+(?:a|and|und|et|e|y|i)${HSPACE}+(?=[${LOWER}])`;
 	const SIMPLE_SEP = `(?:${HSPACE}|[&,.${DASH_INNER}]){1,4}`;
-	const CAP_OR_NUM_WORD = `(?:${CAP_WORD}|\\d{1,4})`;
+	const CAP_OR_NUM_WORD = `(?:${CAP_WORD}|${SINGLE_CAP}|\\d{1,4})`;
 	const LOWER_WORD = `(?:(?!(?:and|und|et)(?![${UPPER}${LOWER}]))[${LOWER}][${LOWER}${UPPER}]+)`;
 	const ANY_WORD_TAIL = `(?:(?!(?:and|und|et)(?![${UPPER}${LOWER}]))[${UPPER}${LOWER}][${LOWER}${UPPER}]+|[${UPPER}]{2,3}|\\d{1,4})`;
-	return `${`(?:${`(?:${CAP_WORD})(?:${SIMPLE_SEP}(?:${CAP_OR_NUM_WORD})){0,10}`})(?:${`${SIMPLE_SEP}(?:${LOWER_WORD})(?:(?:${LOWER_CONNECTOR}|${SIMPLE_SEP})(?:${ANY_WORD_TAIL})){0,10}`})?`}(?:\\s+|,\\s*)(?:${alt})(?![${LOWER}])`;
+	const dottedAbbreviationAlt = buildDottedAbbreviationAlternation(forms);
+	const dottedAbbreviationTail = dottedAbbreviationAlt.length > 0 ? `(?:${SIMPLE_SEP}(?:${dottedAbbreviationAlt})\\.)?` : "";
+	return `${`(?:${`(?:${CAP_WORD})(?:${SIMPLE_SEP}(?:${CAP_OR_NUM_WORD})){0,10}` + dottedAbbreviationTail})(?:${`${SIMPLE_SEP}(?:${LOWER_WORD})(?:(?:${LOWER_CONNECTOR}|${SIMPLE_SEP})(?:${ANY_WORD_TAIL})){0,10}`})?`}${`(?:${HSPACE}+|,${HSPACE}*)`}(?:${alt})(?![${LOWER}])`;
 };
 /**
 * Build legal form regex pattern strings.
@@ -1026,9 +1136,17 @@ const buildLegalFormPatterns = async () => {
 	if (longPattern) patterns.push(longPattern);
 	const shortPattern = buildPatternString(allForms.filter(isShortForm));
 	if (shortPattern) patterns.push(shortPattern);
-	const allcapPrefix = `(?:${ALLCAP_WORD})(?:[ \\t&,.${DASH_INNER}]{1,4}(?:${ALLCAP_WORD})){0,2}`;
 	const allcapAlt = allForms.toSorted((a, b) => b.length - a.length).map(escapeForRegex).join("|");
-	patterns.push(`${allcapPrefix}(?:[ \\t]+|,[ \\t]*)(?:${allcapAlt})(?![${LOWER}])`);
+	const mixedNameSep = `(?:${HSPACE}|[&,.${DASH_INNER}]){1,4}`;
+	const capitalizedNoDigitPrefix = `(?:${CAP_WORD})(?:${mixedNameSep}(?:${CAP_WORD}|${ALLCAP_WORD})){1,8}`;
+	patterns.push(`${capitalizedNoDigitPrefix}(?:${HSPACE}+|,${HSPACE}*)(?:${allcapAlt})(?![${LOWER}])`);
+	const allcapMixedPrefix = `(?:${ALLCAP_WORD})(?:${mixedNameSep}(?:${CAP_WORD}|${ALLCAP_WORD}|\\d{1,4})){1,6}`;
+	patterns.push(`${allcapMixedPrefix}(?:${HSPACE}+|,${HSPACE}*)(?:${allcapAlt})(?![${LOWER}])`);
+	const dottedLineWrapPrefix = `(?:${CAP_WORD})(?:${mixedNameSep}(?:${CAP_WORD}|${ALLCAP_WORD})){1,8}\\.${HSPACE}*\\n${HSPACE}*`;
+	patterns.push(`${dottedLineWrapPrefix}(?:${allcapAlt})(?![${LOWER}])`);
+	const allcapPrefix = `(?:${ALLCAP_WORD})(?:(?:${HSPACE}|[&,.${DASH_INNER}]){1,4}(?:${ALLCAP_WORD})){0,2}`;
+	patterns.push(`${allcapPrefix}(?:${HSPACE}+|,${HSPACE}*)(?:${allcapAlt})(?![${LOWER}])`);
+	patterns.push(`(?:^|(?<=[^${UPPER}${LOWER}\\p{N}]))[${UPPER}](?:${HSPACE}+|,${HSPACE}*)(?:${allcapAlt})(?![${UPPER}${LOWER}\\p{N}])`);
 	return patterns;
 };
 const CONNECTOR_RE = /^(?:a|and|und|et|e|y|i|&)$/i;
@@ -1037,7 +1155,14 @@ const UPPER_LETTER_RE = /^\p{Lu}/u;
 const COMPANY_SUFFIX_WORDS_RE = /^(?:Company|Co|Bank|Brothers|Bros|Sons|Group|Holdings|Trust|Partners|Associates|Corporation|Industries|Enterprises|Solutions|Systems|Services|Foundation|Institute)$/;
 const IN_NAME_PREPOSITION_RE = /^(?:of|the)$/i;
 const ENTITY_HEAD_WORD_RE = /^[\p{L}\p{M}&]+/u;
-const LEADING_CLAUSE_RE = /(?:^|\s)(?:by\s+and\s+between|is\s+between)\s+/giu;
+const BARE_SINGLE_CAP_LEGAL_FORM_RE = new RegExp(`^[${UPPER}](?:${HSPACE}+|,${HSPACE}*)`, "u");
+const STRUCTURAL_SINGLE_CAP_RE = new RegExp(`^([\\p{L}\\p{M}]+)${HSPACE}+[${UPPER}](?:[.${DASH_INNER}]?\\d{1,3})?(?:${HSPACE}+|,${HSPACE}*)`, "u");
+const isStructuralSingleCapMatch = (text) => {
+	const first = STRUCTURAL_SINGLE_CAP_RE.exec(text)?.[1];
+	return first !== void 0 && getStructuralSingleCapPrefixesSync().has(first.toLowerCase());
+};
+const findLastSuffixSeparator = (text) => Math.max(text.lastIndexOf(" "), text.lastIndexOf("	"), text.lastIndexOf("\xA0"), text.lastIndexOf(" "), text.lastIndexOf(","));
+const stripDocxSpaces = (text) => text.replace(/[  ]/g, "");
 /**
 * Find the word ending just before `pos` in `text`,
 * skipping any whitespace (not newlines).
@@ -1062,25 +1187,198 @@ const findWordBefore = (text, pos) => {
 		start: wordStart
 	};
 };
+const hasSingleCapPrefixBefore = (fullText, matchStart) => {
+	const prev = findWordBefore(fullText, matchStart);
+	return prev !== null && prev.word.length === 1 && UPPER_LETTER_RE.test(prev.word);
+};
+const isBareSingleCapStructuralInnerMatch = (fullText, matchStart, text) => {
+	if (!BARE_SINGLE_CAP_LEGAL_FORM_RE.test(text)) return false;
+	const prev = findWordBefore(fullText, matchStart);
+	return prev !== null && getStructuralSingleCapPrefixesSync().has(prev.word.toLowerCase());
+};
+const trimEmbeddedLegalFormListPrefix = (entityStart, entityText) => {
+	let cut = -1;
+	for (const suffix of getAllLegalSuffixesSync()) {
+		const suffixClean = suffix.replace(/[.,\s]/g, "");
+		if (suffixClean.length > 0 && ROMAN_NUMERAL_RE.test(suffixClean)) continue;
+		let fromIndex = 0;
+		while (fromIndex < entityText.length) {
+			const suffixStart = entityText.indexOf(suffix, fromIndex);
+			if (suffixStart === -1) break;
+			fromIndex = suffixStart + suffix.length;
+			const suffixEnd = suffixStart + suffix.length;
+			if (suffixEnd >= entityText.length - 1) continue;
+			const afterSuffix = entityText.slice(suffixEnd);
+			const boundary = /^,\s+(?=\p{Lu})/u.exec(afterSuffix);
+			if (boundary === null) continue;
+			const nextStart = suffixEnd + boundary[0].length;
+			const remainder = entityText.slice(nextStart);
+			if (!getAllLegalSuffixesSync().some((form) => remainder.endsWith(form))) continue;
+			cut = Math.max(cut, nextStart);
+		}
+	}
+	if (cut <= 0) return {
+		entityStart,
+		entityText
+	};
+	return {
+		entityStart: entityStart + cut,
+		entityText: entityText.slice(cut)
+	};
+};
+const splitEmbeddedLegalFormList = (entityStart, entityText) => {
+	const cuts = [0];
+	for (const suffix of getAllLegalSuffixesSync()) {
+		const suffixClean = suffix.replace(/[.,\s]/g, "");
+		if (suffixClean.length > 0 && ROMAN_NUMERAL_RE.test(suffixClean)) continue;
+		let fromIndex = 0;
+		while (fromIndex < entityText.length) {
+			const suffixStart = entityText.indexOf(suffix, fromIndex);
+			if (suffixStart === -1) break;
+			fromIndex = suffixStart + suffix.length;
+			const suffixEnd = suffixStart + suffix.length;
+			if (suffixEnd >= entityText.length - 1) continue;
+			const afterSuffix = entityText.slice(suffixEnd);
+			const boundary = LEGAL_LIST_BOUNDARY_RE.exec(afterSuffix);
+			if (boundary === null) continue;
+			const nextStart = suffixEnd + boundary[0].length;
+			const remainder = entityText.slice(nextStart);
+			if (!getAllLegalSuffixesSync().some((form) => remainder.endsWith(form))) continue;
+			cuts.push(nextStart);
+		}
+	}
+	const uniqueCuts = [...new Set(cuts)].toSorted((a, b) => a - b);
+	if (uniqueCuts.length === 1) return [{
+		entityStart,
+		entityText
+	}];
+	const segments = [];
+	for (let index = 0; index < uniqueCuts.length; index++) {
+		const start = uniqueCuts[index];
+		const end = uniqueCuts[index + 1] ?? entityText.length;
+		if (start === void 0) continue;
+		const segmentText = entityText.slice(start, end).replace(/[,\s;]+$/u, "");
+		if (segmentText.length === 0) continue;
+		segments.push({
+			entityStart: entityStart + start,
+			entityText: segmentText
+		});
+	}
+	return segments;
+};
+const hasDisallowedLineBreak = (text) => {
+	for (const match of text.matchAll(/\n/gu)) {
+		const index = match.index;
+		if (index === void 0) continue;
+		const before = text.slice(0, index);
+		const after = text.slice(index + 1);
+		const dottedDesignatorBefore = /\.[^\S\n]*$/u.test(before);
+		const legalSuffixAfter = /^[^\S\n]*(?:\p{Lu}\.[^\S\n]?){1,}\p{Lu}?\.?$/u.test(after);
+		const allCapsSuffixAfter = /^[^\S\n]*\p{Lu}{2,}\.?$/u.test(after);
+		if (!dottedDesignatorBefore || !legalSuffixAfter && !allCapsSuffixAfter) return true;
+	}
+	return false;
+};
+const hasMiddleInitialBefore = (fullText, pos) => {
+	const previousWord = findWordBefore(fullText, pos);
+	if (!previousWord) return false;
+	let scan = previousWord.start - 1;
+	while (scan >= 0 && (fullText[scan] === " " || fullText[scan] === "	")) scan--;
+	return scan >= 1 && fullText[scan] === "." && UPPER_LETTER_RE.test(fullText[scan - 1] ?? "");
+};
 /**
 * Count consecutive uppercase-starting words immediately
 * before `pos`. Stops at the first non-upper word or at
-* text/line start. Used to disambiguate "<First> <Last>
-* and <ORG>" from "<Multi-word Org> and <Continuation>".
-*/
-const countUpperWordsBefore = (fullText, pos) => {
+* text/line start. Used to disambiguate sentence prose
+* ("<First> <Last> and <ORG>", "<Defined-Term> and
+* <ORG>") from multi-word organisation names that span
+* an "and" connector ("UniCredit Bank Czech Republic and
+* Slovakia, a.s.").
+*
+* When `crossInNamePreps` is true, the walk also steps
+* over in-name lowercase prepositions ("of", "the") as
+* long as they sit between two upper words. This lets
+* the suffix-mode "and"-crossing logic see through
+* "<Trust ← and ← America ← of ← Bank>" and emit one
+* full organisation span.
+*/
+const countUpperWordsBefore = (fullText, pos, crossInNamePreps = false) => {
 	let count = 0;
 	let scan = pos;
 	while (scan > 0) {
 		const found = findWordBefore(fullText, scan);
-		if (!found) break;
-		if (!UPPER_LETTER_RE.test(found.word)) break;
-		count++;
-		scan = found.start;
+		if (found) {
+			if (UPPER_LETTER_RE.test(found.word)) {
+				count++;
+				scan = found.start;
+				continue;
+			}
+			if (crossInNamePreps && IN_NAME_PREPOSITION_RE.test(found.word)) {
+				const prev = findWordBefore(fullText, found.start);
+				if (!prev) break;
+				if (!UPPER_LETTER_RE.test(prev.word)) break;
+				scan = found.start;
+				continue;
+			}
+			break;
+		}
+		let p = scan - 1;
+		while (p >= 0 && (fullText[p] === " " || fullText[p] === "	")) p--;
+		if (p >= 1 && fullText[p] === "." && UPPER_LETTER_RE.test(fullText[p - 1] ?? "")) {
+			count++;
+			scan = p - 1;
+			continue;
+		}
+		break;
 	}
 	return count;
 };
 /**
+* True when `word` is a recognized legal-form suffix
+* (case-sensitive against the legal-forms vocabulary).
+* Used when deciding whether to cross an "and" connector
+* during backward extension — if the word immediately
+* preceding the connector is itself a legal-form suffix,
+* the "and" sits between two organisation names rather
+* than inside one ("Morgan Securities LLC and Allen &
+* Company LLC"), so the walk must stop there.
+*/
+const isKnownLegalFormSuffix = (word) => {
+	if (word.length === 0) return false;
+	return getNormalizedLegalBoundarySuffixesSync().has(word);
+};
+const isInNameLegalFormWord = (word) => {
+	if (word.length === 0) return false;
+	return getNormalizedInNameLegalFormWordsSync().has(word);
+};
+/**
+* If `pos` is immediately preceded (modulo horizontal
+* whitespace) by an initial-dot run like `J.P.`, `U.S.`,
+* or `N.A.`, return the position where the initial run
+* starts. Otherwise return `pos` unchanged. The run must
+* be word-bounded on the left so we never absorb a stray
+* sentence-ending dot.
+*/
+const skipInitialsBackward = (fullText, pos) => {
+	let scan = pos - 1;
+	while (scan >= 0) {
+		const ch = fullText.charAt(scan);
+		if (ch === "\n" || !/\s/.test(ch)) break;
+		scan--;
+	}
+	if (scan < 0 || fullText.charAt(scan) !== ".") return pos;
+	const scanLimit = Math.max(0, scan + 1 - 100);
+	const head = fullText.slice(scanLimit, scan + 1);
+	const match = /(?:\p{Lu}\.[^\S\n]?){2,}$/u.exec(head);
+	if (match === null) return pos;
+	const start = scanLimit + match.index;
+	if (start > 0) {
+		const prevCh = fullText.charAt(start - 1);
+		if (/[\p{L}\p{M}\p{N}]/u.test(prevCh)) return pos;
+	}
+	return start;
+};
+/**
 * Extend a match backward through uppercase words and
 * lowercase connectors. Stops at start of text,
 * newline, or a word that doesn't qualify.
@@ -1109,24 +1407,57 @@ const extendBackward = (fullText, matchStart, options = {}) => {
 		const isConnector = CONNECTOR_RE.test(word);
 		const isInNamePrep = suffixMode && IN_NAME_PREPOSITION_RE.test(word);
 		if (isUpper) pos = wordStart;
-		else if (isConnector) {
-			if (!suffixMode && AND_TYPE_CONNECTOR_RE.test(word) && countUpperWordsBefore(fullText, wordStart) === 2) break;
+		else if (isConnector) if (AND_TYPE_CONNECTOR_RE.test(word)) {
 			const prev = findWordBefore(fullText, wordStart);
 			if (!prev) break;
 			if (!UPPER_LETTER_RE.test(prev.word)) break;
+			if (isKnownLegalFormSuffix(prev.word)) break;
+			const upperWordsBefore = countUpperWordsBefore(fullText, wordStart, suffixMode);
+			const middleInitialBefore = hasMiddleInitialBefore(fullText, wordStart);
+			if (upperWordsBefore <= 1 && (getClauseNounHeadsSync().has(prev.word.toLowerCase()) || getConnectorProseHeadsSync().has(prev.word.toLowerCase()))) break;
+			if (suffixMode ? middleInitialBefore && hasSingleCapPrefixBefore(fullText, matchStart) : upperWordsBefore === 2 && !isInNameLegalFormWord(prev.word) || middleInitialBefore) break;
 			pos = prev.start;
-		} else if (isInNamePrep) {
+		} else {
+			const prev = findWordBefore(fullText, wordStart);
+			if (!prev) break;
+			if (!UPPER_LETTER_RE.test(prev.word)) break;
+			pos = prev.start;
+		}
+		else if (isInNamePrep) {
 			const prev = findWordBefore(fullText, wordStart);
 			if (!prev) break;
 			if (!UPPER_LETTER_RE.test(prev.word)) break;
 			pos = prev.start;
 		} else break;
 	}
+	pos = skipInitialsBackward(fullText, pos);
 	return pos;
 };
 const trimLeadingClause = (text) => {
 	let cut = -1;
-	for (const match of text.matchAll(LEADING_CLAUSE_RE)) cut = match.index + match[0].length;
+	const trims = getLeadingClauseTrimsSync();
+	const phraseAlternation = trims.phrases.map(escapeForRegex).join("|");
+	if (phraseAlternation.length > 0) {
+		const phraseRe = new RegExp(`(?:^|\\s)(?:${phraseAlternation})${HSPACE}+`, "giu");
+		for (const match of text.matchAll(phraseRe)) cut = Math.max(cut, match.index + match[0].length);
+	}
+	const directPrefixAlternation = trims.directPrefixes.map(escapeForRegex).join("|");
+	if (directPrefixAlternation.length > 0) {
+		const directPrefixRe = new RegExp(`\\b(?:${directPrefixAlternation})${HSPACE}+(?=\\p{Lu})`, "giu");
+		for (const match of text.matchAll(directPrefixRe)) {
+			const words = text.slice(0, match.index).match(/\p{L}[\p{L}\p{M}]*/gu) ?? [];
+			if (words.length >= 3 && words.some((word) => /\p{Ll}/u.test(word))) cut = Math.max(cut, match.index + match[0].length);
+		}
+	}
+	for (const match of text.matchAll(/,/gu)) {
+		const comma = match.index;
+		if (comma === void 0) continue;
+		const before = text.slice(0, comma);
+		if (!/\d/u.test(before)) continue;
+		const after = text.slice(comma + 1);
+		const leadingWs = after.match(/^\s*/u)?.[0].length ?? 0;
+		if ((after.slice(leadingWs).match(/\p{Lu}[\p{L}\p{M}\p{N}]*/gu) ?? []).length >= 3) cut = Math.max(cut, comma + 1 + leadingWs);
+	}
 	if (cut <= 0) return {
 		offset: 0,
 		text
@@ -1162,6 +1493,7 @@ const processLegalFormMatches = (allMatches, sliceStart, sliceEnd, fullText) =>
 		const firstWordMatch = /^[\p{L}\p{M}]+(?:-[\p{L}\p{M}]+)*/u.exec(text);
 		let processedStart = match.start;
 		let processedText = text;
+		if (isStructuralSingleCapMatch(processedText) || fullText !== void 0 && isBareSingleCapStructuralInnerMatch(fullText, match.start, text)) continue;
 		let trimmed = false;
 		const firstWordText = firstWordMatch?.[0] ?? "";
 		const firstWordLeading = /^[\p{L}\p{M}]+/u.exec(firstWordText)?.[0] ?? "";
@@ -1208,56 +1540,64 @@ const processLegalFormMatches = (allMatches, sliceStart, sliceEnd, fullText) =>
 				}
 			}
 		}
-		if (processedText.includes("\n")) continue;
+		if (processedText.includes("\n") && hasDisallowedLineBreak(processedText)) continue;
 		let entityStart = processedStart;
 		let entityText = processedText;
 		if (fullText && !trimmed) {
-			const extended = extendBackward(fullText, processedStart);
+			const extended = !BARE_SINGLE_CAP_LEGAL_FORM_RE.test(processedText) ? extendBackward(fullText, processedStart) : processedStart;
 			if (extended < processedStart) {
 				entityStart = extended;
 				entityText = fullText.slice(extended, processedStart + processedText.length).trimEnd();
 			}
 		}
-		const clauseTrim = trimLeadingClause(entityText);
-		if (clauseTrim.offset > 0) {
-			entityStart += clauseTrim.offset;
-			entityText = clauseTrim.text;
-		}
-		const getPrefixInfo = (value) => {
-			const prefixEnd = value.lastIndexOf(",") !== -1 ? value.lastIndexOf(",") : value.lastIndexOf(" ");
-			return {
-				prefixEnd,
-				prefixPart: prefixEnd > 0 ? value.slice(0, prefixEnd).replace(/[^a-zA-ZÀ-ž]/g, "") : value.replace(/[^a-zA-ZÀ-ž]/g, "")
-			};
-		};
-		let { prefixEnd, prefixPart } = getPrefixInfo(entityText);
-		let isAllCapsMatch = prefixPart.length > 2 && prefixPart === prefixPart.toUpperCase();
-		if (isAllCapsMatch && fullText) {
-			const lineStart = fullText.lastIndexOf("\n", entityStart);
-			const lineEnd = fullText.indexOf("\n", entityStart + entityText.length);
-			const lineLetters = fullText.slice(lineStart + 1, lineEnd === -1 ? fullText.length : lineEnd).replace(/[^a-zA-ZÀ-ž]/g, "");
-			const upperCount = [...lineLetters].filter((c) => c === c.toUpperCase()).length;
-			if (lineLetters.length > 5 && upperCount / lineLetters.length >= .95) continue;
-			if ((prefixPart.length > 0 ? entityText.slice(0, prefixEnd > 0 ? prefixEnd : entityText.length).trim().split(/\s+/).length : 0) > 3) {
-				entityStart = match.start;
-				entityText = text;
-				({prefixEnd, prefixPart} = getPrefixInfo(entityText));
-				isAllCapsMatch = prefixPart.length > 2 && prefixPart === prefixPart.toUpperCase();
+		for (const segment of splitEmbeddedLegalFormList(entityStart, entityText)) {
+			entityStart = segment.entityStart;
+			entityText = segment.entityText;
+			const listTrim = trimEmbeddedLegalFormListPrefix(entityStart, entityText);
+			entityStart = listTrim.entityStart;
+			entityText = listTrim.entityText;
+			const clauseTrim = trimLeadingClause(entityText);
+			if (clauseTrim.offset > 0) {
+				entityStart += clauseTrim.offset;
+				entityText = clauseTrim.text;
 			}
-		} else if (isAllCapsMatch) continue;
-		const lastSpace = entityText.lastIndexOf(" ");
-		const rawSuffix = lastSpace !== -1 ? entityText.slice(lastSpace + 1) : "";
-		const suffixClean = rawSuffix.replace(/[.,]/g, "");
-		if (suffixClean.length > 0 && ROMAN_NUMERAL_RE.test(suffixClean)) continue;
-		if (suffixClean.length <= 2 && !/\./.test(rawSuffix) && /[^\x00-\x7F]/.test(entityText.slice(0, lastSpace !== -1 ? lastSpace : entityText.length))) continue;
-		results.push({
-			start: entityStart,
-			end: entityStart + entityText.length,
-			label: "organization",
-			text: entityText,
-			score: .95,
-			source: DETECTION_SOURCES.LEGAL_FORM
-		});
+			if (entityText.includes("\n") && hasDisallowedLineBreak(entityText)) continue;
+			const getPrefixInfo = (value) => {
+				const prefixEnd = value.lastIndexOf(",") !== -1 ? value.lastIndexOf(",") : value.lastIndexOf(" ");
+				return {
+					prefixEnd,
+					prefixPart: prefixEnd > 0 ? value.slice(0, prefixEnd).replace(/[^a-zA-ZÀ-ž]/g, "") : value.replace(/[^a-zA-ZÀ-ž]/g, "")
+				};
+			};
+			let { prefixEnd, prefixPart } = getPrefixInfo(entityText);
+			let isAllCapsMatch = prefixPart.length > 2 && prefixPart === prefixPart.toUpperCase();
+			if (isAllCapsMatch && fullText) {
+				const lineStart = fullText.lastIndexOf("\n", entityStart);
+				const lineEnd = fullText.indexOf("\n", entityStart + entityText.length);
+				const lineLetters = fullText.slice(lineStart + 1, lineEnd === -1 ? fullText.length : lineEnd).replace(/[^a-zA-ZÀ-ž]/g, "");
+				const upperCount = [...lineLetters].filter((c) => c === c.toUpperCase()).length;
+				if (lineLetters.length > 5 && upperCount / lineLetters.length >= .95) continue;
+				if ((prefixPart.length > 0 ? entityText.slice(0, prefixEnd > 0 ? prefixEnd : entityText.length).trim().split(/\s+/).length : 0) > 3) {
+					entityStart = match.start;
+					entityText = text;
+					({prefixEnd, prefixPart} = getPrefixInfo(entityText));
+					isAllCapsMatch = prefixPart.length > 2 && prefixPart === prefixPart.toUpperCase();
+				}
+			} else if (isAllCapsMatch) continue;
+			const lastSuffixSeparator = findLastSuffixSeparator(entityText);
+			const rawSuffix = lastSuffixSeparator !== -1 ? entityText.slice(lastSuffixSeparator + 1) : "";
+			const suffixClean = rawSuffix.replace(/[.,]/g, "");
+			if (suffixClean.length > 0 && ROMAN_NUMERAL_RE.test(suffixClean)) continue;
+			if (suffixClean.length <= 2 && !/\./.test(rawSuffix) && /[^\x00-\x7F]/.test(stripDocxSpaces(entityText.slice(0, lastSuffixSeparator !== -1 ? lastSuffixSeparator : entityText.length)))) continue;
+			results.push({
+				start: entityStart,
+				end: entityStart + entityText.length,
+				label: "organization",
+				text: entityText,
+				score: .95,
+				source: DETECTION_SOURCES.LEGAL_FORM
+			});
+		}
 	}
 	return results;
 };
@@ -1564,20 +1904,23 @@ const processGazetteerMatches = (allMatches, sliceStart, sliceEnd, fullText, dat
 		const label = data.labels[localIdx];
 		if (!label) continue;
 		const extended = tryPrefixExtension(fullText, match.start, match.end);
+		const isExtended = extended !== null;
 		const end = extended?.end ?? match.end;
 		const text = extended?.text ?? fullText.slice(match.start, match.end);
 		exactSpans.push({
 			start: match.start,
 			end
 		});
-		results.push({
+		const entity = {
 			start: match.start,
 			end,
 			label,
 			text,
 			score: .9,
 			source: DETECTION_SOURCES.GAZETTEER
-		});
+		};
+		if (isExtended) entity.sourceDetail = "gazetteer-extension";
+		results.push(entity);
 	}
 	for (const match of allMatches) {
 		const idx = match.pattern;
@@ -1668,20 +2011,31 @@ const getNameCorpusTitles = (ctx = defaultContext) => ctx.nameCorpus?.titlesList
 *   with per-language first names and surnames. When
 *   omitted, only legacy config files are used.
 */
-const initNameCorpus = (ctx = defaultContext, dictionaries) => {
-	if (ctx.nameCorpusPromise) return ctx.nameCorpusPromise;
+const initNameCorpus = (ctx = defaultContext, dictionaries, languages) => {
+	const languageKey = languages?.toSorted().join(",") ?? "*";
+	if (ctx.nameCorpus && ctx.nameCorpusKey === languageKey) return Promise.resolve();
+	if (ctx.nameCorpusPromise && ctx.nameCorpusKey === languageKey) return ctx.nameCorpusPromise;
+	ctx.nameCorpus = null;
+	ctx.nameCorpusKey = languageKey;
 	const promise = (async () => {
 		try {
-			const [legacyFirstMod, legacySurnameMod, titleMod, exclusionMod] = await Promise.all([
+			const [legacyFirstMod, legacySurnameMod, titleMod, exclusionMod, commonWordsMod] = await Promise.all([
 				import("./names-first.mjs"),
 				import("./names-surnames.mjs"),
 				import("./names-title-tokens.mjs"),
-				import("./names-exclusions.mjs")
+				import("./names-exclusions.mjs"),
+				import("./common-words-en.mjs")
 			]);
 			const firstNames = [...legacyFirstMod.default.names];
-			if (dictionaries?.firstNames) for (const names of Object.values(dictionaries.firstNames)) for (const name of names) firstNames.push(name);
+			if (dictionaries?.firstNames) {
+				const entries = languages === void 0 ? Object.entries(dictionaries.firstNames) : Object.entries(dictionaries.firstNames).filter(([language]) => languages.includes(language));
+				for (const [, names] of entries) for (const name of names) firstNames.push(name);
+			}
 			const surnames = [...legacySurnameMod.default.names];
-			if (dictionaries?.surnames) for (const names of Object.values(dictionaries.surnames)) for (const name of names) surnames.push(name);
+			if (dictionaries?.surnames) {
+				const entries = languages === void 0 ? Object.entries(dictionaries.surnames) : Object.entries(dictionaries.surnames).filter(([language]) => languages.includes(language));
+				for (const [, names] of entries) for (const name of names) surnames.push(name);
+			}
 			const dedup = (arr) => {
 				const seen = /* @__PURE__ */ new Set();
 				const result = [];
@@ -1692,8 +2046,9 @@ const initNameCorpus = (ctx = defaultContext, dictionaries) => {
 				}
 				return result;
 			};
+			const commonWords = new Set(commonWordsMod.default.words.map((word) => word.toLowerCase()));
 			const dedupFirst = dedup(firstNames);
-			const dedupSurnames = dedup(surnames);
+			const dedupSurnames = dedup(surnames).filter((name) => !commonWords.has(name.toLowerCase()));
 			const titles = titleMod.default.tokens;
 			const exclusions = exclusionMod.default.words;
 			ctx.nameCorpus = {
@@ -2122,8 +2477,10 @@ const MIN_MONTH_NAME_LENGTH = 3;
 const escapeTitle = (title) => title.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\s+/g, "\\s*");
 /** Escape for use inside a regex alternation. */
 const escapeRegex$2 = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const escapeRegexPhrase = (s) => escapeRegex$2(s.trim()).replace(/\s+/g, "[^\\S\\n\\t]+");
 /** Escape for use inside a regex character class. */
 const escapeCharClass = (s) => s.replace(/[\]\\^-]/g, "\\$&");
+const toSortedAlternation = (values) => [...new Set(values.map(escapeRegexPhrase).filter((value) => value.length > 0))].toSorted((a, b) => b.length - a.length).join("|");
 const TITLE_PREFIX = TITLE_PREFIXES.toSorted((a, b) => b.length - a.length).map(escapeTitle).join("|");
 const POST_NOMINAL = POST_NOMINALS.toSorted((a, b) => b.length - a.length).map(escapeTitle).join("|");
 const NAME_WORD = `\\p{Lu}\\p{Ll}+`;
@@ -2134,6 +2491,7 @@ const HONORIFIC_ALT = [...HONORIFICS].toSorted((a, b) => b.length - a.length).ma
 	const escaped = escapeRegex$2(h);
 	return HONORIFIC_BOUNDARY.has(h) ? `\\b${escaped}` : escaped;
 }).join("|");
+const AMOUNT_WORDS = amount_words_default;
 const toEntry = (validator, label, score) => {
 	const pattern = toRegex(validator).source;
 	if (!pattern) return null;
@@ -2171,9 +2529,14 @@ const STDNUM_ENTRIES = [
 	toEntry(at.uid, "tax identification number", .95),
 	toEntry(at.tin, "tax identification number", .9),
 	toEntry(at.businessid, "registration number", .95),
+	toEntry(ch.uid, "registration number", .95),
+	toEntry(au.abn, "tax identification number", .9),
+	toEntry(au.acn, "registration number", .9),
 	toEntry(be.vat, "tax identification number", .95),
 	toEntry(be.nn, "national identification number", .9),
 	toEntry(nl.vat, "tax identification number", .95),
+	toEntry(no.orgnr, "registration number", .9),
+	toEntry(no.mva, "tax identification number", .95),
 	toEntry(dk.vat, "tax identification number", .95),
 	toEntry(dk.cpr, "national identification number", .9),
 	toEntry(fi.vat, "tax identification number", .95),
@@ -2203,6 +2566,7 @@ const STDNUM_ENTRIES = [
 	toEntry(cy.vat, "tax identification number", .95),
 	toEntry(mt.vat, "tax identification number", .95),
 	toEntry(lu.vat, "tax identification number", .95),
+	toEntry(us.ein, "tax identification number", .9),
 	toEntry(br.cpf, "tax identification number", .95),
 	toEntry(br.cnpj, "tax identification number", .95)
 ].filter((e) => e !== null);
@@ -2315,6 +2679,30 @@ const ES_CIF = {
 	score: .95,
 	validator: es.cif
 };
+const AU_ABN_FORMATTED = {
+	pattern: `\\b\\d{2}[^\\S\\n]\\d{3}[^\\S\\n]\\d{3}[^\\S\\n]\\d{3}\\b`,
+	label: "tax identification number",
+	score: .95,
+	validator: au.abn
+};
+const NO_ORGNR_FORMATTED = {
+	pattern: `\\b\\d{3}[^\\S\\n]\\d{3}[^\\S\\n]\\d{3}\\b`,
+	label: "registration number",
+	score: .9,
+	validator: no.orgnr
+};
+const NO_MVA_FORMATTED = {
+	pattern: "\\bNO[^\\S\\n]?\\d{3}[^\\S\\n]?\\d{3}[^\\S\\n]?\\d{3}[^\\S\\n]?MVA\\b",
+	label: "tax identification number",
+	score: .95,
+	validator: no.mva
+};
+const US_EIN_FORMATTED = {
+	pattern: `\\b\\d{2}${DASH}\\d{7}\\b`,
+	label: "tax identification number",
+	score: .95,
+	validator: us.ein
+};
 const BR_CPF_FORMATTED = {
 	pattern: `\\b\\d{3}\\.\\d{3}\\.\\d{3}${DASH}\\d{2}\\b`,
 	label: "tax identification number",
@@ -2347,6 +2735,58 @@ const SHORT_TLDS = "de|at|be|se|fi|dk|no|it|uk";
 const HOST_LABEL = `[a-zA-Z0-9](?:[a-zA-Z0-9\\-]*[a-zA-Z0-9])?`;
 const BARE_HOST = `\\b[a-zA-Z0-9][a-zA-Z0-9\\-]+[a-zA-Z0-9]`;
 const PATH_SUFFIX = `(?:[/?#][^\\s)\\]>]*[^\\s.,;:!?)\\]>])?`;
+const BARE_DOMAIN = {
+	pattern: `${BARE_HOST}(?:\\.${HOST_LABEL})*\\.(?:${LONG_TLDS})\\b${PATH_SUFFIX}|${BARE_HOST}(?:\\.${HOST_LABEL})+\\.(?:${SHORT_TLDS})\\b${PATH_SUFFIX}`,
+	label: "url",
+	score: .9
+};
+const IPV6_ADDRESS = {
+	pattern: "\\b(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\\b|\\b(?:[0-9a-fA-F]{1,4}:){1,7}:\\b|::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}",
+	label: "ip address",
+	score: 1
+};
+const MAC_ADDRESS = {
+	pattern: "\\b(?:[0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}\\b|\\b(?:[0-9a-fA-F]{2}-){5}[0-9a-fA-F]{2}\\b",
+	label: "mac address",
+	score: 1
+};
+const UK_POSTCODE = {
+	pattern: "\\b(?:GIR[^\\S\\n]?0AA|[A-PR-UWYZ](?:[A-HK-Y][0-9](?:[0-9]|[ABEHMNPRV-Y])?|[0-9](?:[0-9]|[A-HJKPS-UW])?)[^\\S\\n]?[0-9][ABD-HJLNP-UW-Z]{2})\\b",
+	label: "address",
+	score: .9
+};
+const UK_NINO = {
+	pattern: "\\b[A-CEGHJ-PR-TWXYZ][A-CEGHJ-NPR-TWXYZ][^\\S\\n]?\\d{2}[^\\S\\n]?\\d{2}[^\\S\\n]?\\d{2}[^\\S\\n]?[A-D]?\\b",
+	label: "social security number",
+	score: .95,
+	validator: gb.nino
+};
+const TIME_12H = {
+	pattern: "\\b(?:1[0-2]|0?[1-9]):[0-5]\\d[^\\S\\n]?(?:[aApP]\\.?[mM]\\.?)(?=[\\s,;!?)]|$)",
+	label: "date",
+	score: .9
+};
+const PERCENT_TOKEN = `${`(?:[+${DASH_INNER}])?(?:\\d{1,3}(?:[.,]\\d{3})+(?:[.,]\\d{1,4})?|\\d+(?:[.,]\\d{1,4})?)`}[^\\S\\n]{0,2}%`;
+const PERCENT_RANGE_NUMBER = `\\d+(?:[.,]\\d{1,4})?`;
+const PERCENT_RANGE = `${PERCENT_RANGE_NUMBER}[^\\S\\n]*${DASH}[^\\S\\n]*${PERCENT_RANGE_NUMBER}[^\\S\\n]{0,2}%`;
+const buildPercentWordPattern = (config) => {
+	const phrases = [];
+	for (const entry of config.percentages ?? []) {
+		const ones = entry.ones.map(escapeRegex$2);
+		const standalone = (entry.standalone ?? []).map(escapeRegex$2);
+		const baseWords = [
+			...ones,
+			...entry.teens,
+			...entry.tens
+		].map(escapeRegex$2);
+		const compoundSeparator = entry.allowSpaceCompoundSeparator ? `(?:${DASH}|[^\\S\\n]+)` : DASH;
+		const compound = `(?:${baseWords.join("|")})` + (ones.length > 0 ? `(?:${compoundSeparator}(?:${ones.join("|")}))?` : "");
+		const word = `(?:${[...standalone, compound].join("|")})`;
+		const keyword = `(?:${entry.keywords.map(escapeRegex$2).join("|")})`;
+		phrases.push(`${word}[^\\S\\n]+${keyword}`);
+	}
+	return phrases.length > 0 ? `(?i:(?:${phrases.join("|")}))` : "(?!)";
+};
 /**
 * All static PII regex definitions. Scanned in a
 * single pass by @stll/regex-set (Rust DFA).
@@ -2383,41 +2823,25 @@ const ALL_REGEX_DEFS = [
 	ES_DNI,
 	ES_NIE,
 	ES_CIF,
+	AU_ABN_FORMATTED,
+	NO_ORGNR_FORMATTED,
+	NO_MVA_FORMATTED,
+	US_EIN_FORMATTED,
 	BR_CPF_FORMATTED,
 	BR_CNPJ_FORMATTED,
 	BR_RG_WITH_SSP,
 	BR_OAB,
 	URL,
+	IPV6_ADDRESS,
+	MAC_ADDRESS,
+	BARE_DOMAIN,
+	UK_POSTCODE,
+	UK_NINO,
+	TIME_12H,
 	{
-		pattern: "\\b(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\\b|\\b(?:[0-9a-fA-F]{1,4}:){1,7}:\\b|::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}",
-		label: "ip address",
-		score: 1
-	},
-	{
-		pattern: "\\b(?:[0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}\\b|\\b(?:[0-9a-fA-F]{2}-){5}[0-9a-fA-F]{2}\\b",
-		label: "mac address",
-		score: 1
-	},
-	{
-		pattern: `${BARE_HOST}(?:\\.${HOST_LABEL})*\\.(?:${LONG_TLDS})\\b${PATH_SUFFIX}|${BARE_HOST}(?:\\.${HOST_LABEL})+\\.(?:${SHORT_TLDS})\\b${PATH_SUFFIX}`,
-		label: "url",
-		score: .9
-	},
-	{
-		pattern: "\\b(?:GIR[^\\S\\n]?0AA|[A-PR-UWYZ](?:[A-HK-Y][0-9](?:[0-9]|[ABEHMNPRV-Y])?|[0-9](?:[0-9]|[A-HJKPS-UW])?)[^\\S\\n]?[0-9][ABD-HJLNP-UW-Z]{2})\\b",
-		label: "address",
-		score: .9
-	},
-	{
-		pattern: "\\b[A-CEGHJ-PR-TWXYZ][A-CEGHJ-NPR-TWXYZ][^\\S\\n]?\\d{2}[^\\S\\n]?\\d{2}[^\\S\\n]?\\d{2}[^\\S\\n]?[A-D]?\\b",
-		label: "social security number",
-		score: .95,
-		validator: gb.nino
-	},
-	{
-		pattern: "\\b(?:1[0-2]|0?[1-9]):[0-5]\\d[^\\S\\n]?(?:[aApP]\\.?[mM]\\.?)(?=[\\s,;!?)]|$)",
-		label: "date",
-		score: .9
+		pattern: `(?<![\\p{L}\\p{N}_.,])(?:${buildPercentWordPattern(AMOUNT_WORDS)}[^\\S\\n]*\\([^\\S\\n]*${PERCENT_TOKEN}[^\\S\\n]*\\)|${PERCENT_RANGE}|${PERCENT_TOKEN})(?![\\p{L}\\p{N}_])`,
+		label: "monetary amount",
+		score: .85
 	},
 	...STDNUM_ENTRIES
 ];
@@ -2491,6 +2915,41 @@ const DATE_PATTERN_META = Object.freeze({
 	label: "date",
 	score: 1
 });
+const buildMagnitudePattern = (config) => {
+	const words = [];
+	const caseInsensitiveAbbreviations = [];
+	const caseSensitiveAbbreviations = [];
+	for (const entry of config.magnitudeSuffixes ?? []) {
+		words.push(...entry.words ?? []);
+		caseInsensitiveAbbreviations.push(...entry.abbreviationsCaseInsensitive ?? []);
+		caseSensitiveAbbreviations.push(...entry.abbreviationsCaseSensitive ?? []);
+	}
+	const branches = [];
+	const wordsAlt = toSortedAlternation(words);
+	const abbreviationCiAlt = toSortedAlternation(caseInsensitiveAbbreviations);
+	const abbreviationCsAlt = toSortedAlternation(caseSensitiveAbbreviations);
+	if (wordsAlt) branches.push(`[^\\S\\n\\t]+(?i:(?:${wordsAlt}))\\b`);
+	if (abbreviationCiAlt) branches.push(`[^\\S\\n\\t]?(?i:${abbreviationCiAlt})\\b`);
+	if (abbreviationCsAlt) branches.push(`[^\\S\\n\\t]?(?:${abbreviationCsAlt})\\b`);
+	return branches.length > 0 ? `(?:${branches.join("|")})?` : "";
+};
+const buildQuantityFollowerGuard = (config) => {
+	const modifiers = [];
+	const nouns = [];
+	for (const entry of config.shareQuantityTerms ?? []) {
+		modifiers.push(...entry.modifiers ?? []);
+		nouns.push(...entry.nouns);
+	}
+	const modifierAlt = toSortedAlternation(modifiers);
+	const nounAlt = toSortedAlternation(nouns);
+	if (!nounAlt) return "";
+	return `(?![^\\S\\n\\t]+(?i:${modifierAlt ? `(?:(?:${modifierAlt})[^\\S\\n\\t]+){0,3}` : ""}(?:${nounAlt}))\\b)`;
+};
+const buildFinancialLexicons = (config) => Object.freeze({
+	magnitude: buildMagnitudePattern(config),
+	quantityFollowerGuard: buildQuantityFollowerGuard(config)
+});
+const FINANCIAL_LEXICONS = buildFinancialLexicons(AMOUNT_WORDS);
 /**
 * Build symbol character class, code alternation,
 * and local-name alternation from currencies.json,
@@ -2530,9 +2989,13 @@ const buildCurrencyPatterns = (data) => {
 	const patterns = [];
 	const DECIMAL = `(?:[.,](?=\\d|[${DASH_INNER}])[^\\S\\n\\t]?(?:\\d{1,2}${DASH}?|${DASH}{1,2}))?`;
 	const END = `(?:\\b|(?=\\s|[.,;!?)]|$))`;
-	if (symbols) patterns.push(`(?:[${symbols}])[^\\S\\n\\t]?${NUM}${DECIMAL}${END}`);
-	if (trailingAlt) patterns.push(`\\b(?:${trailingAlt})[^\\S\\n\\t]{0,2}${NUM}${DECIMAL}${END}`);
-	if (trailingAlt) patterns.push(`\\b${NUM}${DECIMAL}[^\\S\\n\\t]{0,4}(?:${trailingAlt})${END}`);
+	const MAGNITUDE = FINANCIAL_LEXICONS.magnitude;
+	if (symbols) patterns.push(`(?:[${symbols}])[^\\S\\n\\t]?${NUM}${DECIMAL}${MAGNITUDE}${END}`);
+	if (trailingAlt) patterns.push(`\\b(?:${trailingAlt})[^\\S\\n\\t]{0,2}${NUM}${DECIMAL}${MAGNITUDE}${END}`);
+	if (trailingAlt) {
+		const optionalLeadingSymbol = symbols ? `(?<![\\p{L}\\p{N}_])(?:[${symbols}][^\\S\\n\\t]?)?` : "\\b";
+		patterns.push(`${optionalLeadingSymbol}${NUM}${DECIMAL}${MAGNITUDE}[^\\S\\n\\t]{0,4}(?:${trailingAlt})${FINANCIAL_LEXICONS.quantityFollowerGuard}${END}`);
+	}
 	return patterns;
 };
 /** Cached promise for currency patterns. Loaded once. */
@@ -2846,10 +3309,19 @@ const stripQuotes = (value) => {
 		text: stripped
 	};
 };
-/** Hard stop characters for to-next-comma scanning. */
+/**
+* Hard stop characters for to-next-comma scanning. A closing
+* parenthesis or closing bracket terminates a clause just like
+* an opening one: `State of New York or any other jurisdiction)`
+* is the tail of a parenthesised insertion, not the start of a
+* larger phrase that should be absorbed into a jurisdiction span.
+*/
 const COMMA_STOP_CHARS = new Set([
 	"\n",
 	"(",
+	")",
+	"[",
+	"]",
 	"	",
 	";"
 ]);
@@ -3015,6 +3487,27 @@ const getAddressStopKeywordsSync = () => addressStopKeywordsCache ?? ADDRESS_STO
 const warmAddressStopKeywords = async () => {
 	await loadAddressStopKeywords();
 };
+const MAX_TRIGGER_VALUE_LEN = 100;
+const MIN_TRIGGER_PHONE_DIGITS = 5;
+const PHONE_VALUE_START_RE = /^[+(\d]/;
+const ISO_DATE_PREFIX_RE = /^\d{4}-\d{2}-\d{2}\b/;
+const INLINE_FIELD_LABEL_RE = /\b[\p{L}][\p{L}\p{M} /-]{1,32}:/u;
+const INLINE_FIELD_LABEL_STOP_RE = /(?:^|[^\S\n\t])[\p{L}][\p{L}\p{M} /-]{1,32}:/u;
+const capAtWordBoundary = (valueText, cap) => {
+	let capped = cap;
+	const isWordChar = (i) => /[\p{L}\p{N}]/u.test(valueText[i] ?? "");
+	while (capped > 0 && isWordChar(capped - 1) && isWordChar(capped)) capped--;
+	return capped;
+};
+const isPlausiblePhoneTriggerValue = (value) => {
+	const trimmed = value.trimStart();
+	if (!PHONE_VALUE_START_RE.test(trimmed)) return false;
+	if (ISO_DATE_PREFIX_RE.test(trimmed)) return false;
+	if (INLINE_FIELD_LABEL_RE.test(trimmed)) return false;
+	let digits = 0;
+	for (const ch of trimmed) if (/\d/.test(ch)) digits++;
+	return digits >= MIN_TRIGGER_PHONE_DIGITS;
+};
 const extractValue = (text, triggerEnd, strategy, label) => {
 	const remaining = text.slice(triggerEnd);
 	const stripped = remaining.replace(/^[\s:;]+/, "");
@@ -3026,21 +3519,11 @@ const extractValue = (text, triggerEnd, strategy, label) => {
 			const stopWords = strategy.stopWords ?? [];
 			const stopWordRe = stopWords.length > 0 ? new RegExp(`^(?:${stopWords.map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})(?![\\p{L}\\p{N}])`, "iu") : null;
 			let end = 0;
-			let foundStop = false;
 			while (end < valueText.length) {
 				const ch = valueText[end];
-				if (ch !== void 0 && COMMA_STOP_CHARS.has(ch)) {
-					foundStop = true;
-					break;
-				}
-				if (ch === "." && isSentenceTerminator(valueText, end)) {
-					foundStop = true;
-					break;
-				}
-				if (stopWordRe !== null && (end === 0 || !/[\p{L}\p{N}]/u.test(valueText[end - 1] ?? "")) && stopWordRe.test(valueText.slice(end))) {
-					foundStop = true;
-					break;
-				}
+				if (ch !== void 0 && COMMA_STOP_CHARS.has(ch)) break;
+				if (ch === "." && isSentenceTerminator(valueText, end)) break;
+				if (stopWordRe !== null && (end === 0 || !/[\p{L}\p{N}]/u.test(valueText[end - 1] ?? "")) && stopWordRe.test(valueText.slice(end))) break;
 				if (ch === ",") {
 					const afterComma = valueText.slice(end);
 					if (DECIMAL_COMMA_RE.test(afterComma)) {
@@ -3052,12 +3535,12 @@ const extractValue = (text, triggerEnd, strategy, label) => {
 						end += degreeMatch[0].length;
 						continue;
 					}
-					foundStop = true;
 					break;
 				}
 				end++;
 			}
-			if (!foundStop) end = Math.min(end, 100);
+			const lengthCap = strategy.maxLength ?? 100;
+			if (end > lengthCap) end = capAtWordBoundary(valueText, lengthCap);
 			const rawSlice = valueText.slice(0, end);
 			const extracted = rawSlice.trim();
 			if (extracted.length === 0) return null;
@@ -3071,12 +3554,24 @@ const extractValue = (text, triggerEnd, strategy, label) => {
 		case "to-end-of-line": {
 			const consumed = remaining.length - valueText.length;
 			if (consumed > 0 && remaining.slice(0, consumed).includes("\n")) return null;
-			const LINE_STOPS = ["\n"];
+			const LINE_STOPS = ["\n", "	"];
 			let end = valueText.length;
+			let foundLineStop = false;
 			for (const ch of LINE_STOPS) {
 				const idx = valueText.indexOf(ch);
-				if (idx !== -1 && idx < end) end = idx;
+				if (idx !== -1 && idx < end) {
+					end = idx;
+					foundLineStop = true;
+				}
+			}
+			if (label === "phone number") {
+				const inlineLabel = INLINE_FIELD_LABEL_STOP_RE.exec(valueText.slice(0, end));
+				if (inlineLabel) {
+					end = inlineLabel.index;
+					foundLineStop = true;
+				}
 			}
+			if (!foundLineStop) end = capAtWordBoundary(valueText, Math.min(end, MAX_TRIGGER_VALUE_LEN));
 			const rawSlice = valueText.slice(0, end);
 			const extracted = rawSlice.trim();
 			if (extracted.length === 0) return null;
@@ -3256,6 +3751,7 @@ const processTriggerMatches = (allMatches, sliceStart, sliceEnd, fullText, rules
 		const value = rawValue ? stripQuotes(rawValue) : null;
 		if (value) {
 			if (!applyValidations(value.text, rule.validations)) continue;
+			if (rule.label === "phone number" && !isPlausiblePhoneTriggerValue(value.text)) continue;
 			const entityStart = rule.includeTrigger ? match.start : value.start;
 			const entityEnd = value.end;
 			const entityText = fullText.slice(entityStart, entityEnd);
@@ -3597,7 +4093,7 @@ const normalizeHomoglyphs = (text) => {
 //#endregion
 //#region src/filters/false-positives.ts
 const TEMPLATE_PLACEHOLDER_RE = /^(?:\.{3,}|_{3,}|\[[\w\s]+\]|\{[\w\s]+\})$/;
-const POSTAL_CODE_RE = /\d{3}\s?\d{2}/;
+const POSTAL_CODE_RE$1 = /\d{3}\s?\d{2}/;
 const HAS_DIGIT_RE = /\d/;
 const ADDRESS_COMPONENT_EXTRA_RE = /(?:^|\s)(?:č\.p\.|č\.ev\.|č\.|sídliště)(?=[\s,./]|$)/i;
 const BARE_COURS_PROSE_RE = /(?:^|\s)cours(?!\s+\p{Lu})(?=[\s,./]|$)/u;
@@ -3662,7 +4158,7 @@ const normalizeEntity = (entity) => {
 		text
 	};
 };
-const EMPTY_GENERIC_ROLES = /* @__PURE__ */ new Set();
+const EMPTY_GENERIC_ROLES$1 = /* @__PURE__ */ new Set();
 /**
 * Load generic-roles.json and cache the result on the
 * given context. Must be awaited during pipeline init
@@ -3686,14 +4182,14 @@ const loadGenericRoles = (ctx = defaultContext) => {
 	return ctx.genericRolesPromise;
 };
 /** Sync accessor — returns empty set before init. */
-const getGenericRoles = (ctx) => ctx.genericRoles ?? EMPTY_GENERIC_ROLES;
+const getGenericRoles = (ctx) => ctx.genericRoles ?? EMPTY_GENERIC_ROLES$1;
 const STREET_TYPES_SEED_RE = /(?:^|\s)(?:ul\.|ulice|nám\.|náměstí|tř\.|třída|nábř\.|nábřeží|bulvár)(?=[\s,./]|$)/i;
 let _streetTypesRe = STREET_TYPES_SEED_RE;
 let _streetTypesPromise = null;
 const escapeRegex$1 = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 const loadStreetTypeRegex = async () => {
 	try {
-		const data = (await import("./address-street-types.mjs")).default ?? {};
+		const data = (await import("./address-street-types.mjs").then((n) => n.n)).default ?? {};
 		const words = /* @__PURE__ */ new Set();
 		for (const [key, val] of Object.entries(data)) {
 			if (key.startsWith("_")) continue;
@@ -3762,7 +4258,7 @@ const filterFalsePositives = (entities, ctx = defaultContext, fullText) => {
 		}
 		if ((normalized.label === "person" || normalized.label === "organization") && roles.has(normalizeHomoglyphs(trimmed).toLowerCase())) continue;
 		if (normalized.label === "organization" && normalized.source === "legal-form" && trimmed === trimmed.toUpperCase() && LEGAL_FORM_HEADING_RE.test(trimmed)) continue;
-		if (normalized.label === "address" && trimmed.length > 40 && !POSTAL_CODE_RE.test(trimmed) && !HAS_DIGIT_RE.test(trimmed) && !hasAddressComponent(trimmed) && !JURISDICTION_RE.test(trimmed)) continue;
+		if (normalized.label === "address" && trimmed.length > 40 && !POSTAL_CODE_RE$1.test(trimmed) && !HAS_DIGIT_RE.test(trimmed) && !hasAddressComponent(trimmed) && !JURISDICTION_RE.test(trimmed)) continue;
 		if (normalized.label === "address" && normalized.source === "trigger" && !HAS_DIGIT_RE.test(trimmed) && !hasAddressComponent(trimmed) && !JURISDICTION_RE.test(trimmed)) continue;
 		if (normalized.label === "address" && normalized.source === "trigger" && !HAS_DIGIT_RE.test(trimmed) && isOnlyAmbiguousCours(trimmed)) continue;
 		if (normalized.label === "address" && SIGNING_CLAUSE_ADDRESS_RE.test(trimmed)) continue;
@@ -3826,6 +4322,42 @@ const loadAllowList = (ctx) => {
 const EMPTY_ALLOW_LIST = /* @__PURE__ */ new Set();
 /** Sync accessor — returns empty set before init. */
 const getAllowList = (ctx) => ctx.allowList ?? EMPTY_ALLOW_LIST;
+let commonWordsPromise = null;
+let commonWordsCache = null;
+const loadCommonWords = () => {
+	if (commonWordsCache) return Promise.resolve(commonWordsCache);
+	if (commonWordsPromise) return commonWordsPromise;
+	commonWordsPromise = (async () => {
+		try {
+			const mod = await import("./common-words-en.mjs");
+			const set = new Set((mod.default?.words ?? []).map((word) => word.toLowerCase()));
+			commonWordsCache = set;
+			return set;
+		} catch {
+			const empty = /* @__PURE__ */ new Set();
+			commonWordsCache = empty;
+			return empty;
+		}
+	})();
+	return commonWordsPromise;
+};
+/**
+* Curated dictionary entries that are pure dotted
+* single-letter acronyms (e.g. `S.C.`, `D.N.J.`, `C.E.C.`)
+* need targeted suffix guards. The AC search matches
+* case-insensitively on token boundaries where `.` is not
+* a word character, so `S.C.` can match inside `U.S.C.`.
+* Two-segment non-address aliases are too noisy and are
+* dropped at build time; longer official aliases stay
+* searchable and are only suppressed when the source text
+* shows they are the tail of a longer dotted token.
+* Caller-supplied custom entries are exempted.
+*/
+const DOTTED_ACRONYM_RE = /^(?=.{3,}$)\p{L}(?:\.\p{L}){0,3}\.?$/u;
+const isCuratedNoiseAcronym = (normalized) => DOTTED_ACRONYM_RE.test(normalized);
+const dottedAcronymSegmentCount = (normalized) => normalized.split(".").filter(Boolean).length;
+const isShortCuratedNoiseAcronym = (normalized) => isCuratedNoiseAcronym(normalized) && dottedAcronymSegmentCount(normalized) <= 2;
+const isDottedAcronymSuffixCollision = (fullText, start, matchText) => isCuratedNoiseAcronym(matchText) && /[\p{L}]\.$/u.test(fullText.slice(Math.max(0, start - 2), start));
 /**
 * Common EU given names present in the stopwords-iso dataset
 * but absent from the first-name corpus. Without this
@@ -3962,7 +4494,7 @@ let streetTypeReLoaded = false;
 const loadStreetTypeRe = async () => {
 	if (streetTypeReLoaded) return cachedStreetTypeRe;
 	try {
-		const config = (await import("./address-street-types.mjs")).default ?? {};
+		const config = (await import("./address-street-types.mjs").then((n) => n.n)).default ?? {};
 		const words = [];
 		for (const value of Object.values(config)) {
 			if (!Array.isArray(value)) continue;
@@ -4040,6 +4572,21 @@ const SENTENCE_STARTER_WORDS = new Set([
 const PERSON_CHAIN_BREAK_RE = /[!?;:]|,/u;
 const WORD_CHAR_RE$1 = /[\p{L}\p{N}]/u;
 const isInitialContinuationGap = (text, gap) => /^\p{Lu}$/u.test(text) && /^\.[^\S\n]{1,2}$/u.test(gap) || /^[^\S\n]{1,2}(?:\p{Lu}\.[^\S\n]{1,2})+$/u.test(gap);
+const getCityEntries = (dictionaries, allowedCountries) => {
+	const byCountry = dictionaries?.citiesByCountry;
+	if (!byCountry) return dictionaries?.cities ?? [];
+	const result = [];
+	const append = (entries) => {
+		if (!entries) return;
+		for (const entry of entries) result.push(entry);
+	};
+	if (allowedCountries === null) {
+		for (const entries of Object.values(byCountry)) append(entries);
+		return result;
+	}
+	for (const country of allowedCountries) append(byCountry[country.toUpperCase()]);
+	return result;
+};
 /**
 * Resolve which dictionaries to load based on country
 * and category filters, then build the deny list data.
@@ -4051,21 +4598,24 @@ const isInitialContinuationGap = (text, gap) => /^\p{Lu}$/u.test(text) && /^\.[^
 * Returns null if no dictionaries are provided.
 */
 const buildDenyList = async (config, ctx = defaultContext) => {
-	await initNameCorpus(ctx, config.dictionaries);
+	await initNameCorpus(ctx, config.dictionaries, config.nameCorpusLanguages);
 	await Promise.all([
 		loadStopwords(ctx),
 		loadAllowList(ctx),
 		loadPersonStopwords(ctx),
 		loadAddressStopwords(ctx),
+		loadCommonWords(),
 		loadStreetTypeRe(),
 		loadGenericRoles(ctx)
 	]);
+	const commonWords = await loadCommonWords();
 	const dictionaries = config.dictionaries;
 	const hasDenyList = dictionaries?.denyList && dictionaries?.denyListMeta;
-	const hasCities = dictionaries?.cities && dictionaries.cities.length > 0;
 	const hasCustomDenyList = config.customDenyList !== void 0 && config.customDenyList.length > 0;
-	if (!hasDenyList && !hasCities && !hasCustomDenyList) return buildNameCorpusOnly(config, ctx);
 	const allowedCountries = resolveCountries(config.denyListRegions, config.denyListCountries);
+	const cityEntries = getCityEntries(dictionaries, allowedCountries);
+	const hasCities = cityEntries.length > 0;
+	if (!hasDenyList && !hasCities && !hasCustomDenyList) return buildNameCorpusOnly(config, ctx);
 	const excluded = config.denyListExcludeCategories;
 	const excludeCategories = excluded ? new Set(excluded) : /* @__PURE__ */ new Set();
 	const patternList = [];
@@ -4077,6 +4627,10 @@ const buildDenyList = async (config, ctx = defaultContext) => {
 		const normalized = source === "custom-deny-list" ? normalizeForSearch(entry) : normalizeForSearch(entry).replace(/[|\\]/g, "");
 		if (normalized.length === 0) return;
 		const lower = normalized.toLowerCase();
+		if (source !== "custom-deny-list" && label !== "address") {
+			if (SINGLE_WORD_RE.test(normalized) && commonWords.has(lower)) return;
+			if (isShortCuratedNoiseAcronym(normalized)) return;
+		}
 		const existing = patternIndex.get(lower);
 		if (existing !== void 0) {
 			if (!labelList[existing].includes(label)) labelList[existing].push(label);
@@ -4093,10 +4647,12 @@ const buildDenyList = async (config, ctx = defaultContext) => {
 	if (hasDenyList) {
 		const denyListData = dictionaries.denyList;
 		const metaData = dictionaries.denyListMeta;
+		const useScopedNameCorpus = config.nameCorpusLanguages !== void 0;
 		for (const [id, entries] of Object.entries(denyListData)) {
 			const meta = metaData[id];
 			if (!meta) continue;
 			if (!config.enableNameCorpus && meta.category === "Names") continue;
+			if (useScopedNameCorpus && meta.category === "Names") continue;
 			if (excludeCategories.has(meta.category)) continue;
 			if (allowedCountries !== null && meta.country !== null) {
 				if (!allowedCountries.has(meta.country)) continue;
@@ -4104,7 +4660,7 @@ const buildDenyList = async (config, ctx = defaultContext) => {
 			for (const entry of entries) addDenyListEntry(entry, meta.label);
 		}
 	}
-	if (hasCities && !excludeCategories.has("Places")) for (const entry of dictionaries.cities) addDenyListEntry(entry, "address");
+	if (hasCities && !excludeCategories.has("Places")) for (const entry of cityEntries) addDenyListEntry(entry, "address", "city");
 	if (hasCustomDenyList) for (const entry of config.customDenyList) {
 		addDenyListEntry(entry.value, entry.label, "custom-deny-list");
 		for (const variant of entry.variants ?? []) addDenyListEntry(variant, entry.label, "custom-deny-list");
@@ -4153,6 +4709,7 @@ const appendNameCorpusEntries = (config, ctx, patternList, labelList, sourceList
 	const addNameEntry = (name, source) => {
 		const normalized = normalizeForSearch(name).replace(/[|\\]/g, "");
 		if (normalized.length === 0) return;
+		if (isCuratedNoiseAcronym(normalized)) return;
 		const lower = normalized.toLowerCase();
 		const existing = patternIndex.get(lower);
 		if (existing !== void 0) {
@@ -4198,8 +4755,8 @@ const customMatchHasValidEdges = (fullText, start, end, pattern) => {
 * the search instance was built on a different context
 * (e.g. cachedSearch).
 */
-const ensureDenyListData = async (ctx = defaultContext, dictionaries) => {
-	await initNameCorpus(ctx, dictionaries);
+const ensureDenyListData = async (ctx = defaultContext, dictionaries, nameCorpusLanguages) => {
+	await initNameCorpus(ctx, dictionaries, nameCorpusLanguages);
 	await Promise.all([
 		loadStopwords(ctx),
 		loadAllowList(ctx),
@@ -4239,12 +4796,14 @@ const processDenyListMatches = (allMatches, sliceStart, sliceEnd, fullText, data
 		const customEdgesAreValid = customMatchHasValidEdges(fullText, match.start, match.end, pattern);
 		const customLabels = customEdgesAreValid ? customPatternLabels : [];
 		if ((!labels || labels.length === 0) && customLabels.length === 0) continue;
-		const curatedLabels = UPPER_START_RE.test(sourceChar) && !getStopwords(ctx).has(keyword) && !getAllowList(ctx).has(keyword) && !ALL_UPPER_RE.test(matchText) ? (labels ?? []).filter((label) => !customPatternLabels.includes(label) && customEdgesAreValid) : [];
-		if (curatedLabels.length === 0 && customLabels.length === 0) continue;
+		const acronymMatchesAcronym = !(pattern.length > 0 && pattern.length <= 5 && ALL_UPPER_RE.test(pattern)) || ALL_UPPER_RE.test(matchText);
+		const curatedLabels = UPPER_START_RE.test(sourceChar) && !getStopwords(ctx).has(keyword) && !getAllowList(ctx).has(keyword) && acronymMatchesAcronym && !ALL_UPPER_RE.test(matchText) ? (labels ?? []).filter((label) => !customPatternLabels.includes(label) && customEdgesAreValid) : [];
+		const filteredCuratedLabels = isDottedAcronymSuffixCollision(fullText, match.start, matchText) ? [] : curatedLabels;
+		if (filteredCuratedLabels.length === 0 && customLabels.length === 0) continue;
 		const entry = {
 			start: match.start,
 			end: match.end,
-			labels: curatedLabels,
+			labels: filteredCuratedLabels,
 			customLabels,
 			sources,
 			text: matchText,
@@ -4310,6 +4869,7 @@ const processDenyListMatches = (allMatches, sliceStart, sliceEnd, fullText, data
 		const first = chain.at(0);
 		const last = chain.at(-1);
 		if (!first || !last) continue;
+		if (isSuppressibleDefinedTermQuote(fullText, first.start, ctx)) continue;
 		const extended = extendPersonName(fullText, first.start, last.end, ctx);
 		const score = chain.length >= 2 ? .9 : .5;
 		if (chain.length === 1) {
@@ -4375,7 +4935,7 @@ const extendCityDistricts = (entities, fullText) => {
 			entity.text = fullText.slice(entity.start, entity.end);
 		}
 		const afterDistrict = fullText.slice(entity.end);
-		const dashDistrictM = /^[\s]*[-–][\s]*(\p{Lu}\p{Ll}+)/u.exec(afterDistrict);
+		const dashDistrictM = /^[ \t]{1,4}[-–][ \t]*(\p{Lu}\p{Ll}+)/u.exec(afterDistrict);
 		if (dashDistrictM && !dashDistrictM[0].includes("\n")) {
 			entity.end += dashDistrictM[0].length;
 			entity.text = fullText.slice(entity.start, entity.end);
@@ -4405,6 +4965,95 @@ const extendCityDistricts = (entities, fullText) => {
 * by a capitalized word (for "Miroslav Braňka" when
 * only "Braňka" matched).
 */
+/**
+* Defined-term marker: an opening typographic or straight
+* quote enclosing the chain start, AND a closing quote
+* within a short window followed by a
+* definitional cue (`means`, `shall mean`, `shall have
+* the meaning(s)`, `refers to`). Legal documents reserve
+* this construction for defined terms; the contents are
+* not personal names even when individual tokens collide
+* with the name corpus.
+*
+* Plain quotations like `"John Unknown" said ...` do NOT
+* count: there is no definitional cue, so the trailing
+* surname extension is still allowed to absorb `Unknown`.
+*/
+const OPENING_QUOTES = new Set([
+	"\"",
+	"'",
+	"“",
+	"„",
+	"‟",
+	"‘",
+	"‛",
+	"«"
+]);
+const CLOSING_QUOTES = new Set([
+	"\"",
+	"'",
+	"”",
+	"’",
+	"»",
+	"“"
+]);
+const DEFINED_TERM_CUE_RE = /^[\s,]*(?:means?|shall\s+means?|shall\s+have\s+the\s+meanings?|refers?\s+to|has\s+the\s+meanings?|is\s+defined)\b/iu;
+const DEFINED_TERM_LOOKAHEAD = 120;
+const DEFINED_TERM_LOOKBEHIND = 80;
+const EMPTY_GENERIC_ROLES = /* @__PURE__ */ new Set();
+const isLetter = (ch) => ch !== void 0 && /^\p{L}$/u.test(ch);
+const isApostropheInsideWord = (text, index) => isLetter(text[index - 1]) && isLetter(text[index + 1]);
+const isQuoteBoundary = (text, index) => {
+	const ch = text[index];
+	if (ch !== "'" && ch !== "’") return true;
+	return !isApostropheInsideWord(text, index);
+};
+const findDefinedTermQuoteContent = (text, start) => {
+	const min = Math.max(0, start - DEFINED_TERM_LOOKBEHIND);
+	let quoteStart = -1;
+	for (let i = start - 1; i >= min; i--) {
+		const ch = text[i];
+		if (ch === "\n") break;
+		if (ch && OPENING_QUOTES.has(ch) && isQuoteBoundary(text, i)) {
+			quoteStart = i;
+			break;
+		}
+		if (ch && CLOSING_QUOTES.has(ch) && isQuoteBoundary(text, i)) break;
+	}
+	if (quoteStart === -1) return null;
+	const max = Math.min(text.length, quoteStart + 1 + DEFINED_TERM_LOOKAHEAD);
+	for (let i = start; i < max; i++) {
+		const ch = text[i];
+		if (!ch || !CLOSING_QUOTES.has(ch) || !isQuoteBoundary(text, i)) continue;
+		const after = text.slice(i + 1, max);
+		if (!DEFINED_TERM_CUE_RE.test(after)) return null;
+		return {
+			content: text.slice(quoteStart + 1, i),
+			afterClosingQuote: after
+		};
+	}
+	return null;
+};
+const FIRST_WORD_RE = /^\p{L}+/u;
+const WORD_RE = /\p{L}+/gu;
+const startsWithKnownFirstName = (quoteContent, ctx) => {
+	const firstWord = FIRST_WORD_RE.exec(quoteContent.trim())?.[0];
+	if (!firstWord) return false;
+	return new Set(getNameCorpusFirstNames(ctx).map((name) => name.toLowerCase())).has(firstWord.toLowerCase());
+};
+const hasPersonRoleDefinition = (afterClosingQuote, ctx) => {
+	const roleWords = afterClosingQuote.replace(DEFINED_TERM_CUE_RE, "").match(WORD_RE)?.slice(0, 8) ?? [];
+	if (roleWords.length === 0) return false;
+	const genericRoles = ctx.genericRoles ?? EMPTY_GENERIC_ROLES;
+	return roleWords.some((word) => genericRoles.has(word.toLowerCase()));
+};
+const isSuppressibleDefinedTermQuote = (text, start, ctx) => {
+	const definedTermQuote = findDefinedTermQuoteContent(text, start);
+	if (definedTermQuote === null) return false;
+	const words = definedTermQuote.content.match(WORD_RE) ?? [];
+	if (words.length >= 2 && startsWithKnownFirstName(definedTermQuote.content, ctx) && hasPersonRoleDefinition(definedTermQuote.afterClosingQuote, ctx)) return false;
+	return words.length >= 2;
+};
 const extendPersonName = (text, start, end, ctx) => {
 	let newEnd = end;
 	let pos = newEnd;
@@ -4415,7 +5064,7 @@ const extendPersonName = (text, start, end, ctx) => {
 		if (!UPPER_START_RE.test(char)) break;
 		let wordEnd = wordStart;
 		while (wordEnd < text.length && !/\s/.test(text[wordEnd] ?? "")) wordEnd++;
-		const stripped = text.slice(wordStart, wordEnd).replace(/[,;.]+$/, "");
+		const stripped = text.slice(wordStart, wordEnd).replace(/[,;.”"’'“»]+$/, "");
 		if (stripped.length < 2) break;
 		const lower = stripped.toLowerCase();
 		if (getStopwords(ctx).has(lower) || getPersonStopwords(ctx).has(lower)) break;
@@ -4438,6 +5087,15 @@ const extendPersonName = (text, start, end, ctx) => {
 * cluster occasionally absorbs.
 */
 const ADDRESS_TRAILING_TRIM_RE = new RegExp(`[,;:\\s${OPENING_BRACKETS_INNER}${QUOTE_DOUBLE_INNER}${QUOTE_SINGLE_INNER}′]`, "u");
+const POSTAL_ADJACENT = `\\p{L}\\p{N}_${DASH_INNER}`;
+const POSTAL_CODE_RE = new RegExp(`(?<![${POSTAL_ADJACENT}])(?:\\d{3}\\s\\d{2}|\\d{2}${DASH}\\d{3}|\\d{5}${DASH}\\d{3}|\\d{5}${DASH}\\d{4})(?![${POSTAL_ADJACENT}])`, "gu");
+const BR_CEP_SHAPE_RE = new RegExp(`^\\d{5}${DASH}\\d{3}$`, "u");
+const US_ZIP_PLUS_FOUR_SHAPE_RE = new RegExp(`^\\d{5}${DASH}\\d{4}$`, "u");
+const US_STATE_ABBREV_BEFORE_ZIP_RE = new RegExp(`(?:^|[^A-Za-z0-9])(A[KLRZ]|C[AOT]|D[CE]|F[LM]|G[AU]|HI|I[ADLN]|K[SY]|LA|M[ADEHINOPST]|N[CDEHJMVY]|O[HKR]|P[AR]|RI|S[CD]|T[NX]|UT|V[AIT]|W[AIVY])\\s*,?\\s*$`, "u");
+const US_ZIP_CONTEXT_WINDOW = 120;
+const US_CITY_ZIP_GAP_RE = /^[\s,]+$/u;
+const HOUSE_NUMBER_BEFORE_STREET_RE = /\b\d{1,6}(?:[-/]\d{1,6})?\s+(?:\p{Lu}\p{L}+[^\S\n\t]+){0,4}$/u;
+const HOUSE_NUMBER_AFTER_STREET_RE = /^[^\S\n\t]+\d{1,6}(?:[-/]\d{1,6})?\b/u;
 let cachedBoundaryRe = null;
 const loadBoundaryWords = async () => {
 	try {
@@ -4452,7 +5110,7 @@ let cachedBrCepContextPromise = null;
 const loadBrCueWords = async () => {
 	const sources = await Promise.all([(async () => {
 		try {
-			return (await import("./address-street-types.mjs")).default["pt-br"];
+			return (await import("./address-street-types.mjs").then((n) => n.n)).default["pt-br"];
 		} catch {
 			return;
 		}
@@ -4496,6 +5154,49 @@ const hasBrCueNearby = (fullText, start, end, re) => {
 	const window = fullText.slice(windowStart, windowEnd);
 	return new RegExp(re.source, re.flags.replace("g", "")).test(window);
 };
+const getUsStateSeedBeforeZip = (fullText, start) => {
+	const stateWindowStart = Math.max(0, start - 24);
+	const stateWindow = fullText.slice(stateWindowStart, start);
+	const match = US_STATE_ABBREV_BEFORE_ZIP_RE.exec(stateWindow);
+	const state = match?.[1];
+	if (!match || !state) return null;
+	const stateOffset = match[0].indexOf(state);
+	const stateStart = stateWindowStart + match.index + stateOffset;
+	return {
+		type: "state",
+		start: stateStart,
+		end: stateStart + state.length,
+		text: state
+	};
+};
+const hasHouseNumberNearStreetWord = (fullText, seed) => {
+	if (/\d/.test(seed.text)) return true;
+	const before = fullText.slice(Math.max(0, seed.start - 50), seed.start);
+	if (HOUSE_NUMBER_BEFORE_STREET_RE.test(before)) return true;
+	const after = fullText.slice(seed.end, Math.min(fullText.length, seed.end + 24));
+	return HOUSE_NUMBER_AFTER_STREET_RE.test(after);
+};
+const isLowercaseStreetWordInProse = (fullText, seed) => /^\p{Ll}/u.test(seed.text) && /^\s+\p{Ll}/u.test(fullText.slice(seed.end, seed.end + 16)) && !hasHouseNumberNearStreetWord(fullText, seed);
+const getUsZipPlusFourContext = (fullText, start, seeds) => {
+	const stateSeed = getUsStateSeedBeforeZip(fullText, start);
+	if (stateSeed !== null) return {
+		stateSeed,
+		hasContext: true
+	};
+	return {
+		stateSeed: null,
+		hasContext: seeds.some((seed) => {
+			if (Math.abs(seed.start - start) > US_ZIP_CONTEXT_WINDOW) return false;
+			if (seed.type === "address-trigger") return true;
+			if (seed.type === "city" && seed.end <= start) {
+				const gap = fullText.slice(seed.end, start);
+				return US_CITY_ZIP_GAP_RE.test(gap);
+			}
+			if (seed.type === "street-word") return hasHouseNumberNearStreetWord(fullText, seed);
+			return false;
+		})
+	};
+};
 /**
 * Build regex for boundary words. Matches any
 * boundary word preceded by a word boundary.
@@ -4520,7 +5221,7 @@ const getBoundaryRe = async () => {
 const buildStreetTypePatterns = async () => {
 	let config = {};
 	try {
-		config = (await import("./address-street-types.mjs")).default;
+		config = (await import("./address-street-types.mjs").then((n) => n.n)).default;
 	} catch {
 		return [];
 	}
@@ -4536,12 +5237,14 @@ const collectSeeds = (allMatches, sliceStart, sliceEnd, fullText, existingEntiti
 	for (const match of allMatches) {
 		const idx = match.pattern;
 		if (idx < sliceStart || idx >= sliceEnd) continue;
-		seeds.push({
+		const seed = {
 			type: "street-word",
 			start: match.start,
 			end: match.end,
 			text: match.text
-		});
+		};
+		if (isLowercaseStreetWordInProse(fullText, seed)) continue;
+		seeds.push(seed);
 	}
 	for (const e of existingEntities) {
 		if (e.label !== "address") continue;
@@ -4565,13 +5268,22 @@ const collectSeeds = (allMatches, sliceStart, sliceEnd, fullText, existingEntiti
 			text: e.text
 		});
 	}
-	const postalRe = /\b(?:\d{3}\s\d{2}|\d{2}-\d{3}|\d{5}-\d{3})\b/g;
+	const postalRe = POSTAL_CODE_RE;
+	postalRe.lastIndex = 0;
 	let postalMatch;
 	while ((postalMatch = postalRe.exec(fullText)) !== null) {
 		const start = postalMatch.index;
 		const end = start + postalMatch[0].length;
 		if (seeds.some((s) => s.start <= start && s.end >= end)) continue;
-		if (/^\d{5}-\d{3}$/.test(postalMatch[0]) && (brCepContextRe === null || !hasBrCueNearby(fullText, start, end, brCepContextRe))) continue;
+		if (BR_CEP_SHAPE_RE.test(postalMatch[0]) && (brCepContextRe === null || !hasBrCueNearby(fullText, start, end, brCepContextRe))) continue;
+		if (US_ZIP_PLUS_FOUR_SHAPE_RE.test(postalMatch[0])) {
+			const usContext = getUsZipPlusFourContext(fullText, start, seeds);
+			if (!usContext.hasContext) continue;
+			const stateSeed = usContext.stateSeed;
+			if (stateSeed !== null) {
+				if (!seeds.some((seed) => seed.start === stateSeed.start && seed.end === stateSeed.end)) seeds.push(stateSeed);
+			}
+		}
 		seeds.push({
 			type: "postal-code",
 			start,
@@ -4650,6 +5362,7 @@ const scoreCluster = (cluster) => {
 	let score = .5;
 	if (types.has("postal-code")) score += .15;
 	if (types.has("city")) score += .15;
+	if (types.has("state")) score += .15;
 	if (types.has("street-word")) score += .15;
 	if (types.has("address-trigger")) score += .1;
 	return Math.min(score, .95);
@@ -4670,6 +5383,7 @@ const NON_ADDRESS_LABELS = new Set([
 ]);
 const expandCluster = async (fullText, cluster, existingEntities) => {
 	const { start, end } = cluster;
+	const seedTypes = new Set(cluster.seeds.map((seed) => seed.type));
 	let leftBound = 0;
 	for (const e of existingEntities) if (NON_ADDRESS_LABELS.has(e.label) && e.end <= start && e.end > leftBound) leftBound = e.end;
 	let leftPos = start;
@@ -4684,6 +5398,10 @@ const expandCluster = async (fullText, cluster, existingEntities) => {
 		if (fullText.slice(p + 1, leftPos).includes("\n")) break;
 		leftPos = p + 1;
 	}
+	if (!(seedTypes.has("street-word") || seedTypes.has("house-number") || seedTypes.has("postal-code") || seedTypes.has("address-trigger"))) return {
+		start: Math.min(leftPos, start),
+		end
+	};
 	let rightPos = end;
 	const remaining = fullText.slice(rightPos);
 	let nearestBoundary = Math.min(remaining.length, 200);
@@ -4836,7 +5554,44 @@ const BARE_STOPWORDS = new Set([
 	"Splatnost",
 	"Variabilní",
 	"Konstantní",
-	"Specifický"
+	"Specifický",
+	"Section",
+	"Sections",
+	"Article",
+	"Articles",
+	"Schedule",
+	"Schedules",
+	"Exhibit",
+	"Exhibits",
+	"Annex",
+	"Annexes",
+	"Appendix",
+	"Appendices",
+	"Clause",
+	"Clauses",
+	"Chapter",
+	"Chapters",
+	"Paragraph",
+	"Paragraphs",
+	"Subsection",
+	"Subsections",
+	"Form",
+	"Page",
+	"Pages",
+	"Item",
+	"Items",
+	"Note",
+	"Notes",
+	"Rule",
+	"Rules",
+	"Attachment",
+	"Attachments",
+	"Volume",
+	"Volumes",
+	"Book",
+	"Books",
+	"Part",
+	"Parts"
 ]);
 const NEAR_MISS_BAND = .15;
 const BOOST_PER_NEIGHBOUR = .05;
@@ -4909,21 +5664,23 @@ const initPrepositions = () => {
 };
 const getAddressPreps = () => _addressPreps ?? /* @__PURE__ */ new Set();
 const getTemporalPreps = () => _temporalPreps ?? /* @__PURE__ */ new Set();
-let _streetAbbrevs = null;
+const buildStreetAbbrevs = (data) => {
+	const abbrevs = /* @__PURE__ */ new Set();
+	for (const [key, words] of Object.entries(data)) {
+		if (key.startsWith("_")) continue;
+		if (!Array.isArray(words)) continue;
+		for (const word of words) if (typeof word === "string" && word.includes(".")) abbrevs.add(word.toLowerCase());
+	}
+	return abbrevs;
+};
+let _streetAbbrevs = buildStreetAbbrevs(address_street_types_default);
 let _streetAbbrevsPromise = null;
 const loadStreetAbbrevs = async () => {
 	try {
-		const mod = await import("./address-street-types.mjs");
-		const data = mod.default ?? mod;
-		const abbrevs = /* @__PURE__ */ new Set();
-		for (const [key, words] of Object.entries(data)) {
-			if (key.startsWith("_")) continue;
-			if (!Array.isArray(words)) continue;
-			for (const w of words) if (w.includes(".")) abbrevs.add(w.toLowerCase());
-		}
-		_streetAbbrevs = abbrevs;
+		const mod = await import("./address-street-types.mjs").then((n) => n.n);
+		_streetAbbrevs = buildStreetAbbrevs(mod.default ?? mod);
 	} catch {
-		_streetAbbrevs = /* @__PURE__ */ new Set();
+		_streetAbbrevs ??= /* @__PURE__ */ new Set();
 	}
 };
 /** Ensure street abbreviation data is loaded. */
@@ -5035,7 +5792,7 @@ const detectStreetPatternsNearAddresses = (fullText, existingEntities) => {
 	}
 	return results;
 };
-const ORPHAN_STREET_RE = /^\s*(\p{Lu}[\p{Ll}\p{Lu}]+(?:\s+[\p{Lu}\p{Ll}][\p{Ll}]+)*\s+\d{2,4}[a-zA-Z]?)\s*$/gmu;
+const ORPHAN_STREET_RE = /^[^\S\n]*(\p{Lu}[\p{Ll}\p{Lu}]+(?:[^\S\n]+[\p{Lu}\p{Ll}][\p{Ll}]+)*[^\S\n]+\d{2,4}[a-zA-Z]?)[^\S\n]*$/gmu;
 /**
 * In the header zone (top 15%), find standalone lines
 * matching "[Uppercase word(s)] [number]" that sit
@@ -5413,6 +6170,7 @@ const hasLockedBoundary$1 = (entity) => entity.sourceDetail === "custom-deny-lis
 * of `\s` to avoid merging entities across newlines.
 */
 const GAP_PATTERN = /^[ \t,\-]+$/;
+const isLegalFormOrganization = (entity) => entity.label === "organization" && entity.source === DETECTION_SOURCES.LEGAL_FORM;
 /**
 * Build a set of word boundary offsets for the full
 * text using `Intl.Segmenter`. Returns a sorted array
@@ -5552,7 +6310,7 @@ const mergeAdjacent = (entities, fullText) => {
 				break;
 			}
 		}
-		if (!hasLockedBoundary$1(prev) && !gapOccupied && gap.length <= MAX_GAP && GAP_PATTERN.test(gap)) {
+		if (!hasLockedBoundary$1(prev) && !(isLegalFormOrganization(prev) && isLegalFormOrganization(entity) && gap.includes(",")) && !gapOccupied && gap.length <= MAX_GAP && GAP_PATTERN.test(gap)) {
 			prev.end = entity.end;
 			prev.text = fullText.slice(prev.start, prev.end);
 			prev.score = Math.max(prev.score, entity.score);
@@ -5710,9 +6468,12 @@ const enforceBoundaryConsistency = (entities, fullText) => {
 //#region src/build-unified-search.ts
 const DEFAULT_CUSTOM_REGEX_SCORE$1 = .9;
 const ALNUM_RE = /[\p{L}\p{N}]/u;
+const createAllowedLabelSet$1 = (labels) => labels.length > 0 ? new Set(labels) : null;
+const labelIsAllowed$1 = (label, allowedLabels) => allowedLabels === null || allowedLabels.has(label);
 const buildUnifiedSearch = async (config, gazetteerEntries = [], ctx = defaultContext) => {
 	const legalFormsEnabled = isLegalFormsEnabled(config);
-	const customRegexes = config.enableRegex ? config.customRegexes ?? [] : [];
+	const allowedLabels = createAllowedLabelSet$1(config.enableHotwordRules === true ? expandLabelsForHotwordRules(config.labels) : config.labels);
+	const customRegexes = config.enableRegex ? (config.customRegexes ?? []).filter((entry) => labelIsAllowed$1(entry.label, allowedLabels)) : [];
 	const [legalForms, triggers, denyListData, streetTypes, currencyPatterns, datePatterns, signingPatterns] = await Promise.all([
 		legalFormsEnabled ? buildLegalFormPatterns() : Promise.resolve([]),
 		config.enableTriggerPhrases ? buildTriggerPatterns() : Promise.resolve({
@@ -5721,22 +6482,30 @@ const buildUnifiedSearch = async (config, gazetteerEntries = [], ctx = defaultCo
 		}),
 		config.enableDenyList ? buildDenyList(config, ctx) : Promise.resolve(null),
 		buildStreetTypePatterns(),
-		getCurrencyPatterns(),
-		getDatePatterns(),
-		getSigningClausePatterns()
+		config.enableRegex && labelIsAllowed$1("monetary amount", allowedLabels) ? getCurrencyPatterns() : Promise.resolve([]),
+		config.enableRegex && labelIsAllowed$1("date", allowedLabels) ? getDatePatterns() : Promise.resolve([]),
+		config.enableRegex && labelIsAllowed$1("address", allowedLabels) ? getSigningClausePatterns() : Promise.resolve([])
 	]);
-	const allRegex = [
-		...REGEX_PATTERNS,
-		...currencyPatterns,
-		...datePatterns,
-		...signingPatterns
-	];
-	const regexMeta = [
-		...REGEX_META,
-		...currencyPatterns.map(() => CURRENCY_PATTERN_META),
-		...datePatterns.map(() => DATE_PATTERN_META),
-		...signingPatterns.map(() => SIGNING_CLAUSE_META)
-	];
+	const allRegex = [];
+	const regexMeta = [];
+	if (config.enableRegex) for (const [index, pattern] of REGEX_PATTERNS.entries()) {
+		const meta = REGEX_META[index];
+		if (!meta || !labelIsAllowed$1(meta.label, allowedLabels)) continue;
+		allRegex.push(pattern);
+		regexMeta.push(meta);
+	}
+	for (const pattern of currencyPatterns) {
+		allRegex.push(pattern);
+		regexMeta.push(CURRENCY_PATTERN_META);
+	}
+	for (const pattern of datePatterns) {
+		allRegex.push(pattern);
+		regexMeta.push(DATE_PATTERN_META);
+	}
+	for (const pattern of signingPatterns) {
+		allRegex.push(pattern);
+		regexMeta.push(SIGNING_CLAUSE_META);
+	}
 	const customRegexMeta = customRegexes.map((entry) => ({
 		label: entry.label,
 		score: entry.score ?? DEFAULT_CUSTOM_REGEX_SCORE$1,
@@ -5952,6 +6721,8 @@ const unmaskNerEntities = (nerEntities, maskResult, fullText) => {
 const LITERAL_SOURCES = new Set(["deny-list", "gazetteer"]);
 const isCallerOwnedEntity = (entity) => entity.sourceDetail === "custom-deny-list" || entity.sourceDetail === "custom-regex";
 const hasLockedBoundary = (entity) => isCallerOwnedEntity(entity);
+const LITERAL_BOUNDARY_PUNCT_RE = /^["“„‟‘‛'«]|["”’'»!.]$/u;
+const hasCuratedLiteralBoundary = (entity) => LITERAL_SOURCES.has(entity.source) && entity.label !== "person" && entity.sourceDetail !== "gazetteer-extension" && LITERAL_BOUNDARY_PUNCT_RE.test(entity.text);
 const shouldReplace = (a, b) => {
 	const aLen = a.end - a.start;
 	const bLen = b.end - b.start;
@@ -5967,6 +6738,31 @@ const shouldReplace = (a, b) => {
 /** Labels where colons are structurally significant. */
 const COLON_LABELS = new Set(["ip address", "mac address"]);
 /**
+* Labels whose entities should have a trailing sentence
+* `.` stripped during sanitisation. Restricted to
+* proper-noun-style labels where a final period is
+* almost always the sentence terminator that ran into
+* the capture, not a structural part of the value.
+* Numeric labels (`date`, `date of birth`, `phone
+* number`, `monetary amount`, `time`) and `person`
+* stay out — German writes `21. März`, post-nominal
+* degrees write `M.Sc.`, times write `5:00 p.m.`, and
+* stripping the dot would corrupt those spans.
+*/
+const PERIOD_STRIPPED_LABELS = new Set([
+	"organization",
+	"location",
+	"address"
+]);
+const ADDRESS_FINAL_TOKEN_RE = /(?:^|[\s,])([\p{L}\p{M}.]+\.)$/u;
+const LOCATION_FINAL_DOTTED_ABBREV_RE = /(?:^|[\s,])(?:\p{Lu}\.){2,}$/u;
+const hasKnownAddressFinalAbbrev = (text) => {
+	const finalToken = ADDRESS_FINAL_TOKEN_RE.exec(text)?.[1];
+	if (!finalToken) return false;
+	return getStreetAbbrevs().has(finalToken.toLowerCase());
+};
+const hasLocationFinalAbbrev = (text) => LOCATION_FINAL_DOTTED_ABBREV_RE.test(text);
+/**
 * Labels whose detectors emit precise, evidence-backed spans. When
 * one of these fires at the exact same offsets as a fuzzier
 * `address` hit (city dictionary lookup, address-seed cluster), the
@@ -6039,16 +6835,63 @@ const resolveSameSpanLabelConflicts = (entities) => {
 	if (dropped.size === 0) return entities;
 	return entities.filter((e) => !dropped.has(e));
 };
+/**
+* Trailing typographic punctuation that detectors
+* occasionally swallow when a capture runs to the end
+* of a sentence or quoted phrase. Stripped from every
+* non-literal, non-locked entity. Curated dictionary and
+* gazetteer entries with punctuation that is clearly part of
+* the literal (`Hello bank!`, `"Juez y parte"`) keep their
+* own boundaries. Generated/extended spans from the same
+* sources still pass through cleanup so dangling punctuation
+* does not become part of the redaction
+* (e.g. `Bond Hedge Documentation"` →
+* `Bond Hedge Documentation`).
+*
+* `)` is deliberately omitted — monetary amounts are
+* extended to include trailing "(slovy ...)" / "(in
+* words ...)" parentheticals where the closing paren
+* is structural, and stripping it would leave the open
+* paren dangling. `.` is also omitted because the
+* trailing-period rule below has label-aware handling
+* (legal-form abbreviations keep their dot).
+*/
+const TRAILING_PUNCT_CLASS = `["“”‘’'»!?]`;
+/**
+* Leading typographic punctuation that detectors
+* occasionally swallow when a capture starts at an
+* opening quote. `(` is deliberately omitted — it is
+* almost always the opening of a structural
+* parenthetical (registration number group, monetary
+* "(slovy ...)" extension) that the detector
+* intentionally captured.
+*/
+const LEADING_PUNCT_CLASS = `["“”‘’'«¿¡]`;
+const STRIP_BY_LABEL = {
+	colon: /[\s,;]+/,
+	default: /[\s:,;]+/
+};
+const LEADING_TRIM_BY_LABEL = {
+	colon: new RegExp(`^(?:\\.\\s|${STRIP_BY_LABEL.colon.source}|${LEADING_PUNCT_CLASS})+`),
+	default: new RegExp(`^(?:\\.\\s|${STRIP_BY_LABEL.default.source}|${LEADING_PUNCT_CLASS})+`)
+};
+const TRAILING_TRIM_BY_LABEL = {
+	colon: new RegExp(`(?:${STRIP_BY_LABEL.colon.source}|${TRAILING_PUNCT_CLASS})+$`),
+	default: new RegExp(`(?:${STRIP_BY_LABEL.default.source}|${TRAILING_PUNCT_CLASS})+$`)
+};
 /** Strip leading/trailing whitespace and punctuation. */
 const sanitizeEntities = (entities) => entities.flatMap((e) => {
-	if (hasLockedBoundary(e)) return [e];
-	const strip = COLON_LABELS.has(e.label) ? /[\s,;]+/ : /[\s:,;]+/;
-	const leadTrimmed = e.text.replace(/^(?:\.\s)+/, "").replace(new RegExp(`^${strip.source}`, strip.flags), "");
+	if (hasLockedBoundary(e) || hasCuratedLiteralBoundary(e)) return [e];
+	const stripKind = COLON_LABELS.has(e.label) ? "colon" : "default";
+	const leadRe = LEADING_TRIM_BY_LABEL[stripKind];
+	const trailRe = TRAILING_TRIM_BY_LABEL[stripKind];
+	const leadTrimmed = e.text.replace(leadRe, "");
 	const lead = e.text.length - leadTrimmed.length;
-	let cleaned = leadTrimmed.replace(new RegExp(`${strip.source}$`, strip.flags), "");
-	if (e.label === "organization" && cleaned.endsWith(".") && !LITERAL_SOURCES.has(e.source)) {
-		if (!getKnownLegalSuffixes().some((suffix) => cleaned.endsWith(suffix))) cleaned = cleaned.slice(0, -1).trimEnd();
+	let cleaned = leadTrimmed.replace(trailRe, "");
+	if (PERIOD_STRIPPED_LABELS.has(e.label) && cleaned.endsWith(".") && !LITERAL_SOURCES.has(e.source)) {
+		if (!(getKnownLegalSuffixes().some((suffix) => cleaned.endsWith(suffix)) || e.label === "address" && hasKnownAddressFinalAbbrev(cleaned) || e.label === "location" && hasLocationFinalAbbrev(cleaned))) cleaned = cleaned.slice(0, -1).trimEnd();
 	}
+	cleaned = cleaned.replace(trailRe, "");
 	if (cleaned.length === 0) return [];
 	if (!/[\p{L}\p{N}]/u.test(cleaned)) return [];
 	const collapsed = cleaned.replace(/\s*\n\s*/g, " ").replace(/\s{2,}/g, " ");
@@ -6105,7 +6948,7 @@ let amountWordsLoaded = false;
 const getAmountWordsRe = async () => {
 	if (amountWordsLoaded && amountWordsRe) return amountWordsRe;
 	try {
-		const alt = (await import("./amount-words.mjs")).default.patterns.flatMap((p) => p.keywords).map(escapeRegex).join("|");
+		const alt = (await import("./amount-words.mjs").then((n) => n.n)).default.patterns.flatMap((p) => p.keywords).map(escapeRegex).join("|");
 		amountWordsRe = new RegExp(`^[,;]?[^\\S\\n]*(\\((?:${alt})[:\\s][^)\\n]{1,120}\\))`, "i");
 	} catch {
 		amountWordsRe = /^[,;]?[^\S\n]*(\((?:slovy|slovně)[:\s][^)\n]{1,120}\))/i;
@@ -6154,7 +6997,7 @@ const configKey = (config, gazetteerEntries) => {
 		score: entry.score ?? DEFAULT_CUSTOM_REGEX_SCORE
 	})).sort().join("\n") : "";
 	const gazFingerprint = config.enableGazetteer && gazetteerEntries.length > 0 ? gazetteerEntries.map((e) => `${e.id}:${e.canonical}:${e.label}:${[...e.variants].sort().join(",")}`).toSorted().join(";") : "";
-	return `${config.enableDenyList}:${config.enableTriggerPhrases}:${legalFormsEnabled}:${config.enableNameCorpus}:${config.enableRegex}:${config.denyListCountries?.toSorted().join(",") ?? ""}:${config.denyListRegions?.toSorted().join(",") ?? ""}:${config.denyListExcludeCategories?.toSorted().join(",") ?? ""}:${customDenyFingerprint}:${customRegexFingerprint}:${config.enableGazetteer}:${gazFingerprint}`;
+	return `${config.enableDenyList}:${config.enableTriggerPhrases}:${legalFormsEnabled}:${config.enableNameCorpus}:${config.nameCorpusLanguages?.toSorted().join(",") ?? ""}:${config.enableRegex}:${config.labels.toSorted().join(",")}:${config.denyListCountries?.toSorted().join(",") ?? ""}:${config.denyListRegions?.toSorted().join(",") ?? ""}:${config.denyListExcludeCategories?.toSorted().join(",") ?? ""}:${customDenyFingerprint}:${customRegexFingerprint}:${config.enableGazetteer}:${gazFingerprint}`;
 };
 /**
 * Get or build a cached search instance. Cache state
@@ -6174,6 +7017,13 @@ const getCachedSearch = async (config, gazetteerEntries, ctx) => {
 	return result;
 };
 /**
+* Pre-build and cache the unified search instance for a
+* pipeline configuration. Use the same context in
+* `runPipeline` to reuse the prepared automata without
+* passing `cachedSearch` around manually.
+*/
+const preparePipelineSearch = ({ config, gazetteerEntries = [], context }) => getCachedSearch(config, gazetteerEntries, context ?? defaultContext);
+/**
 * Run the full detection pipeline.
 *
 * Two TextSearch instances scan the text (regex +
@@ -6230,7 +7080,7 @@ const runPipeline = async (options) => {
 		warmAddressStopKeywords(),
 		hotwordInit
 	]);
-	if (cachedSearch && config.enableDenyList) await ensureDenyListData(ctx, config.dictionaries);
+	if (cachedSearch && config.enableDenyList) await ensureDenyListData(ctx, config.dictionaries, config.nameCorpusLanguages);
 	let zones = [];
 	if (config.enableZoneClassification && zoneInitOk) {
 		zones = classifyZones(fullText, ctx);
@@ -6239,7 +7089,11 @@ const runPipeline = async (options) => {
 	checkAbort(signal);
 	const hotwordsActive = enableHotwords && hotwordInitOk;
 	const preHotwordAllowedLabels = hotwordsActive ? createAllowedLabelSetFromLabels(expandLabelsForHotwordRules(config.labels)) : allowedLabels;
-	const search = cachedSearch ?? await getCachedSearch(config, gazetteerEntries, ctx);
+	const searchConfig = hotwordsActive ? {
+		...config,
+		labels: [...expandLabelsForHotwordRules(config.labels)]
+	} : config;
+	const search = cachedSearch ?? await getCachedSearch(searchConfig, gazetteerEntries, ctx);
 	checkAbort(signal);
 	const { regexMatches, customRegexMatches, literalMatches } = runUnifiedSearch(search, fullText);
 	const { slices } = search;
@@ -6259,7 +7113,7 @@ const runPipeline = async (options) => {
 	let rawNameCorpusEntities = [];
 	let nameCorpusEntities = [];
 	if (config.enableNameCorpus && !config.enableDenyList) {
-		await initNameCorpus(ctx, config.dictionaries);
+		await initNameCorpus(ctx, config.dictionaries, config.nameCorpusLanguages);
 		checkAbort(signal);
 		rawNameCorpusEntities = detectNameCorpus(fullText, ctx);
 		nameCorpusEntities = filterAllowedLabels(rawNameCorpusEntities, preHotwordAllowedLabels);
@@ -6958,6 +7812,6 @@ const levenshtein = (rawA, rawB) => {
 //#region src/wasm.ts
 initTextSearch(TextSearch);
 //#endregion
-export { CURRENCY_PATTERN_META, DATE_PATTERN_META, DEFAULT_ENTITY_LABELS, DEFAULT_OPERATOR_CONFIG, DETECTION_SOURCES, DETECTOR_PRIORITY, OPERATOR_REGISTRY, OPERATOR_TYPES, REGEX_META, REGEX_PATTERNS, REGIONS, ZONE_SCORE_ADJUSTMENTS, applyHotwordRules, applyZoneAdjustments, boostNearMissEntities, buildDenyList, buildGazetteerPatterns, buildLegalFormPatterns, buildPlaceholderMap, buildStreetTypePatterns, buildTriggerPatterns, buildUnifiedSearch, chunkText, classifyZones, computeChunkOffsets, corefKey, createPipelineContext, deanonymise, decodeSpans, decodeTokenSpans, detectNameCorpus, ensureDenyListData, exportRedactionKey, extractDefinedTerms, filterFalsePositives, findCoreferenceSpans, getCurrencyPatterns, getDatePatterns, initAddressComponents, initHotwordRules, initNameCorpus, initZoneClassifier, levenshtein, mergeAndDedup, mergeChunkEntities, normalizeForSearch, prepareBatch, processAddressSeeds, processDenyListMatches, processGazetteerMatches, processLegalFormMatches, processRegexMatches, processTriggerMatches, propagateOrgNames, redactText, resolveCountries, resolveOperator, runPipeline, runUnifiedSearch, sanitizeEntities, tokenizeText, warmLegalRoleHeads };
+export { CURRENCY_PATTERN_META, DATE_PATTERN_META, DEFAULT_ENTITY_LABELS, DEFAULT_OPERATOR_CONFIG, DETECTION_SOURCES, DETECTOR_PRIORITY, OPERATOR_REGISTRY, OPERATOR_TYPES, REGEX_META, REGEX_PATTERNS, REGIONS, ZONE_SCORE_ADJUSTMENTS, applyHotwordRules, applyZoneAdjustments, boostNearMissEntities, buildDenyList, buildGazetteerPatterns, buildLegalFormPatterns, buildPlaceholderMap, buildStreetTypePatterns, buildTriggerPatterns, buildUnifiedSearch, chunkText, classifyZones, computeChunkOffsets, corefKey, createPipelineContext, deanonymise, decodeSpans, decodeTokenSpans, detectNameCorpus, ensureDenyListData, exportRedactionKey, extractDefinedTerms, filterFalsePositives, findCoreferenceSpans, getCurrencyPatterns, getDatePatterns, initAddressComponents, initHotwordRules, initNameCorpus, initZoneClassifier, levenshtein, mergeAndDedup, mergeChunkEntities, normalizeForSearch, prepareBatch, preparePipelineSearch, processAddressSeeds, processDenyListMatches, processGazetteerMatches, processLegalFormMatches, processRegexMatches, processTriggerMatches, propagateOrgNames, redactText, resolveCountries, resolveOperator, runPipeline, runUnifiedSearch, sanitizeEntities, tokenizeText, warmLegalRoleHeads };
 
 //# sourceMappingURL=wasm.mjs.map