@yadsh/dsh-l10n-overrides 0.1.0

package/lib/client.js

@@ -0,0 +1,1207 @@
+window.__ModuleLoader__.load({
+	id: "dsh-l10n-overrides",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		//#region src/adapters/dsh-locale-runtime.ts
+		function failure() {
+			return { ok: false };
+		}
+		function adaptDshLocaleRuntime(value) {
+			if (typeof value !== "object" || value === null) return void 0;
+			let translate;
+			let getSnapshot;
+			let subscribe;
+			let originalTranslateDescriptor;
+			try {
+				translate = Reflect.get(value, "translate");
+				getSnapshot = Reflect.get(value, "getSnapshot");
+				subscribe = Reflect.get(value, "subscribe");
+				originalTranslateDescriptor = Reflect.getOwnPropertyDescriptor(value, "translate");
+			} catch {
+				return;
+			}
+			if (typeof translate !== "function" || typeof getSnapshot !== "function" || typeof subscribe !== "function") return;
+			const runtime = value;
+			const originalTranslate = translate;
+			const capturedGetSnapshot = getSnapshot;
+			function inspectRestoration(wrapper) {
+				try {
+					const current = Reflect.get(runtime, "translate");
+					if (current === originalTranslate) return "restored";
+					if (current === wrapper) return "failed";
+					return "replaced";
+				} catch {
+					return "failed";
+				}
+			}
+			function restoreOriginalTranslate(wrapper) {
+				try {
+					if (originalTranslateDescriptor === void 0) {
+						if (Reflect.getOwnPropertyDescriptor(runtime, "translate") === void 0) {
+							if (!Reflect.set(runtime, "translate", originalTranslate)) return inspectRestoration(wrapper);
+						} else if (!Reflect.deleteProperty(runtime, "translate")) return inspectRestoration(wrapper);
+					} else if ("value" in originalTranslateDescriptor) {
+						if (!Reflect.defineProperty(runtime, "translate", originalTranslateDescriptor)) return inspectRestoration(wrapper);
+					} else {
+						if (!Reflect.set(runtime, "translate", originalTranslate)) return inspectRestoration(wrapper);
+						if (!Reflect.defineProperty(runtime, "translate", originalTranslateDescriptor)) return inspectRestoration(wrapper);
+					}
+					return inspectRestoration(wrapper);
+				} catch {
+					return inspectRestoration(wrapper);
+				}
+			}
+			return {
+				runtime,
+				getActiveLocale() {
+					try {
+						const snapshot = Reflect.apply(capturedGetSnapshot, runtime, []);
+						if (typeof snapshot !== "object" || snapshot === null) return failure();
+						const active = Reflect.get(snapshot, "active");
+						return typeof active === "string" ? {
+							ok: true,
+							value: active
+						} : failure();
+					} catch {
+						return failure();
+					}
+				},
+				callOriginal(args) {
+					return Reflect.apply(originalTranslate, runtime, args);
+				},
+				install(wrapper) {
+					const inspectCurrent = () => {
+						try {
+							const current = Reflect.get(runtime, "translate");
+							if (current === wrapper) return "wrapper";
+							if (current === originalTranslate) return "original";
+							return "foreign";
+						} catch {
+							return "unknown";
+						}
+					};
+					const failedInstall = () => {
+						const beforeRollback = inspectCurrent();
+						if (beforeRollback === "wrapper") return {
+							ok: false,
+							runtimeMayBePatched: restoreOriginalTranslate(wrapper) === "failed"
+						};
+						return {
+							ok: false,
+							runtimeMayBePatched: beforeRollback === "unknown"
+						};
+					};
+					try {
+						if (!Reflect.set(runtime, "translate", wrapper)) return failedInstall();
+						if (Reflect.get(runtime, "translate") !== wrapper) return failedInstall();
+						return { ok: true };
+					} catch {
+						return failedInstall();
+					}
+				},
+				restoreOriginalIfCurrent(wrapper) {
+					try {
+						if (Reflect.get(runtime, "translate") !== wrapper) return {
+							ok: true,
+							value: "replaced"
+						};
+						const restoration = restoreOriginalTranslate(wrapper);
+						return restoration === "failed" ? failure() : {
+							ok: true,
+							value: restoration
+						};
+					} catch {
+						return failure();
+					}
+				}
+			};
+		}
+		//#endregion
+		//#region src/packs/example.ts
+		const example = Object.freeze({
+			id: "example-plugin-en",
+			target: Object.freeze({
+				package: "dsh-example-plugin",
+				versions: ">=0.4.0 <1.0.0"
+			}),
+			en: Object.freeze({ "example.settings": Object.freeze({
+				title: "Settings",
+				enabled: "Enabled",
+				server: "Server address",
+				save: "Save"
+			}) }),
+			dom: Object.freeze([Object.freeze({
+				scope: "[data-plugin=\"example-plugin\"]",
+				source: "设置",
+				target: "Settings"
+			})]),
+			metadata: Object.freeze({
+				sourceLanguage: "zh",
+				description: "Example English translation pack"
+			})
+		});
+		//#endregion
+		//#region src/packs/index.ts
+		const translationPacks = Object.freeze([example]);
+		//#endregion
+		//#region src/registry/diagnostics.ts
+		const PREFIX = "[dsh-l10n-overrides]";
+		var Diagnostics = class {
+			logger;
+			#debugEnabled;
+			#entries = [];
+			constructor(logger = console, options = {}) {
+				this.logger = logger;
+				this.#debugEnabled = options.debug === true;
+			}
+			info(code, message) {
+				this.#record("info", "info", code, message);
+			}
+			warning(code, message) {
+				this.#record("warning", "warn", code, message);
+			}
+			error(code, message) {
+				this.#record("error", "error", code, message);
+			}
+			debug(code, message) {
+				if (!this.#debugEnabled) return;
+				this.#record("debug", "debug", code, message);
+			}
+			snapshot() {
+				return Object.freeze(this.#entries.slice());
+			}
+			#record(level, loggerMethod, code, message) {
+				this.#entries.push(Object.freeze({
+					level,
+					code,
+					message
+				}));
+				try {
+					this.logger[loggerMethod](`${PREFIX} ${message}`);
+				} catch {}
+			}
+		};
+		//#endregion
+		//#region src/registry/translation-registry.ts
+		const DOM_TRANSLATION_ATTRIBUTES$1 = /* @__PURE__ */ new Set([
+			"placeholder",
+			"title",
+			"aria-label",
+			"alt"
+		]);
+		const EMPTY_DOM_RULES = Object.freeze([]);
+		function isNonBlankString(value) {
+			return typeof value === "string" && value.trim().length > 0;
+		}
+		function isDomTranslationAttribute(value) {
+			return typeof value === "string" && DOM_TRANSLATION_ATTRIBUTES$1.has(value);
+		}
+		function isDictionary(value) {
+			return typeof value === "object" && value !== null && !Array.isArray(value);
+		}
+		function normalizeDomRule(value) {
+			if (typeof value !== "object" || value === null) return void 0;
+			const rule = value;
+			const source = rule.source;
+			const target = rule.target;
+			const scope = rule.scope;
+			const mode = rule.mode;
+			const rawAttributes = rule.attributes;
+			if (!isNonBlankString(source) || !isNonBlankString(target) || !isNonBlankString(scope) || mode !== void 0 && mode !== "exact" || rawAttributes !== void 0 && !Array.isArray(rawAttributes)) return;
+			let attributes;
+			if (rawAttributes !== void 0) {
+				const capturedAttributes = [];
+				const attributeCount = rawAttributes.length;
+				for (let index = 0; index < attributeCount; index += 1) {
+					const attribute = rawAttributes[index];
+					if (!isDomTranslationAttribute(attribute)) return void 0;
+					capturedAttributes.push(attribute);
+				}
+				attributes = Object.freeze(capturedAttributes);
+			}
+			return Object.freeze({
+				source,
+				target,
+				scope,
+				...mode === void 0 ? {} : { mode },
+				...attributes === void 0 ? {} : { attributes }
+			});
+		}
+		function normalizeTranslations(value) {
+			if (!isDictionary(value)) return void 0;
+			const translations = [];
+			for (const [namespace, dictionary] of Object.entries(value)) {
+				if (!isDictionary(dictionary)) return void 0;
+				for (const [key, translation] of Object.entries(dictionary)) {
+					if (typeof translation !== "string") return void 0;
+					translations.push(Object.freeze({
+						namespace,
+						key,
+						value: translation
+					}));
+				}
+			}
+			return Object.freeze(translations);
+		}
+		function normalizeDomRules(value) {
+			if (value === void 0) return Object.freeze({
+				rules: EMPTY_DOM_RULES,
+				invalidRuleIndexes: Object.freeze([]),
+				invalidDeclaration: false
+			});
+			if (!Array.isArray(value)) return Object.freeze({
+				rules: EMPTY_DOM_RULES,
+				invalidRuleIndexes: Object.freeze([]),
+				invalidDeclaration: true
+			});
+			const rules = [];
+			const invalidRuleIndexes = [];
+			const ruleCount = value.length;
+			for (let index = 0; index < ruleCount; index += 1) try {
+				const rule = normalizeDomRule(value[index]);
+				if (rule === void 0) invalidRuleIndexes.push(index);
+				else rules.push(rule);
+			} catch {
+				invalidRuleIndexes.push(index);
+			}
+			return Object.freeze({
+				rules: Object.freeze(rules),
+				invalidRuleIndexes: Object.freeze(invalidRuleIndexes),
+				invalidDeclaration: false
+			});
+		}
+		function safePackLabel(value) {
+			return isNonBlankString(value) ? `"${value}"` : "<unknown pack>";
+		}
+		var TranslationPackRegistry = class {
+			diagnostics;
+			#translations = /* @__PURE__ */ new Map();
+			#packIds = /* @__PURE__ */ new Set();
+			#domRules = [];
+			#packCount = 0;
+			#overrideCount = 0;
+			constructor(diagnostics) {
+				this.diagnostics = diagnostics;
+			}
+			register(pack) {
+				const source = pack;
+				let rawPackId;
+				try {
+					rawPackId = source.id;
+				} catch {
+					this.diagnostics.error("invalid_pack", "Pack <unknown pack> has an unreadable id and was ignored.");
+					return;
+				}
+				if (!isNonBlankString(rawPackId)) {
+					this.diagnostics.error("invalid_pack", `Pack ${safePackLabel(rawPackId)} has an invalid id and was ignored.`);
+					return;
+				}
+				const packId = rawPackId;
+				if (this.#packIds.has(packId)) {
+					this.diagnostics.error("duplicate_pack_id", `Duplicate pack id "${packId}" ignored.`);
+					return;
+				}
+				let translations;
+				try {
+					const rawTranslations = source.en;
+					translations = normalizeTranslations(rawTranslations);
+				} catch {
+					translations = void 0;
+				}
+				if (translations === void 0) {
+					this.diagnostics.error("invalid_pack", `Pack "${packId}" has invalid English translations and was ignored.`);
+					return;
+				}
+				let normalizedDomRules;
+				try {
+					const rawDom = source.dom;
+					normalizedDomRules = normalizeDomRules(rawDom);
+				} catch {
+					normalizedDomRules = Object.freeze({
+						rules: EMPTY_DOM_RULES,
+						invalidRuleIndexes: Object.freeze([]),
+						invalidDeclaration: true
+					});
+				}
+				this.#packIds.add(packId);
+				this.#packCount += 1;
+				let namespaces = this.#translations.get("en");
+				if (namespaces === void 0) {
+					namespaces = /* @__PURE__ */ new Map();
+					this.#translations.set("en", namespaces);
+				}
+				for (const { namespace, key, value } of translations) {
+					let entries = namespaces.get(namespace);
+					if (entries === void 0) {
+						entries = /* @__PURE__ */ new Map();
+						namespaces.set(namespace, entries);
+					}
+					const previous = entries.get(key);
+					if (previous !== void 0) {
+						this.diagnostics.error("duplicate_override", `Duplicate override en/${namespace}/${key}: keeping pack "${previous.packId}"; ignoring pack "${packId}".`);
+						continue;
+					}
+					entries.set(key, Object.freeze({
+						value,
+						packId
+					}));
+					this.#overrideCount += 1;
+				}
+				for (const rule of normalizedDomRules.rules) this.#domRules.push(rule);
+				if (normalizedDomRules.invalidDeclaration) this.diagnostics.error("invalid_dom_rule", `Pack "${packId}" DOM rules declaration is invalid and was ignored.`);
+				for (const index of normalizedDomRules.invalidRuleIndexes) this.diagnostics.error("invalid_dom_rule", `Pack "${packId}" DOM rule at index ${index} is invalid and was ignored.`);
+				if (normalizedDomRules.rules.some((rule) => rule.scope === "global")) this.diagnostics.warning("global_dom_scope", `Pack "${packId}" contains global DOM translation rules.`);
+			}
+			resolve(locale, namespace, key) {
+				return this.resolveEntry(locale, namespace, key)?.value;
+			}
+			resolveEntry(locale, namespace, key) {
+				return this.#translations.get(locale)?.get(namespace)?.get(key);
+			}
+			getStats() {
+				return Object.freeze({
+					packs: this.#packCount,
+					localeOverrides: this.#overrideCount,
+					domRules: this.#domRules.length
+				});
+			}
+			getDomRules(locale) {
+				return locale === "en" ? Object.freeze(this.#domRules.slice()) : EMPTY_DOM_RULES;
+			}
+		};
+		//#endregion
+		//#region src/runtime/dom-translator.ts
+		const DOM_TRANSLATION_ATTRIBUTES = /* @__PURE__ */ new Set([
+			"placeholder",
+			"title",
+			"aria-label",
+			"alt"
+		]);
+		const ELEMENT_NODE = 1;
+		const TEXT_NODE = 3;
+		const SHOW_ELEMENT_AND_TEXT = 5;
+		const KNOWN_PROTECTION_ATTRIBUTES = /* @__PURE__ */ new Set([
+			"class",
+			"contenteditable",
+			"data-no-translate",
+			"data-message-id",
+			"data-testid"
+		]);
+		const CLASS_PROTECTION_PATTERN = /conversation|message|markdown|editor|terminal|prompt/i;
+		const TEST_ID_PROTECTION_PATTERN = /conversation|message|markdown|editor|terminal|prompt|composer/i;
+		const SCOPE_AND_PROTECTION_ATTRIBUTES = [
+			"class",
+			"id",
+			...KNOWN_PROTECTION_ATTRIBUTES
+		];
+		const SHARED_PROTECTED_SURFACES = [
+			"[contenteditable]",
+			"[data-no-translate]",
+			"[data-message-id]",
+			"[data-testid*=\"conversation\" i]",
+			"[data-testid*=\"message\" i]",
+			"[data-testid*=\"markdown\" i]",
+			"[data-testid*=\"editor\" i]",
+			"[data-testid*=\"terminal\" i]",
+			"[data-testid*=\"prompt\" i]",
+			"[data-testid*=\"composer\" i]",
+			"[class*=\"conversation\" i]",
+			"[class*=\"message\" i]",
+			"[class*=\"markdown\" i]",
+			"[class*=\"editor\" i]",
+			"[class*=\"terminal\" i]",
+			"[class*=\"prompt\" i]"
+		];
+		const CODE_LIKE_PROTECTED_SURFACES = [
+			"pre",
+			"code",
+			"kbd",
+			"samp",
+			"script",
+			"style"
+		];
+		const TEXT_PROTECTED_SURFACE_SELECTOR = [
+			"input",
+			"textarea",
+			...CODE_LIKE_PROTECTED_SURFACES,
+			...SHARED_PROTECTED_SURFACES
+		].join(",");
+		const ATTRIBUTE_PROTECTED_SURFACE_SELECTOR = [...CODE_LIKE_PROTECTED_SURFACES, ...SHARED_PROTECTED_SURFACES].join(",");
+		function isScopeIdentifierStart(character) {
+			return character !== void 0 && /[A-Z_a-z\u0080-\uFFFF]/.test(character);
+		}
+		function consumeScopeIdentifier(scope, start) {
+			let index = start;
+			if (scope[index] === "-") {
+				index += 1;
+				if (scope[index] === "-") index += 1;
+				else if (!isScopeIdentifierStart(scope[index])) return start;
+			} else if (isScopeIdentifierStart(scope[index])) index += 1;
+			else return start;
+			while (index < scope.length && /[-0-9A-Z_a-z\u0080-\uFFFF]/.test(scope[index] ?? "")) index += 1;
+			return index;
+		}
+		function skipScopeWhitespace(scope, start) {
+			let index = start;
+			while (index < scope.length && /[\t\n\f\r ]/.test(scope[index] ?? "")) index += 1;
+			return index;
+		}
+		function parseScopeAttribute(scope, start) {
+			let index = skipScopeWhitespace(scope, start + 1);
+			const nameStart = index;
+			if (!/[A-Z_a-z]/.test(scope[index] ?? "")) return void 0;
+			index += 1;
+			while (index < scope.length && /[-0-9A-Z_a-z]/.test(scope[index] ?? "")) index += 1;
+			const dependency = scope.slice(nameStart, index).toLowerCase();
+			index = skipScopeWhitespace(scope, index);
+			if (scope[index] === "]") return {
+				dependency,
+				nextIndex: index + 1
+			};
+			const operatorStart = scope[index];
+			if (operatorStart === "=") index += 1;
+			else if (operatorStart !== void 0 && "~|^$*".includes(operatorStart) && scope[index + 1] === "=") index += 2;
+			else return;
+			index = skipScopeWhitespace(scope, index);
+			const quote = scope[index];
+			if (quote === "\"" || quote === "'") {
+				index += 1;
+				while (index < scope.length && scope[index] !== quote) index += 1;
+				if (scope[index] !== quote) return void 0;
+				index += 1;
+			} else {
+				const next = consumeScopeIdentifier(scope, index);
+				if (next === index) return void 0;
+				index = next;
+			}
+			const valueEnd = index;
+			index = skipScopeWhitespace(scope, index);
+			if (index > valueEnd && /[IiSs]/.test(scope[index] ?? "")) {
+				index += 1;
+				index = skipScopeWhitespace(scope, index);
+			}
+			if (scope[index] !== "]") return void 0;
+			return {
+				dependency,
+				nextIndex: index + 1
+			};
+		}
+		function parseSupportedScopeSelector(scope) {
+			if (scope.length === 0 || scope.includes("\\") || scope.includes(",") || scope.includes("/*") || scope.includes("*/")) return;
+			const dependencies = /* @__PURE__ */ new Set();
+			let index = 0;
+			let components = 0;
+			if (scope[index] === "*") {
+				index += 1;
+				components += 1;
+			} else {
+				const next = consumeScopeIdentifier(scope, index);
+				if (next !== index) {
+					index = next;
+					components += 1;
+				}
+			}
+			while (index < scope.length) {
+				const character = scope[index];
+				if (character === "." || character === "#") {
+					const next = consumeScopeIdentifier(scope, index + 1);
+					if (next === index + 1) return void 0;
+					dependencies.add(character === "." ? "class" : "id");
+					index = next;
+					components += 1;
+				} else if (character === "[") {
+					const parsed = parseScopeAttribute(scope, index);
+					if (parsed === void 0) return void 0;
+					dependencies.add(parsed.dependency);
+					index = parsed.nextIndex;
+					components += 1;
+				} else return;
+			}
+			return components > 0 ? { dependencies } : void 0;
+		}
+		var DomTranslator = class {
+			document;
+			diagnostics;
+			#scopes;
+			#attributeFilter;
+			#scopeAndProtectionAttributes;
+			#textOwnership = /* @__PURE__ */ new WeakMap();
+			#ownedTextNodes = /* @__PURE__ */ new Set();
+			#attributeOwnership = /* @__PURE__ */ new WeakMap();
+			#ownedAttributeElements = /* @__PURE__ */ new Set();
+			#reportedFailures = /* @__PURE__ */ new Set();
+			#locale;
+			#disposed = false;
+			#observer;
+			constructor(document, rules, diagnostics) {
+				this.document = document;
+				this.diagnostics = diagnostics;
+				const scopes = /* @__PURE__ */ new Map();
+				for (const rule of rules) {
+					let scopeRules = scopes.get(rule.scope);
+					if (scopeRules === void 0) {
+						scopeRules = {
+							text: /* @__PURE__ */ new Map(),
+							attributes: /* @__PURE__ */ new Map()
+						};
+						scopes.set(rule.scope, scopeRules);
+					}
+					if (!scopeRules.text.has(rule.source)) scopeRules.text.set(rule.source, rule);
+					for (const attribute of rule.attributes ?? []) {
+						if (!DOM_TRANSLATION_ATTRIBUTES.has(attribute)) continue;
+						let attributeRules = scopeRules.attributes.get(attribute);
+						if (attributeRules === void 0) {
+							attributeRules = /* @__PURE__ */ new Map();
+							scopeRules.attributes.set(attribute, attributeRules);
+						}
+						if (!attributeRules.has(rule.source)) attributeRules.set(rule.source, rule);
+					}
+				}
+				const validatedScopes = Array.from(scopes, ([scope, indexed]) => ({
+					scope,
+					text: indexed.text,
+					attributes: indexed.attributes
+				})).flatMap((indexed) => {
+					if (indexed.scope === "global") return [{
+						...indexed,
+						dependencies: /* @__PURE__ */ new Set()
+					}];
+					const parsed = parseSupportedScopeSelector(indexed.scope);
+					if (parsed === void 0) {
+						this.diagnostics.error("invalid_dom_scope", `Invalid DOM translation scope "${indexed.scope}" was ignored.`);
+						return [];
+					}
+					try {
+						this.document.createDocumentFragment().querySelector(indexed.scope);
+					} catch {
+						this.diagnostics.error("invalid_dom_scope", `Invalid DOM translation scope "${indexed.scope}" was ignored.`);
+						return [];
+					}
+					return [{
+						...indexed,
+						dependencies: parsed.dependencies
+					}];
+				});
+				this.#scopes = validatedScopes.map(({ scope, text, attributes, dependencies }) => {
+					const safeAttributes = new Map(attributes);
+					for (const attribute of attributes.keys()) {
+						if (!dependencies.has(attribute)) continue;
+						safeAttributes.delete(attribute);
+						this.diagnostics.error("invalid_dom_rule", `DOM attribute "${attribute}" was ignored because it controls scope "${scope}".`);
+					}
+					return {
+						scope,
+						text,
+						attributes: safeAttributes,
+						dependencies
+					};
+				});
+				const translationAttributes = this.#scopes.flatMap(({ attributes }) => [...attributes.keys()]);
+				const scopeAndProtectionAttributes = new Set(SCOPE_AND_PROTECTION_ATTRIBUTES);
+				for (const { dependencies } of this.#scopes) for (const attribute of dependencies) scopeAndProtectionAttributes.add(attribute);
+				this.#scopeAndProtectionAttributes = scopeAndProtectionAttributes;
+				this.#attributeFilter = Array.from(/* @__PURE__ */ new Set([...translationAttributes, ...scopeAndProtectionAttributes]));
+			}
+			setLocale(locale) {
+				if (this.#disposed || this.#locale === locale) return;
+				const previousLocale = this.#locale;
+				this.#locale = locale;
+				if (locale !== "en") {
+					if (previousLocale === "en") {
+						this.#disconnectObserver();
+						this.#restoreOwnedValues();
+					}
+					return;
+				}
+				for (const scopeRules of this.#scopes) {
+					let roots;
+					try {
+						roots = scopeRules.scope === "global" ? this.document.body === null ? [] : [this.document.body] : Array.from(this.document.querySelectorAll(scopeRules.scope));
+						roots = this.#topmostRoots(roots);
+					} catch {
+						this.#reportOnce(`initial-query:${scopeRules.scope}`, "dom_translation_failed", `DOM translation roots could not be found for scope "${scopeRules.scope}".`);
+						continue;
+					}
+					for (const root of roots) this.#translateRoot(root, scopeRules);
+				}
+				this.#connectObserver();
+			}
+			dispose() {
+				if (this.#disposed) return;
+				this.#disconnectObserver();
+				this.#restoreOwnedValues();
+				this.#disposed = true;
+			}
+			#disconnectObserver() {
+				try {
+					this.#observer?.disconnect();
+				} catch {}
+				this.#observer = void 0;
+			}
+			#restoreOwnedValues() {
+				for (const node of this.#ownedTextNodes) {
+					const ownership = this.#textOwnership.get(node);
+					try {
+						if (ownership !== void 0 && node.textContent === ownership.translated) node.textContent = ownership.original;
+					} catch {}
+					this.#textOwnership.delete(node);
+				}
+				this.#ownedTextNodes.clear();
+				for (const element of this.#ownedAttributeElements) {
+					const attributes = this.#attributeOwnership.get(element);
+					if (attributes !== void 0) for (const [attribute, ownership] of attributes) try {
+						if (element.getAttribute(attribute) !== ownership.translated) continue;
+						if (ownership.wasPresent) element.setAttribute(attribute, ownership.original ?? "");
+						else element.removeAttribute(attribute);
+					} catch {}
+					this.#attributeOwnership.delete(element);
+				}
+				this.#ownedAttributeElements.clear();
+			}
+			#connectObserver() {
+				if (this.#scopes.length === 0) return;
+				let body;
+				let MutationObserverConstructor;
+				try {
+					body = this.document.body;
+					MutationObserverConstructor = this.document.defaultView?.MutationObserver;
+				} catch {
+					this.#reportOnce("dom-environment", "dom_translation_failed", "DOM translation APIs are unavailable.");
+					return;
+				}
+				if (body === null || MutationObserverConstructor === void 0) {
+					this.#reportOnce("dom-environment", "dom_translation_failed", "DOM translation observation is unavailable.");
+					return;
+				}
+				try {
+					this.#observer = new MutationObserverConstructor((records) => {
+						try {
+							this.#processMutations(records);
+						} catch {
+							this.#reportOnce("mutation-callback", "dom_translation_failed", "Dynamic DOM translation failed.");
+						}
+					});
+					this.#observer.observe(body, {
+						childList: true,
+						subtree: true,
+						characterData: true,
+						attributes: true,
+						attributeFilter: [...this.#attributeFilter],
+						attributeOldValue: true
+					});
+				} catch {
+					this.#observer = void 0;
+					this.#reportOnce("observer-construction", "dom_translation_failed", "DOM mutation observation could not be started.");
+				}
+			}
+			#processMutations(records) {
+				if (this.#disposed || this.#locale !== "en") return;
+				const touchedSubtrees = /* @__PURE__ */ new Set();
+				for (const record of records) {
+					try {
+						if (record.type === "characterData") {
+							this.#translateChangedText(record.target);
+							continue;
+						}
+						if (record.type === "attributes") {
+							if (record.target.nodeType === ELEMENT_NODE && record.attributeName !== null) {
+								const element = record.target;
+								if (this.#scopeAndProtectionAttributes.has(record.attributeName)) {
+									this.#reconcileOwnedWithin(element);
+									if (this.#isConnectedToDocument(element)) this.#reapplyAfterStructuralAttribute(element, record.attributeName, record.oldValue);
+								} else this.#translateChangedAttribute(element, record.attributeName);
+							}
+							continue;
+						}
+					} catch {
+						this.#reportMutationFailure();
+						continue;
+					}
+					for (const node of record.removedNodes) touchedSubtrees.add(node);
+					for (const node of record.addedNodes) touchedSubtrees.add(node);
+				}
+				for (const node of touchedSubtrees) try {
+					this.#reconcileSubtree(node);
+					if (this.#isConnectedToDocument(node)) this.#translateAddedNode(node);
+				} catch {
+					this.#reportMutationFailure();
+				}
+			}
+			#reportMutationFailure() {
+				this.#reportOnce("mutation-callback", "dom_translation_failed", "Dynamic DOM translation failed.");
+			}
+			#translateChangedText(node) {
+				this.#reconcileTextOwnership(node);
+				const parent = node.parentElement;
+				if (parent === null) return;
+				for (const scopeRules of this.#scopes) if (this.#isInScope(parent, scopeRules.scope)) this.#translateText(node, scopeRules);
+			}
+			#translateChangedAttribute(element, attributeName) {
+				this.#reconcileAttributeOwnership(element, attributeName);
+				for (const scopeRules of this.#scopes) {
+					const rules = scopeRules.attributes.get(attributeName);
+					if (rules !== void 0 && this.#isInScope(element, scopeRules.scope)) this.#translateAttribute(element, attributeName, rules, scopeRules.scope);
+				}
+			}
+			#translateAddedNode(node) {
+				if (node.nodeType === TEXT_NODE) {
+					this.#translateChangedText(node);
+					return;
+				}
+				if (node.nodeType !== ELEMENT_NODE) return;
+				const element = node;
+				for (const scopeRules of this.#scopes) {
+					if (this.#isInScope(element, scopeRules.scope)) {
+						this.#translateRoot(element, scopeRules);
+						continue;
+					}
+					if (scopeRules.scope === "global") continue;
+					const roots = this.#topmostRoots([...element.querySelectorAll(scopeRules.scope)]);
+					for (const root of roots) this.#translateRoot(root, scopeRules);
+				}
+			}
+			#topmostRoots(roots) {
+				if (roots.length < 2) return roots;
+				const candidates = new Set(roots);
+				return roots.filter((root) => {
+					let ancestor = root.parentElement;
+					while (ancestor !== null) {
+						if (candidates.has(ancestor)) return false;
+						ancestor = ancestor.parentElement;
+					}
+					return true;
+				});
+			}
+			#reconcileSubtree(root) {
+				this.#reconcileOwnedNode(root);
+				if (root.nodeType !== ELEMENT_NODE) return;
+				const walker = this.document.createTreeWalker(root, SHOW_ELEMENT_AND_TEXT);
+				let node = walker.nextNode();
+				while (node !== null) {
+					try {
+						this.#reconcileOwnedNode(node);
+					} catch {
+						this.#reportMutationFailure();
+					}
+					node = walker.nextNode();
+				}
+			}
+			#reconcileOwnedWithin(root) {
+				for (const node of this.#ownedTextNodes) {
+					if (!root.contains(node)) continue;
+					try {
+						this.#reconcileTextOwnership(node);
+					} catch {
+						this.#reportMutationFailure();
+					}
+				}
+				for (const element of this.#ownedAttributeElements) {
+					if (element !== root && !root.contains(element)) continue;
+					try {
+						this.#reconcileElementOwnership(element);
+					} catch {
+						this.#reportMutationFailure();
+					}
+				}
+			}
+			#reapplyAfterStructuralAttribute(target, attribute, oldValue) {
+				const protectionRemoved = this.#protectionWasRemoved(target, attribute, oldValue);
+				for (const rules of this.#scopes) {
+					let shouldTranslate = false;
+					if (rules.dependencies.has(attribute)) shouldTranslate = rules.scope !== "global" && target.matches(rules.scope);
+					if (!shouldTranslate && protectionRemoved && this.#isInScope(target, rules.scope)) shouldTranslate = true;
+					if (shouldTranslate) this.#translateRoot(target, rules);
+				}
+			}
+			#protectionWasRemoved(target, attribute, oldValue) {
+				if (oldValue === null || !KNOWN_PROTECTION_ATTRIBUTES.has(attribute) || target.closest(ATTRIBUTE_PROTECTED_SURFACE_SELECTOR) !== null) return false;
+				if (attribute === "class") return CLASS_PROTECTION_PATTERN.test(oldValue);
+				if (attribute === "data-testid") return TEST_ID_PROTECTION_PATTERN.test(oldValue);
+				return true;
+			}
+			#reconcileOwnedNode(node) {
+				if (node.nodeType === TEXT_NODE) this.#reconcileTextOwnership(node);
+				else if (node.nodeType === ELEMENT_NODE) this.#reconcileElementOwnership(node);
+			}
+			#reconcileTextOwnership(node) {
+				const ownership = this.#textOwnership.get(node);
+				if (ownership === void 0) return;
+				if ((node.textContent ?? "") !== ownership.translated) {
+					this.#releaseTextOwnership(node);
+					return;
+				}
+				const parent = node.parentElement;
+				if (parent !== null && this.#isConnectedToDocument(node) && this.#isInScope(parent, ownership.scope) && parent.closest(TEXT_PROTECTED_SURFACE_SELECTOR) === null) return;
+				node.textContent = ownership.original;
+				this.#releaseTextOwnership(node);
+			}
+			#reconcileElementOwnership(element) {
+				const attributes = this.#attributeOwnership.get(element);
+				if (attributes === void 0) return;
+				for (const attribute of [...attributes.keys()]) this.#reconcileAttributeOwnership(element, attribute);
+			}
+			#reconcileAttributeOwnership(element, attribute) {
+				const ownership = this.#attributeOwnership.get(element)?.get(attribute);
+				if (ownership === void 0) return;
+				if (element.getAttribute(attribute) !== ownership.translated) {
+					this.#releaseAttributeOwnership(element, attribute);
+					return;
+				}
+				if (this.#isConnectedToDocument(element) && this.#isInScope(element, ownership.scope) && element.closest(ATTRIBUTE_PROTECTED_SURFACE_SELECTOR) === null) return;
+				if (ownership.wasPresent) element.setAttribute(attribute, ownership.original ?? "");
+				else element.removeAttribute(attribute);
+				this.#releaseAttributeOwnership(element, attribute);
+			}
+			#releaseTextOwnership(node) {
+				this.#textOwnership.delete(node);
+				this.#ownedTextNodes.delete(node);
+			}
+			#releaseAttributeOwnership(element, attribute) {
+				const attributes = this.#attributeOwnership.get(element);
+				if (attributes === void 0) return;
+				attributes.delete(attribute);
+				if (attributes.size !== 0) return;
+				this.#attributeOwnership.delete(element);
+				this.#ownedAttributeElements.delete(element);
+			}
+			#isConnectedToDocument(node) {
+				return this.document.body?.contains(node) === true;
+			}
+			#translateRoot(root, rules) {
+				try {
+					this.#translateTree(root, rules);
+				} catch {
+					this.#reportOnce(`root:${rules.scope}`, "dom_translation_failed", `DOM translation failed for a root in scope "${rules.scope}".`);
+				}
+			}
+			#isInScope(element, scope) {
+				return scope === "global" ? this.document.body?.contains(element) === true : element.closest(scope) !== null;
+			}
+			#translateTree(root, rules) {
+				this.#translateAttributesSafely(root, rules);
+				for (const element of root.querySelectorAll("*")) this.#translateAttributesSafely(element, rules);
+				const walker = this.document.createTreeWalker(root, 4);
+				let node = walker.nextNode();
+				while (node !== null) {
+					try {
+						this.#translateText(node, rules);
+					} catch {
+						this.#reportDescendantFailure(rules.scope);
+					}
+					node = walker.nextNode();
+				}
+			}
+			#translateAttributesSafely(element, rules) {
+				try {
+					this.#translateAttributes(element, rules);
+				} catch {
+					this.#reportDescendantFailure(rules.scope);
+				}
+			}
+			#reportDescendantFailure(scope) {
+				this.#reportOnce(`descendant:${scope}`, "dom_translation_failed", `A DOM descendant in scope "${scope}" could not be translated.`);
+			}
+			#translateText(node, rules) {
+				const value = node.textContent ?? "";
+				let ownership = this.#textOwnership.get(node);
+				if (ownership !== void 0 && value === ownership.translated) return;
+				const rule = rules.text.get(value.trim());
+				const parent = node.parentElement;
+				if (rule === void 0 || parent === null || parent.closest(TEXT_PROTECTED_SURFACE_SELECTOR) !== null) return;
+				const start = value.search(/\S/);
+				const end = value.search(/\s*$/);
+				const translated = `${value.slice(0, start)}${rule.target}${value.slice(end)}`;
+				if (ownership === void 0) {
+					ownership = {
+						original: value,
+						translated,
+						scope: rules.scope
+					};
+					this.#textOwnership.set(node, ownership);
+					this.#ownedTextNodes.add(node);
+				} else {
+					ownership.original = value;
+					ownership.translated = translated;
+					ownership.scope = rules.scope;
+				}
+				node.textContent = translated;
+			}
+			#translateAttributes(element, rules) {
+				if (rules.attributes.size === 0 || element.closest(ATTRIBUTE_PROTECTED_SURFACE_SELECTOR) !== null) return;
+				for (const [attribute, attributeRules] of rules.attributes) this.#translateAttribute(element, attribute, attributeRules, rules.scope);
+			}
+			#translateAttribute(element, attribute, rules, scope) {
+				if (element.closest(ATTRIBUTE_PROTECTED_SURFACE_SELECTOR) !== null) return;
+				const value = element.getAttribute(attribute);
+				if (value === null) return;
+				let attributes = this.#attributeOwnership.get(element);
+				let ownership = attributes?.get(attribute);
+				if (ownership !== void 0 && value === ownership.translated) return;
+				const rule = rules.get(value);
+				if (rule === void 0) return;
+				if (attributes === void 0) {
+					attributes = /* @__PURE__ */ new Map();
+					this.#attributeOwnership.set(element, attributes);
+					this.#ownedAttributeElements.add(element);
+				}
+				if (ownership === void 0) {
+					ownership = {
+						wasPresent: element.hasAttribute(attribute),
+						original: value,
+						translated: rule.target,
+						scope
+					};
+					attributes.set(attribute, ownership);
+				} else {
+					ownership.wasPresent = element.hasAttribute(attribute);
+					ownership.original = value;
+					ownership.translated = rule.target;
+					ownership.scope = scope;
+				}
+				element.setAttribute(attribute, rule.target);
+			}
+			#reportOnce(key, code, message) {
+				if (this.#reportedFailures.has(key)) return;
+				this.#reportedFailures.add(key);
+				try {
+					this.diagnostics.error(code, message);
+				} catch {}
+			}
+		};
+		//#endregion
+		//#region src/runtime/interpolate.ts
+		function interpolate(template, params) {
+			if (params === void 0) return template;
+			return template.replace(/\{(\w+)\}/g, (match, name) => {
+				try {
+					if (!Object.hasOwn(params, name)) return match;
+					const value = params[name];
+					if (value === null || value === void 0) return match;
+					return String(value);
+				} catch {
+					return match;
+				}
+			});
+		}
+		//#endregion
+		//#region src/runtime/locale-hook.ts
+		const installedHooks = /* @__PURE__ */ new WeakMap();
+		function installLocaleHook(runtime, registry, diagnostics) {
+			const adapter = adaptDshLocaleRuntime(runtime);
+			if (adapter === void 0) {
+				diagnostics.error("incompatible_locale_runtime", "The DSH locale runtime is incompatible; locale overrides were not installed.");
+				return () => true;
+			}
+			if (installedHooks.has(adapter.runtime)) {
+				diagnostics.warning("duplicate_locale_hook", "A locale override hook is already installed on this DSH runtime.");
+				return () => true;
+			}
+			let snapshotFailureDiagnosed = false;
+			const wrapper = function(...args) {
+				const [namespace, key, params] = args;
+				const locale = adapter.getActiveLocale();
+				if (!locale.ok && !snapshotFailureDiagnosed) {
+					snapshotFailureDiagnosed = true;
+					diagnostics.error("locale_snapshot_failed", "The active DSH locale could not be read; the original translator will be used.");
+				}
+				if (locale.ok && locale.value === "en") {
+					const entry = registry.resolveEntry(locale.value, namespace, key);
+					if (entry !== void 0) {
+						diagnostics.debug("locale_override_hit", `Locale override hit locale=${locale.value} namespace=${namespace} key=${key} pack=${entry.packId}.`);
+						return interpolate(entry.value, params);
+					}
+				}
+				return adapter.callOriginal(args);
+			};
+			installedHooks.set(adapter.runtime, wrapper);
+			const installed = adapter.install(wrapper);
+			if (!installed.ok) {
+				diagnostics.error("locale_hook_install_failed", "The DSH locale translator could not be patched; locale overrides were not installed.");
+				if (!installed.runtimeMayBePatched) {
+					installedHooks.delete(adapter.runtime);
+					return () => true;
+				}
+			}
+			let disposed = false;
+			let restoreFailureDiagnosed = false;
+			return () => {
+				if (disposed) return true;
+				const restored = adapter.restoreOriginalIfCurrent(wrapper);
+				if (!restored.ok && !restoreFailureDiagnosed) {
+					restoreFailureDiagnosed = true;
+					diagnostics.error("locale_hook_restore_failed", "The DSH locale translator could not be inspected or restored during disposal.");
+				}
+				if (!restored.ok) return false;
+				disposed = true;
+				installedHooks.delete(adapter.runtime);
+				return true;
+			};
+		}
+		//#endregion
+		//#region src/client/index.ts
+		const inject = ["locale"];
+		const sharedInstallations = /* @__PURE__ */ new WeakMap();
+		const terminalCleanup = () => true;
+		function createCleanupResource(code, message) {
+			return {
+				state: "done",
+				run: terminalCleanup,
+				diagnosed: false,
+				code,
+				message
+			};
+		}
+		function armCleanup(resource, run) {
+			resource.state = "idle";
+			resource.run = run;
+		}
+		function attemptCleanup(installation, resource) {
+			if (resource.state !== "idle") return;
+			resource.state = "running";
+			try {
+				if (resource.run() === false) {
+					resource.state = "idle";
+					return;
+				}
+				resource.state = "done";
+				resource.run = terminalCleanup;
+			} catch {
+				resource.state = "idle";
+				if (resource.diagnosed) return;
+				resource.diagnosed = true;
+				installation.diagnostics.error(resource.code, resource.message);
+			}
+		}
+		function cleanupInstallation(installation) {
+			attemptCleanup(installation, installation.domCleanup);
+			attemptCleanup(installation, installation.listenerCleanup);
+			attemptCleanup(installation, installation.localeCleanup);
+			if (!(installation.domCleanup.state === "done" && installation.listenerCleanup.state === "done" && installation.localeCleanup.state === "done")) return false;
+			const { runtimeKey } = installation;
+			if (runtimeKey !== void 0 && sharedInstallations.get(runtimeKey) === installation) sharedInstallations.delete(runtimeKey);
+			return true;
+		}
+		function createLease(installation) {
+			let released = false;
+			let terminal = false;
+			return () => {
+				if (terminal) return;
+				if (!released) {
+					released = true;
+					installation.refs -= 1;
+					if (installation.refs > 0) {
+						terminal = true;
+						return;
+					}
+				}
+				if (cleanupInstallation(installation)) terminal = true;
+			};
+		}
+		function selectDocument(options) {
+			if (options.document !== void 0) return options.document ?? void 0;
+			return typeof document === "undefined" ? void 0 : document;
+		}
+		function describeCount(count, singular, plural) {
+			return `${count} ${count === 1 ? singular : plural}`;
+		}
+		function apply(ctx, options = {}) {
+			let localeRuntime;
+			try {
+				localeRuntime = ctx.locale;
+			} catch {
+				localeRuntime = void 0;
+			}
+			const localeAdapter = adaptDshLocaleRuntime(localeRuntime);
+			const runtimeKey = localeAdapter?.runtime;
+			if (runtimeKey !== void 0) {
+				const existing = sharedInstallations.get(runtimeKey);
+				if (existing !== void 0) {
+					existing.refs += 1;
+					return createLease(existing);
+				}
+			}
+			const diagnostics = new Diagnostics(options.logger ?? console, options.debug === void 0 ? {} : { debug: options.debug });
+			const registry = new TranslationPackRegistry(diagnostics);
+			const installation = {
+				refs: 1,
+				runtimeKey,
+				diagnostics,
+				domCleanup: createCleanupResource("dom_dispose_failed", "DOM translation could not be fully restored during disposal."),
+				listenerCleanup: createCleanupResource("locale_listener_dispose_failed", "The locale change listener could not be removed during disposal."),
+				localeCleanup: createCleanupResource("locale_hook_dispose_failed", "The locale override hook could not be restored during disposal.")
+			};
+			if (runtimeKey !== void 0) sharedInstallations.set(runtimeKey, installation);
+			for (const pack of translationPacks) try {
+				registry.register(pack);
+			} catch {
+				diagnostics.error("pack_registration_failed", `Pack "${pack.id}" could not be registered and was ignored.`);
+			}
+			const stats = registry.getStats();
+			diagnostics.info("startup_summary", `Loaded ${describeCount(stats.packs, "pack", "packs")}, ${describeCount(stats.localeOverrides, "locale override", "locale overrides")}, and ${describeCount(stats.domRules, "DOM rule", "DOM rules")}.`);
+			try {
+				armCleanup(installation.localeCleanup, installLocaleHook(localeRuntime, registry, diagnostics));
+			} catch {
+				diagnostics.error("locale_hook_startup_failed", "The locale override hook could not be started.");
+			}
+			let candidateDocument;
+			try {
+				candidateDocument = selectDocument(options);
+			} catch {
+				candidateDocument = void 0;
+			}
+			let domAvailable = false;
+			if (candidateDocument !== void 0) try {
+				domAvailable = candidateDocument.body !== null && candidateDocument.defaultView?.MutationObserver !== void 0;
+			} catch {}
+			if (!domAvailable) diagnostics.warning("dom_unavailable", "DOM translation is unavailable; locale overrides remain active.");
+			let domTranslator;
+			if (domAvailable && candidateDocument !== void 0 && localeAdapter) try {
+				const translator = new DomTranslator(candidateDocument, registry.getDomRules("en"), diagnostics);
+				domTranslator = translator;
+				armCleanup(installation.domCleanup, () => {
+					translator.dispose();
+					return true;
+				});
+			} catch {
+				diagnostics.error("dom_startup_failed", "DOM translation could not be started; locale overrides remain active.");
+			}
+			if (domTranslator !== void 0 && localeAdapter !== void 0) {
+				const initialLocale = localeAdapter.getActiveLocale();
+				if (initialLocale.ok) try {
+					domTranslator.setLocale(initialLocale.value);
+				} catch {
+					diagnostics.error("dom_initial_locale_failed", "The initial locale could not be applied to DOM translation.");
+				}
+				else diagnostics.error("initial_locale_snapshot_failed", "The initial locale could not be read; DOM translation was not activated.");
+			}
+			if (domTranslator !== void 0) {
+				let switchingFailureDiagnosed = false;
+				try {
+					const unsubscribe = ctx.on("locale/change", (snapshot) => {
+						try {
+							domTranslator?.setLocale(snapshot.active);
+						} catch {
+							if (switchingFailureDiagnosed) return;
+							switchingFailureDiagnosed = true;
+							diagnostics.error("locale_switch_failed", "A locale change could not be applied to DOM translation.");
+						}
+					});
+					if (typeof unsubscribe === "function") armCleanup(installation.listenerCleanup, () => {
+						unsubscribe();
+						return true;
+					});
+					else diagnostics.error("locale_listener_failed", "The locale change listener could not be registered; DOM language switching is disabled.");
+				} catch {
+					diagnostics.error("locale_listener_failed", "The locale change listener could not be registered; DOM language switching is disabled.");
+				}
+			}
+			return createLease(installation);
+		}
+		//#endregion
+		exports.apply = apply;
+		exports.inject = inject;
+		return module.exports;
+	}
+});