@stll/anonymize 1.5.0 → 2.0.0

package/dist/native-node2.mjs

@@ -0,0 +1,728 @@
+import { PreparedNativeAnonymizer, PreparedNativePipeline, assertNativeBindingVersion, createNativePipelineFromPackage, diagnostics_json as diagnostics_json$1, diagnostics_stream_json as diagnostics_stream_json$1, load_prepared_package as load_prepared_package$1, native_package_version as native_package_version$1, normalize_for_search as normalize_for_search$1, prepare_search_package as prepare_search_package$1, redact_text as redact_text$1, redact_text_json as redact_text_json$1, redact_text_stream_json as redact_text_stream_json$1, summary_diagnostics_json as summary_diagnostics_json$1 } from "./native.mjs";
+import { DEFAULT_ENTITY_LABELS } from "./constants.mjs";
+import { createRequire } from "node:module";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import process from "node:process";
+//#region src/context.ts
+/** Create a fresh, empty pipeline context. */
+const createPipelineContext = () => ({
+	nativePipelinePackage: null,
+	nativePipelinePackageKey: "",
+	nativePipelinePackagePromise: null
+});
+/**
+* Module-level default context. Used when callers
+* don't provide an explicit context, preserving full
+* backward compatibility with the existing API.
+*/
+const defaultContext = createPipelineContext();
+//#endregion
+//#region src/language-scope.ts
+const scopeData = {
+	_comment: "Default dictionary scopes for content language hints. Lower-level caller config can still override name corpus languages and deny-list countries independently.",
+	languages: {
+		"cs": {
+			"nameCorpusLanguages": ["cs", "sk"],
+			"denyListCountries": ["CZ", "SK"]
+		},
+		"de": {
+			"nameCorpusLanguages": ["de"],
+			"denyListCountries": [
+				"DE",
+				"AT",
+				"CH"
+			]
+		},
+		"en": {
+			"nameCorpusLanguages": ["en"],
+			"denyListCountries": [
+				"US",
+				"GB",
+				"CA",
+				"AU",
+				"IE"
+			]
+		},
+		"es": {
+			"nameCorpusLanguages": ["es"],
+			"denyListCountries": [
+				"ES",
+				"MX",
+				"AR",
+				"CL",
+				"CO",
+				"PE",
+				"EC",
+				"VE",
+				"UY",
+				"PY",
+				"BO",
+				"CR",
+				"PA",
+				"DO",
+				"GT",
+				"HN",
+				"SV",
+				"NI",
+				"CU"
+			]
+		},
+		"fr": {
+			"nameCorpusLanguages": ["fr"],
+			"denyListCountries": [
+				"FR",
+				"BE",
+				"CH",
+				"CA",
+				"LU",
+				"MC"
+			]
+		},
+		"hu": {
+			"nameCorpusLanguages": ["hu"],
+			"denyListCountries": ["HU"]
+		},
+		"it": {
+			"nameCorpusLanguages": ["it"],
+			"denyListCountries": ["IT", "CH"]
+		},
+		"pl": {
+			"nameCorpusLanguages": ["pl"],
+			"denyListCountries": ["PL"]
+		},
+		"pt-br": {
+			"nameCorpusLanguages": ["pt-br"],
+			"denyListCountries": ["BR"]
+		},
+		"ro": {
+			"nameCorpusLanguages": ["ro"],
+			"denyListCountries": ["RO", "MD"]
+		},
+		"sk": {
+			"nameCorpusLanguages": ["sk", "cs"],
+			"denyListCountries": ["SK", "CZ"]
+		},
+		"sv": {
+			"nameCorpusLanguages": ["sv"],
+			"denyListCountries": ["SE", "FI"]
+		}
+	}
+};
+const normalizeLanguage = (language) => language.trim().toLowerCase();
+const fallbackLanguage = (language) => {
+	const index = language.indexOf("-");
+	return index === -1 ? null : language.slice(0, index);
+};
+const uniquePush = (target, values) => {
+	const seen = new Set(target);
+	for (const value of values) {
+		if (seen.has(value)) continue;
+		seen.add(value);
+		target.push(value);
+	}
+};
+const resolveLanguageScope = (language) => {
+	const normalized = normalizeLanguage(language);
+	if (normalized.length === 0) return null;
+	const exact = scopeData.languages[normalized];
+	if (exact !== void 0) return exact;
+	const fallback = fallbackLanguage(normalized);
+	return fallback === null ? null : scopeData.languages[fallback] ?? null;
+};
+const configuredLanguages = (config) => {
+	if (config.languages !== void 0) return config.languages;
+	return config.language === void 0 ? [] : [config.language];
+};
+const applyPipelineLanguageScope = (config) => {
+	const languages = configuredLanguages(config);
+	if (languages.length === 0) return config;
+	const nameCorpusLanguages = [];
+	const denyListCountries = [];
+	for (const language of languages) {
+		const scope = resolveLanguageScope(language);
+		if (scope === null) continue;
+		uniquePush(nameCorpusLanguages, scope.nameCorpusLanguages ?? []);
+		uniquePush(denyListCountries, scope.denyListCountries ?? []);
+	}
+	const next = {};
+	if (config.nameCorpusLanguages === void 0 && nameCorpusLanguages.length > 0) next.nameCorpusLanguages = nameCorpusLanguages;
+	if (config.denyListCountries === void 0 && denyListCountries.length > 0) next.denyListCountries = denyListCountries;
+	return Object.keys(next).length === 0 ? config : {
+		...config,
+		...next
+	};
+};
+//#endregion
+//#region src/types.ts
+const isLegalFormsEnabled = (config) => config.enableLegalForms !== false;
+//#endregion
+//#region src/util/language-selection.ts
+const normalizeLanguageCode = (language) => language.trim().toLowerCase();
+const normalizeLanguageSelection = (languages) => languages === void 0 ? [] : languages.map(normalizeLanguageCode).filter((language) => language.length > 0);
+const languageSelectionKey = (languages) => {
+	const normalized = normalizeLanguageSelection(languages).toSorted();
+	return normalized.length === 0 ? "*" : normalized.join(",");
+};
+//#endregion
+//#region src/pipeline-cache-key.ts
+const DEFAULT_CUSTOM_REGEX_SCORE = .9;
+const contentLanguageFingerprint = (config) => {
+	return languageSelectionKey(config.languages ?? (config.language === void 0 ? [] : [config.language]));
+};
+const pipelineConfigKey = (config, gazetteerEntries) => {
+	const legalFormsEnabled = isLegalFormsEnabled(config);
+	const customDenyFingerprint = config.enableDenyList && config.customDenyList ? config.customDenyList.map((entry) => JSON.stringify({
+		label: entry.label,
+		value: entry.value,
+		variants: [...entry.variants ?? []].sort()
+	})).sort().join("\n") : "";
+	const customRegexFingerprint = config.enableRegex && config.customRegexes ? config.customRegexes.map((entry) => JSON.stringify({
+		label: entry.label,
+		pattern: entry.pattern,
+		preparedArtifactPolicy: entry.preparedArtifactPolicy ?? null,
+		score: entry.score ?? DEFAULT_CUSTOM_REGEX_SCORE
+	})).sort().join("\n") : "";
+	const gazFingerprint = config.enableGazetteer && gazetteerEntries.length > 0 ? gazetteerEntries.map((entry) => `${entry.id}:${entry.canonical}:${entry.label}:${[...entry.variants].sort().join(",")}`).toSorted().join(";") : "";
+	return `${config.enableDenyList}:${config.enableTriggerPhrases}:${legalFormsEnabled}:${config.enableNameCorpus}:${contentLanguageFingerprint(config)}:${config.nameCorpusLanguages?.toSorted().join(",") ?? ""}:${config.enableRegex}:${config.threshold}:${config.enableConfidenceBoost}:${config.enableHotwordRules === true}:${config.enableCoreference === true}:${config.enableZoneClassification === true}:${config.labels.toSorted().join(",")}:${config.denyListCountries?.toSorted().join(",") ?? ""}:${config.denyListRegions?.toSorted().join(",") ?? ""}:${config.denyListExcludeCategories?.toSorted().join(",") ?? ""}:${customDenyFingerprint}:${customRegexFingerprint}:${config.enableGazetteer}:${gazFingerprint}:${config.enableCountries !== false}`;
+};
+//#endregion
+//#region src/native-pipeline.ts
+const sharedPackageByDictionaries = /* @__PURE__ */ new WeakMap();
+const sharedPackageWithoutDictionaries = /* @__PURE__ */ new Map();
+const dictionaryCacheIds = /* @__PURE__ */ new WeakMap();
+let nextDictionaryCacheId = 0;
+const dictionaryCacheKey = (dictionaries) => {
+	if (dictionaries === void 0) return "none";
+	const existing = dictionaryCacheIds.get(dictionaries);
+	if (existing !== void 0) return `dict:${existing}`;
+	nextDictionaryCacheId += 1;
+	dictionaryCacheIds.set(dictionaries, nextDictionaryCacheId);
+	return `dict:${nextDictionaryCacheId}`;
+};
+const sharedPackageCacheFor = (dictionaries) => {
+	if (dictionaries === void 0) return sharedPackageWithoutDictionaries;
+	const cached = sharedPackageByDictionaries.get(dictionaries);
+	if (cached !== void 0) return cached;
+	const created = /* @__PURE__ */ new Map();
+	sharedPackageByDictionaries.set(dictionaries, created);
+	return created;
+};
+const getNativePipelineCompatibility = (config) => {
+	const unsupportedFeatures = [];
+	if (config.enableNer) unsupportedFeatures.push("enableNer");
+	if (unsupportedFeatures.length === 0) return { status: "supported" };
+	return {
+		status: "unsupported",
+		unsupportedFeatures
+	};
+};
+const assertNativePipelineSupported = (config) => {
+	const compatibility = getNativePipelineCompatibility(config);
+	if (compatibility.status === "supported") return;
+	throw new Error(`Native pipeline does not yet support: ${compatibility.unsupportedFeatures.join(", ")}`);
+};
+const encoder = new TextEncoder();
+/**
+* Serialize the assembler inputs the Rust binding expects. Dictionaries are
+* stripped from the pipeline config and passed out of band: the assembler reads
+* the separate bundle preferentially, and keeping the (large) dictionaries out
+* of the config JSON avoids serializing them twice.
+*/
+const toAssembleInputs = ({ dictionaries, ...config }, gazetteerEntries) => ({
+	pipelineConfigJson: encoder.encode(JSON.stringify(config)),
+	dictionariesJson: dictionaries === void 0 ? void 0 : encoder.encode(JSON.stringify(dictionaries)),
+	gazetteerJson: gazetteerEntries.length === 0 ? void 0 : encoder.encode(JSON.stringify(gazetteerEntries))
+});
+const assemblePackageBytes = (binding, { pipelineConfigJson, dictionariesJson, gazetteerJson }, compressed) => {
+	const assemble = compressed ? binding.assembleStaticSearchCompressedPackageBytes : binding.assembleStaticSearchPackageBytes;
+	if (assemble === void 0) throw new Error("Native anonymize binding does not support static-search config assembly");
+	return assemble(pipelineConfigJson, dictionariesJson, gazetteerJson);
+};
+const prepareNativePipelineConfig = async ({ binding, config, gazetteerEntries = [] }) => {
+	const scopedConfig = applyPipelineLanguageScope(config);
+	assertNativePipelineSupported(scopedConfig);
+	const assemble = binding.assembleStaticSearchConfigJson;
+	if (assemble === void 0) throw new Error("Native anonymize binding does not support static-search config assembly");
+	const { pipelineConfigJson, dictionariesJson, gazetteerJson } = toAssembleInputs(scopedConfig, gazetteerEntries);
+	const configJson = assemble(pipelineConfigJson, dictionariesJson, gazetteerJson);
+	return JSON.parse(new TextDecoder().decode(configJson));
+};
+const prepareNativePipelinePackage = async ({ binding, config, gazetteerEntries = [], context, compressed = false }) => {
+	const packageBytes = await getCachedNativePipelinePackage({
+		config,
+		binding,
+		gazetteerEntries,
+		...context ? { context } : {},
+		compressed
+	});
+	return new Uint8Array(packageBytes);
+};
+const createNativePipelineFromConfig = async ({ binding, config, gazetteerEntries = [], context }) => {
+	return createNativePipelineFromPackage({
+		binding,
+		packageBytes: await getCachedNativePipelinePackage({
+			binding,
+			config,
+			gazetteerEntries,
+			...context ? { context } : {}
+		})
+	});
+};
+const getCachedNativePipelinePackage = async ({ binding, config, gazetteerEntries = [], context, compressed = false }) => {
+	const scopedConfig = applyPipelineLanguageScope(config);
+	assertNativePipelineSupported(scopedConfig);
+	const ctx = context ?? defaultContext;
+	const key = nativePackageCacheKey({
+		binding,
+		config: scopedConfig,
+		gazetteerEntries,
+		compressed
+	});
+	if (ctx.nativePipelinePackage && ctx.nativePipelinePackageKey === key) return ctx.nativePipelinePackage;
+	if (ctx.nativePipelinePackagePromise && ctx.nativePipelinePackageKey === key) return ctx.nativePipelinePackagePromise;
+	const sharedCache = sharedPackageCacheFor(scopedConfig.dictionaries);
+	const shared = sharedCache.get(key);
+	if (shared !== void 0) {
+		const packageBytes = await shared;
+		ctx.nativePipelinePackage = packageBytes;
+		ctx.nativePipelinePackageKey = key;
+		ctx.nativePipelinePackagePromise = null;
+		return packageBytes;
+	}
+	ctx.nativePipelinePackage = null;
+	ctx.nativePipelinePackageKey = key;
+	const promise = buildNativePipelinePackage({
+		binding,
+		config: scopedConfig,
+		gazetteerEntries,
+		compressed
+	});
+	ctx.nativePipelinePackagePromise = promise;
+	sharedCache.set(key, promise);
+	let packageBytes;
+	try {
+		packageBytes = await promise;
+	} catch (error) {
+		if (sharedCache.get(key) === promise) sharedCache.delete(key);
+		if (ctx.nativePipelinePackageKey === key && ctx.nativePipelinePackagePromise === promise) {
+			ctx.nativePipelinePackage = null;
+			ctx.nativePipelinePackagePromise = null;
+		}
+		throw error;
+	}
+	if (sharedCache.get(key) === promise) sharedCache.set(key, packageBytes);
+	if (ctx.nativePipelinePackageKey === key) {
+		ctx.nativePipelinePackage = packageBytes;
+		ctx.nativePipelinePackagePromise = null;
+	}
+	return packageBytes;
+};
+const buildNativePipelinePackage = async ({ binding, config, gazetteerEntries, compressed }) => assemblePackageBytes(binding, toAssembleInputs(config, gazetteerEntries), compressed);
+const nativePackageCacheKey = ({ binding, config, gazetteerEntries, compressed }) => [
+	binding.nativePackageVersion(),
+	compressed ? "compressed" : "raw",
+	dictionaryCacheKey(config.dictionaries),
+	pipelineConfigKey(config, gazetteerEntries)
+].join(":");
+//#endregion
+//#region src/native-default-config.ts
+const DEFAULT_NATIVE_PIPELINE_CONFIG = {
+	threshold: .3,
+	enableTriggerPhrases: true,
+	enableRegex: true,
+	enableLegalForms: true,
+	enableNameCorpus: true,
+	enableDenyList: true,
+	enableGazetteer: false,
+	enableCountries: true,
+	enableNer: false,
+	enableConfidenceBoost: true,
+	enableCoreference: true,
+	enableHotwordRules: true,
+	enableZoneClassification: true,
+	labels: [...DEFAULT_ENTITY_LABELS],
+	workspaceId: "native-pipeline-default"
+};
+//#endregion
+//#region src/native-node.ts
+const DEFAULT_NATIVE_PIPELINE_WARMUPS = {
+	lazyRegex: "lazy-regex",
+	none: "none"
+};
+const LOCAL_NATIVE_LOADER = "../index.cjs";
+const PACKAGE_SPECIFIC_NATIVE_PATH = "STELLA_ANONYMIZE_NATIVE_LIBRARY_PATH";
+const DEFAULT_NATIVE_PIPELINE_PACKAGE_URL = new URL("../native-pipeline.stlanonpkg", import.meta.url);
+const DEFAULT_NATIVE_PIPELINE_PACKAGE_DIR_URL = new URL("../", import.meta.url);
+const DEFAULT_NATIVE_PIPELINE_LANGUAGE_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+const DEFAULT_NATIVE_PIPELINE_LANGUAGE_PACKAGE_PATTERN = /^native-pipeline\.([a-z0-9]+(?:-[a-z0-9]+)*)\.stlanonpkg$/u;
+const DEFAULT_NATIVE_PIPELINE_PACKAGE_CACHE_KEY = "<default>";
+const defaultNativePipelineCache = /* @__PURE__ */ new WeakMap();
+const warmedDefaultNativePipelines = /* @__PURE__ */ new WeakSet();
+const defaultNativePipelineInflightCache = /* @__PURE__ */ new WeakMap();
+const loadNativeAnonymizeBinding = (options = {}) => {
+	const requireModule = options.requireModule ?? createRequire(import.meta.url);
+	const platform = options.platform ?? process.platform;
+	const arch = options.arch ?? process.arch;
+	const libc = options.libc ?? detectNativeLibc(platform);
+	const specifiers = nativeBindingSpecifiers({
+		arch,
+		env: options.env ?? process.env,
+		libc,
+		platform
+	});
+	const errors = [];
+	for (const specifier of specifiers) {
+		const binding = tryLoadNativeBinding({
+			specifier,
+			requireModule,
+			errors
+		});
+		if (!binding) continue;
+		if (options.expectedVersion !== void 0) assertNativeBindingVersion({
+			binding,
+			expectedVersion: options.expectedVersion
+		});
+		return binding;
+	}
+	if (nativeBindingPackageName({
+		arch,
+		libc,
+		platform
+	}) === null) throw unsupportedNativeTargetError({
+		arch,
+		errors,
+		libc,
+		platform
+	});
+	throw new Error(`Unable to load native anonymize binding for ${platform}/${arch}:\n${errors.join("\n")}`);
+};
+const readNativePipelinePackageFile = (packagePath) => readFileSync(packagePath);
+const readNativePipelinePackageFileAsync = async (packagePath) => readFile(packagePath);
+const native_package_version = (options = {}) => native_package_version$1(resolveNativeSdkBinding(options));
+const normalize_for_search = (text, options = {}) => {
+	return normalize_for_search$1({
+		binding: resolveNativeSdkBinding(options),
+		text
+	});
+};
+const prepare_search_package = (config, { compressed = false, ...options } = {}) => prepare_search_package$1({
+	binding: resolveNativeSdkBinding(options),
+	config,
+	compressed
+});
+const load_prepared_package = (packageBytes, options = {}) => load_prepared_package$1({
+	binding: resolveNativeSdkBinding(options),
+	packageBytes
+});
+const load_prepared_package_file = (packagePath, options = {}) => load_prepared_package(readNativePipelinePackageFile(packagePath), options);
+const redact_text = (config, fullText, operators, options = {}) => redact_text$1({
+	binding: resolveNativeSdkBinding(options),
+	config,
+	fullText,
+	...operators !== void 0 ? { operators } : {}
+});
+const redact_text_json = (config, fullText, operators, options = {}) => redact_text_json$1({
+	binding: resolveNativeSdkBinding(options),
+	config,
+	fullText,
+	...operators !== void 0 ? { operators } : {}
+});
+const redact_text_stream_json = (config, fullText, onEvent, operators, options = {}) => redact_text_stream_json$1({
+	binding: resolveNativeSdkBinding(options),
+	config,
+	fullText,
+	onEvent,
+	...operators !== void 0 ? { operators } : {}
+});
+const diagnostics_json = (config, fullText, operators, options = {}) => diagnostics_json$1({
+	binding: resolveNativeSdkBinding(options),
+	config,
+	fullText,
+	...operators !== void 0 ? { operators } : {}
+});
+const diagnostics_stream_json = (config, fullText, onBatch, operators, options = {}) => diagnostics_stream_json$1({
+	binding: resolveNativeSdkBinding(options),
+	config,
+	fullText,
+	onBatch,
+	...operators !== void 0 ? { operators } : {}
+});
+const summary_diagnostics_json = (config, fullText, operators, options = {}) => summary_diagnostics_json$1({
+	binding: resolveNativeSdkBinding(options),
+	config,
+	fullText,
+	...operators !== void 0 ? { operators } : {}
+});
+const readDefaultNativePipelinePackageFile = ({ language } = {}) => {
+	const packageUrl = defaultNativePipelinePackageUrl(language);
+	try {
+		return readFileSync(packageUrl);
+	} catch (error) {
+		throw new Error(`${defaultNativePipelinePackageDescription(language)} is unavailable: ${formatLoadError(error)}`);
+	}
+};
+const read_default_native_pipeline_package_file = (options = {}) => readDefaultNativePipelinePackageFile(options);
+const availableDefaultNativePipelineLanguages = () => {
+	const languages = /* @__PURE__ */ new Set();
+	try {
+		for (const fileName of readdirSync(DEFAULT_NATIVE_PIPELINE_PACKAGE_DIR_URL)) {
+			const match = fileName.match(DEFAULT_NATIVE_PIPELINE_LANGUAGE_PACKAGE_PATTERN);
+			if (match?.[1] !== void 0) languages.add(match[1]);
+		}
+	} catch (error) {
+		throw new Error(`Default native pipeline package directory is unavailable: ${formatLoadError(error)}`);
+	}
+	return [...languages].toSorted();
+};
+const available_default_native_pipeline_languages = availableDefaultNativePipelineLanguages;
+const readDefaultNativePipelinePackageFileAsync = async ({ language } = {}) => {
+	const packageUrl = defaultNativePipelinePackageUrl(language);
+	try {
+		return await readFile(packageUrl);
+	} catch (error) {
+		throw new Error(`${defaultNativePipelinePackageDescription(language)} is unavailable: ${formatLoadError(error)}`);
+	}
+};
+const createNativePipelineFromPackageFile = ({ binding, packagePath, expectedVersion, ...loadOptions }) => {
+	const resolvedBinding = binding ?? loadNativeAnonymizeBinding({
+		...loadOptions,
+		...expectedVersion !== void 0 ? { expectedVersion } : {}
+	});
+	if (binding && expectedVersion !== void 0) assertNativeBindingVersion({
+		binding,
+		expectedVersion
+	});
+	return createNativePipelineFromPackage({
+		binding: resolvedBinding,
+		packageBytes: readNativePipelinePackageFile(packagePath)
+	});
+};
+const createNativePipelineFromDefaultPackage = (options = {}) => {
+	const resolvedOptions = resolveDefaultNativePipelineOptions(options);
+	return applyDefaultNativePipelineWarmup(createNativePipelineFromResolvedDefaultPackage(resolvedOptions), resolvedOptions.warmup);
+};
+const create_native_pipeline_from_default_package = (options = {}) => createNativePipelineFromDefaultPackage(options);
+const getDefaultNativePipeline = (options = {}) => {
+	const resolvedOptions = resolveDefaultNativePipelineOptions(options);
+	const cache = defaultPipelineCacheFor(resolvedOptions.binding);
+	const key = defaultPipelineCacheKey(resolvedOptions);
+	const cached = cache.get(key);
+	if (cached !== void 0) return applyDefaultNativePipelineWarmup(cached, resolvedOptions.warmup);
+	const pipeline = createNativePipelineFromResolvedDefaultPackage(resolvedOptions);
+	cache.set(key, pipeline);
+	return applyDefaultNativePipelineWarmup(pipeline, resolvedOptions.warmup);
+};
+const get_default_native_pipeline = (options = {}) => getDefaultNativePipeline(options);
+const preloadDefaultNativePipeline = (options = {}) => {
+	return applyDefaultNativePipelineWarmup(getDefaultNativePipeline(options), DEFAULT_NATIVE_PIPELINE_WARMUPS.lazyRegex);
+};
+const preload_default_native_pipeline = (options = {}) => preloadDefaultNativePipeline(options);
+const redactDefaultText = (fullText, operators, options = {}) => getDefaultNativePipeline(options).redactText(fullText, operators);
+const redact_default_text = (fullText, operators, options = {}) => redactDefaultText(fullText, operators, options);
+const redactDefaultTextJson = (fullText, operators, options = {}) => getDefaultNativePipeline(options).redact_text_json(fullText, operators);
+const redact_default_text_json = (fullText, operators, options = {}) => redactDefaultTextJson(fullText, operators, options);
+const preloadDefaultNativePipelineAsync = (options = {}) => {
+	const resolvedOptions = {
+		...resolveDefaultNativePipelineOptions(options),
+		warmup: DEFAULT_NATIVE_PIPELINE_WARMUPS.lazyRegex
+	};
+	const cache = defaultPipelineCacheFor(resolvedOptions.binding);
+	const key = defaultPipelineCacheKey(resolvedOptions);
+	const cached = cache.get(key);
+	if (cached !== void 0) return Promise.resolve(applyDefaultNativePipelineWarmup(cached, resolvedOptions.warmup));
+	const inflightCache = defaultPipelineInflightCacheFor(resolvedOptions.binding);
+	const inflight = inflightCache.get(key);
+	if (inflight !== void 0) return inflight;
+	const promise = createNativePipelineFromResolvedDefaultPackageAsync(resolvedOptions).then((pipeline) => {
+		cache.set(key, pipeline);
+		return applyDefaultNativePipelineWarmup(pipeline, resolvedOptions.warmup);
+	}).finally(() => {
+		inflightCache.delete(key);
+	});
+	inflightCache.set(key, promise);
+	return promise;
+};
+const resolveDefaultNativePipelineOptions = ({ binding, language, packagePath, warmup, expectedVersion, ...loadOptions } = {}) => {
+	if (language !== void 0 && packagePath !== void 0) throw new Error("Use either language or packagePath, not both");
+	const resolvedBinding = binding ?? loadNativeAnonymizeBinding({
+		...loadOptions,
+		...expectedVersion !== void 0 ? { expectedVersion } : {}
+	});
+	if (binding && expectedVersion !== void 0) assertNativeBindingVersion({
+		binding,
+		expectedVersion
+	});
+	return {
+		binding: resolvedBinding,
+		warmup: normalizeDefaultNativePipelineWarmup(warmup),
+		...language !== void 0 ? { language: resolveDefaultNativePipelineLanguage(language) } : {},
+		...packagePath !== void 0 ? { packagePath } : {}
+	};
+};
+const applyDefaultNativePipelineWarmup = (pipeline, warmup) => {
+	if (warmup !== DEFAULT_NATIVE_PIPELINE_WARMUPS.lazyRegex) return pipeline;
+	if (!warmedDefaultNativePipelines.has(pipeline)) {
+		pipeline.warmLazyRegex();
+		warmedDefaultNativePipelines.add(pipeline);
+	}
+	return pipeline;
+};
+const createNativePipelineFromResolvedDefaultPackage = ({ binding, language, packagePath }) => {
+	return createNativePipelineFromTrustedDefaultPackage(binding, packagePath === void 0 ? readDefaultNativePipelinePackageFile(defaultPackageFileOptions(language)) : readNativePipelinePackageFile(packagePath));
+};
+const createNativePipelineFromResolvedDefaultPackageAsync = async ({ binding, language, packagePath }) => {
+	return createNativePipelineFromTrustedDefaultPackage(binding, packagePath === void 0 ? await readDefaultNativePipelinePackageFileAsync(defaultPackageFileOptions(language)) : await readNativePipelinePackageFileAsync(packagePath));
+};
+const createNativePipelineFromTrustedDefaultPackage = (binding, packageBytes) => new PreparedNativePipeline(new PreparedNativeAnonymizer(binding.NativePreparedSearch.fromTrustedPreparedPackageBytesWithoutCache?.(packageBytes) ?? binding.NativePreparedSearch.fromTrustedPreparedPackageBytes?.(packageBytes) ?? binding.NativePreparedSearch.fromPreparedPackageBytesWithoutCache?.(packageBytes) ?? binding.NativePreparedSearch.fromPreparedPackageBytes(packageBytes)));
+const defaultPackageFileOptions = (language) => language === void 0 ? {} : { language };
+const normalizeDefaultNativePipelineWarmup = (warmup) => {
+	if (warmup === void 0) return DEFAULT_NATIVE_PIPELINE_WARMUPS.none;
+	switch (warmup) {
+		case DEFAULT_NATIVE_PIPELINE_WARMUPS.lazyRegex:
+		case DEFAULT_NATIVE_PIPELINE_WARMUPS.none: return warmup;
+	}
+	throw new Error("Default native pipeline warmup must be \"lazy-regex\" or \"none\"");
+};
+const resolveNativeSdkBinding = ({ binding, expectedVersion, ...loadOptions }) => {
+	const resolvedBinding = binding ?? loadNativeAnonymizeBinding({
+		...loadOptions,
+		...expectedVersion !== void 0 ? { expectedVersion } : {}
+	});
+	if (binding && expectedVersion !== void 0) assertNativeBindingVersion({
+		binding,
+		expectedVersion
+	});
+	return resolvedBinding;
+};
+const defaultPipelineCacheFor = (binding) => {
+	const cached = defaultNativePipelineCache.get(binding);
+	if (cached !== void 0) return cached;
+	const created = /* @__PURE__ */ new Map();
+	defaultNativePipelineCache.set(binding, created);
+	return created;
+};
+const defaultPipelineInflightCacheFor = (binding) => {
+	const cached = defaultNativePipelineInflightCache.get(binding);
+	if (cached !== void 0) return cached;
+	const created = /* @__PURE__ */ new Map();
+	defaultNativePipelineInflightCache.set(binding, created);
+	return created;
+};
+const defaultPipelineCacheKey = ({ binding, language, packagePath }) => [binding.nativePackageVersion(), packagePath ?? (language === void 0 ? DEFAULT_NATIVE_PIPELINE_PACKAGE_CACHE_KEY : `language:${language}`)].join("\0");
+const defaultNativePipelinePackageUrl = (language) => {
+	if (language === void 0) return DEFAULT_NATIVE_PIPELINE_PACKAGE_URL;
+	return defaultNativePipelineLanguagePackageUrl(resolveDefaultNativePipelineLanguage(language));
+};
+const defaultNativePipelineLanguagePackageUrl = (language) => new URL(`../native-pipeline.${language}.stlanonpkg`, import.meta.url);
+const resolveDefaultNativePipelineLanguage = (language) => {
+	const normalized = normalizeDefaultNativePipelineLanguage(language);
+	if (existsSync(defaultNativePipelineLanguagePackageUrl(normalized))) return normalized;
+	const baseLanguage = normalized.split("-").at(0);
+	if (baseLanguage === void 0 || baseLanguage === normalized) return normalized;
+	if (existsSync(defaultNativePipelineLanguagePackageUrl(baseLanguage))) return baseLanguage;
+	return normalized;
+};
+const defaultNativePipelinePackageDescription = (language) => language === void 0 ? "Default native pipeline package" : `Default native pipeline package for language "${resolveDefaultNativePipelineLanguage(language)}"`;
+const normalizeDefaultNativePipelineLanguage = (language) => {
+	const normalized = language.trim().toLowerCase();
+	if (!DEFAULT_NATIVE_PIPELINE_LANGUAGE_PATTERN.test(normalized)) throw new Error(`Default native pipeline language must match ${DEFAULT_NATIVE_PIPELINE_LANGUAGE_PATTERN.source}`);
+	return normalized;
+};
+const nativeBindingSpecifiers = ({ arch, env, libc, platform }) => {
+	const specifiers = [];
+	const overridePath = env[PACKAGE_SPECIFIC_NATIVE_PATH];
+	if (overridePath) specifiers.push(overridePath);
+	specifiers.push(LOCAL_NATIVE_LOADER);
+	const platformPackage = nativeBindingPackageName({
+		arch,
+		libc,
+		platform
+	});
+	if (platformPackage !== null) specifiers.push(platformPackage);
+	return specifiers;
+};
+const NATIVE_BINDING_TARGETS = [
+	{
+		platform: "darwin",
+		arch: "arm64",
+		package: "@stll/anonymize-darwin-arm64"
+	},
+	{
+		platform: "darwin",
+		arch: "x64",
+		package: "@stll/anonymize-darwin-x64"
+	},
+	{
+		platform: "linux",
+		arch: "arm64",
+		libc: "gnu",
+		package: "@stll/anonymize-linux-arm64-gnu"
+	},
+	{
+		platform: "linux",
+		arch: "x64",
+		libc: "gnu",
+		package: "@stll/anonymize-linux-x64-gnu"
+	},
+	{
+		platform: "win32",
+		arch: "x64",
+		package: "@stll/anonymize-win32-x64-msvc"
+	}
+];
+const describeNativeTarget = ({ arch, libc, platform }) => libc === void 0 ? `${platform}-${arch}` : `${platform}-${arch}-${libc}`;
+const SUPPORTED_NATIVE_TARGETS = NATIVE_BINDING_TARGETS.map((target) => describeNativeTarget(target));
+const nativeBindingPackageName = ({ arch, libc, platform }) => {
+	return NATIVE_BINDING_TARGETS.find((target) => target.platform === platform && target.arch === arch && (target.libc === void 0 || target.libc === libc))?.package ?? null;
+};
+const unsupportedNativeTargetError = ({ arch, errors, libc, platform }) => {
+	const target = describeNativeTarget({
+		arch,
+		libc,
+		platform
+	});
+	const supported = SUPPORTED_NATIVE_TARGETS.join(", ");
+	const attempts = errors.length > 0 ? `\n${errors.join("\n")}` : "";
+	return /* @__PURE__ */ new Error(`No native anonymize binding is published for ${target}; supported targets: ${supported}. Set ${PACKAGE_SPECIFIC_NATIVE_PATH} to a locally built binding to run on this platform.${attempts}`);
+};
+const detectNativeLibc = (platform) => {
+	if (platform !== "linux") return;
+	const report = process.report?.getReport();
+	return typeof (isPropertyBag(report) && isPropertyBag(report["header"]) ? report["header"] : null)?.["glibcVersionRuntime"] === "string" ? "gnu" : "musl";
+};
+const tryLoadNativeBinding = ({ specifier, requireModule, errors }) => {
+	try {
+		const binding = toNativeAnonymizeBinding(requireModule(specifier));
+		if (binding) return binding;
+		errors.push(`${specifier}: module does not match native binding shape`);
+	} catch (error) {
+		errors.push(`${specifier}: ${formatLoadError(error)}`);
+	}
+	return null;
+};
+const toNativeAnonymizeBinding = (value) => {
+	const candidate = isPropertyBag(value) && isPropertyBag(value["default"]) ? value["default"] : value;
+	return isNativeAnonymizeBinding(candidate) ? candidate : null;
+};
+const isNativeAnonymizeBinding = (candidate) => {
+	if (!isPropertyBag(candidate)) return false;
+	if (typeof candidate["nativePackageVersion"] !== "function") return false;
+	if (typeof candidate["normalizeForSearch"] !== "function") return false;
+	if (typeof candidate["prepareStaticSearchPackageBytes"] !== "function") return false;
+	if (typeof candidate["prepareStaticSearchCompressedPackageBytes"] !== "function") return false;
+	const preparedSearch = candidate["NativePreparedSearch"];
+	if (!isPropertyBag(preparedSearch)) return false;
+	if (typeof preparedSearch["fromConfigJsonBytes"] !== "function") return false;
+	if (typeof preparedSearch["fromPreparedPackageBytes"] !== "function") return false;
+	return true;
+};
+const isPropertyBag = (value) => typeof value === "object" && value !== null || typeof value === "function";
+const formatLoadError = (error) => {
+	if (error instanceof Error) return error.message;
+	return String(error);
+};
+//#endregion
+export { redact_text_json as A, readNativePipelinePackageFileAsync as C, redact_default_text as D, redactDefaultTextJson as E, createNativePipelineFromConfig as F, getNativePipelineCompatibility as I, prepareNativePipelineConfig as L, summary_diagnostics_json as M, DEFAULT_NATIVE_PIPELINE_CONFIG as N, redact_default_text_json as O, assertNativePipelineSupported as P, prepareNativePipelinePackage as R, readNativePipelinePackageFile as S, redactDefaultText as T, preloadDefaultNativePipelineAsync as _, createNativePipelineFromPackageFile as a, readDefaultNativePipelinePackageFile as b, diagnostics_stream_json as c, loadNativeAnonymizeBinding as d, load_prepared_package as f, preloadDefaultNativePipeline as g, normalize_for_search as h, createNativePipelineFromDefaultPackage as i, redact_text_stream_json as j, redact_text as k, getDefaultNativePipeline as l, native_package_version as m, availableDefaultNativePipelineLanguages as n, create_native_pipeline_from_default_package as o, load_prepared_package_file as p, available_default_native_pipeline_languages as r, diagnostics_json as s, DEFAULT_NATIVE_PIPELINE_WARMUPS as t, get_default_native_pipeline as u, preload_default_native_pipeline as v, read_default_native_pipeline_package_file as w, readDefaultNativePipelinePackageFileAsync as x, prepare_search_package as y };
+
+//# sourceMappingURL=native-node2.mjs.map