@stll/anonymize-wasm 1.4.5 → 1.4.6

package/dist/wasm.mjs

@@ -1,9 +1,19 @@
 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, 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 { at, au, be, bg, br, ch, cn, 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 \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
 //#region src/search-engine.ts
 let _TextSearch;
 const initTextSearch = (ctor) => {
@@ -180,7 +190,7 @@ const loadLanguageConfigs = async (configType, mapFn) => {
 		}
 		return lang[configType] === true;
 	}).map(([code]) => code) : [...FALLBACK_LANGUAGES[configType]];
-	const results = new Array(codes.length);
+	const results = codes.map(() => void 0);
 	const loads = codes.map(async (code, i) => {
 		const loader = registry[code];
 		if (!loader) {
@@ -897,12 +907,8 @@ const loadSentenceVerbIndicators = async () => {
 	return sentenceVerbIndicatorsPromise;
 };
 const getSentenceVerbIndicatorsSync = () => sentenceVerbIndicatorsCache ?? SENTENCE_VERB_INDICATORS_SEED;
-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 UPPER = "A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽÄÖÜÀÂÆÇÈÊËÎÏÔÙÛŸÑĄĆĘŁŃŚŹŻ\\u0130";
 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 = {
@@ -986,7 +992,7 @@ const loadAllLegalSuffixes = async () => {
 	if (allLegalSuffixesCache) return allLegalSuffixesCache;
 	if (allLegalSuffixesPromise) return allLegalSuffixesPromise;
 	allLegalSuffixesPromise = (async () => {
-		let data = {};
+		let data;
 		try {
 			data = (await import("./legal-forms.mjs")).default;
 		} catch {
@@ -1106,20 +1112,6 @@ const loadStructuralSingleCapPrefixes = async () => {
 };
 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 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}|${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})`;
-	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.
 * Returns an array of regex strings for the unified
@@ -1127,43 +1119,11 @@ const buildPatternString = (forms) => {
 * installed.
 */
 const buildLegalFormPatterns = async () => {
-	let data = {};
-	try {
-		data = (await import("./legal-forms.mjs")).default;
-	} catch {
-		return [];
-	}
-	const allForms = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const forms of Object.values(data)) for (const form of forms) if (!seen.has(form)) {
-		seen.add(form);
-		allForms.push(form);
-	}
-	for (const form of LEGAL_SUFFIXES) if (!seen.has(form)) {
-		seen.add(form);
-		allForms.push(form);
-	}
-	const patterns = [];
-	const longPattern = buildPatternString(allForms.filter((f) => !isShortForm(f)));
-	if (longPattern) patterns.push(longPattern);
-	const shortPattern = buildPatternString(allForms.filter(isShortForm));
-	if (shortPattern) patterns.push(shortPattern);
-	const allcapAlt = allForms.toSorted((a, b) => b.length - a.length).map(escapeForRegex).join("|");
-	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;
+	return [];
 };
-const CONNECTOR_RE = /^(?:a|and|und|et|e|y|i|&)$/i;
-const AND_TYPE_CONNECTOR_RE = /^(?:and|und|et)$/i;
-const UPPER_LETTER_RE = /^\p{Lu}/u;
+const CONNECTOR_RE$1 = /^(?:a|and|und|et|e|y|i|&)$/i;
+const AND_TYPE_CONNECTOR_RE$1 = /^(?:and|und|et)$/i;
+const UPPER_LETTER_RE$1 = /^\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;
@@ -1201,7 +1161,7 @@ const findWordBefore = (text, pos) => {
 };
 const hasSingleCapPrefixBefore = (fullText, matchStart) => {
 	const prev = findWordBefore(fullText, matchStart);
-	return prev !== null && prev.word.length === 1 && UPPER_LETTER_RE.test(prev.word);
+	return prev !== null && prev.word.length === 1 && UPPER_LETTER_RE$1.test(prev.word);
 };
 const isBareSingleCapStructuralInnerMatch = (fullText, matchStart, text) => {
 	if (!BARE_SINGLE_CAP_LEGAL_FORM_RE.test(text)) return false;
@@ -1290,12 +1250,12 @@ const hasDisallowedLineBreak = (text) => {
 	}
 	return false;
 };
-const hasMiddleInitialBefore = (fullText, pos) => {
+const hasMiddleInitialBefore$1 = (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] ?? "");
+	return scan >= 1 && fullText[scan] === "." && UPPER_LETTER_RE$1.test(fullText[scan - 1] ?? "");
 };
 /**
 * Count consecutive uppercase-starting words immediately
@@ -1319,7 +1279,7 @@ const countUpperWordsBefore = (fullText, pos, crossInNamePreps = false) => {
 	while (scan > 0) {
 		const found = findWordBefore(fullText, scan);
 		if (found) {
-			if (UPPER_LETTER_RE.test(found.word)) {
+			if (UPPER_LETTER_RE$1.test(found.word)) {
 				count++;
 				scan = found.start;
 				continue;
@@ -1327,7 +1287,7 @@ const countUpperWordsBefore = (fullText, pos, crossInNamePreps = false) => {
 			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;
+				if (!UPPER_LETTER_RE$1.test(prev.word)) break;
 				scan = found.start;
 				continue;
 			}
@@ -1335,7 +1295,7 @@ const countUpperWordsBefore = (fullText, pos, crossInNamePreps = false) => {
 		}
 		let p = scan - 1;
 		while (p >= 0 && (fullText[p] === " " || fullText[p] === "	")) p--;
-		if (p >= 1 && fullText[p] === "." && UPPER_LETTER_RE.test(fullText[p - 1] ?? "")) {
+		if (p >= 1 && fullText[p] === "." && UPPER_LETTER_RE$1.test(fullText[p - 1] ?? "")) {
 			count++;
 			scan = p - 1;
 			continue;
@@ -1414,30 +1374,30 @@ const extendBackward = (fullText, matchStart, options = {}) => {
 		const found = findWordBefore(fullText, pos);
 		if (!found) break;
 		const { word, start: wordStart } = found;
-		const isUpper = UPPER_LETTER_RE.test(word);
-		const isConnector = CONNECTOR_RE.test(word);
+		const isUpper = UPPER_LETTER_RE$1.test(word);
+		const isConnector = CONNECTOR_RE$1.test(word);
 		const isInNamePrep = suffixMode && IN_NAME_PREPOSITION_RE.test(word);
 		if (isUpper) pos = wordStart;
-		else if (isConnector) if (AND_TYPE_CONNECTOR_RE.test(word)) {
+		else if (isConnector) if (AND_TYPE_CONNECTOR_RE$1.test(word)) {
 			const prev = findWordBefore(fullText, wordStart);
 			if (!prev) break;
-			if (!UPPER_LETTER_RE.test(prev.word)) break;
+			if (!UPPER_LETTER_RE$1.test(prev.word)) break;
 			if (isKnownLegalFormSuffix(prev.word)) break;
 			const upperWordsBefore = countUpperWordsBefore(fullText, wordStart, suffixMode);
-			const middleInitialBefore = hasMiddleInitialBefore(fullText, wordStart);
+			const middleInitialBefore = hasMiddleInitialBefore$1(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 {
 			const prev = findWordBefore(fullText, wordStart);
 			if (!prev) break;
-			if (!UPPER_LETTER_RE.test(prev.word)) break;
+			if (!UPPER_LETTER_RE$1.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;
+			if (!UPPER_LETTER_RE$1.test(prev.word)) break;
 			pos = prev.start;
 		} else break;
 	}
@@ -1458,13 +1418,18 @@ const trimLeadingClause = (text) => {
 		"amongst",
 		"between"
 	]);
+	const verbIndicators = getSentenceVerbIndicatorsSync();
 	if (directPrefixAlternation.length > 0) {
 		const directPrefixRe = new RegExp(`\\b(?:${directPrefixAlternation})${HSPACE}+(?=\\p{Lu})`, "giu");
 		for (const match of text.matchAll(directPrefixRe)) {
 			const matchedPrefix = match[0].trim().toLowerCase();
 			const before = text.slice(0, match.index);
-			if (COMMA_GATED_DIRECT_PREFIXES.has(matchedPrefix) && !/,\s*$/u.test(before)) continue;
-			const words = before.match(/\p{L}[\p{L}\p{M}]*/gu) ?? [];
+			if (COMMA_GATED_DIRECT_PREFIXES.has(matchedPrefix)) {
+				const hasComma = /,\s*$/u.test(before);
+				const hasSentenceVerb = (before.match(/\p{L}[\p{L}\p{M}'’]*/gu) ?? []).some((word) => /^\p{Ll}/u.test(word) && verbIndicators.has(word.toLowerCase()));
+				if (!hasComma && !hasSentenceVerb) continue;
+			}
+			const words = before.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);
 		}
 	}
@@ -1501,7 +1466,7 @@ const trimLeadingClause = (text) => {
 * otherwise the trim falls back to a no-op and sentence-
 * fragment fixes do not apply.
 */
-const processLegalFormMatches = (allMatches, sliceStart, sliceEnd, fullText) => {
+const processLegalFormMatches = (allMatches, sliceStart, sliceEnd, fullText, options = {}) => {
 	const results = [];
 	for (const match of allMatches) {
 		const idx = match.pattern;
@@ -1519,9 +1484,9 @@ const processLegalFormMatches = (allMatches, sliceStart, sliceEnd, fullText) =>
 		if (firstWordMatch !== null && (roleHeads.has(firstWordText.toLowerCase()) || firstWordLeading.length > 0 && roleHeads.has(firstWordLeading.toLowerCase()))) {
 			let suffixOffset = -1;
 			for (const suffix of getAllLegalSuffixesSync()) {
-				const idx = text.lastIndexOf(suffix);
-				if (idx !== -1 && idx + suffix.length >= text.length - 1) {
-					suffixOffset = idx;
+				const suffixIdx = text.lastIndexOf(suffix);
+				if (suffixIdx !== -1 && suffixIdx + suffix.length >= text.length - 1) {
+					suffixOffset = suffixIdx;
 					break;
 				}
 			}
@@ -1531,7 +1496,7 @@ const processLegalFormMatches = (allMatches, sliceStart, sliceEnd, fullText) =>
 				const midSection = text.slice(midStart, midEnd);
 				const verbIndicators = getSentenceVerbIndicatorsSync();
 				let lastVerbEndInMid = -1;
-				for (const match of midSection.matchAll(/(?<![\p{L}\p{N}])[\p{L}\p{M}]+/gu)) if (match[0] !== void 0 && match.index !== void 0 && verbIndicators.has(match[0].toLowerCase())) lastVerbEndInMid = match.index + match[0].length;
+				for (const wordMatch of midSection.matchAll(/(?<![\p{L}\p{N}])[\p{L}\p{M}]+/gu)) if (wordMatch[0] !== void 0 && wordMatch.index !== void 0 && verbIndicators.has(wordMatch[0].toLowerCase())) lastVerbEndInMid = wordMatch.index + wordMatch[0].length;
 				const digitAfterRole = /^\s+\d+(?:\.|\b)/u.test(midSection);
 				let appositiveRoleHead = false;
 				if (!digitAfterRole && lastVerbEndInMid === -1 && fullText) {
@@ -1562,7 +1527,7 @@ const processLegalFormMatches = (allMatches, sliceStart, sliceEnd, fullText) =>
 		if (processedText.includes("\n") && hasDisallowedLineBreak(processedText)) continue;
 		let entityStart = processedStart;
 		let entityText = processedText;
-		if (fullText && !trimmed) {
+		if (fullText && !trimmed && options.suppressExtendBackward !== true) {
 			const extended = !BARE_SINGLE_CAP_LEGAL_FORM_RE.test(processedText) ? extendBackward(fullText, processedStart) : processedStart;
 			if (extended < processedStart) {
 				entityStart = extended;
@@ -1594,15 +1559,13 @@ const processLegalFormMatches = (allMatches, sliceStart, sliceEnd, fullText) =>
 				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;
+			if (suffixClean.length <= 2 && !/\./.test(rawSuffix) && /[^\p{ASCII}]/u.test(stripDocxSpaces(entityText.slice(0, lastSuffixSeparator !== -1 ? lastSuffixSeparator : entityText.length)))) continue;
 			results.push({
 				start: entityStart,
 				end: entityStart + entityText.length,
@@ -1983,31 +1946,57 @@ const tryPrefixExtension = (fullText, start, end) => {
 };
 //#endregion
 //#region src/util/normalize.ts
-const CHAR_MAP$1 = new Map([
-	[160, 32],
-	[8199, 32],
-	[8239, 32],
-	[8211, 45],
-	[8212, 45],
-	[8220, 34],
-	[8221, 34]
-]);
+/**
+* Normalize typographic variants for search matching.
+*
+* Legal documents (especially Czech/German) use
+* non-breaking spaces, smart quotes, and en/em dashes
+* that differ from their ASCII equivalents. Since all
+* replacements are same-length (single code unit →
+* single code unit), character offsets remain valid.
+*
+* Lives here (application layer) rather than in the
+* AC library: what to normalize is domain-specific.
+*
+* Uses a char-code lookup (`Map<number, number>`) and
+* `Uint16Array` instead of 7 sequential `replaceAll`
+* calls. For a 50 KB document this eliminates ~350 KB
+* of intermediate string allocations.
+*
+* When no replaceable characters are present (common
+* for plain-text inputs), a fast-path scan returns the
+* original string without any allocation. When special
+* characters exist, the string is scanned twice: once
+* to detect, once to build the replacement array.
+*/
+const replacementCode = (code) => {
+	switch (code) {
+		case 160:
+		case 8199:
+		case 8239: return 32;
+		case 8211:
+		case 8212: return 45;
+		case 8220:
+		case 8221: return 34;
+		default: return code;
+	}
+};
 /** Chunk size for `String.fromCharCode` to avoid
 *  hitting the call-stack limit on very large strings. */
 const CHUNK_SIZE$1 = 8192;
 const normalizeForSearch = (text) => {
 	let hasSpecial = false;
-	for (let i = 0; i < text.length; i++) if (CHAR_MAP$1.has(text.charCodeAt(i))) {
-		hasSpecial = true;
-		break;
+	for (let i = 0; i < text.length; i++) {
+		const code = text.charCodeAt(i);
+		if (replacementCode(code) !== code) {
+			hasSpecial = true;
+			break;
+		}
 	}
 	if (!hasSpecial) return text;
 	const len = text.length;
 	const codes = new Uint16Array(len);
-	for (let i = 0; i < len; i++) {
-		const code = text.charCodeAt(i);
-		codes[i] = CHAR_MAP$1.get(code) ?? code;
-	}
+	for (let i = 0; i < len; i++) codes[i] = replacementCode(text.charCodeAt(i));
 	if (len <= CHUNK_SIZE$1) return String.fromCharCode(...codes);
 	let result = "";
 	for (let offset = 0; offset < len; offset += CHUNK_SIZE$1) {
@@ -7857,6 +7846,7 @@ const NAME_BLOCKLIST = new Set([
 	"island",
 	"indie"
 ].map((s) => s.toLowerCase()));
+let cachedCountryPatterns = null;
 /**
 * Build country patterns for the literal search instance.
 * Returns patterns and parallel metadata arrays.
@@ -7868,6 +7858,7 @@ const NAME_BLOCKLIST = new Set([
 * country entry.
 */
 const buildCountryPatterns = () => {
+	if (cachedCountryPatterns !== null) return cachedCountryPatterns;
 	const raw = countries_default;
 	const surfaceToMeta = /* @__PURE__ */ new Map();
 	const register = (surface, isoCode, variant) => {
@@ -7907,7 +7898,7 @@ const buildCountryPatterns = () => {
 		isoCodes.push(isoCode);
 		variants.push(variant);
 	}
-	return {
+	cachedCountryPatterns = {
 		patterns,
 		data: {
 			labels,
@@ -7915,6 +7906,7 @@ const buildCountryPatterns = () => {
 			variants
 		}
 	};
+	return cachedCountryPatterns;
 };
 /**
 * Whether the match starts on a proper-noun character.
@@ -8147,7 +8139,7 @@ const isAllCapsLineNameShaped = (fullText, start) => {
 	const lineEndIdx = fullText.indexOf("\n", start);
 	const line = fullText.slice(lineStart, lineEndIdx === -1 ? fullText.length : lineEndIdx);
 	if (/\d/.test(line)) return false;
-	const tokens = line.match(/\p{L}[\p{L}\p{M}'\-]*/gu) ?? [];
+	const tokens = line.match(/\p{L}[\p{L}\p{M}'-]*/gu) ?? [];
 	return tokens.length > 0 && tokens.length <= ALL_CAPS_NAME_LINE_MAX_TOKENS;
 };
 const isAllCapsContextLine = (fullText, start) => {
@@ -8182,7 +8174,7 @@ const classifyToken = (word, corpus, fullText) => {
 	if (text.length === 1 && UPPER_START_RE.test(text) && fullText[end] === ".") {
 		const lineStart = fullText.lastIndexOf("\n", start - 1) + 1;
 		const before = fullText.slice(lineStart, start).trimEnd();
-		const lastWord = /\p{L}[\p{L}\p{M}'\-]*$/u.exec(before)?.[0];
+		const lastWord = /\p{L}[\p{L}\p{M}'-]*$/u.exec(before)?.[0];
 		if (lastWord) {
 			const lookup = (token) => isFirstNameToken(token, corpus) || isFirstNameToken((token[0] ?? "") + token.slice(1).toLowerCase(), corpus);
 			if (lookup(lastWord)) return {
@@ -8309,7 +8301,7 @@ const detectNameCorpus = (fullText, ctx = defaultContext) => {
 		const hasAbbreviation = chain.some((t) => t.type === TOKEN_TYPE.ABBREVIATION);
 		const corpusCount = chain.filter((t) => isCorpusMatch(t.type)).length;
 		const capitalizedCount = chain.filter((t) => t.type === TOKEN_TYPE.CAPITALIZED).length;
-		let score = 0;
+		let score;
 		if (hasTitle && hasCorpusName) score = .95;
 		else if (corpusCount >= 2) score = .9;
 		else if (hasCorpusName && capitalizedCount > 0) score = .7;
@@ -8637,6 +8629,480 @@ const POST_NOMINALS = [
 	"QC"
 ];
 //#endregion
+//#region src/data/amount-words.json
+var amount_words_exports = /* @__PURE__ */ __exportAll({
+	_comment: () => _comment$1,
+	default: () => amount_words_default,
+	magnitudeSuffixes: () => magnitudeSuffixes,
+	patterns: () => patterns,
+	percentages: () => percentages,
+	shareQuantityTerms: () => shareQuantityTerms
+});
+var _comment$1 = "Patterns for written-out monetary amounts, magnitude suffixes, share-quantity guards, and numeric percentage phrases, by language.";
+var patterns = [
+	{
+		"lang": "cs",
+		"keywords": ["slovy", "slovně"]
+	},
+	{
+		"lang": "sk",
+		"keywords": ["slovom", "slovami"]
+	},
+	{
+		"lang": "de",
+		"keywords": ["in Worten", "in Buchstaben"]
+	},
+	{
+		"lang": "en",
+		"keywords": ["in words", "in letters"]
+	},
+	{
+		"lang": "fr",
+		"keywords": ["en lettres", "en toutes lettres"]
+	},
+	{
+		"lang": "pl",
+		"keywords": ["słownie"]
+	},
+	{
+		"lang": "it",
+		"keywords": ["in lettere"]
+	},
+	{
+		"lang": "es",
+		"keywords": ["en letras"]
+	}
+];
+var percentages = [{
+	"lang": "en",
+	"keywords": ["percent"],
+	"standalone": ["zero", "one hundred"],
+	"ones": [
+		"one",
+		"two",
+		"three",
+		"four",
+		"five",
+		"six",
+		"seven",
+		"eight",
+		"nine"
+	],
+	"teens": [
+		"ten",
+		"eleven",
+		"twelve",
+		"thirteen",
+		"fourteen",
+		"fifteen",
+		"sixteen",
+		"seventeen",
+		"eighteen",
+		"nineteen"
+	],
+	"tens": [
+		"twenty",
+		"thirty",
+		"forty",
+		"fifty",
+		"sixty",
+		"seventy",
+		"eighty",
+		"ninety"
+	],
+	"allowSpaceCompoundSeparator": true
+}];
+var magnitudeSuffixes = [
+	{
+		"lang": "cs",
+		"words": [
+			"sto",
+			"sta",
+			"stě",
+			"sty",
+			"stovka",
+			"stovky",
+			"stovek",
+			"tisíc",
+			"tisíce",
+			"tisíců",
+			"milion",
+			"miliony",
+			"milionů",
+			"miliarda",
+			"miliardy",
+			"miliard",
+			"bilion",
+			"biliony",
+			"bilionů"
+		],
+		"abbreviationsCaseInsensitive": ["mld"],
+		"abbreviationsCaseSensitive": ["K", "M"]
+	},
+	{
+		"lang": "de",
+		"words": [
+			"hundert",
+			"hunderte",
+			"hunderten",
+			"tausend",
+			"million",
+			"millionen",
+			"milliarde",
+			"milliarden",
+			"billion",
+			"billionen"
+		],
+		"abbreviationsCaseInsensitive": ["mio", "mrd"],
+		"abbreviationsCaseSensitive": ["K", "M"]
+	},
+	{
+		"lang": "en",
+		"words": [
+			"hundred",
+			"hundreds",
+			"thousand",
+			"thousands",
+			"million",
+			"millions",
+			"billion",
+			"billions",
+			"trillion",
+			"trillions",
+			"quadrillion",
+			"quadrillions"
+		],
+		"abbreviationsCaseInsensitive": [
+			"bn",
+			"bln",
+			"tn",
+			"trn"
+		],
+		"abbreviationsCaseSensitive": ["K", "M"]
+	},
+	{
+		"lang": "es",
+		"words": [
+			"cien",
+			"ciento",
+			"cientos",
+			"millón",
+			"millones",
+			"billón",
+			"billones"
+		],
+		"abbreviationsCaseInsensitive": ["mln"],
+		"abbreviationsCaseSensitive": ["K", "M"]
+	},
+	{
+		"lang": "fr",
+		"words": [
+			"cent",
+			"cents",
+			"centaine",
+			"centaines",
+			"mille",
+			"million",
+			"millions",
+			"milliard",
+			"milliards",
+			"billion",
+			"billions"
+		],
+		"abbreviationsCaseInsensitive": [
+			"mio",
+			"md",
+			"mrd"
+		],
+		"abbreviationsCaseSensitive": ["K", "M"]
+	},
+	{
+		"lang": "it",
+		"words": [
+			"cento",
+			"centinaio",
+			"centinaia",
+			"mille",
+			"milione",
+			"milioni",
+			"miliardo",
+			"miliardi",
+			"bilione",
+			"bilioni"
+		],
+		"abbreviationsCaseInsensitive": ["mln", "mld"],
+		"abbreviationsCaseSensitive": ["K", "M"]
+	},
+	{
+		"lang": "pl",
+		"words": [
+			"sto",
+			"sta",
+			"stów",
+			"stoma",
+			"setki",
+			"setek",
+			"tysiąc",
+			"tysiące",
+			"tysięcy",
+			"milion",
+			"miliony",
+			"milionów",
+			"miliard",
+			"miliardy",
+			"miliardów",
+			"bilion",
+			"biliony",
+			"bilionów"
+		],
+		"abbreviationsCaseInsensitive": ["mln", "mld"],
+		"abbreviationsCaseSensitive": ["K", "M"]
+	},
+	{
+		"lang": "pt-br",
+		"words": [
+			"cem",
+			"cento",
+			"centena",
+			"centenas",
+			"milhão",
+			"milhões",
+			"bilhão",
+			"bilhões",
+			"trilhão",
+			"trilhões"
+		],
+		"abbreviationsCaseInsensitive": [],
+		"abbreviationsCaseSensitive": ["K", "M"]
+	},
+	{
+		"lang": "sk",
+		"words": [
+			"sto",
+			"sta",
+			"stoviek",
+			"stovka",
+			"stovky",
+			"tisíc",
+			"tisíce",
+			"tisícov",
+			"milión",
+			"milióny",
+			"miliónov",
+			"milion",
+			"miliony",
+			"milionov",
+			"miliarda",
+			"miliardy",
+			"miliárd",
+			"bilión",
+			"bilióny",
+			"biliónov"
+		],
+		"abbreviationsCaseInsensitive": ["mld"],
+		"abbreviationsCaseSensitive": ["K", "M"]
+	}
+];
+var shareQuantityTerms = [
+	{
+		"lang": "cs",
+		"modifiers": [
+			"kmenové",
+			"obyčejné",
+			"prioritní",
+			"registrované",
+			"vlastní",
+			"hlasovací",
+			"nehlasovací",
+			"omezené",
+			"třída",
+			"série"
+		],
+		"nouns": [
+			"akcie",
+			"cenné papíry",
+			"podíly",
+			"jednotky"
+		]
+	},
+	{
+		"lang": "de",
+		"modifiers": [
+			"stamm",
+			"vorzugs",
+			"namens",
+			"eigene",
+			"stimmberechtigte",
+			"stimmrechtslose",
+			"beschränkte",
+			"klasse",
+			"serie"
+		],
+		"nouns": [
+			"aktien",
+			"wertpapiere",
+			"anteile",
+			"einheiten"
+		]
+	},
+	{
+		"lang": "en",
+		"modifiers": [
+			"ordinary",
+			"common",
+			"preferred",
+			"registered",
+			"treasury",
+			"voting",
+			"non-voting",
+			"restricted",
+			"class",
+			"series"
+		],
+		"nouns": [
+			"share",
+			"shares",
+			"stock",
+			"stocks",
+			"security",
+			"securities",
+			"unit",
+			"units"
+		]
+	},
+	{
+		"lang": "es",
+		"modifiers": [
+			"ordinarias",
+			"comunes",
+			"preferentes",
+			"nominativas",
+			"propias",
+			"con derecho a voto",
+			"sin derecho a voto",
+			"restringidas",
+			"clase",
+			"serie"
+		],
+		"nouns": [
+			"acciones",
+			"valores",
+			"participaciones",
+			"unidades"
+		]
+	},
+	{
+		"lang": "fr",
+		"modifiers": [
+			"ordinaires",
+			"communes",
+			"privilégiées",
+			"nominatives",
+			"propres",
+			"votantes",
+			"sans droit de vote",
+			"restreintes",
+			"classe",
+			"série"
+		],
+		"nouns": [
+			"actions",
+			"titres",
+			"unités"
+		]
+	},
+	{
+		"lang": "it",
+		"modifiers": [
+			"ordinarie",
+			"comuni",
+			"privilegiate",
+			"nominative",
+			"proprie",
+			"votanti",
+			"senza diritto di voto",
+			"vincolate",
+			"classe",
+			"serie"
+		],
+		"nouns": [
+			"azioni",
+			"titoli",
+			"quote",
+			"unità"
+		]
+	},
+	{
+		"lang": "pl",
+		"modifiers": [
+			"zwykłe",
+			"imienne",
+			"uprzywilejowane",
+			"własne",
+			"głosujące",
+			"nieme",
+			"ograniczone",
+			"klasa",
+			"seria"
+		],
+		"nouns": [
+			"akcje",
+			"papiery wartościowe",
+			"udziały",
+			"jednostki"
+		]
+	},
+	{
+		"lang": "pt-br",
+		"modifiers": [
+			"ordinárias",
+			"comuns",
+			"preferenciais",
+			"nominativas",
+			"próprias",
+			"votantes",
+			"sem direito a voto",
+			"restritas",
+			"classe",
+			"série"
+		],
+		"nouns": [
+			"ações",
+			"valores mobiliários",
+			"participações",
+			"unidades"
+		]
+	},
+	{
+		"lang": "sk",
+		"modifiers": [
+			"kmeňové",
+			"obyčajné",
+			"prioritné",
+			"registrované",
+			"vlastné",
+			"hlasovacie",
+			"nehlasovacie",
+			"obmedzené",
+			"trieda",
+			"séria"
+		],
+		"nouns": [
+			"akcie",
+			"cenné papiere",
+			"podiely",
+			"jednotky"
+		]
+	}
+];
+var amount_words_default = {
+	_comment: _comment$1,
+	patterns,
+	percentages,
+	magnitudeSuffixes,
+	shareQuantityTerms
+};
+//#endregion
 //#region src/detectors/regex.ts
 const MIN_PHONE_LENGTH = 7;
 const MIN_MONTH_NAME_LENGTH = 3;
@@ -8734,7 +9200,13 @@ const STDNUM_ENTRIES = [
 	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)
+	toEntry(br.cnpj, "tax identification number", .95),
+	{
+		validator: cn.ric,
+		label: "national identification number",
+		score: .95,
+		pattern: "(?<![A-Za-z0-9_])\\d{17}[\\dXx](?![A-Za-z0-9_])"
+	}
 ].filter((e) => e !== null);
 const TITLED_PERSON = {
 	pattern: `(?:${TITLE_PREFIX})(?:${SP}+(?:${TITLE_PREFIX}))*${SP}+(?:${NAME_WORD})(?:${SP}{1,4}(?:${PARTICLE}${SP}+)?${NAME_WORD}){1,3}(?:,?${SP}+(?:${POST_NOMINAL})(?:,?${SP}+(?:${POST_NOMINAL}))*)?`,
@@ -8781,6 +9253,24 @@ const TEL_PREFIX_PHONE = {
 	label: "phone number",
 	score: .95
 };
+/**
+* US phone numbers in the (NNN) NNN-NNNN form. Dominant
+* shape in US notice blocks ("(212) 735-3000"); not
+* covered by INTL_PHONE (which requires a leading `+`)
+* or TEL_PREFIX_PHONE (which requires a `tel.:` label).
+*
+* The parenthesised area code is the constraint that
+* keeps this from matching random digit clusters —
+* `(212) 555-1212` looks like nothing else in a contract.
+* Score below INTL_PHONE (1) and TEL_PREFIX_PHONE (0.95)
+* so labelled / fully-qualified forms still win the
+* overlap resolver when both fire on the same span.
+*/
+const US_PAREN_PHONE = {
+	pattern: "\\(\\d{3}\\)(?:[^\\S\\n]|[.\\-])?\\d{3}(?:[^\\S\\n]|[.\\-])\\d{4}\\b",
+	label: "phone number",
+	score: .9
+};
 const CREDIT_CARD = {
 	pattern: "\\b(?:4\\d{3}|5[1-5]\\d{2}|3[47]\\d{2})(?:[^\\S\\n]|[.\\-])?\\d{4}(?:[^\\S\\n]|[.\\-])?\\d{4}(?:[^\\S\\n]|[.\\-])?\\d{2,4}\\b",
 	label: "credit card number",
@@ -8982,6 +9472,7 @@ const ALL_REGEX_DEFS = [
 	INTL_PHONE,
 	CZ_PHONE,
 	TEL_PREFIX_PHONE,
+	US_PAREN_PHONE,
 	CREDIT_CARD,
 	CZ_BIRTH_NUMBER,
 	CZ_COMMERCIAL_REGISTER,
@@ -9103,7 +9594,16 @@ const buildMagnitudePattern = (config) => {
 	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 required = branches.length > 0 ? `(?:${branches.join("|")})` : "";
+	return {
+		optional: required ? `${required}?` : "",
+		required,
+		prefilterTerms: [
+			...words,
+			...caseInsensitiveAbbreviations,
+			...caseSensitiveAbbreviations
+		]
+	};
 };
 const buildQuantityFollowerGuard = (config) => {
 	const modifiers = [];
@@ -9117,10 +9617,15 @@ const buildQuantityFollowerGuard = (config) => {
 	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 buildFinancialLexicons = (config) => {
+	const magnitude = buildMagnitudePattern(config);
+	return Object.freeze({
+		magnitudeOptional: magnitude.optional,
+		magnitudeRequired: magnitude.required,
+		magnitudePrefilterTerms: magnitude.prefilterTerms,
+		quantityFollowerGuard: buildQuantityFollowerGuard(config)
+	});
+};
 const FINANCIAL_LEXICONS = buildFinancialLexicons(AMOUNT_WORDS);
 /**
 * Build symbol character class, code alternation,
@@ -9132,50 +9637,113 @@ const FINANCIAL_LEXICONS = buildFinancialLexicons(AMOUNT_WORDS);
 * thousands (1,000) and plain integers (100000)
 * via `\d{1,9}` to catch unformatted amounts.
 */
-const buildCurrencyPatterns = (data) => {
+const buildCurrencyPatternEntries = (data) => {
 	const symbols = data.symbols.map(escapeCharClass).join("");
 	const isAsciiAlpha = /^[a-zA-Z\s]+$/;
-	const parts = data.codes.map((code) => ({
+	const codeParts = data.codes.map((code) => ({
+		term: code,
 		len: code.length,
 		alt: escapeRegex$2(code)
 	}));
+	const localNameParts = [];
 	const MIN_CI_LENGTH = 3;
 	if (data.localNames) for (const name of data.localNames) {
 		const escaped = escapeRegex$2(name);
-		if (isAsciiAlpha.test(name) && name.length >= MIN_CI_LENGTH) parts.push({
+		if (isAsciiAlpha.test(name) && name.length >= MIN_CI_LENGTH) localNameParts.push({
+			term: name,
 			len: name.length,
 			alt: `(?i:${escaped})`
 		});
-		else parts.push({
+		else localNameParts.push({
+			term: name,
 			len: name.length,
 			alt: escaped
 		});
 	}
-	if (symbols) for (const ch of data.symbols) parts.push({
-		len: ch.length,
-		alt: escapeRegex$2(ch)
-	});
-	const trailingAlt = parts.toSorted((a, b) => b.len - a.len).map((p) => p.alt).join("|");
+	const toPartAlternation = (parts) => parts.toSorted((a, b) => b.len - a.len).map((p) => p.alt).join("|");
+	const codeAlt = toPartAlternation(codeParts);
+	const localNameAlt = toPartAlternation(localNameParts);
+	const codeTerms = codeParts.map((part) => part.term);
+	const localNameTerms = localNameParts.map((part) => part.term);
+	const trailingAlt = [...codeParts, ...localNameParts].toSorted((a, b) => b.len - a.len).map((p) => p.alt).join("|");
 	if (!symbols && !trailingAlt) return [];
 	const NUM = "(?:\\d{1,3}(?:[,.'[^\\S\\n\\t]]\\d{3})+|\\d{1,9})";
+	const PREFILTER_NUM = `(?:\\d{1,3}(?:[,.'\\s]\\d{3})+|\\d{1,9})`;
+	const PREFILTER_DECIMAL = `(?:[.,](?=\\d|[${DASH_INNER}])\\s?(?:\\d{1,2}${DASH}?|${DASH}{1,2}))?`;
 	const patterns = [];
+	const lazyCurrencyPattern = (pattern, prefilterAny, prefilterCaseInsensitive, prefilterRegex) => ({
+		pattern,
+		lazy: true,
+		prefilterAny,
+		prefilterCaseInsensitive,
+		...prefilterRegex ? { prefilterRegex } : {}
+	});
+	const makeLeadingPrefilter = (terms, caseInsensitive) => {
+		const termAlt = toSortedAlternation(terms);
+		if (!termAlt) return void 0;
+		return new RegExp(`(?:^|[^\\p{L}\\p{N}_])(?:${termAlt})[^\\S\\n\\t]{0,2}\\d`, caseInsensitive ? "iu" : "u");
+	};
+	const makeTrailingPrefilter = (terms, caseInsensitive) => {
+		const termAlt = toSortedAlternation(terms);
+		if (!termAlt) return void 0;
+		return new RegExp(`${PREFILTER_NUM}${PREFILTER_DECIMAL}[^\\S\\n\\t]{0,4}(?:${termAlt})`, caseInsensitive ? "iu" : "u");
+	};
+	const makeLeadingMagnitudePrefilter = (terms, caseInsensitive) => {
+		const termAlt = toSortedAlternation(terms);
+		const magnitudeAlt = toSortedAlternation(FINANCIAL_LEXICONS.magnitudePrefilterTerms);
+		if (!termAlt || !magnitudeAlt) return void 0;
+		return new RegExp(`(?:^|[^\\p{L}\\p{N}_])(?:${termAlt})[^\\S\\n\\t]{0,2}${PREFILTER_NUM}${PREFILTER_DECIMAL}[^\\S\\n\\t]{0,8}(?:${magnitudeAlt})(?:$|[^\\p{L}\\p{N}_])`, caseInsensitive ? "iu" : "u");
+	};
+	const makeLeadingSymbolMagnitudePrefilter = () => {
+		const magnitudeAlt = toSortedAlternation(FINANCIAL_LEXICONS.magnitudePrefilterTerms);
+		if (!magnitudeAlt) return void 0;
+		return new RegExp(`(?:^|[^\\p{L}\\p{N}_])(?:[${symbols}])[^\\S\\n\\t]{0,2}${PREFILTER_NUM}${PREFILTER_DECIMAL}[^\\S\\n\\t]{0,8}(?:${magnitudeAlt})(?:$|[^\\p{L}\\p{N}_])`, "iu");
+	};
+	const makeTrailingMagnitudePrefilter = (terms, caseInsensitive) => {
+		const termAlt = toSortedAlternation(terms);
+		const magnitudeAlt = toSortedAlternation(FINANCIAL_LEXICONS.magnitudePrefilterTerms);
+		if (!termAlt || !magnitudeAlt) return void 0;
+		return new RegExp(`${PREFILTER_NUM}${PREFILTER_DECIMAL}[^\\S\\n\\t]{0,8}(?:${magnitudeAlt})(?:$|[^\\p{L}\\p{N}_])[\\s\\S]{0,24}(?:${termAlt})`, caseInsensitive ? "iu" : "u");
+	};
 	const DECIMAL = `(?:[.,](?=\\d|[${DASH_INNER}])[^\\S\\n\\t]?(?:\\d{1,2}${DASH}?|${DASH}{1,2}))?`;
 	const END = `(?:\\b|(?=\\s|[.,;!?)]|$))`;
-	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}`);
+	const MAGNITUDE_OPTIONAL = FINANCIAL_LEXICONS.magnitudeOptional;
+	const MAGNITUDE_REQUIRED = FINANCIAL_LEXICONS.magnitudeRequired;
+	if (symbols) {
+		patterns.push(lazyCurrencyPattern(`(?:[${symbols}])[^\\S\\n\\t]?${NUM}${DECIMAL}${END}`, data.symbols, true));
+		if (MAGNITUDE_REQUIRED) patterns.push(lazyCurrencyPattern(`(?:[${symbols}])[^\\S\\n\\t]?${NUM}${DECIMAL}${MAGNITUDE_REQUIRED}${END}`, data.symbols, true, makeLeadingSymbolMagnitudePrefilter()));
+	}
+	if (codeAlt) {
+		patterns.push(lazyCurrencyPattern(`\\b(?:${codeAlt})[^\\S\\n\\t]{0,2}${NUM}${DECIMAL}${END}`, codeTerms, false, makeLeadingPrefilter(codeTerms, false)));
+		if (MAGNITUDE_REQUIRED) patterns.push(lazyCurrencyPattern(`\\b(?:${codeAlt})[^\\S\\n\\t]{0,2}${NUM}${DECIMAL}${MAGNITUDE_REQUIRED}${END}`, codeTerms, false, makeLeadingMagnitudePrefilter(codeTerms, false)));
+	}
+	if (localNameAlt) {
+		patterns.push(lazyCurrencyPattern(`\\b(?:${localNameAlt})[^\\S\\n\\t]{0,2}${NUM}${DECIMAL}${END}`, localNameTerms, true, makeLeadingPrefilter(localNameTerms, true)));
+		if (MAGNITUDE_REQUIRED) patterns.push(lazyCurrencyPattern(`\\b(?:${localNameAlt})[^\\S\\n\\t]{0,2}${NUM}${DECIMAL}${MAGNITUDE_REQUIRED}${END}`, localNameTerms, true, makeLeadingMagnitudePrefilter(localNameTerms, true)));
+	}
+	const optionalLeadingSymbol = symbols ? `(?<![\\p{L}\\p{N}_])(?:[${symbols}][^\\S\\n\\t]?)?` : "\\b";
+	if (codeAlt) {
+		patterns.push(lazyCurrencyPattern(`${optionalLeadingSymbol}${NUM}${DECIMAL}[^\\S\\n\\t]{0,4}(?:${codeAlt})${END}`, codeTerms, false, makeTrailingPrefilter(codeTerms, false)));
+		if (MAGNITUDE_REQUIRED) patterns.push(lazyCurrencyPattern(`${optionalLeadingSymbol}${NUM}${DECIMAL}${MAGNITUDE_REQUIRED}[^\\S\\n\\t]{0,4}(?:${codeAlt})${FINANCIAL_LEXICONS.quantityFollowerGuard}${END}`, codeTerms, false, makeTrailingMagnitudePrefilter(codeTerms, false)));
+	}
+	if (localNameAlt) {
+		patterns.push(lazyCurrencyPattern(`${optionalLeadingSymbol}${NUM}${DECIMAL}[^\\S\\n\\t]{0,4}(?:${localNameAlt})${END}`, localNameTerms, true, makeTrailingPrefilter(localNameTerms, true)));
+		if (MAGNITUDE_REQUIRED) patterns.push(lazyCurrencyPattern(`${optionalLeadingSymbol}${NUM}${DECIMAL}${MAGNITUDE_REQUIRED}[^\\S\\n\\t]{0,4}(?:${localNameAlt})${FINANCIAL_LEXICONS.quantityFollowerGuard}${END}`, localNameTerms, true, makeTrailingMagnitudePrefilter(localNameTerms, true)));
+	}
+	if (symbols) {
+		const trailingSymbolPrefilter = new RegExp(`${PREFILTER_NUM}${PREFILTER_DECIMAL}[^\\S\\n\\t]{0,4}[${symbols}]`, "u");
+		patterns.push(lazyCurrencyPattern(`${NUM}${DECIMAL}${MAGNITUDE_OPTIONAL}[^\\S\\n\\t]{0,4}(?:[${symbols}])${END}`, data.symbols, true, trailingSymbolPrefilter));
 	}
 	return patterns;
 };
 /** Cached promise for currency patterns. Loaded once. */
 let currencyPatternPromise = null;
-const loadCurrencyPatterns = async () => {
+let currencyPatternEntryPromise = null;
+const loadCurrencyPatternEntries = async () => {
 	const mod = await import("./currencies.mjs");
-	return buildCurrencyPatterns(mod.default ?? mod);
+	return buildCurrencyPatternEntries(mod.default ?? mod);
 };
+const loadCurrencyPatterns = async () => (await loadCurrencyPatternEntries()).map((entry) => entry.pattern);
 /**
 * Get dynamically built monetary amount patterns from
 * currencies.json. Returns a cached promise; the JSON
@@ -9188,6 +9756,13 @@ const getCurrencyPatterns = () => {
 	});
 	return currencyPatternPromise;
 };
+const getCurrencyPatternEntries = () => {
+	if (!currencyPatternEntryPromise) currencyPatternEntryPromise = loadCurrencyPatternEntries().catch((err) => {
+		currencyPatternEntryPromise = null;
+		throw err;
+	});
+	return currencyPatternEntryPromise;
+};
 /** Currency pattern metadata (score 0.9). */
 const CURRENCY_PATTERN_META = Object.freeze({
 	label: "monetary amount",
@@ -9268,6 +9843,249 @@ const getSigningClausePatterns = () => {
 	return signingPatternPromise;
 };
 //#endregion
+//#region src/detectors/legal-forms-v2.ts
+const normalizeSuffixToken = (s) => s.replace(/[.,\s]/g, "").toLowerCase();
+let cachedNormalizedSuffixes = null;
+const getNormalizedSuffixSet = () => {
+	if (cachedNormalizedSuffixes !== null) return cachedNormalizedSuffixes;
+	const out = /* @__PURE__ */ new Set();
+	for (const s of getKnownLegalSuffixes()) {
+		const n = normalizeSuffixToken(s);
+		if (n.length > 0) out.add(n);
+	}
+	cachedNormalizedSuffixes = out;
+	return out;
+};
+const isLegalFormSuffixWord = (word) => {
+	const n = normalizeSuffixToken(word);
+	if (n.length === 0) return false;
+	return getNormalizedSuffixSet().has(n);
+};
+let cachedSuffixSearch = null;
+const getSuffixSearch = () => {
+	const suffixes = getKnownLegalSuffixes();
+	if (cachedSuffixSearch !== null && cachedSuffixSearch.suffixes === suffixes) return cachedSuffixSearch;
+	const patterns = suffixes.map((suffix) => ({
+		pattern: suffix,
+		literal: true
+	}));
+	cachedSuffixSearch = {
+		ts: new (getTextSearch())(patterns),
+		suffixes
+	};
+	return cachedSuffixSearch;
+};
+const ANY_LETTER_RE = /\p{L}/u;
+const ANY_LETTER_OR_DIGIT_RE = /[\p{L}\p{N}]/u;
+const isTrailingBoundary = (fullText, end) => {
+	if (end >= fullText.length) return true;
+	const next = fullText.charAt(end);
+	if (ANY_LETTER_RE.test(next)) return false;
+	if (/\d/.test(next)) return false;
+	return true;
+};
+const isLeadingSeparator = (fullText, suffixStart) => {
+	if (suffixStart === 0) return true;
+	const prev = fullText.charAt(suffixStart - 1);
+	if (ANY_LETTER_OR_DIGIT_RE.test(prev)) return false;
+	if (prev === "." && suffixStart >= 2 && ANY_LETTER_RE.test(fullText.charAt(suffixStart - 2))) return false;
+	return true;
+};
+const HEAD_TOKEN_CAP = 20;
+const TOKEN_RE = /[\p{L}\p{N}'’.&-]+/u;
+const isInterTokenWs = (ch) => ch === " " || ch === "	" || ch === "\xA0" || ch === " " || ch === ",";
+const findTokenBefore = (fullText, pos) => {
+	let end = pos;
+	while (end > 0) {
+		const ch = fullText.charAt(end - 1);
+		if (ch === "\n") return null;
+		if (isInterTokenWs(ch) || ch === ";") {
+			end--;
+			continue;
+		}
+		break;
+	}
+	if (end === 0) return null;
+	let start = end;
+	while (start > 0) {
+		const ch = fullText.charAt(start - 1);
+		if (ch === "\n") break;
+		if (!TOKEN_RE.test(ch)) break;
+		start--;
+	}
+	if (start === end) return null;
+	return {
+		start,
+		end,
+		text: fullText.slice(start, end)
+	};
+};
+const crossesSentenceEnd = (fullText, candidateStart, suffixStart) => {
+	const slice = fullText.slice(candidateStart, suffixStart);
+	return /\p{Lu}\p{Ll}{2,}\.\s/u.test(slice) || /\p{Lu}{2,}\.\s/u.test(slice);
+};
+const UPPER_LETTER_RE = /^\p{Lu}/u;
+const LOWER_LETTER_RE = /^\p{Ll}/u;
+const DIGIT_RE = /^\d/;
+const CONNECTOR_RE = /^(?:a|and|und|et|e|y|i|&)$/i;
+const isAcceptableToken = (tok) => {
+	if (tok.length === 0) return false;
+	if (UPPER_LETTER_RE.test(tok)) return true;
+	if (DIGIT_RE.test(tok)) return true;
+	if (CONNECTOR_RE.test(tok)) return true;
+	if (LOWER_LETTER_RE.test(tok)) return true;
+	return false;
+};
+const AND_TYPE_CONNECTOR_RE = /^(?:and|und|et)$/i;
+const MIDDLE_INITIAL_RE = /\p{Lu}\.[^\S\n]+\p{L}[\p{L}\p{M}'’]*[^\S\n]*$/u;
+const hasMiddleInitialBefore = (fullText, pos) => {
+	const slice = fullText.slice(Math.max(0, pos - 32), pos);
+	return MIDDLE_INITIAL_RE.test(slice);
+};
+/**
+* Count consecutive uppercase-starting tokens immediately before
+* `pos`. Stops at the first non-upper token, a hard newline, or
+* text start.
+*/
+const countUpperBefore = (fullText, pos) => {
+	let scan = pos;
+	let count = 0;
+	while (true) {
+		const tok = findTokenBefore(fullText, scan);
+		if (!tok) break;
+		if (!UPPER_LETTER_RE.test(tok.text)) break;
+		count++;
+		scan = tok.start;
+	}
+	return count;
+};
+const MAX_LOWER_BRIDGE = 4;
+const walkBackward = (fullText, suffixStart) => {
+	let pos = suffixStart;
+	let stepsLeft = HEAD_TOKEN_CAP;
+	let leftmostCapPos = -1;
+	let lowerBridgeRun = 0;
+	while (stepsLeft > 0) {
+		const tok = findTokenBefore(fullText, pos);
+		if (!tok) break;
+		if (!isAcceptableToken(tok.text)) break;
+		if (LOWER_LETTER_RE.test(tok.text) && leftmostCapPos >= 0) {
+			const afterTok = fullText.slice(tok.end, pos);
+			if (/^[,;]/.test(afterTok) && isLegalFormSuffixWord(tok.text)) break;
+		}
+		if (CONNECTOR_RE.test(tok.text)) {
+			const prevPeek = findTokenBefore(fullText, tok.start);
+			if (prevPeek && isLegalFormSuffixWord(prevPeek.text)) break;
+			if (AND_TYPE_CONNECTOR_RE.test(tok.text)) {
+				if (countUpperBefore(fullText, tok.start) <= 2) break;
+				if (hasMiddleInitialBefore(fullText, tok.start)) break;
+			}
+		}
+		if (UPPER_LETTER_RE.test(tok.text)) {
+			leftmostCapPos = tok.start;
+			lowerBridgeRun = 0;
+		} else if (LOWER_LETTER_RE.test(tok.text)) {
+			if (leftmostCapPos >= 0) {
+				lowerBridgeRun++;
+				if (lowerBridgeRun > MAX_LOWER_BRIDGE) break;
+			}
+		} else lowerBridgeRun = 0;
+		pos = tok.start;
+		stepsLeft--;
+	}
+	return leftmostCapPos < 0 ? suffixStart : leftmostCapPos;
+};
+const CAP_TOKEN_RE = /(?<![\p{L}\p{N}])\p{Lu}[\p{L}\p{M}\p{N}'’.&-]*/gu;
+const LOWER_WORD_RE = /(?<![\p{L}\p{N}])\p{Ll}[\p{L}\p{M}'’]*/gu;
+/**
+* Post-walker verb gate. The walker admits any lowercase token so
+* Czech and German extended state-form tails (`Krajská správa,
+* příspěvková organizace`, `Národní agentura pro komunikační a
+* informační technologie, s. p.`) keep their full vocabulary. The
+* trade-off is that prose sentences ending in a legal-form descriptor
+* (`...převádí na příspěvková organizace.`) get swept too. When the
+* candidate text contains a known lowercase sentence-verb token we
+* slide `candidateStart` forward to the first capitalised token after
+* the last verb; if no capitalised token follows the verb, the
+* candidate is prose and gets dropped.
+*/
+const trimToFirstCapAfterVerb = (fullText, candidateStart, suffixStart) => {
+	if (candidateStart >= suffixStart) return candidateStart;
+	const head = fullText.slice(candidateStart, suffixStart);
+	const verbIndicators = getSentenceVerbIndicatorsSync();
+	let lastVerbEnd = -1;
+	for (const wordMatch of head.matchAll(LOWER_WORD_RE)) if (wordMatch.index !== void 0 && verbIndicators.has(wordMatch[0].toLowerCase())) lastVerbEnd = wordMatch.index + wordMatch[0].length;
+	if (lastVerbEnd < 0) return candidateStart;
+	const roleHeads = getLegalRoleHeadsSync();
+	const clauseNouns = getClauseNounHeadsSync();
+	CAP_TOKEN_RE.lastIndex = lastVerbEnd;
+	for (let next = CAP_TOKEN_RE.exec(head); next !== null; next = CAP_TOKEN_RE.exec(head)) {
+		const word = next[0].toLowerCase();
+		if (roleHeads.has(word) || clauseNouns.has(word)) continue;
+		return candidateStart + next.index;
+	}
+	return suffixStart;
+};
+const synthMatch = (start, end, fullText) => ({
+	start,
+	end,
+	pattern: 0,
+	text: fullText.slice(start, end)
+});
+const detectLegalFormsV2 = (fullText) => {
+	const { ts } = getSuffixSearch();
+	const searchText = normalizeForSearch(fullText);
+	const candidates = [];
+	const trimmedCandidates = /* @__PURE__ */ new Set();
+	for (const match of ts.findIter(searchText)) {
+		const suffixStart = match.start;
+		const suffixEnd = match.end;
+		let effectiveSuffixStart = suffixStart;
+		{
+			let scan = suffixStart;
+			while (scan > 0) {
+				const ch = fullText.charAt(scan - 1);
+				if (ch === " " || ch === "	") {
+					scan--;
+					continue;
+				}
+				break;
+			}
+			if (scan > 0 && fullText.charAt(scan - 1) === "\n") {
+				let p = scan - 1;
+				while (p > 0 && fullText.charAt(p - 1) === " ") p--;
+				if (p > 0 && fullText.charAt(p - 1) === ".") effectiveSuffixStart = p;
+			}
+		}
+		if (!isLeadingSeparator(fullText, suffixStart)) continue;
+		if (!isTrailingBoundary(fullText, suffixEnd)) continue;
+		const walkerStart = walkBackward(fullText, effectiveSuffixStart);
+		if (walkerStart >= effectiveSuffixStart) continue;
+		if (crossesSentenceEnd(fullText, walkerStart, effectiveSuffixStart)) continue;
+		const candidateStart = trimToFirstCapAfterVerb(fullText, walkerStart, effectiveSuffixStart);
+		if (candidateStart >= effectiveSuffixStart) continue;
+		const candidate = synthMatch(candidateStart, suffixEnd, fullText);
+		if (candidateStart !== walkerStart) trimmedCandidates.add(candidate);
+		candidates.push(candidate);
+	}
+	if (candidates.length === 0) return [];
+	const dedupedCandidates = dropOverlapping(candidates);
+	const trimmed = [];
+	const untrimmed = [];
+	for (const c of dedupedCandidates) (trimmedCandidates.has(c) ? trimmed : untrimmed).push(c);
+	return [...processLegalFormMatches(trimmed, 0, 1, fullText, { suppressExtendBackward: true }), ...processLegalFormMatches(untrimmed, 0, 1, fullText)];
+};
+const dropOverlapping = (candidates) => {
+	const sorted = [...candidates].sort((a, b) => a.start - b.start || b.end - a.end);
+	const out = [];
+	for (const c of sorted) {
+		const last = out.at(-1);
+		if (last && c.start >= last.start && c.end <= last.end) continue;
+		out.push(c);
+	}
+	return out;
+};
+//#endregion
 //#region src/detectors/triggers.ts
 const VALID_ID_VALIDATORS = {
 	"br.cpf": br.cpf,
@@ -9287,22 +10105,31 @@ const DECIMAL_COMMA_RE = new RegExp(`^,(?:\\d|${DASH}{1,2})`);
 * etc.), skip the comma and degree, then continue.
 */
 const POST_NOMINAL_RE = new RegExp(`^,\\s*(?:${POST_NOMINALS.toSorted((a, b) => b.length - a.length).map((d) => d.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\\./g, "\\.\\s*")).join("|")})\\.?`, "i");
-const buildLegalFormCheckRe = (forms) => {
-	const parts = forms.map((f) => {
-		const escaped = f.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\\./g, "\\.\\s*");
-		return /^[\p{L}\p{M}]+$/u.test(f) ? `(?<![\\p{L}\\p{N}])${escaped}(?![\\p{L}\\p{N}])` : escaped;
-	});
-	return new RegExp(parts.join("|"), "u");
-};
-let cachedLegalFormCheckRe = null;
 let cachedLegalFormCheckSource = null;
-const getLegalFormCheckRe = () => {
+let cachedLegalFormCheckForms = [];
+const LEGAL_FORM_ALNUM_RE = /[\p{L}\p{N}]/u;
+const LETTER_ONLY_LEGAL_FORM_RE = /^[\p{L}\p{M}]+$/u;
+const getLegalFormCheckForms = () => {
 	const source = getKnownLegalSuffixes();
-	if (cachedLegalFormCheckSource !== source || cachedLegalFormCheckRe === null) {
+	if (cachedLegalFormCheckSource !== source) {
 		cachedLegalFormCheckSource = source;
-		cachedLegalFormCheckRe = buildLegalFormCheckRe(source);
+		cachedLegalFormCheckForms = source;
+	}
+	return cachedLegalFormCheckForms;
+};
+const hasKnownLegalFormSuffix = (text) => {
+	for (const form of getLegalFormCheckForms()) {
+		let fromIndex = 0;
+		while (fromIndex < text.length) {
+			const start = text.indexOf(form, fromIndex);
+			if (start === -1) break;
+			const end = start + form.length;
+			fromIndex = start + 1;
+			if (!LETTER_ONLY_LEGAL_FORM_RE.test(form)) return true;
+			if (!LEGAL_FORM_ALNUM_RE.test(text[start - 1] ?? "") && !LEGAL_FORM_ALNUM_RE.test(text[end] ?? "")) return true;
+		}
 	}
-	return cachedLegalFormCheckRe;
+	return false;
 };
 const compileValidations = (validations) => validations.map((v) => {
 	switch (v.type) {
@@ -9396,12 +10223,13 @@ const expandTriggerGroups = (groups) => {
 	}
 	return rules;
 };
+let triggerPatternsPromise = null;
 /**
 * Build trigger patterns and rules from data configs.
 * Returns string[] for the unified TextSearch
 * builder and the parallel rules array.
 */
-const buildTriggerPatterns = async () => {
+const loadTriggerPatterns = async () => {
 	const rules = [];
 	const allGroups = await loadLanguageConfigs("triggers", (mod) => {
 		return mod.default ?? mod;
@@ -9468,6 +10296,10 @@ const buildTriggerPatterns = async () => {
 		rules
 	};
 };
+const buildTriggerPatterns = async () => {
+	triggerPatternsPromise ??= loadTriggerPatterns();
+	return triggerPatternsPromise;
+};
 const LEADING_PUNCT = /^[„""»«'"()\s]+/;
 const TRAILING_PUNCT = /[""»«'"()\s]+$/;
 const stripQuotes = (value) => {
@@ -9661,6 +10493,9 @@ const warmAddressStopKeywords = async () => {
 };
 const MAX_TRIGGER_VALUE_LEN = 100;
 const MIN_TRIGGER_PHONE_DIGITS = 5;
+const TRIGGER_LOOKAHEAD_MARGIN = 128;
+const LINE_TRIGGER_LOOKAHEAD = 2048;
+const MATCH_PATTERN_LOOKAHEAD = 512;
 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;
@@ -9680,8 +10515,20 @@ const isPlausiblePhoneTriggerValue = (value) => {
 	for (const ch of trimmed) if (/\d/.test(ch)) digits++;
 	return digits >= MIN_TRIGGER_PHONE_DIGITS;
 };
+const getTriggerLookahead = (strategy) => {
+	switch (strategy.type) {
+		case "to-next-comma": return (strategy.maxLength ?? 100) + TRIGGER_LOOKAHEAD_MARGIN;
+		case "to-end-of-line": return LINE_TRIGGER_LOOKAHEAD;
+		case "n-words": return strategy.count * 64 + TRIGGER_LOOKAHEAD_MARGIN;
+		case "company-id-value": return 256;
+		case "address": return (strategy.maxChars ?? 120) + TRIGGER_LOOKAHEAD_MARGIN;
+		case "match-pattern": return MATCH_PATTERN_LOOKAHEAD;
+		default: throw new Error(`Unknown trigger strategy: ${JSON.stringify(strategy)}`);
+	}
+};
 const extractValue = (text, triggerEnd, strategy, label) => {
-	const remaining = text.slice(triggerEnd);
+	const lookaheadEnd = Math.min(text.length, triggerEnd + getTriggerLookahead(strategy));
+	const remaining = text.slice(triggerEnd, lookaheadEnd);
 	const stripped = remaining.replace(/^[\s:;]+/, "");
 	const valueStart = triggerEnd + (remaining.length - stripped.length);
 	const valueText = stripped;
@@ -9927,7 +10774,7 @@ const processTriggerMatches = (allMatches, sliceStart, sliceEnd, fullText, rules
 			const entityStart = rule.includeTrigger ? match.start : value.start;
 			const entityEnd = value.end;
 			const entityText = fullText.slice(entityStart, entityEnd);
-			const effectiveLabel = rule.label === "person" && getLegalFormCheckRe().test(entityText) ? "organization" : rule.label;
+			const effectiveLabel = rule.label === "person" && hasKnownLegalFormSuffix(entityText) ? "organization" : rule.label;
 			results.push({
 				start: entityStart,
 				end: entityEnd,
@@ -10293,7 +11140,7 @@ const ALL_CAPS_LINE_PROSE_EXTRA_LETTERS = 20;
 const ALL_CAPS_LINE_HEADING_WORD_LIMIT = 5;
 const SECTION_HEADING_PREFIX_RE = /^\s*(?:§\s*)?\d{1,3}(?:\.\d{1,3}){0,4}\.?\s*\p{Lu}/u;
 const LINE_LETTER_RE = /\p{L}/gu;
-const ENTITY_WORD_TOKEN_RE = /\p{L}[\p{L}\p{M}\p{N}'’\-]*/gu;
+const ENTITY_WORD_TOKEN_RE = /\p{L}[\p{L}\p{M}\p{N}'’-]*/gu;
 const isAllCapsBoilerplateLine = (fullText, start, length) => {
 	const lineStart = fullText.lastIndexOf("\n", start) + 1;
 	const lineEndIdx = fullText.indexOf("\n", start + length);
@@ -10371,6 +11218,47 @@ const normalizeEntity = (entity) => {
 		text
 	};
 };
+let cachedHeadingRe = null;
+let cachedHeadingPromise = null;
+const ORDINAL_MARKER = "(?:č|no|nr|n)\\.?";
+const buildHeadingRegex = (words) => {
+	if (words.length === 0) return /[\s\S](?!)/u;
+	const escaped = [...words].sort((a, b) => b.length - a.length).map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+	return new RegExp(`^(?:${escaped})[\\s\\u00a0]+(?:${ORDINAL_MARKER}|#)[\\s\\u00a0]*\\d`, "iu");
+};
+const loadHeadingWords = async () => {
+	try {
+		const mod = await import("./document-structure-headings.mjs");
+		const data = mod.default ?? mod;
+		const entries = Object.entries(data);
+		const out = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const [key, value] of entries) {
+			if (key.startsWith("_")) continue;
+			if (!Array.isArray(value)) continue;
+			for (const word of value) {
+				if (typeof word !== "string" || word.length === 0) continue;
+				const lc = word.toLowerCase();
+				if (seen.has(lc)) continue;
+				seen.add(lc);
+				out.push(lc);
+			}
+		}
+		return out;
+	} catch {
+		return [];
+	}
+};
+const loadDocumentStructureHeadings = async () => {
+	if (cachedHeadingRe) return;
+	cachedHeadingPromise ??= loadHeadingWords().then(buildHeadingRegex);
+	cachedHeadingRe = await cachedHeadingPromise;
+};
+const isDocumentStructureHeading = (text) => {
+	const re = cachedHeadingRe;
+	if (!re) return false;
+	return re.test(text);
+};
 const EMPTY_GENERIC_ROLES$1 = /* @__PURE__ */ new Set();
 /**
 * Load generic-roles.json and cache the result on the
@@ -10402,7 +11290,7 @@ let _streetTypesPromise = null;
 const escapeRegex$1 = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 const loadStreetTypeRegex = async () => {
 	try {
-		const data = (await import("./address-street-types.mjs").then((n) => n.n)).default ?? {};
+		const data = (await Promise.resolve().then(() => address_street_types_exports)).default ?? {};
 		const words = /* @__PURE__ */ new Set();
 		for (const [key, val] of Object.entries(data)) {
 			if (key.startsWith("_")) continue;
@@ -10465,6 +11353,7 @@ const filterFalsePositives = (entities, ctx = defaultContext, fullText) => {
 		if (STANDALONE_YEAR_RE.test(trimmed) && normalized.source !== "trigger") continue;
 		if (fullText && normalized.source !== "trigger" && /^\d/.test(trimmed) && NUMBER_ABBREV_RE.test(fullText.slice(Math.max(0, normalized.start - 10), normalized.start))) continue;
 		if (normalized.label === "registration number" && /^[\p{L}]{1,2}$/u.test(trimmed)) continue;
+		if (normalized.label === "organization" && isDocumentStructureHeading(trimmed)) continue;
 		if (normalized.label === "person" && HAS_DIGIT_RE.test(trimmed)) continue;
 		if (normalized.label === "person") {
 			const trimmedToken = trimmed.replace(/[.,;:!?]+$/u, "").trim();
@@ -10679,7 +11568,7 @@ let streetTypeReLoaded = false;
 const loadStreetTypeRe = async () => {
 	if (streetTypeReLoaded) return cachedStreetTypeRe;
 	try {
-		const config = (await import("./address-street-types.mjs").then((n) => n.n)).default ?? {};
+		const config = (await Promise.resolve().then(() => address_street_types_exports)).default ?? {};
 		const words = [];
 		for (const value of Object.values(config)) {
 			if (!Array.isArray(value)) continue;
@@ -10756,7 +11645,55 @@ const SENTENCE_STARTER_WORDS = new Set([
 ]);
 const PERSON_CHAIN_BREAK_RE = /[!?;:]|,/u;
 const WORD_CHAR_RE$1 = /[\p{L}\p{N}]/u;
+const CURATED_PATTERN_SYNTAX_RE = /[|\\]/g;
+const stripCuratedPatternSyntax = (value) => value.includes("|") || value.includes("\\") ? value.replace(CURATED_PATTERN_SYNTAX_RE, "") : value;
 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 EMPTY_PATTERN_LABELS = [];
+const EMPTY_PATTERN_SOURCES = [];
+const patternLabels = (labels) => {
+	if (labels === void 0) return EMPTY_PATTERN_LABELS;
+	return Array.isArray(labels) ? labels : [labels];
+};
+const patternSources = (sources) => {
+	if (sources === void 0) return EMPTY_PATTERN_SOURCES;
+	return Array.isArray(sources) ? sources : [sources];
+};
+const addPatternLabel = (list, index, label) => {
+	const existing = list[index];
+	if (existing === void 0) {
+		list[index] = label;
+		return;
+	}
+	if (Array.isArray(existing)) {
+		if (!existing.includes(label)) existing.push(label);
+		return;
+	}
+	if (existing !== label) list[index] = [existing, label];
+};
+const addPatternSource = (list, index, source) => {
+	const existing = list[index];
+	if (existing === void 0) {
+		list[index] = source;
+		return;
+	}
+	if (Array.isArray(existing)) {
+		if (!existing.includes(source)) existing.push(source);
+		return;
+	}
+	if (existing !== source) list[index] = [existing, source];
+};
+const addOptionalPatternLabel = (list, index, label) => {
+	const existing = list[index];
+	if (existing === void 0) {
+		list[index] = label;
+		return;
+	}
+	if (Array.isArray(existing)) {
+		if (!existing.includes(label)) existing.push(label);
+		return;
+	}
+	if (existing !== label) list[index] = [existing, label];
+};
 const getCityEntries = (dictionaries, allowedCountries) => {
 	const byCountry = dictionaries?.citiesByCountry;
 	if (!byCountry) return dictionaries?.cities ?? [];
@@ -10809,7 +11746,7 @@ const buildDenyList = async (config, ctx = defaultContext) => {
 	const sourceList = [];
 	const patternIndex = /* @__PURE__ */ new Map();
 	const addDenyListEntry = (entry, label, source = "deny-list") => {
-		const normalized = source === "custom-deny-list" ? normalizeForSearch(entry) : normalizeForSearch(entry).replace(/[|\\]/g, "");
+		const normalized = source === "custom-deny-list" ? normalizeForSearch(entry) : stripCuratedPatternSyntax(normalizeForSearch(entry));
 		if (normalized.length === 0) return;
 		const lower = normalized.toLowerCase();
 		if (source !== "custom-deny-list" && label !== "address") {
@@ -10818,15 +11755,15 @@ const buildDenyList = async (config, ctx = defaultContext) => {
 		}
 		const existing = patternIndex.get(lower);
 		if (existing !== void 0) {
-			if (!labelList[existing].includes(label)) labelList[existing].push(label);
-			if (!sourceList[existing].includes(source)) sourceList[existing].push(source);
-			if (source === "custom-deny-list" && !customLabelList[existing].includes(label)) customLabelList[existing].push(label);
+			addPatternLabel(labelList, existing, label);
+			addPatternSource(sourceList, existing, source);
+			if (source === "custom-deny-list" && !patternLabels(customLabelList[existing]).includes(label)) addOptionalPatternLabel(customLabelList, existing, label);
 		} else {
 			patternIndex.set(lower, patternList.length);
 			patternList.push(normalized);
-			labelList.push([label]);
-			customLabelList.push(source === "custom-deny-list" ? [label] : []);
-			sourceList.push([source]);
+			labelList.push(label);
+			if (source === "custom-deny-list") customLabelList[patternList.length - 1] = label;
+			sourceList.push(source);
 		}
 	};
 	if (hasDenyList) {
@@ -10893,35 +11830,34 @@ const appendNameCorpusEntries = (config, ctx, patternList, labelList, sourceList
 	const excludeCategories = excluded ? new Set(excluded) : /* @__PURE__ */ new Set();
 	if (!config.enableNameCorpus || excludeCategories.has("Names")) return;
 	const addNameEntry = (name, source) => {
-		const normalized = normalizeForSearch(name).replace(/[|\\]/g, "");
+		const normalized = stripCuratedPatternSyntax(normalizeForSearch(name));
 		if (normalized.length === 0) return;
 		if (isCuratedNoiseAcronym(normalized)) return;
 		const lower = normalized.toLowerCase();
 		const existing = patternIndex.get(lower);
 		if (existing !== void 0) {
-			if (!labelList[existing].includes("person")) labelList[existing].push("person");
-			if (!sourceList[existing].includes(source)) sourceList[existing].push(source);
+			addPatternLabel(labelList, existing, "person");
+			addPatternSource(sourceList, existing, source);
 		} else {
 			patternIndex.set(lower, patternList.length);
 			patternList.push(normalized);
-			labelList.push(["person"]);
-			sourceList.push([source]);
+			labelList.push("person");
+			sourceList.push(source);
 		}
 	};
 	for (const name of getNameCorpusFirstNames(ctx)) addNameEntry(name, "first-name");
 	for (const name of getNameCorpusSurnames(ctx)) addNameEntry(name, "surname");
 	for (const title of getNameCorpusTitles(ctx)) {
-		const norm = normalizeForSearch(title).replace(/[|\\]/g, "");
+		const norm = stripCuratedPatternSyntax(normalizeForSearch(title));
 		if (norm.length === 0) continue;
 		const lower = norm.toLowerCase();
 		const existing = patternIndex.get(lower);
-		if (existing !== void 0) {
-			if (!sourceList[existing].includes("title")) sourceList[existing].push("title");
-		} else {
+		if (existing !== void 0) addPatternSource(sourceList, existing, "title");
+		else {
 			patternIndex.set(lower, patternList.length);
 			patternList.push(norm);
-			labelList.push(["person"]);
-			sourceList.push(["title"]);
+			labelList.push("person");
+			sourceList.push("title");
 		}
 	}
 };
@@ -10972,18 +11908,18 @@ const processDenyListMatches = (allMatches, sliceStart, sliceEnd, fullText, data
 		const idx = match.pattern;
 		if (idx < sliceStart || idx >= sliceEnd) continue;
 		const localIdx = idx - sliceStart;
-		const sources = data.sources[localIdx] ?? [];
+		const sources = patternSources(data.sources[localIdx]);
 		const matchText = fullText.slice(match.start, match.end);
 		const sourceChar = fullText[match.start] ?? "";
 		const keyword = matchText.toLowerCase();
-		const labels = data.labels[localIdx];
+		const labels = patternLabels(data.labels[localIdx]);
 		const pattern = data.originals[localIdx] ?? "";
-		const customPatternLabels = data.customLabels[localIdx] ?? [];
+		const customPatternLabels = patternLabels(data.customLabels[localIdx]);
 		const customEdgesAreValid = customMatchHasValidEdges(fullText, match.start, match.end, pattern);
 		const customLabels = customEdgesAreValid ? customPatternLabels : [];
-		if ((!labels || labels.length === 0) && customLabels.length === 0) continue;
+		if (labels.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 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 = {
@@ -11296,7 +12232,7 @@ let cachedBrCepContextPromise = null;
 const loadBrCueWords = async () => {
 	const sources = await Promise.all([(async () => {
 		try {
-			return (await import("./address-street-types.mjs").then((n) => n.n)).default["pt-br"];
+			return (await Promise.resolve().then(() => address_street_types_exports)).default["pt-br"];
 		} catch {
 			return;
 		}
@@ -11404,10 +12340,11 @@ const getBoundaryRe = async () => {
 * Returns string[] for the unified TextSearch
 * builder. Empty if data package is not installed.
 */
-const buildStreetTypePatterns = async () => {
-	let config = {};
+let streetTypePatternsPromise = null;
+const loadStreetTypePatterns = async () => {
+	let config;
 	try {
-		config = (await import("./address-street-types.mjs").then((n) => n.n)).default;
+		config = (await Promise.resolve().then(() => address_street_types_exports)).default;
 	} catch {
 		return [];
 	}
@@ -11418,6 +12355,10 @@ const buildStreetTypePatterns = async () => {
 	}
 	return words;
 };
+const buildStreetTypePatterns = async () => {
+	streetTypePatternsPromise ??= loadStreetTypePatterns();
+	return streetTypePatternsPromise;
+};
 const collectSeeds = (allMatches, sliceStart, sliceEnd, fullText, existingEntities, brCepContextRe) => {
 	const seeds = [];
 	for (const match of allMatches) {
@@ -11607,6 +12548,35 @@ const expandCluster = async (fullText, cluster, existingEntities) => {
 		end: Math.max(rightPos, end)
 	};
 };
+const STREET_SEED_TYPES = new Set(["street-word", "house-number"]);
+const DESTINATION_SEED_TYPES = new Set(["postal-code", "city"]);
+const resolveNewlineBoundary = (spanStart, text, cluster) => {
+	const newlines = (text.match(/\n/gu) ?? []).length;
+	if (newlines === 0) return { kind: "keep" };
+	if (newlines > 1) return { kind: "drop" };
+	const relativeNewline = text.indexOf("\n");
+	const newlineAbs = spanStart + relativeNewline;
+	let streetAbove = false;
+	let streetBelow = false;
+	let destAbove = false;
+	let destBelow = false;
+	for (const seed of cluster.seeds) {
+		const isAbove = seed.end <= newlineAbs;
+		const isStreet = STREET_SEED_TYPES.has(seed.type);
+		const isDest = DESTINATION_SEED_TYPES.has(seed.type);
+		if (isStreet && isAbove) streetAbove = true;
+		if (isStreet && !isAbove) streetBelow = true;
+		if (isDest && isAbove) destAbove = true;
+		if (isDest && !isAbove) destBelow = true;
+	}
+	if (streetAbove && destBelow || streetBelow && destAbove) return { kind: "keep" };
+	if (streetAbove && destAbove) return {
+		kind: "trim",
+		relativeEnd: relativeNewline
+	};
+	return { kind: "drop" };
+};
+const normaliseLineBreaks = (text) => text.replace(/\r\n?/gu, "\n");
 /**
 * Process address seeds from the unified search.
 * Receives all matches; filters to the street types
@@ -11624,14 +12594,16 @@ const processAddressSeeds = async (allMatches, sliceStart, sliceEnd, fullText, e
 		const score = scoreCluster(cluster);
 		if (score < .6) continue;
 		const { start, end } = await expandCluster(fullText, cluster, existingEntities);
-		const text = fullText.slice(start, end).trim();
-		if (text.length < 5 || text.length > 300) continue;
-		if (text.includes("\n")) continue;
+		const rawText = fullText.slice(start, end);
+		const resolution = resolveNewlineBoundary(start, normaliseLineBreaks(rawText), cluster);
+		if (resolution.kind === "drop") continue;
+		const effectiveText = resolution.kind === "trim" ? rawText.slice(0, resolution.relativeEnd).trim() : rawText.trim();
+		if (effectiveText.length < 5 || effectiveText.length > 300) continue;
 		results.push({
 			start,
-			end: start + text.length,
+			end: start + effectiveText.length,
 			label: "address",
-			text,
+			text: effectiveText,
 			score,
 			source: DETECTION_SOURCES.REGEX
 		});
@@ -11713,6 +12685,246 @@ const propagateOrgNames = (entities, fullText) => {
 	return results;
 };
 //#endregion
+//#region src/data/address-street-types.json
+var address_street_types_exports = /* @__PURE__ */ __exportAll({
+	_comment: () => _comment,
+	cs: () => cs,
+	de: () => de$1,
+	default: () => address_street_types_default,
+	en: () => en,
+	es: () => es$1,
+	fr: () => fr$1,
+	hu: () => hu$1,
+	it: () => it$1,
+	nl: () => nl$1,
+	pl: () => pl$1,
+	pt: () => pt$1,
+	"pt-br": () => pt_br,
+	ro: () => ro$1,
+	sk: () => sk$1,
+	sv: () => sv
+});
+var _comment = "Street type words by language. Used by address seed detector to identify street names via Aho-Corasick.";
+var cs = [
+	"alej",
+	"bulvár",
+	"nábř.",
+	"nábřeží",
+	"nám.",
+	"náměstí",
+	"sady",
+	"tř.",
+	"třída",
+	"ul.",
+	"ulice"
+];
+var de$1 = [
+	"Allee",
+	"Gasse",
+	"Platz",
+	"Ring",
+	"Straße",
+	"Strasse",
+	"Weg"
+];
+var en = [
+	"Ave.",
+	"Avenue",
+	"Blvd.",
+	"Boulevard",
+	"Circle",
+	"Court",
+	"Crescent",
+	"Drive",
+	"Highway",
+	"Lane",
+	"Parkway",
+	"Place",
+	"Rd.",
+	"Road",
+	"Square",
+	"St.",
+	"Street",
+	"Terrace",
+	"Way"
+];
+var es$1 = [
+	"Av.",
+	"Avda.",
+	"avenida",
+	"bulevar",
+	"C/",
+	"calle",
+	"camino",
+	"carrera",
+	"carretera",
+	"Cra.",
+	"Ctra.",
+	"glorieta",
+	"paseo",
+	"plaza",
+	"Pza.",
+	"ronda",
+	"travesía"
+];
+var fr$1 = [
+	"allée",
+	"av",
+	"av.",
+	"avenue",
+	"bd",
+	"bd.",
+	"boulevard",
+	"chemin",
+	"cours",
+	"impasse",
+	"passage",
+	"pl",
+	"pl.",
+	"place",
+	"quai",
+	"résidence",
+	"route",
+	"rte",
+	"rte.",
+	"rue",
+	"ruelle",
+	"square",
+	"voie"
+];
+var hu$1 = [
+	"fasor",
+	"körút",
+	"köz",
+	"krt.",
+	"rakpart",
+	"sétány",
+	"sor",
+	"tér",
+	"u.",
+	"út",
+	"utca"
+];
+var it$1 = [
+	"borgo",
+	"calle",
+	"contrada",
+	"corso",
+	"largo",
+	"lungarno",
+	"lungomare",
+	"lungotevere",
+	"passeggiata",
+	"piazza",
+	"piazzale",
+	"salita",
+	"strada",
+	"stradone",
+	"traversa",
+	"via",
+	"viale",
+	"vico",
+	"vicolo",
+	"v.le",
+	"v.lo"
+];
+var nl$1 = [
+	"gracht",
+	"kade",
+	"laan",
+	"plein",
+	"straat",
+	"weg"
+];
+var pl$1 = [
+	"al.",
+	"aleja",
+	"aleje",
+	"aleją",
+	"alei",
+	"bulwar",
+	"os.",
+	"osiedle",
+	"pl.",
+	"plac",
+	"placu",
+	"rondo",
+	"rynek",
+	"skwer",
+	"ul.",
+	"ulica",
+	"ulicy"
+];
+var pt$1 = [
+	"avenida",
+	"largo",
+	"praça",
+	"rua",
+	"travessa"
+];
+var pt_br = [
+	"alameda",
+	"av.",
+	"avenida",
+	"estrada",
+	"largo",
+	"praça",
+	"praca",
+	"rodovia",
+	"rua",
+	"travessa"
+];
+var ro$1 = [
+	"aleea",
+	"bd.",
+	"bulevardul",
+	"calea",
+	"fundătura",
+	"intrare",
+	"piața",
+	"șoseaua",
+	"splaiul",
+	"str.",
+	"strada"
+];
+var sk$1 = [
+	"alej",
+	"nábr.",
+	"nábrežie",
+	"nám.",
+	"námest.",
+	"námestie",
+	"sady",
+	"tr.",
+	"trieda",
+	"ul.",
+	"ulica"
+];
+var sv = [
+	"allé",
+	"backe",
+	"gata",
+	"gränd",
+	"torg"
+];
+var address_street_types_default = {
+	_comment,
+	cs,
+	de: de$1,
+	en,
+	es: es$1,
+	fr: fr$1,
+	hu: hu$1,
+	it: it$1,
+	nl: nl$1,
+	pl: pl$1,
+	pt: pt$1,
+	"pt-br": pt_br,
+	ro: ro$1,
+	sk: sk$1,
+	sv
+};
+//#endregion
 //#region src/filters/confidence-boost.ts
 const BARE_STOPWORDS = new Set([
 	"Příloha",
@@ -11863,7 +13075,7 @@ let _streetAbbrevs = buildStreetAbbrevs(address_street_types_default);
 let _streetAbbrevsPromise = null;
 const loadStreetAbbrevs = async () => {
 	try {
-		const mod = await import("./address-street-types.mjs").then((n) => n.n);
+		const mod = await Promise.resolve().then(() => address_street_types_exports);
 		_streetAbbrevs = buildStreetAbbrevs(mod.default ?? mod);
 	} catch {
 		_streetAbbrevs ??= /* @__PURE__ */ new Set();
@@ -11939,7 +13151,10 @@ const detectStreetPatternsNearAddresses = (fullText, existingEntities) => {
 		if (streetText.length < 4) continue;
 		if (hasTemporalPrep) continue;
 		if (existingEntities.some((e) => e.start <= streetStart && e.end >= numEnd)) continue;
-		const score = fullText.slice(Math.max(0, streetStart - 5), streetStart).includes(":") ? .95 : inHeader ? .85 : .8;
+		const hasColon = fullText.slice(Math.max(0, streetStart - 5), streetStart).includes(":");
+		let score = .8;
+		if (hasColon) score = .95;
+		else if (inHeader) score = .85;
 		results.push({
 			start: streetStart,
 			end: numEnd,
@@ -12352,10 +13567,10 @@ const hasLockedBoundary$1 = (entity) => entity.sourceDetail === "custom-deny-lis
 /**
 * Characters allowed in the gap between two adjacent
 * same-label entities that should be merged: spaces,
-* tabs, commas, and hyphens. Uses `[ \t,\-]` instead
+* tabs, commas, and hyphens. Uses `[ \t,-]` instead
 * of `\s` to avoid merging entities across newlines.
 */
-const GAP_PATTERN = /^[ \t,\-]+$/;
+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
@@ -12496,7 +13711,8 @@ const mergeAdjacent = (entities, fullText) => {
 				break;
 			}
 		}
-		if (!hasLockedBoundary$1(prev) && !((isLegalFormOrganization(prev) || isLegalFormOrganization(entity)) && gap.includes(",")) && entity.label !== "country" && !gapOccupied && gap.length <= MAX_GAP && GAP_PATTERN.test(gap)) {
+		const isMergeableGap = gap.length === 0 || gap.length <= MAX_GAP && GAP_PATTERN.test(gap);
+		if (!hasLockedBoundary$1(prev) && !((isLegalFormOrganization(prev) || isLegalFormOrganization(entity)) && gap.includes(",")) && entity.label !== "country" && !gapOccupied && isMergeableGap) {
 			prev.end = entity.end;
 			prev.text = fullText.slice(prev.start, prev.end);
 			prev.score = Math.max(prev.score, entity.score);
@@ -12529,6 +13745,7 @@ const fixPartialWords = (entities, fullText) => {
 	const endPositions = byEnd.map((x) => x.entity.end);
 	return sorted.map((e, eIdx) => {
 		if (hasLockedBoundary$1(e)) return e;
+		if (e.text !== fullText.slice(e.start, e.end)) return e;
 		let newStart = wordStartAt(e.start, boundaries, fullText);
 		let newEnd = wordEndAt(e.end, boundaries, fullText);
 		let lo = 0;
@@ -12657,21 +13874,21 @@ 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);
+	isLegalFormsEnabled(config);
 	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([]),
+	const [triggers, denyListData, streetTypes, currencyPatterns, datePatterns, signingPatterns] = await Promise.all([
 		config.enableTriggerPhrases ? buildTriggerPatterns() : Promise.resolve({
 			patterns: [],
 			rules: []
 		}),
 		config.enableDenyList ? buildDenyList(config, ctx) : Promise.resolve(null),
 		buildStreetTypePatterns(),
-		config.enableRegex && labelIsAllowed$1("monetary amount", allowedLabels) ? getCurrencyPatterns() : Promise.resolve([]),
+		config.enableRegex && labelIsAllowed$1("monetary amount", allowedLabels) ? getCurrencyPatternEntries() : Promise.resolve([]),
 		config.enableRegex && labelIsAllowed$1("date", allowedLabels) ? getDatePatterns() : Promise.resolve([]),
 		config.enableRegex && labelIsAllowed$1("address", allowedLabels) ? getSigningClausePatterns() : Promise.resolve([])
 	]);
+	const legalForms = [];
 	const allRegex = [];
 	const regexMeta = [];
 	if (config.enableRegex) for (const [index, pattern] of REGEX_PATTERNS.entries()) {
@@ -12751,7 +13968,6 @@ const buildUnifiedSearch = async (config, gazetteerEntries = [], ctx = defaultCo
 		start: offset,
 		end: offset + (countryResult?.patterns.length ?? 0)
 	};
-	offset = countriesSlice.end;
 	const wrapWholeWord = (s, wholeWords) => ({
 		pattern: s,
 		literal: true,
@@ -12762,7 +13978,18 @@ const buildUnifiedSearch = async (config, gazetteerEntries = [], ctx = defaultCo
 		const last = pattern.at(-1) ?? "";
 		return ALNUM_RE.test(first) && ALNUM_RE.test(last);
 	};
-	const literalAllPatterns = [
+	const literalPatternText = (entry) => {
+		if (typeof entry === "string") return entry;
+		if (entry instanceof RegExp) throw new Error("Expected literal country pattern, got RegExp");
+		if (entry.pattern instanceof RegExp) throw new Error("Expected literal country pattern, got RegExp entry");
+		return entry.pattern;
+	};
+	const canUseGlobalWholeWordLiterals = !(denyListData?.sources.some((sources) => sources.includes("custom-deny-list")) ?? false) && gazResult === null;
+	const literalAllPatterns = canUseGlobalWholeWordLiterals ? [
+		...denyListOriginals,
+		...streetTypes,
+		...countryResult?.patterns.map(literalPatternText) ?? []
+	] : [
 		...denyListOriginals.map((pattern, index) => wrapWholeWord(pattern, (denyListData?.sources[index] ?? []).includes("custom-deny-list") ? customDenyListNeedsWholeWords(pattern) : true)),
 		...streetTypes.map((pattern) => wrapWholeWord(pattern, true)),
 		...gazResult?.patterns ?? [],
@@ -12772,6 +13999,10 @@ const buildUnifiedSearch = async (config, gazetteerEntries = [], ctx = defaultCo
 		tsRegex,
 		tsCustomRegex,
 		tsLiterals: literalAllPatterns.length > 0 ? new (getTextSearch())(literalAllPatterns, {
+			...canUseGlobalWholeWordLiterals ? {
+				allLiteral: true,
+				wholeWords: true
+			} : {},
 			caseInsensitive: true,
 			overlapStrategy: "all"
 		}) : new (getTextSearch())([]),
@@ -12917,6 +14148,7 @@ 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 BARE_POSTAL_CODE_RE = /^\s*(?:\d{3}\s?\d{2}|\d{2}[-–]\d{3}|\d{5}(?:[-–]\d{3,4})?)\s*$/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;
@@ -12925,6 +14157,19 @@ const shouldReplace = (a, b) => {
 	if (aCallerOwned !== isCallerOwnedEntity(b)) return aCallerOwned;
 	if (a.label === b.label && LITERAL_SOURCES.has(a.source) && a.start <= b.start && a.end >= b.end && aLen > bLen) return true;
 	if (a.label === b.label && LITERAL_SOURCES.has(b.source) && b.start <= a.start && b.end >= a.end && bLen > aLen) return false;
+	if (a.label === "address" && b.label === "address" && a.start <= b.start && a.end >= b.end && aLen > bLen && BARE_POSTAL_CODE_RE.test(b.text)) return true;
+	if (a.label === "address" && b.label === "address" && b.start <= a.start && b.end >= a.end && bLen > aLen && BARE_POSTAL_CODE_RE.test(a.text)) return false;
+	if (a.label === b.label && a.source === DETECTION_SOURCES.LEGAL_FORM && a.start <= b.start && a.end >= b.end && aLen > bLen) return true;
+	if (a.label === b.label && b.source === DETECTION_SOURCES.LEGAL_FORM && b.start <= a.start && b.end >= a.end && bLen > aLen) return false;
+	const LONGEST_WINS_LABELS = new Set([
+		"date",
+		"date of birth",
+		"monetary amount",
+		"phone number",
+		"email address",
+		"url"
+	]);
+	if (a.label === b.label && a.start === b.start && aLen !== bLen && LONGEST_WINS_LABELS.has(a.label)) return aLen > bLen;
 	if (a.label === "country" && (b.label === "person" || b.label === "organization") && b.start <= a.start && b.end >= a.end && bLen > aLen) return false;
 	if (b.label === "country" && (a.label === "person" || a.label === "organization") && a.start <= b.start && a.end >= b.end && aLen > bLen) return true;
 	const aPri = DETECTOR_PRIORITY[a.source] ?? 0;
@@ -13080,6 +14325,16 @@ const TRAILING_PUNCT_CLASS = `["“”‘’'»!?]`;
 * intentionally captured.
 */
 const LEADING_PUNCT_CLASS = `["“”‘’'«¿¡]`;
+const LEADING_ELLIPSIS_RE = /^(?:\.{2,}|…+)/u;
+const ELLIPSIS_PREFIX_LABELS = new Set([
+	"date",
+	"date of birth",
+	"monetary amount",
+	"phone number",
+	"email address",
+	"url",
+	"time"
+]);
 const STRIP_BY_LABEL = {
 	colon: /[\s,;]+/,
 	default: /[\s:,;]+/
@@ -13098,7 +14353,7 @@ const sanitizeEntities = (entities) => entities.flatMap((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 leadTrimmed = (ELLIPSIS_PREFIX_LABELS.has(e.label) ? e.text.replace(LEADING_ELLIPSIS_RE, "") : e.text).replace(leadRe, "");
 	const lead = e.text.length - leadTrimmed.length;
 	let cleaned = leadTrimmed.replace(trailRe, "");
 	if (PERIOD_STRIPPED_LABELS.has(e.label) && cleaned.endsWith(".") && !LITERAL_SOURCES.has(e.source)) {
@@ -13126,7 +14381,7 @@ const mergeAndDedup = (...layers) => {
 	const merged = [{ ...first }];
 	for (let i = 1; i < sorted.length; i++) {
 		const entity = sorted[i];
-		const last = merged[merged.length - 1];
+		const last = merged.at(-1);
 		if (!entity || !last) continue;
 		if (last.end <= entity.start) {
 			merged.push({ ...entity });
@@ -13161,7 +14416,7 @@ let amountWordsLoaded = false;
 const getAmountWordsRe = async () => {
 	if (amountWordsLoaded && amountWordsRe) return amountWordsRe;
 	try {
-		const alt = (await import("./amount-words.mjs").then((n) => n.n)).default.patterns.flatMap((p) => p.keywords).map(escapeRegex).join("|");
+		const alt = (await Promise.resolve().then(() => amount_words_exports)).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;
@@ -13181,6 +14436,45 @@ const extendMonetaryAmountWords = (entities, fullText, re) => entities.map((e) =
 		text: fullText.slice(e.start, newEnd)
 	};
 });
+let monetaryTrailingCurrencyRe = null;
+let monetaryTrailingCurrencyLoaded = false;
+const getMonetaryTrailingCurrencyRe = async () => {
+	if (monetaryTrailingCurrencyLoaded) return monetaryTrailingCurrencyRe;
+	try {
+		const mod = await import("./currencies.mjs");
+		const data = mod.default ?? mod;
+		const codes = (data.codes ?? []).filter((c) => /^[A-Z]{2,4}$/.test(c));
+		const names = (data.localNames ?? []).filter((n) => n.length > 0);
+		const parts = [];
+		if (names.length > 0) parts.push(names.map(escapeRegex).join("|"));
+		if (codes.length > 0) parts.push(codes.map(escapeRegex).join("|"));
+		if (parts.length === 0) monetaryTrailingCurrencyRe = null;
+		else {
+			const alt = parts.join("|");
+			monetaryTrailingCurrencyRe = new RegExp(`^([^\\S\\n\\t]{0,4})(${alt})(?![\\p{L}\\p{N}])`, "u");
+		}
+	} catch {
+		monetaryTrailingCurrencyRe = null;
+	}
+	monetaryTrailingCurrencyLoaded = true;
+	return monetaryTrailingCurrencyRe;
+};
+const extendMonetaryTrailingCurrency = (entities, fullText, re) => {
+	if (!re) return entities;
+	return entities.map((e) => {
+		if (e.label !== "monetary amount" || isCallerOwnedEntity(e)) return e;
+		if (/\p{L}/u.test(e.text.slice(-1) ?? "")) return e;
+		const after = fullText.slice(e.end);
+		const m = re.exec(after);
+		if (!m) return e;
+		const newEnd = e.end + m[0].length;
+		return {
+			...e,
+			end: newEnd,
+			text: fullText.slice(e.start, newEnd)
+		};
+	});
+};
 const createAllowedLabelSetFromLabels = (labels) => labels.length > 0 ? new Set(labels) : null;
 const createAllowedLabelSet = (config) => createAllowedLabelSetFromLabels(config.labels);
 const DEFAULT_CUSTOM_REGEX_SCORE = .9;
@@ -13212,20 +14506,54 @@ const configKey = (config, gazetteerEntries) => {
 	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.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}:${config.enableCountries !== false}`;
 };
+const sharedSearchByDictionaries = /* @__PURE__ */ new WeakMap();
+const sharedSearchWithoutDictionaries = /* @__PURE__ */ new Map();
+const sharedSearchCacheFor = (dictionaries) => {
+	if (dictionaries === void 0) return sharedSearchWithoutDictionaries;
+	const cached = sharedSearchByDictionaries.get(dictionaries);
+	if (cached !== void 0) return cached;
+	const created = /* @__PURE__ */ new Map();
+	sharedSearchByDictionaries.set(dictionaries, created);
+	return created;
+};
+const ensureSearchSupportData = async (config, ctx) => {
+	if (!config.enableDenyList) return;
+	await ensureDenyListData(ctx, config.dictionaries, config.nameCorpusLanguages);
+};
 /**
 * Get or build a cached search instance. Cache state
-* lives on the provided PipelineContext, not at module
-* level.
+* lives on the provided PipelineContext first. A
+* dictionary-scoped process cache prevents fresh
+* contexts with the same immutable dictionary bundle
+* from rebuilding identical automata.
 */
 const getCachedSearch = async (config, gazetteerEntries, ctx) => {
 	const key = configKey(config, gazetteerEntries);
 	if (ctx.search && ctx.searchKey === key) return ctx.search;
 	if (ctx.searchPromise && ctx.searchKey === key) return ctx.searchPromise;
+	const sharedCache = sharedSearchCacheFor(config.dictionaries);
+	const shared = sharedCache.get(key);
+	if (shared !== void 0) {
+		const result = await shared;
+		await ensureSearchSupportData(config, ctx);
+		ctx.search = result;
+		ctx.searchKey = key;
+		ctx.searchPromise = null;
+		return result;
+	}
 	ctx.search = null;
 	ctx.searchKey = key;
 	const promise = buildUnifiedSearch(config, gazetteerEntries, ctx);
 	ctx.searchPromise = promise;
-	const result = await promise;
+	sharedCache.set(key, promise);
+	let result;
+	try {
+		result = await promise;
+	} catch (err) {
+		if (sharedCache.get(key) === promise) sharedCache.delete(key);
+		throw err;
+	}
+	if (sharedCache.get(key) === promise) sharedCache.set(key, result);
 	if (ctx.searchKey === key) ctx.search = result;
 	return result;
 };
@@ -13278,6 +14606,7 @@ const runPipeline = async (options) => {
 		});
 		await Promise.all([
 			loadGenericRoles(ctx),
+			loadDocumentStructureHeadings(),
 			initPrepositions(),
 			initStreetAbbrevs(),
 			initAddressComponents(),
@@ -13287,6 +14616,7 @@ const runPipeline = async (options) => {
 		]);
 	} else await Promise.all([
 		loadGenericRoles(ctx),
+		loadDocumentStructureHeadings(),
 		initPrepositions(),
 		initStreetAbbrevs(),
 		initAddressComponents(),
@@ -13315,7 +14645,7 @@ const runPipeline = async (options) => {
 	const regexEntities = filterAllowedLabels([...rawRegexEntities, ...customRegexEntities], preHotwordAllowedLabels);
 	if (regexEntities.length > 0) log("regex", `${regexEntities.length} matches`);
 	if (legalFormsEnabled || config.enableTriggerPhrases) await warmLegalRoleHeads();
-	const rawLegalFormEntities = legalFormsEnabled ? processLegalFormMatches(regexMatches, slices.legalForms.start, slices.legalForms.end, fullText) : [];
+	const rawLegalFormEntities = legalFormsEnabled ? detectLegalFormsV2(fullText) : [];
 	const legalFormEntities = filterAllowedLabels(rawLegalFormEntities, preHotwordAllowedLabels);
 	if (legalFormEntities.length > 0) log("legal-forms", `${legalFormEntities.length} matches`);
 	if (config.enableTriggerPhrases) await warmAddressStopKeywords();
@@ -13419,7 +14749,8 @@ const runPipeline = async (options) => {
 	}
 	const rawMerged = mergeAndDedup(allEntities);
 	log("merge", `${rawMerged.length} after dedup`);
-	const mergedExtended = extendMonetaryAmountWords(rawMerged, fullText, await getAmountWordsRe());
+	const monetaryAmountWordsRe = await getAmountWordsRe();
+	const mergedExtended = extendMonetaryAmountWords(extendMonetaryTrailingCurrency(rawMerged, fullText, await getMonetaryTrailingCurrencyRe()), fullText, monetaryAmountWordsRe);
 	const consistent = enforceBoundaryConsistency(mergedExtended, fullText);
 	if (consistent.length < mergedExtended.length) log("boundary", `${mergedExtended.length - consistent.length} consolidated`);
 	let postOrgEntities = consistent;