@generative-a11y/dom 0.0.0

package/dist/index.js

@@ -0,0 +1,976 @@
+// src/composed-tree.ts
+function deepActiveElement(document2) {
+  let active = document2.activeElement;
+  const visited = /* @__PURE__ */ new Set();
+  while (active) {
+    if (visited.has(active)) throw new Error("Cyclic active element");
+    visited.add(active);
+    const shadow = active.shadowRoot;
+    const nested = shadow?.activeElement;
+    if (!nested) return active;
+    active = nested;
+  }
+  return null;
+}
+function composedContains(ancestor, target) {
+  let current = target;
+  const visited = /* @__PURE__ */ new Set();
+  while (current) {
+    if (current === ancestor) return true;
+    if (visited.has(current)) throw new Error("Cyclic composed tree");
+    visited.add(current);
+    current = composedParent(current);
+  }
+  return false;
+}
+function composedParent(element) {
+  const assignedSlot = element.assignedSlot;
+  if (assignedSlot) return assignedSlot;
+  if (element.parentElement) return element.parentElement;
+  const root = element.getRootNode();
+  if (root && "host" in root) {
+    const host = root.host;
+    if (host.ownerDocument === element.ownerDocument) return host;
+  }
+  return null;
+}
+
+// src/attention.ts
+var UNKNOWN_SNAPSHOT = Object.freeze({
+  visibility: "unknown",
+  windowFocus: "unknown",
+  focusArea: "unknown",
+  newestResponse: "unknown",
+  mode: "unknown"
+});
+function createAttentionStore(options = {}) {
+  const selectedDocument = options.document ?? (typeof document === "undefined" ? void 0 : document);
+  if (!selectedDocument) {
+    return {
+      subscribe: () => () => void 0,
+      getSnapshot: () => UNKNOWN_SNAPSHOT,
+      getServerSnapshot: () => UNKNOWN_SNAPSHOT,
+      registerComposer: () => () => void 0,
+      registerConversation: () => () => void 0,
+      registerNewestResponse: () => () => void 0,
+      dispose: () => void 0
+    };
+  }
+  const listeners = /* @__PURE__ */ new Set();
+  const composers = /* @__PURE__ */ new Map();
+  const conversations = /* @__PURE__ */ new Map();
+  const selectedWindow = selectedDocument.defaultView;
+  let disposed = false;
+  let newestTarget;
+  let newestResult = "unobserved";
+  let newestRegistration = 0;
+  let observer;
+  let snapshot = makeSnapshot(
+    selectedDocument,
+    composers,
+    conversations,
+    newestResult
+  );
+  const update = () => {
+    if (disposed) return;
+    const next = makeSnapshot(
+      selectedDocument,
+      composers,
+      conversations,
+      newestResult
+    );
+    if (sameSnapshot(snapshot, next)) return;
+    snapshot = next;
+    for (const listener of [...listeners]) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  };
+  const handleFocusOut = (event) => {
+    if (event.relatedTarget === null) update();
+  };
+  const listenerCleanups = [];
+  const installListener = (install, cleanup) => {
+    listenerCleanups.push(cleanup);
+    install();
+  };
+  const cleanupListeners = () => {
+    for (const cleanup of listenerCleanups.splice(0).reverse()) {
+      try {
+        cleanup();
+      } catch {
+      }
+    }
+  };
+  try {
+    installListener(
+      () => selectedDocument.addEventListener("visibilitychange", update),
+      () => selectedDocument.removeEventListener("visibilitychange", update)
+    );
+    if (selectedWindow) {
+      installListener(
+        () => selectedWindow.addEventListener("focus", update),
+        () => selectedWindow.removeEventListener("focus", update)
+      );
+      installListener(
+        () => selectedWindow.addEventListener("blur", update),
+        () => selectedWindow.removeEventListener("blur", update)
+      );
+    }
+    installListener(
+      () => selectedDocument.addEventListener("focusin", update),
+      () => selectedDocument.removeEventListener("focusin", update)
+    );
+    installListener(
+      () => selectedDocument.addEventListener("focusout", handleFocusOut),
+      () => selectedDocument.removeEventListener("focusout", handleFocusOut)
+    );
+  } catch (error) {
+    cleanupListeners();
+    throw error;
+  }
+  const register = (elements, element) => {
+    if (disposed) throw new Error("AttentionStore is disposed");
+    elements.set(element, (elements.get(element) ?? 0) + 1);
+    update();
+    let registered = true;
+    return () => {
+      if (!registered) return;
+      registered = false;
+      const remaining = (elements.get(element) ?? 1) - 1;
+      if (remaining === 0) elements.delete(element);
+      else elements.set(element, remaining);
+      update();
+    };
+  };
+  const createObserver = (registration, target) => {
+    const factory = options.createIntersectionObserver ?? defaultIntersectionObserverFactory(selectedWindow);
+    if (!factory) return void 0;
+    let created;
+    try {
+      created = factory((entries) => {
+        if (disposed || registration !== newestRegistration || newestTarget !== target || observer !== created) {
+          return;
+        }
+        let latest;
+        for (const entry of entries) {
+          if (entry.target === target) latest = entry;
+        }
+        if (!latest) return;
+        newestResult = latest.isIntersecting ? "visible" : "outside";
+        update();
+      }, options.intersectionObserverInit);
+      created.observe(target);
+      return created;
+    } catch {
+      cleanupObserver(created, target);
+      return void 0;
+    }
+  };
+  const stopObserver = (target) => {
+    const current = observer;
+    observer = void 0;
+    cleanupObserver(current, target);
+  };
+  return {
+    subscribe(listener) {
+      if (disposed) throw new Error("AttentionStore is disposed");
+      listeners.add(listener);
+      let subscribed = true;
+      return () => {
+        if (!subscribed) return;
+        subscribed = false;
+        listeners.delete(listener);
+      };
+    },
+    getSnapshot: () => snapshot,
+    getServerSnapshot: () => UNKNOWN_SNAPSHOT,
+    registerComposer: (element) => register(composers, element),
+    registerConversation: (element) => register(conversations, element),
+    registerNewestResponse(element) {
+      if (disposed) throw new Error("AttentionStore is disposed");
+      const registration = ++newestRegistration;
+      stopObserver(newestTarget);
+      newestTarget = element;
+      newestResult = "unknown";
+      observer = createObserver(registration, element);
+      update();
+      let registered = true;
+      return () => {
+        if (!registered) return;
+        registered = false;
+        if (registration !== newestRegistration || newestTarget !== element)
+          return;
+        stopObserver(element);
+        newestTarget = void 0;
+        newestResult = "unobserved";
+        update();
+      };
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      listeners.clear();
+      composers.clear();
+      conversations.clear();
+      stopObserver(newestTarget);
+      newestTarget = void 0;
+      cleanupListeners();
+    }
+  };
+}
+function makeSnapshot(document2, composers, conversations, newestResponse) {
+  const visibility = readVisibility(document2);
+  const windowFocus = readWindowFocus(document2);
+  return Object.freeze({
+    visibility,
+    windowFocus,
+    focusArea: readFocusArea(document2, composers, conversations),
+    newestResponse,
+    mode: deriveMode(visibility, windowFocus, newestResponse)
+  });
+}
+function deriveMode(visibility, windowFocus, newestResponse) {
+  if (visibility === "hidden") return "background";
+  if (visibility !== "visible") return "unknown";
+  if (windowFocus === "blurred") return "away";
+  if (windowFocus !== "focused") return "unknown";
+  if (newestResponse === "outside") return "reading-history";
+  if (newestResponse === "visible") return "foreground";
+  return "unknown";
+}
+function defaultIntersectionObserverFactory(window2) {
+  const Constructor = window2?.IntersectionObserver;
+  if (typeof Constructor !== "function") return void 0;
+  return (callback, options) => new Constructor(callback, options);
+}
+function cleanupObserver(observer, target) {
+  if (!observer) return;
+  if (target) {
+    try {
+      observer.unobserve(target);
+    } catch {
+    }
+  }
+  try {
+    observer.disconnect();
+  } catch {
+  }
+}
+function readFocusArea(document2, composers, conversations) {
+  let activeElement;
+  try {
+    activeElement = deepActiveElement(document2);
+  } catch {
+    return "unknown";
+  }
+  if (activeElement === null || activeElement === document2.body || activeElement === document2.documentElement) {
+    return "none";
+  }
+  if ([...composers.keys()].some(
+    (element) => composedContains(element, activeElement)
+  )) {
+    return "composer";
+  }
+  if ([...conversations.keys()].some(
+    (element) => composedContains(element, activeElement)
+  )) {
+    return "conversation";
+  }
+  return "elsewhere";
+}
+function readVisibility(document2) {
+  try {
+    if (document2.visibilityState === "visible") return "visible";
+    if (document2.visibilityState === "hidden") return "hidden";
+  } catch {
+  }
+  return "unknown";
+}
+function readWindowFocus(document2) {
+  try {
+    if (typeof document2.hasFocus !== "function") return "unknown";
+    return document2.hasFocus() ? "focused" : "blurred";
+  } catch {
+    return "unknown";
+  }
+}
+function sameSnapshot(left, right) {
+  return left.visibility === right.visibility && left.windowFocus === right.windowFocus && left.focusArea === right.focusArea && left.newestResponse === right.newestResponse && left.mode === right.mode;
+}
+
+// src/focus.ts
+function captureFocus(selectedDocument) {
+  const document2 = selectedDocument ?? (typeof globalThis.document === "undefined" ? void 0 : globalThis.document);
+  if (!document2) return Object.freeze({ document: null, target: null });
+  let target = null;
+  try {
+    const active = deepActiveElement(document2);
+    if (active !== null && active !== document2.body && active !== document2.documentElement && active.ownerDocument === document2) {
+      target = active;
+    }
+  } catch {
+  }
+  return Object.freeze({ document: document2, target });
+}
+function focusElement(target, options = {}) {
+  const eligibility = focusEligibility(target);
+  if (eligibility) {
+    return { status: "skipped", reason: eligibility, target };
+  }
+  let focus;
+  let document2;
+  let previous;
+  try {
+    document2 = target.ownerDocument;
+    previous = deepActiveElement(document2);
+    focus = target.focus;
+  } catch {
+    return { status: "skipped", reason: "unavailable", target };
+  }
+  if (typeof focus !== "function") {
+    return { status: "skipped", reason: "missing-focus", target };
+  }
+  let focusThrew = false;
+  try {
+    focus.call(target, { preventScroll: options.preventScroll ?? true });
+  } catch {
+    focusThrew = true;
+  }
+  if (focusThrew) {
+    restorePreviousFocus(previous, target, document2);
+    return { status: "skipped", reason: "focus-error", target };
+  }
+  const postFocusEligibility = focusEligibility(target);
+  let active;
+  try {
+    active = deepActiveElement(document2);
+  } catch {
+    return { status: "skipped", reason: "focus-error", target };
+  }
+  if (postFocusEligibility) {
+    if (active === target) restorePreviousFocus(previous, target, document2);
+    return { status: "skipped", reason: postFocusEligibility, target };
+  }
+  if (active !== target) {
+    return { status: "skipped", reason: "focus-not-applied", target };
+  }
+  return { status: "focused", target };
+}
+function restoreFocus(capture, options = {}) {
+  let document2;
+  let target;
+  try {
+    document2 = capture.document;
+    target = capture.target;
+  } catch {
+    return { status: "skipped", reason: "unavailable", target: null };
+  }
+  if (!document2 || !target) {
+    return { status: "skipped", reason: "unavailable", target: null };
+  }
+  try {
+    if (target.ownerDocument !== document2) {
+      return { status: "skipped", reason: "cross-document", target };
+    }
+    const guard = options.onlyIfFocusWithin;
+    if (guard !== void 0) {
+      const active = deepActiveElement(document2);
+      if (guard.ownerDocument !== document2 || active === null || !composedContains(guard, active)) {
+        return { status: "skipped", reason: "guard-mismatch", target };
+      }
+    }
+  } catch {
+    return { status: "skipped", reason: "guard-mismatch", target };
+  }
+  return focusElement(target, options);
+}
+function focusEligibility(target) {
+  let ownerDocument;
+  try {
+    ownerDocument = target.ownerDocument;
+    const ElementConstructor = ownerDocument.defaultView?.Element;
+    if (!ownerDocument || ElementConstructor && !(target instanceof ElementConstructor)) {
+      return "unavailable";
+    }
+    if (target.isConnected !== true) return "disconnected";
+    if (target.getAttribute("disabled") !== null || target.disabled === true) {
+      return "disabled";
+    }
+  } catch {
+    return "unavailable";
+  }
+  try {
+    const matches = target.matches;
+    if (typeof matches === "function" && matches.call(target, ":disabled")) {
+      return "disabled";
+    }
+  } catch {
+  }
+  try {
+    let current = target;
+    const visited = /* @__PURE__ */ new Set();
+    while (current) {
+      if (visited.has(current)) return "unavailable";
+      visited.add(current);
+      if (current.hasAttribute("hidden")) return "hidden";
+      if (current.getAttribute("aria-hidden")?.trim().toLowerCase() === "true")
+        return "aria-hidden";
+      if (current.hasAttribute("inert") || current.inert === true) {
+        return "inert";
+      }
+      current = composedParent(current);
+    }
+  } catch {
+    return "unavailable";
+  }
+  try {
+    const focus = target.focus;
+    if (typeof focus !== "function") return "missing-focus";
+  } catch {
+    return "unavailable";
+  }
+  return void 0;
+}
+function restorePreviousFocus(previous, attempted, document2) {
+  try {
+    if (!previous || deepActiveElement(document2) !== attempted || focusEligibility(previous) !== void 0) {
+      return;
+    }
+    const focus = previous.focus;
+    if (typeof focus === "function")
+      focus.call(previous, { preventScroll: true });
+  } catch {
+  }
+}
+
+// src/preferences.ts
+var defaultPreferences = Object.freeze({
+  version: 1,
+  preset: "balanced",
+  streaming: "preset",
+  tools: "preset"
+});
+function preferencesToCoreConfiguration(value) {
+  const preferences = normalizePreferences(value);
+  if (preferences.preset === "completion-only") {
+    return { preset: "completion-only" };
+  }
+  const policy = {};
+  const text = mapStreaming(preferences.streaming);
+  const tools = mapTools(preferences.tools);
+  if (text) policy.text = text;
+  if (tools) policy.tools = tools;
+  return Object.keys(policy).length === 0 ? { preset: preferences.preset } : { preset: preferences.preset, policy };
+}
+function createPreferenceStore(options = {}) {
+  const configuredDefault = options.defaultValue ? normalizePreferences(options.defaultValue) : defaultPreferences;
+  const persistence = resolvePersistence(options.persistence);
+  const report = (source, code, cause) => {
+    const diagnostic = {
+      source,
+      code,
+      ...cause === void 0 ? {} : { error: serializeError(cause) }
+    };
+    try {
+      options.onDiagnostic?.(diagnostic);
+    } catch {
+    }
+  };
+  let current = configuredDefault;
+  if (persistence?.storage) {
+    try {
+      const stored = persistence.storage.getItem(persistence.key);
+      if (stored !== null) {
+        current = parsePreferences(stored, "storage-read", report) ?? current;
+      }
+    } catch (cause) {
+      report("storage-read", "operation-failed", cause);
+    }
+  }
+  let disposed = false;
+  let eventEpoch = 0;
+  const listeners = /* @__PURE__ */ new Set();
+  let unsubscribeEvents;
+  const notify = () => {
+    for (const listener of [...listeners]) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  };
+  const replace = (next) => {
+    if (samePreferences(current, next)) return false;
+    current = next;
+    notify();
+    return true;
+  };
+  const handleStorageEvent = (event) => {
+    if (disposed || !persistence) return;
+    const epoch = ++eventEpoch;
+    let key;
+    let newValue;
+    let storageArea;
+    try {
+      key = event.key;
+      newValue = event.newValue;
+      storageArea = event.storageArea;
+    } catch (cause) {
+      if (!disposed && epoch === eventEpoch) {
+        report("storage-event", "operation-failed", cause);
+      }
+      return;
+    }
+    if (disposed || epoch !== eventEpoch) return;
+    try {
+      if (storageArea != null && storageArea !== persistence.storage) {
+        return;
+      }
+      if (key !== null && key !== persistence.key) return;
+      if (key === null || newValue === null) {
+        replace(configuredDefault);
+        return;
+      }
+      const next = parsePreferences(newValue, "storage-event", report);
+      if (!disposed && epoch === eventEpoch && next) replace(next);
+    } catch (cause) {
+      if (!disposed && epoch === eventEpoch) {
+        report("storage-event", "operation-failed", cause);
+      }
+    }
+  };
+  if (persistence?.events) {
+    try {
+      unsubscribeEvents = persistence.events.subscribe(handleStorageEvent);
+    } catch (cause) {
+      report("event-subscribe", "operation-failed", cause);
+    }
+  }
+  return {
+    subscribe(listener) {
+      if (disposed) throw new Error("PreferenceStore is disposed");
+      listeners.add(listener);
+      let subscribed = true;
+      return () => {
+        if (!subscribed) return;
+        subscribed = false;
+        listeners.delete(listener);
+      };
+    },
+    getSnapshot: () => current,
+    getServerSnapshot: () => configuredDefault,
+    setPreferences(value) {
+      if (disposed) throw new Error("PreferenceStore is disposed");
+      const next = normalizePreferences(value);
+      const changed = replace(next);
+      if (!disposed && persistence?.storage && samePreferences(current, next)) {
+        const serialized = JSON.stringify(next);
+        if (!changed) {
+          const epoch = eventEpoch;
+          let matchesStoredValue = false;
+          try {
+            matchesStoredValue = persistence.storage.getItem(persistence.key) === serialized;
+          } catch (cause) {
+            report("storage-read", "operation-failed", cause);
+          }
+          if (matchesStoredValue || disposed || epoch !== eventEpoch || !samePreferences(current, next)) {
+            return;
+          }
+        }
+        if (disposed || !samePreferences(current, next)) return;
+        try {
+          persistence.storage.setItem(persistence.key, serialized);
+        } catch (cause) {
+          report("storage-write", "operation-failed", cause);
+        }
+      }
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      eventEpoch += 1;
+      listeners.clear();
+      const unsubscribe = unsubscribeEvents;
+      unsubscribeEvents = void 0;
+      if (unsubscribe) {
+        try {
+          unsubscribe();
+        } catch (cause) {
+          report("event-unsubscribe", "operation-failed", cause);
+        }
+      }
+    }
+  };
+}
+function resolvePersistence(persistence) {
+  if (!persistence) return void 0;
+  if (persistence.storage) return persistence;
+  const browser = getBrowserPersistence();
+  return {
+    key: persistence.key,
+    ...browser?.storage ? { storage: browser.storage } : {},
+    ...persistence.events ? { events: persistence.events } : browser?.events ? { events: browser.events } : {}
+  };
+}
+function getBrowserPersistence() {
+  if (typeof window === "undefined") return void 0;
+  try {
+    const browserWindow = window;
+    const storage = browserWindow.localStorage;
+    if (!storage) return void 0;
+    return {
+      storage,
+      events: {
+        subscribe(listener) {
+          const handle = (event) => listener(event);
+          browserWindow.addEventListener("storage", handle);
+          return () => browserWindow.removeEventListener("storage", handle);
+        }
+      }
+    };
+  } catch {
+    return void 0;
+  }
+}
+function parsePreferences(raw, source, report) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch (cause) {
+    report(source, "invalid-json", cause);
+    return void 0;
+  }
+  try {
+    return normalizePreferences(value);
+  } catch (cause) {
+    report(
+      source,
+      cause instanceof UnsupportedPreferenceVersionError ? "unsupported-version" : "invalid-preference",
+      cause
+    );
+    return void 0;
+  }
+}
+var UnsupportedPreferenceVersionError = class extends TypeError {
+};
+function normalizePreferences(value) {
+  const fields = snapshotPreferenceFields(value);
+  if (fields.version !== 1)
+    throw new UnsupportedPreferenceVersionError(
+      "Unsupported preference version"
+    );
+  if (fields.preset === "completion-only") {
+    if (!hasExactKeys(fields, ["version", "preset"]))
+      throw new TypeError("Invalid completion-only preferences");
+    return Object.freeze({ version: 1, preset: "completion-only" });
+  }
+  if (!["minimal", "balanced", "verbose"].includes(fields.preset))
+    throw new TypeError("Invalid preference preset");
+  if (!hasExactKeys(fields, ["version", "preset", "streaming", "tools"]))
+    throw new TypeError("Invalid preference fields");
+  if (!STREAMING_VALUES.includes(fields.streaming))
+    throw new TypeError("Invalid streaming preference");
+  if (!TOOL_VALUES.includes(fields.tools))
+    throw new TypeError("Invalid tool preference");
+  return Object.freeze({
+    version: 1,
+    preset: fields.preset,
+    streaming: fields.streaming,
+    tools: fields.tools
+  });
+}
+var STREAMING_VALUES = [
+  "preset",
+  "off",
+  "completion",
+  "paragraph",
+  "sentence"
+];
+var TOOL_VALUES = [
+  "preset",
+  "off",
+  "failures",
+  "status",
+  "progress"
+];
+function snapshotPreferenceFields(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError("Invalid preferences");
+  }
+  try {
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const fields = /* @__PURE__ */ Object.create(null);
+    for (const key of Reflect.ownKeys(descriptors)) {
+      if (typeof key !== "string")
+        throw new TypeError("Invalid preference fields");
+      const descriptor = descriptors[key];
+      if (!descriptor?.enumerable || !("value" in descriptor)) {
+        throw new TypeError(
+          "Preference fields must be enumerable data properties"
+        );
+      }
+      fields[key] = descriptor.value;
+    }
+    return fields;
+  } catch {
+    throw new TypeError("Invalid preferences");
+  }
+}
+function hasExactKeys(value, expected) {
+  const keys = Object.keys(value);
+  return keys.length === expected.length && expected.every((key) => keys.includes(key));
+}
+function samePreferences(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function mapStreaming(value) {
+  if (value === "preset") return void 0;
+  if (value === "off") return { strategy: "silent" };
+  if (value === "completion")
+    return { strategy: "completion", minimumCharacters: 0, maximumDelayMs: 0 };
+  return { strategy: value };
+}
+function mapTools(value) {
+  if (value === "preset") return void 0;
+  return {
+    announceStart: value === "status" || value === "progress",
+    announceProgress: value === "progress",
+    announceCompletion: value === "status" || value === "progress",
+    announceFailure: value !== "off"
+  };
+}
+function serializeError(cause) {
+  const fallback = { name: "Error", message: "Unknown error" };
+  try {
+    if (cause instanceof Error) {
+      const name = cause.name;
+      const message = cause.message;
+      if (typeof name !== "string" || typeof message !== "string") {
+        return fallback;
+      }
+      return { name: name || "Error", message };
+    }
+    if (typeof cause === "string" || typeof cause === "number" || typeof cause === "boolean" || typeof cause === "bigint" || typeof cause === "symbol") {
+      return { name: "Error", message: String(cause) };
+    }
+  } catch {
+    return fallback;
+  }
+  return fallback;
+}
+
+// src/index.ts
+function createDOMAnnouncer(options = {}) {
+  validateSuppliedRegions(options);
+  const selectedDocument = options.document ?? options.regions?.polite.ownerDocument ?? (typeof document === "undefined" ? void 0 : document);
+  const ownsRegions = options.regions === void 0;
+  const regions = options.regions ?? createLiveRegions(selectedDocument);
+  if (regions) {
+    configureRegion(regions.polite, "polite");
+    configureRegion(regions.assertive, "assertive");
+  }
+  let notifierEnabled = true;
+  let disposed = false;
+  const report = (result) => {
+    try {
+      options.onDiagnostic?.(result);
+    } catch {
+    }
+    return result;
+  };
+  return {
+    announce(intent) {
+      if (disposed) {
+        return report({
+          status: "disposed",
+          method: "none",
+          channel: intent.channel
+        });
+      }
+      if (regions) {
+        const region = regions[intent.channel];
+        applyLocale(region, intent.locale);
+        let error;
+        if (notifierEnabled && options.mode !== "live-region") {
+          let notified = false;
+          try {
+            const ariaNotify = region.ariaNotify;
+            if (typeof ariaNotify === "function") {
+              ariaNotify.call(region, intent.text, {
+                priority: intent.channel === "assertive" ? "high" : "normal"
+              });
+              notified = true;
+            }
+          } catch (cause) {
+            notifierEnabled = false;
+            error = serializeError2(cause);
+          }
+          if (notified) {
+            return report({
+              status: "notified",
+              method: "aria-notify",
+              channel: intent.channel
+            });
+          }
+        }
+        region.textContent = intent.text;
+        return report({
+          status: "mutated",
+          method: "live-region",
+          channel: intent.channel,
+          ...error === void 0 ? {} : { error }
+        });
+      }
+      return report({
+        status: "unavailable",
+        method: "none",
+        channel: intent.channel
+      });
+    },
+    getRegions() {
+      return regions;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      if (ownsRegions) {
+        regions?.polite.remove();
+        regions?.assertive.remove();
+      }
+    }
+  };
+}
+function validateSuppliedRegions(options) {
+  if (options.regions === void 0) return;
+  const { polite, assertive } = options.regions;
+  if (polite === assertive) {
+    throw new TypeError(
+      "Polite and assertive regions must be distinct elements"
+    );
+  }
+  if (!polite.isConnected || !assertive.isConnected) {
+    throw new TypeError("Supplied regions must be connected");
+  }
+  if (polite.contains(assertive) || assertive.contains(polite)) {
+    throw new TypeError(
+      "Polite and assertive regions must not contain one another"
+    );
+  }
+  if (polite.ownerDocument !== assertive.ownerDocument) {
+    throw new TypeError(
+      "Polite and assertive regions must belong to the same document"
+    );
+  }
+  if (options.document !== void 0 && (polite.ownerDocument !== options.document || assertive.ownerDocument !== options.document)) {
+    throw new TypeError(
+      "Supplied regions must belong to the provided document"
+    );
+  }
+}
+function serializeError2(error) {
+  try {
+    if (error instanceof Error) {
+      return {
+        name: readErrorString(error, "name", "Error"),
+        message: readErrorString(error, "message", "Unknown error")
+      };
+    }
+  } catch {
+  }
+  return { name: "Error", message: safeString(error, "Unknown error") };
+}
+function readErrorString(error, property, fallback) {
+  try {
+    return safeString(error[property], fallback);
+  } catch {
+    return fallback;
+  }
+}
+function safeString(value, fallback) {
+  try {
+    return String(value);
+  } catch {
+    return fallback;
+  }
+}
+function createLiveRegions(selectedDocument) {
+  const parent = selectedDocument?.body ?? selectedDocument?.documentElement;
+  if (!selectedDocument || !parent) return void 0;
+  const regions = {
+    polite: selectedDocument.createElement("div"),
+    assertive: selectedDocument.createElement("div")
+  };
+  parent.append(regions.polite, regions.assertive);
+  return regions;
+}
+function configureRegion(region, channel) {
+  region.removeAttribute("role");
+  region.removeAttribute("aria-busy");
+  region.removeAttribute("hidden");
+  region.removeAttribute("aria-hidden");
+  region.inert = false;
+  region.removeAttribute("inert");
+  region.style.removeProperty("display");
+  region.style.removeProperty("visibility");
+  region.style.removeProperty("content-visibility");
+  region.setAttribute("aria-live", channel);
+  region.setAttribute("aria-atomic", "true");
+  region.setAttribute("aria-relevant", "additions text");
+  Object.assign(region.style, {
+    position: "absolute",
+    width: "1px",
+    height: "1px",
+    padding: "0",
+    margin: "-1px",
+    overflow: "hidden",
+    clip: "rect(0, 0, 0, 0)",
+    whiteSpace: "nowrap",
+    border: "0"
+  });
+}
+function applyLocale(region, locale) {
+  if (locale === void 0) region.removeAttribute("lang");
+  else region.setAttribute("lang", locale);
+}
+function connectRuntimeToDOM(runtime, options = {}) {
+  const announcer = createDOMAnnouncer(options);
+  let disposed = false;
+  let unsubscribe;
+  try {
+    unsubscribe = runtime.subscribeAnnouncements((intent) => {
+      if (!disposed) announcer.announce(intent);
+    });
+  } catch (cause) {
+    announcer.dispose();
+    throw cause;
+  }
+  return {
+    announcer,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      try {
+        unsubscribe();
+      } finally {
+        announcer.dispose();
+      }
+    }
+  };
+}
+export {
+  captureFocus,
+  connectRuntimeToDOM,
+  createAttentionStore,
+  createDOMAnnouncer,
+  createPreferenceStore,
+  defaultPreferences,
+  focusElement,
+  normalizePreferences,
+  preferencesToCoreConfiguration,
+  restoreFocus,
+  samePreferences
+};
+//# sourceMappingURL=index.js.map