@pie-players/pie-players-shared 1.0.0-beta.6 → 1.0.0-beta.8

package/dist/i18n/messages/en-US.d.ts

@@ -301,6 +301,12 @@ declare const enUS: {
                 lanthanide: string;
                 actinide: string;
             };
+            /** Standard-state phase, keyed by the data file's lowercased `phase` value. */
+            phaseValue: {
+                solid: string;
+                liquid: string;
+                gas: string;
+            };
         };
         ruler: {
             name: string;
@@ -431,6 +437,12 @@ declare const enUS: {
             description: string;
             buttonA11y: string;
             tooltip: string;
+            /** A choice's toggle; `{choice}` is the choice's own accessible name. */
+            toggleA11y: string;
+            /** Appended to an eliminated choice's label for assistive technology. */
+            eliminatedA11y: string;
+            /** Stands in for `{choice}` when a choice has no text of its own. */
+            unlabeledChoice: string;
         };
         highlighter: {
             name: string;
@@ -456,6 +468,17 @@ declare const enUS: {
             highlightPinkA11y: string;
             highlightBlueA11y: string;
             highlightGreenA11y: string;
+            selectionAvailableA11y: string;
+            highlightedYellowA11y: string;
+            highlightedPinkA11y: string;
+            highlightedBlueA11y: string;
+            highlightedGreenA11y: string;
+            underlinedA11y: string;
+            removedA11y: string;
+            clearedA11y: {
+                one: string;
+                other: string;
+            };
         };
         theme: {
             name: string;

package/dist/i18n/messages/en-US.js

@@ -306,6 +306,12 @@ const enUS = {
                 lanthanide: "Lanthanide",
                 actinide: "Actinide",
             },
+            /** Standard-state phase, keyed by the data file's lowercased `phase` value. */
+            phaseValue: {
+                solid: "Solid",
+                liquid: "Liquid",
+                gas: "Gas",
+            },
         },
         ruler: {
             name: "Ruler",
@@ -448,6 +454,12 @@ const enUS = {
             description: "Strike through answer choices",
             buttonA11y: "Strike Through, eliminate answer choices",
             tooltip: "Strike Through",
+            /** A choice's toggle; `{choice}` is the choice's own accessible name. */
+            toggleA11y: "Toggle elimination for {choice}",
+            /** Appended to an eliminated choice's label for assistive technology. */
+            eliminatedA11y: "(eliminated)",
+            /** Stands in for `{choice}` when a choice has no text of its own. */
+            unlabeledChoice: "Unlabeled choice",
         },
         highlighter: {
             name: "Highlighter",
@@ -476,6 +488,19 @@ const enUS = {
             highlightPinkA11y: "Pink highlight",
             highlightBlueA11y: "Blue highlight",
             highlightGreenA11y: "Green highlight",
+            // Announced in the strip's live region. A colour is authored per phrase:
+            // a colour adjective agrees with its noun in some languages.
+            selectionAvailableA11y: "Annotation toolbar available for “{text}”. Press Shift+F10 for annotation tools.",
+            highlightedYellowA11y: "“{text}” highlighted in yellow",
+            highlightedPinkA11y: "“{text}” highlighted in pink",
+            highlightedBlueA11y: "“{text}” highlighted in blue",
+            highlightedGreenA11y: "“{text}” highlighted in green",
+            underlinedA11y: "“{text}” underlined",
+            removedA11y: "Removed annotation from “{text}”",
+            clearedA11y: {
+                one: "{count} annotation cleared",
+                other: "{count} annotations cleared",
+            },
         },
         theme: {
             name: "Theme",

package/dist/i18n/provider.d.ts

@@ -122,12 +122,9 @@ export declare class SimpleI18n implements I18nServiceApi {
     /** The resolved catalog for a locale, for a host that wants to inspect it. */
     getBundle(locale?: LocaleCode): TranslationBundle | undefined;
     /**
-     * Which shipped catalog serves a requested tag.
-     *
-     * RFC 4647 lookup first, so `nl-BE` reaches `nl-NL` through `nl`; then
-     * primary-subtag widening, so a bare `nl` reaches the regional `nl-NL`
-     * catalog we actually ship. POSIX `nl_NL` normalizes on the way in, which is
-     * the form the Learnosity transform emits.
+     * Which shipped catalog serves a requested tag, under
+     * `findClosestLanguageMatch`. POSIX `nl_NL` normalizes on the way in, which
+     * is the form the Learnosity transform emits.
      */
     private resolveLocaleTag;
     private loadCatalog;

package/dist/i18n/provider.js

@@ -9,7 +9,7 @@
  *
  * @module @pie-players/pie-players-shared/i18n/provider
  */
-import { canonicalLanguageTag, findBestLanguageMatch, normalizeLanguageTag, toLanguageTag, } from "./language-tags.js";
+import { canonicalLanguageTag, findClosestLanguageMatch, normalizeLanguageTag, toLanguageTag, } from "./language-tags.js";
 import enUS from "./messages/en-US.js";
 /** The locale every fallback chain terminates at. */
 export const DEFAULT_LOCALE = "en-US";
@@ -302,24 +302,14 @@ export class SimpleI18n {
         return { locale: tag, translations, direction: localeDirection(tag) };
     }
     /**
-     * Which shipped catalog serves a requested tag.
-     *
-     * RFC 4647 lookup first, so `nl-BE` reaches `nl-NL` through `nl`; then
-     * primary-subtag widening, so a bare `nl` reaches the regional `nl-NL`
-     * catalog we actually ship. POSIX `nl_NL` normalizes on the way in, which is
-     * the form the Learnosity transform emits.
+     * Which shipped catalog serves a requested tag, under
+     * `findClosestLanguageMatch`. POSIX `nl_NL` normalizes on the way in, which
+     * is the form the Learnosity transform emits.
      */
     resolveLocaleTag(locale) {
         if (!locale)
             return undefined;
-        const available = this.getAvailableLocales();
-        const exactOrPrefix = findBestLanguageMatch(locale, available);
-        if (exactOrPrefix)
-            return exactOrPrefix;
-        const requestedLanguage = normalizeLanguageTag(locale).split("-")[0];
-        if (!requestedLanguage)
-            return undefined;
-        return available.find((candidate) => normalizeLanguageTag(candidate).split("-")[0] === requestedLanguage);
+        return findClosestLanguageMatch(locale, this.getAvailableLocales());
     }
     async loadCatalog(locale) {
         const load = this.config.loadCatalog;

package/dist/i18n/types.d.ts

@@ -16,8 +16,13 @@ import type enUS from "./messages/en-US.js";
  * syntax — the Learnosity transform emits POSIX `nl_NL`, QTI catalog cards carry
  * `xml:lang` — and the resolver normalizes both onto these, so this list is the
  * set of catalogs, not the set of accepted inputs.
+ *
+ * `en-US` is the only bundled catalog: the statically resident source of truth
+ * every other locale falls back through. Every other locale this repository
+ * ships lives in the optional generated tier
+ * (`@pie-players/pie-i18n-generated`), which a host composes into its loader.
  */
-export type BundledLocaleCode = "en-US" | "nl-NL";
+export type BundledLocaleCode = "en-US";
 /**
  * Any locale tag. A host may supply a locale we ship no catalog for and provide
  * its own messages through {@link I18nConfig.customMessages}, so this is

package/dist/index.d.ts

@@ -16,6 +16,7 @@ export * from "./ui/pointer-rotate.js";
 export * from "./ui/overlay-containment.js";
 export * from "./ui/overlay-placement.js";
 export * from "./ui/focus-trap.js";
+export * from "./ui/ime.js";
 export * from "./ui/first-focusable.js";
 export * from "./ui/safe-storage.js";
 export * from "./ui/scope-css.js";

package/dist/index.js

@@ -15,6 +15,7 @@ export * from "./ui/pointer-rotate.js";
 export * from "./ui/overlay-containment.js";
 export * from "./ui/overlay-placement.js";
 export * from "./ui/focus-trap.js";
+export * from "./ui/ime.js";
 export * from "./ui/first-focusable.js";
 export * from "./ui/safe-storage.js";
 export * from "./ui/scope-css.js";

package/dist/loaders/ElementLoader.d.ts

@@ -41,4 +41,4 @@ export type ElementMap = {
  * // }
  * ```
  */
-export declare function aggregateElements(items: ItemEntity[]): ElementMap;
+export declare function aggregateElements(items: ReadonlyArray<Pick<ItemEntity, "config">>): ElementMap;

package/dist/loaders/element-loader.d.ts

@@ -88,7 +88,10 @@ export type EnsureRegisteredOptions = {
  *
  * The primitive is the sole authority on registration state:
  * - Empty element map resolves immediately (no backend call).
- * - Already-registered tags resolve immediately (no backend call).
+ * - Already-registered tags resolve immediately (no backend call). A request
+ *   that loads other tags through an IIFE or ESM backend that loads controllers
+ *   also loads its registered tags with no controller, so their controllers
+ *   fill in.
  * - Concurrent identical requests share one backend call.
  * - After the adapter's `load` settles, a post-load verification pass
  *   (bounded `customElements.whenDefined`) checks every tag. Any missing

package/dist/loaders/element-loader.js

@@ -26,7 +26,7 @@ import { parsePackageName } from "../pie/utils.js";
 import { parseVersionedTagName } from "../pie/versioned-tag.js";
 import { AdapterFailure, } from "./element-loader-types.js";
 import { clearPackageMetadataRequests, createEsmBackend, } from "./esm-adapter.js";
-import { createIifeBackend } from "./iife-adapter.js";
+import { createIifeBackend, findIifeElementMapConflict, } from "./iife-adapter.js";
 import { assertElementPackagesAllowed, } from "./element-package-policy.js";
 export { AdapterFailure } from "./element-loader-types.js";
 /**
@@ -125,9 +125,10 @@ function registeredPackageName(tag) {
 }
 const DEFAULT_WHEN_DEFINED_TIMEOUT_MS = 5000;
 const DEFAULT_LOAD_TIMEOUT_MS = DEFAULT_IIFE_BUNDLE_RETRY_CONFIG.timeoutMs;
-// Module-scoped in-flight cache. Key: backend signature + sorted elements.
-// Keeps concurrent identical requests collapsed to one backend call.
+// Requests share a backend call by both the original map and the unresolved
+// subset, so incremental registration does not change an in-flight identity.
 const inFlightRequests = new Map();
+const inFlightKeysByPromise = new Map();
 // An ESM backend keeps page state that later loads build on (the import maps it
 // injected, the shared dependency versions they fixed), so every load with the
 // same config reuses one backend. IIFE backends are created per call.
@@ -139,7 +140,10 @@ const resolvedBackendOverrides = new Map();
  *
  * The primitive is the sole authority on registration state:
  * - Empty element map resolves immediately (no backend call).
- * - Already-registered tags resolve immediately (no backend call).
+ * - Already-registered tags resolve immediately (no backend call). A request
+ *   that loads other tags through an IIFE or ESM backend that loads controllers
+ *   also loads its registered tags with no controller, so their controllers
+ *   fill in.
  * - Concurrent identical requests share one backend call.
  * - After the adapter's `load` settles, a post-load verification pass
  *   (bounded `customElements.whenDefined`) checks every tag. Any missing
@@ -153,30 +157,54 @@ export async function ensureRegistered(elements, options) {
     // Enforce policy before the already-registered fast path: a matching tag in
     // the registry must not turn a disallowed authored package into valid input.
     assertElementPackagesAllowed(elements, options.elementPackagePolicy);
-    const tags = Object.keys(elements);
+    // Preserve the original request identity while tags register mid-flight.
+    const originalDedupKey = buildDedupKey(options.backend, elements);
+    const originalRequest = inFlightRequests.get(originalDedupKey);
+    if (originalRequest)
+        return originalRequest;
+    if (Object.keys(elements).every(isRegistered))
+        return;
+    const loadsControllers = backendLoadsControllers(options.backend);
+    const unresolvedElements = {};
+    for (const [tag, packageSpec] of Object.entries(elements)) {
+        if (!isRegistered(tag) || (loadsControllers && awaitsController(tag))) {
+            unresolvedElements[tag] = packageSpec;
+        }
+    }
+    const tags = Object.keys(unresolvedElements);
     const timeoutMs = options.whenDefinedTimeoutMs ?? DEFAULT_WHEN_DEFINED_TIMEOUT_MS;
     const loadTimeoutMs = options.loadTimeoutMs ?? DEFAULT_LOAD_TIMEOUT_MS;
-    // Fast path: everything already registered. Skip backend and dedup
-    // bookkeeping entirely.
-    if (allAlreadyRegistered(tags))
-        return;
-    const dedupKey = buildDedupKey(options.backend, elements);
+    const dedupKey = buildDedupKey(options.backend, unresolvedElements);
     const existing = inFlightRequests.get(dedupKey);
-    if (existing)
+    if (existing) {
+        aliasInFlightRequest(originalDedupKey, existing);
         return existing;
+    }
     const backend = resolveBackend(options.backend);
     const doc = resolveDoc(options.doc);
-    const promise = runEnsureRegistered(elements, tags, backend, { doc, whenDefinedTimeoutMs: timeoutMs }, timeoutMs, loadTimeoutMs);
-    inFlightRequests.set(dedupKey, promise);
+    const loadElements = isIifeConfig(options.backend)
+        ? iifeLoadElements(elements, unresolvedElements)
+        : unresolvedElements;
+    const promise = runEnsureRegistered(loadElements, tags, backend, { doc, whenDefinedTimeoutMs: timeoutMs }, timeoutMs, loadTimeoutMs);
+    aliasInFlightRequest(originalDedupKey, promise);
+    aliasInFlightRequest(dedupKey, promise);
     try {
         await promise;
     }
     finally {
-        if (inFlightRequests.get(dedupKey) === promise) {
-            inFlightRequests.delete(dedupKey);
+        for (const key of inFlightKeysByPromise.get(promise) ?? []) {
+            if (inFlightRequests.get(key) === promise)
+                inFlightRequests.delete(key);
         }
+        inFlightKeysByPromise.delete(promise);
     }
 }
+function aliasInFlightRequest(key, promise) {
+    inFlightRequests.set(key, promise);
+    const keys = inFlightKeysByPromise.get(promise) ?? new Set();
+    keys.add(key);
+    inFlightKeysByPromise.set(promise, keys);
+}
 async function runEnsureRegistered(elements, tags, backend, context, timeoutMs, loadTimeoutMs) {
     let adapterError;
     try {
@@ -273,13 +301,13 @@ function resolveBackend(backend) {
     if (isDirectBackend(backend))
         return backend;
     if ("kind" in backend) {
+        const backendKey = backendKeyOf(backend);
+        const override = resolvedBackendOverrides.get(backendKey);
+        if (override)
+            return override;
         if (backend.kind === "iife")
             return createIifeBackend(backend);
         if (backend.kind === "esm") {
-            const backendKey = backendKeyOf(backend);
-            const override = resolvedBackendOverrides.get(backendKey);
-            if (override)
-                return override;
             const existing = resolvedEsmBackends.get(backendKey);
             if (existing)
                 return existing;
@@ -415,8 +443,32 @@ function getOpaqueObjectRefId(value) {
     }
     return id;
 }
-function allAlreadyRegistered(tags) {
-    return tags.every((tag) => isRegistered(tag));
+function isIifeConfig(backend) {
+    return !isDirectBackend(backend) && "kind" in backend && backend.kind === "iife";
+}
+/**
+ * An IIFE bundle URL names its packages, so the full map keeps it the URL a
+ * host already fetched. Two specs of one package cannot share a bundle, so a
+ * conflict narrows the map: first to the unresolved tags, then to the undefined.
+ */
+function iifeLoadElements(elements, unresolvedElements) {
+    if (!findIifeElementMapConflict(elements))
+        return elements;
+    if (!findIifeElementMapConflict(unresolvedElements))
+        return unresolvedElements;
+    return Object.fromEntries(Object.entries(unresolvedElements).filter(([tag]) => !isRegistered(tag)));
+}
+function backendLoadsControllers(backend) {
+    if (isDirectBackend(backend) || !("kind" in backend))
+        return false;
+    if (backend.kind === "iife")
+        return backend.needsControllers ?? true;
+    if (backend.kind === "esm")
+        return backend.loadControllers ?? true;
+    return false;
+}
+function awaitsController(tag) {
+    return typeof window !== "undefined" && !pieRegistry()[tag]?.controller;
 }
 function isRegistered(tag) {
     if (typeof customElements === "undefined")
@@ -471,6 +523,7 @@ function extractAdapterReason(err, tag) {
 export const __testing = {
     resetDedupState() {
         inFlightRequests.clear();
+        inFlightKeysByPromise.clear();
         resolvedEsmBackends.clear();
         resolvedBackendOverrides.clear();
         clearPackageMetadataRequests();

package/dist/loaders/iife-adapter.d.ts

@@ -21,6 +21,7 @@
 import type { InstrumentationProvider } from "../instrumentation/types.js";
 import { type IifeBundleRetryConfig } from "../loader-config.js";
 import { BundleType } from "../pie/types.js";
+import type { ElementMap } from "./ElementLoader.js";
 import { type ElementLoaderBackend } from "./element-loader-types.js";
 /**
  * Bundle-build retry status emitted while a bundle is being built or after
@@ -77,4 +78,10 @@ export type IifeBackendConfig = {
     instrumentationProvider?: InstrumentationProvider;
 };
 export type IifeBackend = ElementLoaderBackend & {};
+/**
+ * The legacy IIFE bundle global is keyed by unversioned package name. Two
+ * distinct specs for one package therefore cannot coexist in a single bundle:
+ * one constructor would silently be reused for both requested versioned tags.
+ */
+export declare function findIifeElementMapConflict(elements: ElementMap): string | undefined;
 export declare function createIifeBackend(config: IifeBackendConfig): IifeBackend;

package/dist/loaders/iife-adapter.js

@@ -31,7 +31,7 @@ import { AdapterFailure, } from "./element-loader-types.js";
  * distinct specs for one package therefore cannot coexist in a single bundle:
  * one constructor would silently be reused for both requested versioned tags.
  */
-function findIifeElementMapConflict(elements) {
+export function findIifeElementMapConflict(elements) {
     const specsByPackageName = new Map();
     for (const packageSpecValue of Object.values(elements)) {
         const packageSpec = String(packageSpecValue);

package/dist/security/private-hosts.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Hostname classification for a URL a server fetches on someone else's behalf,
+ * such as an SSML `<audio src>` a TTS provider will request or an asset URL an
+ * upstream service returns. Every such check reads this module, so no two
+ * copies of it can drift apart.
+ *
+ * IP literals are classified by `ipaddr.js`, whose ranges follow the IANA IPv4
+ * and IPv6 Special-Purpose Address Registries (RFC 6890). A host is private
+ * unless it is a public unicast address or a name: loopback, private, link-local,
+ * unique-local, carrier-grade NAT, multicast, broadcast, documentation and
+ * reserved ranges, and the IPv6 forms that embed an IPv4 address (NAT64, 6to4,
+ * Teredo), all count. `ipaddr.js` also reads the numeric IPv4 forms (`2130706433`,
+ * `0x7f000001`, `0177.0.0.1`) and unmaps IPv4-mapped IPv6.
+ *
+ * Only the literal is checked. A public name that resolves to a private address
+ * passes; guarding that takes a check of the resolved address at connect time.
+ *
+ * @module
+ */
+/** Whether `hostname` is a cloud instance-metadata endpoint. */
+export declare function isCloudMetadataHostname(hostname: string): boolean;
+/**
+ * Whether `hostname` is anything other than a public unicast address or a
+ * public name: `localhost` and its subdomains (RFC 6761), or an IP literal in
+ * any special-purpose range.
+ */
+export declare function isPrivateHostname(hostname: string): boolean;

package/dist/security/private-hosts.js

@@ -0,0 +1,85 @@
+/**
+ * Hostname classification for a URL a server fetches on someone else's behalf,
+ * such as an SSML `<audio src>` a TTS provider will request or an asset URL an
+ * upstream service returns. Every such check reads this module, so no two
+ * copies of it can drift apart.
+ *
+ * IP literals are classified by `ipaddr.js`, whose ranges follow the IANA IPv4
+ * and IPv6 Special-Purpose Address Registries (RFC 6890). A host is private
+ * unless it is a public unicast address or a name: loopback, private, link-local,
+ * unique-local, carrier-grade NAT, multicast, broadcast, documentation and
+ * reserved ranges, and the IPv6 forms that embed an IPv4 address (NAT64, 6to4,
+ * Teredo), all count. `ipaddr.js` also reads the numeric IPv4 forms (`2130706433`,
+ * `0x7f000001`, `0177.0.0.1`) and unmaps IPv4-mapped IPv6.
+ *
+ * Only the literal is checked. A public name that resolves to a private address
+ * passes; guarding that takes a check of the resolved address at connect time.
+ *
+ * @module
+ */
+import ipaddr from "ipaddr.js";
+/**
+ * Cloud instance-metadata hostnames. They hand out credentials. No registry
+ * lists them; each is the provider's documented name.
+ */
+const CLOUD_METADATA_HOSTNAMES = new Set([
+    "metadata.google.internal",
+    "metadata.azure.internal",
+    "metadata.packet.net",
+    "metadata.oci.oraclecloud.com",
+]);
+/** Cloud instance-metadata addresses: the link-local one most clouds use, and AWS's IPv6 one. */
+const CLOUD_METADATA_ADDRESSES = ["169.254.169.254", "fd00:ec2::254"].map((address) => ipaddr.parse(address));
+/** Lower-cased, without brackets or a trailing dot. */
+function normalizeHostname(hostname) {
+    return hostname
+        .replace(/^\[|\]$/g, "")
+        .replace(/\.$/, "")
+        .toLowerCase();
+}
+/**
+ * The address `host` is a literal for, IPv4-mapped (`::ffff:a.b.c.d`) and
+ * IPv4-compatible (`::a.b.c.d`) IPv6 reduced to IPv4, or `null` for a name.
+ */
+function parseAddress(host) {
+    if (!ipaddr.isValid(host))
+        return null;
+    const address = ipaddr.process(host);
+    if (address.kind() !== "ipv6")
+        return address;
+    // `ipaddr.js` classifies deprecated IPv4-compatible addresses as unicast;
+    // read the IPv4 address in their low 32 bits instead.
+    const { parts } = address;
+    const isIpv4Compatible = parts.slice(0, 6).every((part) => part === 0) &&
+        (parts[6] !== 0 || parts[7] > 1);
+    return isIpv4Compatible
+        ? new ipaddr.IPv4([
+            parts[6] >> 8,
+            parts[6] & 0xff,
+            parts[7] >> 8,
+            parts[7] & 0xff,
+        ])
+        : address;
+}
+/** Whether `hostname` is a cloud instance-metadata endpoint. */
+export function isCloudMetadataHostname(hostname) {
+    const host = normalizeHostname(hostname);
+    if (CLOUD_METADATA_HOSTNAMES.has(host))
+        return true;
+    const address = parseAddress(host);
+    return (address !== null &&
+        CLOUD_METADATA_ADDRESSES.some((metadata) => metadata.kind() === address.kind() &&
+            metadata.toNormalizedString() === address.toNormalizedString()));
+}
+/**
+ * Whether `hostname` is anything other than a public unicast address or a
+ * public name: `localhost` and its subdomains (RFC 6761), or an IP literal in
+ * any special-purpose range.
+ */
+export function isPrivateHostname(hostname) {
+    const host = normalizeHostname(hostname);
+    if (host === "localhost" || host.endsWith(".localhost"))
+        return true;
+    const address = parseAddress(host);
+    return address !== null && address.range() !== "unicast";
+}

package/dist/security/validate-style-url.js

@@ -30,11 +30,11 @@ export function validateExternalStyleUrl(url, options = {}) {
             ? new URL(url, options.baseUrl)
             : new URL(url);
     }
-    catch (err) {
+    catch {
         return {
             ok: false,
             reason: "invalid-url",
-            message: `External stylesheet URL could not be parsed: ${String(err)}`,
+            message: "External stylesheet URL could not be parsed.",
         };
     }
     if (resolvedUrl.protocol !== "http:" && resolvedUrl.protocol !== "https:") {

package/dist/tools/term-lookup.d.ts

@@ -13,6 +13,7 @@
  * corpus behind one is licensed per programme, so a host supplies either an endpoint
  * or a resolver of its own.
  */
+import type { TextDirection } from "../i18n/types.js";
 /** What a host's term service is asked for. */
 export interface TermLookupRequest {
     /** The term, already normalised by {@link normalizeTerm}. */
@@ -187,3 +188,17 @@ export declare function termPanelStatusMessage<TItem>(state: TermPanelState<TIte
     countLabel: (count: number) => string;
     emptyLabel: (term: string) => string;
 }): string;
+/**
+ * `lang` and `dir` for a lookup's results: the language the lookup asked in.
+ *
+ * Results are in the corpus's language, which is neither the panel's interface
+ * locale nor necessarily the content the term came from: a Spanish gloss for an
+ * English passage. Stamped on the results, an Arabic definition in an English panel
+ * reads and lays out as Arabic, and the panel's language never reaches the content.
+ * With no language named the corpus's is unknown, so the stamp is `lang=""` and
+ * `dir="auto"`, the one undeclared content gets.
+ */
+export declare function termResultLanguage(language: string | undefined): {
+    lang: string;
+    dir: TextDirection | "auto";
+};

package/dist/tools/term-lookup.js

@@ -13,6 +13,8 @@
  * corpus behind one is licensed per programme, so a host supplies either an endpoint
  * or a resolver of its own.
  */
+import { toLanguageTag } from "../i18n/language-tags.js";
+import { localeDirection } from "../i18n/provider.js";
 /** Longest term worth sending. Past this it is prose, not a headword. */
 export const MAX_LOOKUP_TERM_LENGTH = 80;
 /** Words a term may span. Generous enough for `carbon dioxide` and `mother in law`. */
@@ -282,3 +284,17 @@ export function termPanelStatusMessage(state, labels) {
         return labels.emptyLabel(state.term);
     return "";
 }
+/**
+ * `lang` and `dir` for a lookup's results: the language the lookup asked in.
+ *
+ * Results are in the corpus's language, which is neither the panel's interface
+ * locale nor necessarily the content the term came from: a Spanish gloss for an
+ * English passage. Stamped on the results, an Arabic definition in an English panel
+ * reads and lays out as Arabic, and the panel's language never reaches the content.
+ * With no language named the corpus's is unknown, so the stamp is `lang=""` and
+ * `dir="auto"`, the one undeclared content gets.
+ */
+export function termResultLanguage(language) {
+    const tag = toLanguageTag(language);
+    return tag ? { lang: tag, dir: localeDirection(tag) } : { lang: "", dir: "auto" };
+}