@pibbl/core 0.0.1

package/dist/lib/focus/directional-navigation.js

@@ -0,0 +1,86 @@
+function findDirectionalCandidate(current, candidates, direction, eligible = () => true) {
+  let winner;
+  let winningScore;
+  for (const candidate of candidates) {
+    if (!eligible(candidate)) continue;
+    const score = scoreDirectionalCandidate(current, candidate, direction);
+    if (!score || winningScore && compareScores(score, winningScore) >= 0) {
+      continue;
+    }
+    winner = candidate;
+    winningScore = score;
+  }
+  return winner;
+}
+function findNearestDirectionalCandidate(current, direction, eligible) {
+  const boundary = current.directionalBoundary;
+  return boundary ? findDirectionalCandidate(
+    current,
+    boundary.candidates,
+    direction,
+    eligible
+  ) : void 0;
+}
+function scoreDirectionalCandidate(current, candidate, direction) {
+  const currentBounds = normalizeBounds(current.rootBounds);
+  const candidateBounds = normalizeBounds(candidate.rootBounds);
+  if (!currentBounds || !candidateBounds) return void 0;
+  const horizontal = direction === "left" || direction === "right";
+  const forward = direction === "right" ? candidateBounds.centerX > currentBounds.centerX : direction === "left" ? candidateBounds.centerX < currentBounds.centerX : direction === "down" ? candidateBounds.centerY > currentBounds.centerY : candidateBounds.centerY < currentBounds.centerY;
+  if (!forward) return void 0;
+  const beamOverlap = horizontal ? intervalsOverlap(
+    currentBounds.top,
+    currentBounds.bottom,
+    candidateBounds.top,
+    candidateBounds.bottom
+  ) : intervalsOverlap(
+    currentBounds.left,
+    currentBounds.right,
+    candidateBounds.left,
+    candidateBounds.right
+  );
+  const forwardEdgeDistance = direction === "right" ? Math.max(0, candidateBounds.left - currentBounds.right) : direction === "left" ? Math.max(0, currentBounds.left - candidateBounds.right) : direction === "down" ? Math.max(0, candidateBounds.top - currentBounds.bottom) : Math.max(0, currentBounds.top - candidateBounds.bottom);
+  const perpendicularDistance = horizontal ? Math.abs(candidateBounds.centerY - currentBounds.centerY) : Math.abs(candidateBounds.centerX - currentBounds.centerX);
+  return [
+    beamOverlap ? 0 : 1,
+    forwardEdgeDistance,
+    perpendicularDistance,
+    candidate.sourceIndex
+  ];
+}
+function normalizeBounds(bounds) {
+  if (!bounds || !Number.isFinite(bounds.x) || !Number.isFinite(bounds.y) || !Number.isFinite(bounds.width) || !Number.isFinite(bounds.height)) {
+    return void 0;
+  }
+  const x2 = bounds.x + bounds.width;
+  const y2 = bounds.y + bounds.height;
+  if (!Number.isFinite(x2) || !Number.isFinite(y2)) return void 0;
+  const left = Math.min(bounds.x, x2);
+  const right = Math.max(bounds.x, x2);
+  const top = Math.min(bounds.y, y2);
+  const bottom = Math.max(bounds.y, y2);
+  return {
+    left,
+    right,
+    top,
+    bottom,
+    centerX: left / 2 + right / 2,
+    centerY: top / 2 + bottom / 2
+  };
+}
+function intervalsOverlap(firstStart, firstEnd, secondStart, secondEnd) {
+  return firstStart <= secondEnd && secondStart <= firstEnd;
+}
+function compareScores(left, right) {
+  for (let index = 0; index < left.length; index++) {
+    if (left[index] < right[index]) return -1;
+    if (left[index] > right[index]) return 1;
+  }
+  return 0;
+}
+export {
+  findDirectionalCandidate,
+  findNearestDirectionalCandidate,
+  scoreDirectionalCandidate
+};
+//# sourceMappingURL=directional-navigation.js.map

package/dist/lib/focus/directional-navigation.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/focus/directional-navigation.ts"],
+  "sourcesContent": ["import type { LayoutBox } from \"../layout/types.js\";\nimport type { PibblNavigationCandidate } from \"./types.js\";\n\nexport type PibblDirection = \"left\" | \"right\" | \"up\" | \"down\";\n\nexport type DirectionalScore = readonly [\n  beamPenalty: 0 | 1,\n  forwardEdgeDistance: number,\n  perpendicularDistance: number,\n  sourceIndex: number,\n];\n\ninterface NormalizedBounds {\n  readonly left: number;\n  readonly right: number;\n  readonly top: number;\n  readonly bottom: number;\n  readonly centerX: number;\n  readonly centerY: number;\n}\n\nexport function findDirectionalCandidate(\n  current: PibblNavigationCandidate,\n  candidates: readonly PibblNavigationCandidate[],\n  direction: PibblDirection,\n  eligible: (candidate: PibblNavigationCandidate) => boolean = () => true,\n): PibblNavigationCandidate | undefined {\n  let winner: PibblNavigationCandidate | undefined;\n  let winningScore: DirectionalScore | undefined;\n  for (const candidate of candidates) {\n    if (!eligible(candidate)) continue;\n    const score = scoreDirectionalCandidate(current, candidate, direction);\n    if (!score || (winningScore && compareScores(score, winningScore) >= 0)) {\n      continue;\n    }\n    winner = candidate;\n    winningScore = score;\n  }\n  return winner;\n}\n\n/** Resolves only within the candidate's nearest committed boundary. */\nexport function findNearestDirectionalCandidate(\n  current: PibblNavigationCandidate,\n  direction: PibblDirection,\n  eligible?: (candidate: PibblNavigationCandidate) => boolean,\n): PibblNavigationCandidate | undefined {\n  const boundary = current.directionalBoundary;\n  return boundary\n    ? findDirectionalCandidate(\n        current,\n        boundary.candidates,\n        direction,\n        eligible,\n      )\n    : undefined;\n}\n\nexport function scoreDirectionalCandidate(\n  current: PibblNavigationCandidate,\n  candidate: PibblNavigationCandidate,\n  direction: PibblDirection,\n): DirectionalScore | undefined {\n  const currentBounds = normalizeBounds(current.rootBounds);\n  const candidateBounds = normalizeBounds(candidate.rootBounds);\n  if (!currentBounds || !candidateBounds) return undefined;\n\n  const horizontal = direction === \"left\" || direction === \"right\";\n  const forward =\n    direction === \"right\"\n      ? candidateBounds.centerX > currentBounds.centerX\n      : direction === \"left\"\n        ? candidateBounds.centerX < currentBounds.centerX\n        : direction === \"down\"\n          ? candidateBounds.centerY > currentBounds.centerY\n          : candidateBounds.centerY < currentBounds.centerY;\n  if (!forward) return undefined;\n\n  const beamOverlap = horizontal\n    ? intervalsOverlap(\n        currentBounds.top,\n        currentBounds.bottom,\n        candidateBounds.top,\n        candidateBounds.bottom,\n      )\n    : intervalsOverlap(\n        currentBounds.left,\n        currentBounds.right,\n        candidateBounds.left,\n        candidateBounds.right,\n      );\n  const forwardEdgeDistance =\n    direction === \"right\"\n      ? Math.max(0, candidateBounds.left - currentBounds.right)\n      : direction === \"left\"\n        ? Math.max(0, currentBounds.left - candidateBounds.right)\n        : direction === \"down\"\n          ? Math.max(0, candidateBounds.top - currentBounds.bottom)\n          : Math.max(0, currentBounds.top - candidateBounds.bottom);\n  const perpendicularDistance = horizontal\n    ? Math.abs(candidateBounds.centerY - currentBounds.centerY)\n    : Math.abs(candidateBounds.centerX - currentBounds.centerX);\n\n  return [\n    beamOverlap ? 0 : 1,\n    forwardEdgeDistance,\n    perpendicularDistance,\n    candidate.sourceIndex,\n  ];\n}\n\nfunction normalizeBounds(\n  bounds: Readonly<LayoutBox> | undefined,\n): NormalizedBounds | undefined {\n  if (\n    !bounds ||\n    !Number.isFinite(bounds.x) ||\n    !Number.isFinite(bounds.y) ||\n    !Number.isFinite(bounds.width) ||\n    !Number.isFinite(bounds.height)\n  ) {\n    return undefined;\n  }\n  const x2 = bounds.x + bounds.width;\n  const y2 = bounds.y + bounds.height;\n  if (!Number.isFinite(x2) || !Number.isFinite(y2)) return undefined;\n  const left = Math.min(bounds.x, x2);\n  const right = Math.max(bounds.x, x2);\n  const top = Math.min(bounds.y, y2);\n  const bottom = Math.max(bounds.y, y2);\n  return {\n    left,\n    right,\n    top,\n    bottom,\n    centerX: left / 2 + right / 2,\n    centerY: top / 2 + bottom / 2,\n  };\n}\n\nfunction intervalsOverlap(\n  firstStart: number,\n  firstEnd: number,\n  secondStart: number,\n  secondEnd: number,\n): boolean {\n  return firstStart <= secondEnd && secondStart <= firstEnd;\n}\n\nfunction compareScores(\n  left: DirectionalScore,\n  right: DirectionalScore,\n): number {\n  for (let index = 0; index < left.length; index++) {\n    if (left[index] < right[index]) return -1;\n    if (left[index] > right[index]) return 1;\n  }\n  return 0;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/lib/focus/dom-focus-host.d.ts

@@ -0,0 +1,13 @@
+import type { Teardowns } from "../teardowns.js";
+import type { PibblEventRoot } from "../types.js";
+import type { PibblEventType } from "../events/types.js";
+import type { PibblFocusManager } from "./focus-manager.js";
+import type { HtmlFocusRegion } from "./html-focus-region.js";
+export interface PibblMountedDOMFocusHost {
+    beforeNativeDispatch(type: PibblEventType, event: Event): boolean;
+    focusFromPress(): void;
+    setManager(manager: PibblFocusManager | undefined): void;
+    syncCandidateAvailability(hasCandidates: boolean): void;
+    syncHtmlRegions(regions: readonly HtmlFocusRegion[]): void;
+}
+export declare function mountDOMFocusHost(canvas: HTMLCanvasElement, eventRoot: PibblEventRoot, teardowns: Teardowns): PibblMountedDOMFocusHost;

package/dist/lib/focus/dom-focus-host.js

@@ -0,0 +1,352 @@
+import { moveTab } from "./keyboard-defaults.js";
+import { getManagedTabStops } from "./dom-tab-stops.js";
+function mountDOMFocusHost(canvas, eventRoot, teardowns) {
+  let tabIndexOwnership;
+  let candidateReason = false;
+  let pressReason = false;
+  let pendingTabEntry;
+  let pendingTabExpiry;
+  let manager;
+  let disposed = false;
+  let domFocusActive = canvas.ownerDocument.activeElement === canvas;
+  let htmlRegions = Object.freeze([]);
+  let managedHtmlReason = false;
+  let leadingSentinel;
+  let trailingSentinel;
+  let exitingSentinel;
+  let pendingPointerRegion;
+  let pendingKeyboardFocus = false;
+  const supportsHtmlRegions = Boolean(eventRoot.htmlOverlay);
+  const keydownsWithTarget = /* @__PURE__ */ new WeakSet();
+  const restoreSnapshot = (ownership) => {
+    if (ownership.snapshot.existed) {
+      canvas.setAttribute("tabindex", ownership.snapshot.value ?? "");
+    } else {
+      canvas.removeAttribute("tabindex");
+    }
+  };
+  const snapshotTabIndex = () => ({
+    existed: canvas.hasAttribute("tabindex"),
+    value: canvas.getAttribute("tabindex")
+  });
+  const matchesSnapshot = (snapshot) => canvas.hasAttribute("tabindex") === snapshot.existed && canvas.getAttribute("tabindex") === snapshot.value;
+  const syncTabIndex = () => {
+    const hasReason = candidateReason || pressReason;
+    if (!tabIndexOwnership && hasReason) {
+      tabIndexOwnership = {
+        snapshot: snapshotTabIndex(),
+        baseTabIndex: canvas.tabIndex,
+        ownedValue: void 0,
+        lost: false
+      };
+    }
+    const ownership = tabIndexOwnership;
+    if (!ownership) return;
+    if (!ownership.lost && ownership.ownedValue !== void 0 && (!canvas.hasAttribute("tabindex") || canvas.getAttribute("tabindex") !== ownership.ownedValue)) {
+      ownership.lost = true;
+      ownership.ownedValue = void 0;
+    }
+    if (!ownership.lost && ownership.ownedValue === void 0 && !matchesSnapshot(ownership.snapshot)) {
+      ownership.snapshot = snapshotTabIndex();
+      ownership.baseTabIndex = canvas.tabIndex;
+    }
+    if (!hasReason) {
+      if (!ownership.lost && ownership.ownedValue !== void 0) {
+        restoreSnapshot(ownership);
+      }
+      tabIndexOwnership = void 0;
+      return;
+    }
+    if (ownership.lost) return;
+    const desired = candidateReason ? managedHtmlReason ? "-1" : ownership.snapshot.existed && ownership.baseTabIndex >= 0 ? void 0 : "0" : ownership.snapshot.existed ? void 0 : "-1";
+    if (desired === ownership.ownedValue) return;
+    if (desired === void 0) {
+      if (ownership.ownedValue !== void 0) {
+        restoreSnapshot(ownership);
+        ownership.ownedValue = void 0;
+      }
+      return;
+    }
+    canvas.setAttribute("tabindex", desired);
+    ownership.ownedValue = desired;
+  };
+  const focusFromPress = () => {
+    if (disposed) return;
+    pressReason = true;
+    syncTabIndex();
+    canvas.focus({ preventScroll: true });
+    if (canvas.ownerDocument.activeElement !== canvas) {
+      pressReason = false;
+      syncTabIndex();
+    }
+  };
+  const syncCandidateAvailability = (hasCandidates) => {
+    if (disposed) return;
+    if (candidateReason === hasCandidates) return;
+    candidateReason = hasCandidates;
+    syncTabIndex();
+  };
+  const setManager = (nextManager) => {
+    if (disposed) return;
+    manager = nextManager;
+    syncCandidateAvailability(Boolean(nextManager?.hasFocusCandidates));
+    syncHtmlRegions(nextManager?.htmlFocusRegions ?? []);
+  };
+  const isManagedRegion = (target) => target instanceof Node ? htmlRegions.find(
+    (region) => region.active && region.content?.contains(target)
+  ) : void 0;
+  const removeSentinels = () => {
+    leadingSentinel?.remove();
+    trailingSentinel?.remove();
+    leadingSentinel = void 0;
+    trailingSentinel = void 0;
+    exitingSentinel = void 0;
+  };
+  const makeSentinel = () => {
+    const sentinel = canvas.ownerDocument.createElement("span");
+    sentinel.tabIndex = 0;
+    sentinel.setAttribute("aria-hidden", "true");
+    sentinel.style.cssText = "position:fixed;width:1px;height:1px;overflow:hidden;opacity:0;pointer-events:none;";
+    return sentinel;
+  };
+  const enterFromSentinel = (backwards, sentinel) => {
+    if (exitingSentinel === sentinel) {
+      exitingSentinel = void 0;
+      return;
+    }
+    const activeManager = manager;
+    if (!activeManager) return;
+    activeManager.enterDOMFocus(backwards);
+  };
+  const syncHtmlRegions = (regions) => {
+    htmlRegions = regions.filter((region) => region.active && region.content);
+    managedHtmlReason = htmlRegions.length > 0;
+    syncTabIndex();
+    removeSentinels();
+    const activeRegion = isManagedRegion(canvas.ownerDocument.activeElement);
+    manager?.reconcileNativeHtmlFocus(activeRegion);
+    if (!manager || htmlRegions.length === 0) return;
+    const parent = canvas.parentElement;
+    if (!parent) return;
+    leadingSentinel = makeSentinel();
+    trailingSentinel = makeSentinel();
+    parent.insertBefore(leadingSentinel, canvas);
+    const overlay = canvas.nextElementSibling;
+    parent.insertBefore(
+      trailingSentinel,
+      overlay ? overlay.nextSibling : canvas.nextSibling
+    );
+    leadingSentinel.addEventListener(
+      "focus",
+      () => enterFromSentinel(true, leadingSentinel)
+    );
+    trailingSentinel.addEventListener(
+      "focus",
+      () => enterFromSentinel(false, trailingSentinel)
+    );
+  };
+  const exitSurface = (backwards) => {
+    const sentinel = backwards ? leadingSentinel : trailingSentinel;
+    if (!sentinel) return;
+    exitingSentinel = sentinel;
+    sentinel.focus({ preventScroll: true });
+  };
+  const clearPendingTabEntry = () => {
+    pendingTabEntry = void 0;
+    if (pendingTabExpiry !== void 0) clearTimeout(pendingTabExpiry);
+    pendingTabExpiry = void 0;
+  };
+  const onDocumentKeyDown = (event) => {
+    pendingPointerRegion = void 0;
+    pendingKeyboardFocus = event.key === "Tab";
+    if (event.key !== "Tab") return;
+    clearPendingTabEntry();
+    const entry = {
+      event,
+      origin: canvas.ownerDocument.activeElement
+    };
+    pendingTabEntry = entry;
+    const expiry = setTimeout(() => {
+      if (pendingTabEntry === entry) pendingTabEntry = void 0;
+      if (pendingTabExpiry === expiry) pendingTabExpiry = void 0;
+    }, 0);
+    pendingTabExpiry = expiry;
+  };
+  const beforeNativeDispatch = (type, event) => {
+    const activeManager = manager;
+    if (!activeManager) return true;
+    if (type === "focus" || type === "focusin") {
+      if (canvas.ownerDocument.activeElement !== canvas) return false;
+      if (domFocusActive) return false;
+      domFocusActive = true;
+      const entry = pendingTabEntry;
+      clearPendingTabEntry();
+      activeManager.enterDOMFocus(
+        Boolean(
+          entry && entry.event.eventPhase === Event.NONE && !entry.event.defaultPrevented && entry.origin?.ownerDocument === canvas.ownerDocument && isFocusEventForCanvas(event, canvas) && event.relatedTarget === entry.origin && entry.event.shiftKey
+        )
+      );
+      return false;
+    }
+    if (type === "blur" || type === "focusout") {
+      if (canvas.ownerDocument.activeElement === canvas) return false;
+      if (domFocusActive) {
+        domFocusActive = false;
+        clearPendingTabEntry();
+        activeManager.leaveDOMFocus();
+      }
+      return false;
+    }
+    if (type === "keydown" && event instanceof KeyboardEvent && activeManager.resolveKeyboardTarget()) {
+      keydownsWithTarget.add(event);
+    }
+    return true;
+  };
+  const onNativeFocus = () => void 0;
+  const onNativeKeyUp = () => void 0;
+  const onNativePress = () => void 0;
+  const onNativeExit = () => {
+    pressReason = false;
+    syncTabIndex();
+  };
+  const onNativeKeyDown = (event) => {
+    if (!(event instanceof KeyboardEvent) || event.key !== "Tab") return;
+    if (keydownsWithTarget.delete(event)) return;
+    const activeManager = manager;
+    if (!activeManager || event.defaultPrevented || activeManager.resolveKeyboardTarget()) {
+      return;
+    }
+    if (moveTab(activeManager, event.shiftKey) === "moved") {
+      event.preventDefault();
+    }
+  };
+  const onHtmlFocusIn = (event) => {
+    const region = isManagedRegion(event.target);
+    if (!region || !manager) return;
+    const pointerOrigin = pendingPointerRegion === region;
+    const keyboardOrigin = pendingKeyboardFocus;
+    pendingPointerRegion = void 0;
+    pendingKeyboardFocus = false;
+    manager.adoptNativeHtmlFocus(
+      region,
+      pointerOrigin ? "pointer" : keyboardOrigin ? "keyboard" : void 0
+    );
+  };
+  const onHtmlPointerDown = (event) => {
+    pendingKeyboardFocus = false;
+    pendingPointerRegion = isManagedRegion(event.target);
+  };
+  const onHtmlFocusOut = (event) => {
+    const region = isManagedRegion(event.target);
+    if (!region || !manager) return;
+    queueMicrotask(() => {
+      if (!region.content?.contains(canvas.ownerDocument.activeElement)) {
+        manager?.clearNativeHtmlFocus(region);
+      }
+    });
+  };
+  const onHtmlKeyDown = (event) => {
+    if (event.key !== "Tab" || event.defaultPrevented || !manager) return;
+    const region = isManagedRegion(event.target);
+    if (!region?.content) return;
+    const stops = getManagedTabStops(region.content);
+    const index = stops.indexOf(
+      canvas.ownerDocument.activeElement
+    );
+    if (index < 0) return;
+    const next = index + (event.shiftKey ? -1 : 1);
+    if (next >= 0 && next < stops.length) return;
+    if (moveTab(manager, event.shiftKey) === "moved") {
+      event.preventDefault();
+    } else {
+      exitSurface(event.shiftKey);
+    }
+  };
+  const focusObservers = requireObservers(eventRoot, "focus");
+  const focusinObservers = requireObservers(eventRoot, "focusin");
+  const blurObservers = requireObservers(eventRoot, "blur");
+  const focusoutObservers = requireObservers(eventRoot, "focusout");
+  const keydownObservers = requireObservers(eventRoot, "keydown");
+  const keyupObservers = requireObservers(eventRoot, "keyup");
+  const pointerdownObservers = requireObservers(eventRoot, "pointerdown");
+  const mousedownObservers = requireObservers(eventRoot, "mousedown");
+  const touchstartObservers = requireObservers(eventRoot, "touchstart");
+  const touchendObservers = requireObservers(eventRoot, "touchend");
+  const touchcancelObservers = requireObservers(eventRoot, "touchcancel");
+  focusObservers.add(onNativeFocus);
+  focusinObservers.add(onNativeFocus);
+  blurObservers.add(onNativeExit);
+  focusoutObservers.add(onNativeExit);
+  keydownObservers.add(onNativeKeyDown);
+  keyupObservers.add(onNativeKeyUp);
+  pointerdownObservers.add(onNativePress);
+  mousedownObservers.add(onNativePress);
+  touchstartObservers.add(onNativePress);
+  touchendObservers.add(onNativePress);
+  touchcancelObservers.add(onNativePress);
+  canvas.ownerDocument.addEventListener("keydown", onDocumentKeyDown, true);
+  if (supportsHtmlRegions) {
+    canvas.ownerDocument.addEventListener("focusin", onHtmlFocusIn, true);
+    canvas.ownerDocument.addEventListener("focusout", onHtmlFocusOut, true);
+    canvas.ownerDocument.addEventListener("pointerdown", onHtmlPointerDown, true);
+    canvas.ownerDocument.addEventListener("keydown", onHtmlKeyDown);
+  }
+  teardowns.add(() => {
+    if (disposed) return;
+    disposed = true;
+    manager = void 0;
+    clearPendingTabEntry();
+    candidateReason = false;
+    pressReason = false;
+    syncTabIndex();
+    focusObservers.delete(onNativeFocus);
+    focusinObservers.delete(onNativeFocus);
+    blurObservers.delete(onNativeExit);
+    focusoutObservers.delete(onNativeExit);
+    keydownObservers.delete(onNativeKeyDown);
+    keyupObservers.delete(onNativeKeyUp);
+    pointerdownObservers.delete(onNativePress);
+    mousedownObservers.delete(onNativePress);
+    touchstartObservers.delete(onNativePress);
+    touchendObservers.delete(onNativePress);
+    touchcancelObservers.delete(onNativePress);
+    canvas.ownerDocument.removeEventListener(
+      "keydown",
+      onDocumentKeyDown,
+      true
+    );
+    if (supportsHtmlRegions) {
+      canvas.ownerDocument.removeEventListener("focusin", onHtmlFocusIn, true);
+      canvas.ownerDocument.removeEventListener("focusout", onHtmlFocusOut, true);
+      canvas.ownerDocument.removeEventListener(
+        "pointerdown",
+        onHtmlPointerDown,
+        true
+      );
+      canvas.ownerDocument.removeEventListener("keydown", onHtmlKeyDown);
+    }
+    removeSentinels();
+  });
+  return {
+    beforeNativeDispatch,
+    focusFromPress,
+    setManager,
+    syncCandidateAvailability,
+    syncHtmlRegions
+  };
+}
+function isFocusEventForCanvas(event, canvas) {
+  const FocusEventClass = canvas.ownerDocument.defaultView?.FocusEvent;
+  return Boolean(FocusEventClass && event instanceof FocusEventClass);
+}
+function requireObservers(eventRoot, type) {
+  const observers = eventRoot.observers.get(type);
+  if (!observers) {
+    throw new Error(`Pibbl ${type} observer registry is unavailable.`);
+  }
+  return observers;
+}
+export {
+  mountDOMFocusHost
+};
+//# sourceMappingURL=dom-focus-host.js.map

package/dist/lib/focus/dom-focus-host.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/focus/dom-focus-host.ts"],
+  "sourcesContent": ["import type { Teardowns } from \"../teardowns.js\";\nimport type { PibblEventRoot } from \"../types.js\";\nimport type { PibblEventType } from \"../events/types.js\";\nimport type { PibblFocusManager } from \"./focus-manager.js\";\nimport { moveTab } from \"./keyboard-defaults.js\";\nimport type { HtmlFocusRegion } from \"./html-focus-region.js\";\nimport { getManagedTabStops } from \"./dom-tab-stops.js\";\n\ninterface TabIndexSnapshot {\n  readonly existed: boolean;\n  readonly value: string | null;\n}\n\ninterface TabIndexOwnership {\n  snapshot: TabIndexSnapshot;\n  baseTabIndex: number;\n  ownedValue: string | undefined;\n  lost: boolean;\n}\n\ninterface PendingTabEntry {\n  readonly event: KeyboardEvent;\n  readonly origin: Element | null;\n}\n\nexport interface PibblMountedDOMFocusHost {\n  beforeNativeDispatch(type: PibblEventType, event: Event): boolean;\n  focusFromPress(): void;\n  setManager(manager: PibblFocusManager | undefined): void;\n  syncCandidateAvailability(hasCandidates: boolean): void;\n  syncHtmlRegions(regions: readonly HtmlFocusRegion[]): void;\n}\n\nexport function mountDOMFocusHost(\n  canvas: HTMLCanvasElement,\n  eventRoot: PibblEventRoot,\n  teardowns: Teardowns,\n): PibblMountedDOMFocusHost {\n  let tabIndexOwnership: TabIndexOwnership | undefined;\n  let candidateReason = false;\n  let pressReason = false;\n  let pendingTabEntry: PendingTabEntry | undefined;\n  let pendingTabExpiry: ReturnType<typeof setTimeout> | undefined;\n  let manager: PibblFocusManager | undefined;\n  let disposed = false;\n  let domFocusActive = canvas.ownerDocument.activeElement === canvas;\n  let htmlRegions: readonly HtmlFocusRegion[] = Object.freeze([]);\n  let managedHtmlReason = false;\n  let leadingSentinel: HTMLSpanElement | undefined;\n  let trailingSentinel: HTMLSpanElement | undefined;\n  let exitingSentinel: HTMLSpanElement | undefined;\n  let pendingPointerRegion: HtmlFocusRegion | undefined;\n  let pendingKeyboardFocus = false;\n  // htmlOverlay is mount configuration: it cannot appear after this focus host\n  // is constructed. Keep the ordinary Canvas-only listener footprint intact.\n  const supportsHtmlRegions = Boolean(eventRoot.htmlOverlay);\n  const keydownsWithTarget = new WeakSet<KeyboardEvent>();\n\n  const restoreSnapshot = (ownership: TabIndexOwnership) => {\n    if (ownership.snapshot.existed) {\n      canvas.setAttribute(\"tabindex\", ownership.snapshot.value ?? \"\");\n    } else {\n      canvas.removeAttribute(\"tabindex\");\n    }\n  };\n\n  const snapshotTabIndex = (): TabIndexSnapshot => ({\n    existed: canvas.hasAttribute(\"tabindex\"),\n    value: canvas.getAttribute(\"tabindex\"),\n  });\n\n  const matchesSnapshot = (snapshot: TabIndexSnapshot): boolean =>\n    canvas.hasAttribute(\"tabindex\") === snapshot.existed &&\n    canvas.getAttribute(\"tabindex\") === snapshot.value;\n\n  const syncTabIndex = () => {\n    const hasReason = candidateReason || pressReason;\n    if (!tabIndexOwnership && hasReason) {\n      tabIndexOwnership = {\n        snapshot: snapshotTabIndex(),\n        baseTabIndex: canvas.tabIndex,\n        ownedValue: undefined,\n        lost: false,\n      };\n    }\n    const ownership = tabIndexOwnership;\n    if (!ownership) return;\n\n    if (\n      !ownership.lost &&\n      ownership.ownedValue !== undefined &&\n      (!canvas.hasAttribute(\"tabindex\") ||\n        canvas.getAttribute(\"tabindex\") !== ownership.ownedValue)\n    ) {\n      ownership.lost = true;\n      ownership.ownedValue = undefined;\n    }\n\n    if (\n      !ownership.lost &&\n      ownership.ownedValue === undefined &&\n      !matchesSnapshot(ownership.snapshot)\n    ) {\n      ownership.snapshot = snapshotTabIndex();\n      ownership.baseTabIndex = canvas.tabIndex;\n    }\n\n    if (!hasReason) {\n      if (!ownership.lost && ownership.ownedValue !== undefined) {\n        restoreSnapshot(ownership);\n      }\n      tabIndexOwnership = undefined;\n      return;\n    }\n    if (ownership.lost) return;\n\n    const desired = candidateReason\n      ? managedHtmlReason\n        ? \"-1\"\n        : ownership.snapshot.existed && ownership.baseTabIndex >= 0\n          ? undefined\n          : \"0\"\n      : ownership.snapshot.existed\n        ? undefined\n        : \"-1\";\n    if (desired === ownership.ownedValue) return;\n    if (desired === undefined) {\n      if (ownership.ownedValue !== undefined) {\n        restoreSnapshot(ownership);\n        ownership.ownedValue = undefined;\n      }\n      return;\n    }\n    canvas.setAttribute(\"tabindex\", desired);\n    ownership.ownedValue = desired;\n  };\n\n  const focusFromPress = () => {\n    if (disposed) return;\n    pressReason = true;\n    syncTabIndex();\n    canvas.focus({ preventScroll: true });\n    if (canvas.ownerDocument.activeElement !== canvas) {\n      pressReason = false;\n      syncTabIndex();\n    }\n  };\n\n  const syncCandidateAvailability = (hasCandidates: boolean) => {\n    if (disposed) return;\n    if (candidateReason === hasCandidates) return;\n    candidateReason = hasCandidates;\n    syncTabIndex();\n  };\n\n  const setManager = (nextManager: PibblFocusManager | undefined) => {\n    if (disposed) return;\n    manager = nextManager;\n    syncCandidateAvailability(Boolean(nextManager?.hasFocusCandidates));\n    syncHtmlRegions(nextManager?.htmlFocusRegions ?? []);\n  };\n\n  const isManagedRegion = (\n    target: EventTarget | null,\n  ): HtmlFocusRegion | undefined =>\n    target instanceof Node\n      ? htmlRegions.find(\n          (region) => region.active && region.content?.contains(target),\n        )\n      : undefined;\n\n  const removeSentinels = () => {\n    leadingSentinel?.remove();\n    trailingSentinel?.remove();\n    leadingSentinel = undefined;\n    trailingSentinel = undefined;\n    exitingSentinel = undefined;\n  };\n\n  const makeSentinel = () => {\n    const sentinel = canvas.ownerDocument.createElement(\"span\");\n    sentinel.tabIndex = 0;\n    sentinel.setAttribute(\"aria-hidden\", \"true\");\n    sentinel.style.cssText =\n      \"position:fixed;width:1px;height:1px;overflow:hidden;opacity:0;pointer-events:none;\";\n    return sentinel;\n  };\n\n  const enterFromSentinel = (backwards: boolean, sentinel: HTMLSpanElement) => {\n    if (exitingSentinel === sentinel) {\n      exitingSentinel = undefined;\n      return;\n    }\n    const activeManager = manager;\n    if (!activeManager) return;\n    activeManager.enterDOMFocus(backwards);\n  };\n\n  const syncHtmlRegions = (regions: readonly HtmlFocusRegion[]) => {\n    htmlRegions = regions.filter((region) => region.active && region.content);\n    managedHtmlReason = htmlRegions.length > 0;\n    syncTabIndex();\n    removeSentinels();\n    const activeRegion = isManagedRegion(canvas.ownerDocument.activeElement);\n    manager?.reconcileNativeHtmlFocus(activeRegion);\n    if (!manager || htmlRegions.length === 0) return;\n    const parent = canvas.parentElement;\n    if (!parent) return;\n    leadingSentinel = makeSentinel();\n    trailingSentinel = makeSentinel();\n    parent.insertBefore(leadingSentinel, canvas);\n    // The configured overlay is the canvas's adjacent sibling. Keeping the\n    // trailing sentinel after it makes native entry/exit cover both surfaces.\n    const overlay = canvas.nextElementSibling;\n    parent.insertBefore(\n      trailingSentinel,\n      overlay ? overlay.nextSibling : canvas.nextSibling,\n    );\n    leadingSentinel.addEventListener(\"focus\", () =>\n      enterFromSentinel(true, leadingSentinel!),\n    );\n    trailingSentinel.addEventListener(\"focus\", () =>\n      enterFromSentinel(false, trailingSentinel!),\n    );\n  };\n\n  const exitSurface = (backwards: boolean) => {\n    const sentinel = backwards ? leadingSentinel : trailingSentinel;\n    if (!sentinel) return;\n    exitingSentinel = sentinel;\n    sentinel.focus({ preventScroll: true });\n  };\n\n  const clearPendingTabEntry = () => {\n    pendingTabEntry = undefined;\n    if (pendingTabExpiry !== undefined) clearTimeout(pendingTabExpiry);\n    pendingTabExpiry = undefined;\n  };\n\n  const onDocumentKeyDown = (event: KeyboardEvent) => {\n    // A click on an already focused control has no focusin to consume this\n    // marker. Keyboard navigation must establish a fresh keyboard modality.\n    pendingPointerRegion = undefined;\n    pendingKeyboardFocus = event.key === \"Tab\";\n    if (event.key !== \"Tab\") return;\n    clearPendingTabEntry();\n    const entry: PendingTabEntry = {\n      event,\n      origin: canvas.ownerDocument.activeElement,\n    };\n    pendingTabEntry = entry;\n    const expiry = setTimeout(() => {\n      if (pendingTabEntry === entry) pendingTabEntry = undefined;\n      if (pendingTabExpiry === expiry) pendingTabExpiry = undefined;\n    }, 0);\n    pendingTabExpiry = expiry;\n  };\n\n  const beforeNativeDispatch = (type: PibblEventType, event: Event) => {\n    const activeManager = manager;\n    if (!activeManager) return true;\n    if (type === \"focus\" || type === \"focusin\") {\n      if (canvas.ownerDocument.activeElement !== canvas) return false;\n      if (domFocusActive) return false;\n      domFocusActive = true;\n      const entry = pendingTabEntry;\n      clearPendingTabEntry();\n      activeManager.enterDOMFocus(\n        Boolean(\n          entry &&\n          entry.event.eventPhase === Event.NONE &&\n          !entry.event.defaultPrevented &&\n          entry.origin?.ownerDocument === canvas.ownerDocument &&\n          isFocusEventForCanvas(event, canvas) &&\n          event.relatedTarget === entry.origin &&\n          entry.event.shiftKey,\n        ),\n      );\n      return false;\n    }\n    if (type === \"blur\" || type === \"focusout\") {\n      if (canvas.ownerDocument.activeElement === canvas) return false;\n      if (domFocusActive) {\n        domFocusActive = false;\n        clearPendingTabEntry();\n        activeManager.leaveDOMFocus();\n      }\n      return false;\n    }\n    if (\n      type === \"keydown\" &&\n      event instanceof KeyboardEvent &&\n      activeManager.resolveKeyboardTarget()\n    ) {\n      keydownsWithTarget.add(event);\n    }\n    return true;\n  };\n\n  const onNativeFocus = () => undefined;\n  const onNativeKeyUp = () => undefined;\n  const onNativePress = () => undefined;\n  const onNativeExit = () => {\n    pressReason = false;\n    syncTabIndex();\n  };\n  const onNativeKeyDown = (event: Event) => {\n    if (!(event instanceof KeyboardEvent) || event.key !== \"Tab\") return;\n    if (keydownsWithTarget.delete(event)) return;\n    const activeManager = manager;\n    if (\n      !activeManager ||\n      event.defaultPrevented ||\n      activeManager.resolveKeyboardTarget()\n    ) {\n      return;\n    }\n    if (moveTab(activeManager, event.shiftKey) === \"moved\") {\n      event.preventDefault();\n    }\n  };\n\n  const onHtmlFocusIn = (event: FocusEvent) => {\n    const region = isManagedRegion(event.target);\n    if (!region || !manager) return;\n    const pointerOrigin = pendingPointerRegion === region;\n    const keyboardOrigin = pendingKeyboardFocus;\n    pendingPointerRegion = undefined;\n    pendingKeyboardFocus = false;\n    manager.adoptNativeHtmlFocus(\n      region,\n      pointerOrigin ? \"pointer\" : keyboardOrigin ? \"keyboard\" : undefined,\n    );\n  };\n\n  const onHtmlPointerDown = (event: PointerEvent) => {\n    // A pointer interaction supersedes a Tab origin even when it occurs\n    // outside this root; no later programmatic focus may inherit that Tab.\n    pendingKeyboardFocus = false;\n    pendingPointerRegion = isManagedRegion(event.target);\n  };\n\n  const onHtmlFocusOut = (event: FocusEvent) => {\n    const region = isManagedRegion(event.target);\n    if (!region || !manager) return;\n    queueMicrotask(() => {\n      if (!region.content?.contains(canvas.ownerDocument.activeElement)) {\n        manager?.clearNativeHtmlFocus(region);\n      }\n    });\n  };\n\n  const onHtmlKeyDown = (event: KeyboardEvent) => {\n    if (event.key !== \"Tab\" || event.defaultPrevented || !manager) return;\n    const region = isManagedRegion(event.target);\n    if (!region?.content) return;\n    const stops = getManagedTabStops(region.content);\n    const index = stops.indexOf(\n      canvas.ownerDocument.activeElement as HTMLElement,\n    );\n    if (index < 0) return;\n    const next = index + (event.shiftKey ? -1 : 1);\n    if (next >= 0 && next < stops.length) return;\n    if (moveTab(manager, event.shiftKey) === \"moved\") {\n      event.preventDefault();\n    } else {\n      exitSurface(event.shiftKey);\n    }\n  };\n\n  const focusObservers = requireObservers(eventRoot, \"focus\");\n  const focusinObservers = requireObservers(eventRoot, \"focusin\");\n  const blurObservers = requireObservers(eventRoot, \"blur\");\n  const focusoutObservers = requireObservers(eventRoot, \"focusout\");\n  const keydownObservers = requireObservers(eventRoot, \"keydown\");\n  const keyupObservers = requireObservers(eventRoot, \"keyup\");\n  const pointerdownObservers = requireObservers(eventRoot, \"pointerdown\");\n  const mousedownObservers = requireObservers(eventRoot, \"mousedown\");\n  const touchstartObservers = requireObservers(eventRoot, \"touchstart\");\n  const touchendObservers = requireObservers(eventRoot, \"touchend\");\n  const touchcancelObservers = requireObservers(eventRoot, \"touchcancel\");\n  focusObservers.add(onNativeFocus);\n  focusinObservers.add(onNativeFocus);\n  blurObservers.add(onNativeExit);\n  focusoutObservers.add(onNativeExit);\n  keydownObservers.add(onNativeKeyDown);\n  keyupObservers.add(onNativeKeyUp);\n  pointerdownObservers.add(onNativePress);\n  mousedownObservers.add(onNativePress);\n  touchstartObservers.add(onNativePress);\n  touchendObservers.add(onNativePress);\n  touchcancelObservers.add(onNativePress);\n  canvas.ownerDocument.addEventListener(\"keydown\", onDocumentKeyDown, true);\n  if (supportsHtmlRegions) {\n    canvas.ownerDocument.addEventListener(\"focusin\", onHtmlFocusIn, true);\n    canvas.ownerDocument.addEventListener(\"focusout\", onHtmlFocusOut, true);\n    canvas.ownerDocument.addEventListener(\"pointerdown\", onHtmlPointerDown, true);\n    canvas.ownerDocument.addEventListener(\"keydown\", onHtmlKeyDown);\n  }\n\n  teardowns.add(() => {\n    if (disposed) return;\n    disposed = true;\n    manager = undefined;\n    clearPendingTabEntry();\n    candidateReason = false;\n    pressReason = false;\n    syncTabIndex();\n    focusObservers.delete(onNativeFocus);\n    focusinObservers.delete(onNativeFocus);\n    blurObservers.delete(onNativeExit);\n    focusoutObservers.delete(onNativeExit);\n    keydownObservers.delete(onNativeKeyDown);\n    keyupObservers.delete(onNativeKeyUp);\n    pointerdownObservers.delete(onNativePress);\n    mousedownObservers.delete(onNativePress);\n    touchstartObservers.delete(onNativePress);\n    touchendObservers.delete(onNativePress);\n    touchcancelObservers.delete(onNativePress);\n    canvas.ownerDocument.removeEventListener(\n      \"keydown\",\n      onDocumentKeyDown,\n      true,\n    );\n    if (supportsHtmlRegions) {\n      canvas.ownerDocument.removeEventListener(\"focusin\", onHtmlFocusIn, true);\n      canvas.ownerDocument.removeEventListener(\"focusout\", onHtmlFocusOut, true);\n      canvas.ownerDocument.removeEventListener(\n        \"pointerdown\",\n        onHtmlPointerDown,\n        true,\n      );\n      canvas.ownerDocument.removeEventListener(\"keydown\", onHtmlKeyDown);\n    }\n    removeSentinels();\n  });\n\n  return {\n    beforeNativeDispatch,\n    focusFromPress,\n    setManager,\n    syncCandidateAvailability,\n    syncHtmlRegions,\n  };\n}\n\nfunction isFocusEventForCanvas(\n  event: Event,\n  canvas: HTMLCanvasElement,\n): event is FocusEvent {\n  const FocusEventClass = canvas.ownerDocument.defaultView?.FocusEvent;\n  return Boolean(FocusEventClass && event instanceof FocusEventClass);\n}\n\nfunction requireObservers(\n  eventRoot: PibblEventRoot,\n  type:\n    | \"blur\"\n    | \"focus\"\n    | \"focusin\"\n    | \"focusout\"\n    | \"keydown\"\n    | \"keyup\"\n    | \"mousedown\"\n    | \"pointerdown\"\n    | \"touchcancel\"\n    | \"touchend\"\n    | \"touchstart\",\n): Set<(event: Event) => void> {\n  const observers = eventRoot.observers.get(type);\n  if (!observers) {\n    throw new Error(`Pibbl ${type} observer registry is unavailable.`);\n  }\n  return observers;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/lib/focus/dom-tab-stops.d.ts

@@ -0,0 +1,3 @@
+/** Native light-DOM tab-stop discovery for managed HtmlBox regions. */
+export declare function getManagedTabStops(root: HTMLElement): HTMLElement[];
+export declare function isManagedTabStop(element: HTMLElement, root: HTMLElement): boolean;

package/dist/lib/focus/dom-tab-stops.js

@@ -0,0 +1,71 @@
+const CANDIDATE_SELECTOR = [
+  "a[href]",
+  "area[href]",
+  "button",
+  "input",
+  "select",
+  "textarea",
+  "summary",
+  "iframe",
+  "object",
+  "embed",
+  "[contenteditable]",
+  "[tabindex]"
+].join(",");
+function getManagedTabStops(root) {
+  const candidates = Array.from(
+    root.querySelectorAll(CANDIDATE_SELECTOR)
+  );
+  const stops = candidates.filter((element) => isManagedTabStop(element, root));
+  const positive = stops.find((element) => element.tabIndex > 0);
+  if (positive) {
+    throw new Error(
+      'HtmlBox managed focus does not support positive tabindex. Use source order or tabindex="0".'
+    );
+  }
+  return removeUncheckedRadioPeers(stops);
+}
+function isManagedTabStop(element, root) {
+  if (!root.contains(element) || element.tabIndex < 0) return false;
+  if (element.matches(":disabled, [inert]") || isInertOrHidden(element, root))
+    return false;
+  if (element instanceof HTMLInputElement && element.type === "hidden")
+    return false;
+  if (element instanceof HTMLDetailsElement && !element.open) return false;
+  if (element.closest("details:not([open])") && !element.matches("summary"))
+    return false;
+  if (element.matches("summary") && !element.parentElement?.matches("details"))
+    return false;
+  return true;
+}
+function isInertOrHidden(element, root) {
+  for (let current = element; current && current !== root.parentElement; current = current.parentElement) {
+    if (current.hasAttribute("inert") || current.hidden || current.getAttribute("aria-hidden") === "true")
+      return true;
+    const style = current.ownerDocument.defaultView?.getComputedStyle(current);
+    if (style?.display === "none" || style?.visibility === "hidden")
+      return true;
+  }
+  return false;
+}
+function removeUncheckedRadioPeers(stops) {
+  const checkedGroups = /* @__PURE__ */ new Set();
+  for (const element of stops) {
+    if (element instanceof HTMLInputElement && element.type === "radio" && element.name && element.checked) {
+      checkedGroups.add(radioKey(element));
+    }
+  }
+  return stops.filter((element) => {
+    if (!(element instanceof HTMLInputElement) || element.type !== "radio" || !element.name)
+      return true;
+    return !checkedGroups.has(radioKey(element)) || element.checked;
+  });
+}
+function radioKey(input) {
+  return `${input.form ? String(input.form) : ""}\0${input.name}`;
+}
+export {
+  getManagedTabStops,
+  isManagedTabStop
+};
+//# sourceMappingURL=dom-tab-stops.js.map

package/dist/lib/focus/dom-tab-stops.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/focus/dom-tab-stops.ts"],
+  "sourcesContent": ["/** Native light-DOM tab-stop discovery for managed HtmlBox regions. */\n\nconst CANDIDATE_SELECTOR = [\n  \"a[href]\",\n  \"area[href]\",\n  \"button\",\n  \"input\",\n  \"select\",\n  \"textarea\",\n  \"summary\",\n  \"iframe\",\n  \"object\",\n  \"embed\",\n  \"[contenteditable]\",\n  \"[tabindex]\",\n].join(\",\");\n\nexport function getManagedTabStops(root: HTMLElement): HTMLElement[] {\n  const candidates = Array.from(\n    root.querySelectorAll<HTMLElement>(CANDIDATE_SELECTOR),\n  );\n  const stops = candidates.filter((element) => isManagedTabStop(element, root));\n  const positive = stops.find((element) => element.tabIndex > 0);\n  if (positive) {\n    throw new Error(\n      'HtmlBox managed focus does not support positive tabindex. Use source order or tabindex=\"0\".',\n    );\n  }\n  return removeUncheckedRadioPeers(stops);\n}\n\nexport function isManagedTabStop(\n  element: HTMLElement,\n  root: HTMLElement,\n): boolean {\n  if (!root.contains(element) || element.tabIndex < 0) return false;\n  if (element.matches(\":disabled, [inert]\") || isInertOrHidden(element, root))\n    return false;\n  if (element instanceof HTMLInputElement && element.type === \"hidden\")\n    return false;\n  if (element instanceof HTMLDetailsElement && !element.open) return false;\n  if (element.closest(\"details:not([open])\") && !element.matches(\"summary\"))\n    return false;\n  if (element.matches(\"summary\") && !element.parentElement?.matches(\"details\"))\n    return false;\n  return true;\n}\n\nfunction isInertOrHidden(element: HTMLElement, root: HTMLElement): boolean {\n  for (\n    let current: HTMLElement | null = element;\n    current && current !== root.parentElement;\n    current = current.parentElement\n  ) {\n    if (\n      current.hasAttribute(\"inert\") ||\n      current.hidden ||\n      current.getAttribute(\"aria-hidden\") === \"true\"\n    )\n      return true;\n    const style = current.ownerDocument.defaultView?.getComputedStyle(current);\n    if (style?.display === \"none\" || style?.visibility === \"hidden\")\n      return true;\n  }\n  return false;\n}\n\nfunction removeUncheckedRadioPeers(\n  stops: readonly HTMLElement[],\n): HTMLElement[] {\n  const checkedGroups = new Set<string>();\n  for (const element of stops) {\n    if (\n      element instanceof HTMLInputElement &&\n      element.type === \"radio\" &&\n      element.name &&\n      element.checked\n    ) {\n      checkedGroups.add(radioKey(element));\n    }\n  }\n  return stops.filter((element) => {\n    if (\n      !(element instanceof HTMLInputElement) ||\n      element.type !== \"radio\" ||\n      !element.name\n    )\n      return true;\n    return !checkedGroups.has(radioKey(element)) || element.checked;\n  });\n}\n\nfunction radioKey(input: HTMLInputElement): string {\n  return `${input.form ? String(input.form) : \"\"}\\u0000${input.name}`;\n}\n"],
+  "mappings": "AAEA,MAAM,qBAAqB;AAAA,EACzB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,EAAE,KAAK,GAAG;AAEH,SAAS,mBAAmB,MAAkC;AACnE,QAAM,aAAa,MAAM;AAAA,IACvB,KAAK,iBAA8B,kBAAkB;AAAA,EACvD;AACA,QAAM,QAAQ,WAAW,OAAO,CAAC,YAAY,iBAAiB,SAAS,IAAI,CAAC;AAC5E,QAAM,WAAW,MAAM,KAAK,CAAC,YAAY,QAAQ,WAAW,CAAC;AAC7D,MAAI,UAAU;AACZ,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,SAAO,0BAA0B,KAAK;AACxC;AAEO,SAAS,iBACd,SACA,MACS;AACT,MAAI,CAAC,KAAK,SAAS,OAAO,KAAK,QAAQ,WAAW,EAAG,QAAO;AAC5D,MAAI,QAAQ,QAAQ,oBAAoB,KAAK,gBAAgB,SAAS,IAAI;AACxE,WAAO;AACT,MAAI,mBAAmB,oBAAoB,QAAQ,SAAS;AAC1D,WAAO;AACT,MAAI,mBAAmB,sBAAsB,CAAC,QAAQ,KAAM,QAAO;AACnE,MAAI,QAAQ,QAAQ,qBAAqB,KAAK,CAAC,QAAQ,QAAQ,SAAS;AACtE,WAAO;AACT,MAAI,QAAQ,QAAQ,SAAS,KAAK,CAAC,QAAQ,eAAe,QAAQ,SAAS;AACzE,WAAO;AACT,SAAO;AACT;AAEA,SAAS,gBAAgB,SAAsB,MAA4B;AACzE,WACM,UAA8B,SAClC,WAAW,YAAY,KAAK,eAC5B,UAAU,QAAQ,eAClB;AACA,QACE,QAAQ,aAAa,OAAO,KAC5B,QAAQ,UACR,QAAQ,aAAa,aAAa,MAAM;AAExC,aAAO;AACT,UAAM,QAAQ,QAAQ,cAAc,aAAa,iBAAiB,OAAO;AACzE,QAAI,OAAO,YAAY,UAAU,OAAO,eAAe;AACrD,aAAO;AAAA,EACX;AACA,SAAO;AACT;AAEA,SAAS,0BACP,OACe;AACf,QAAM,gBAAgB,oBAAI,IAAY;AACtC,aAAW,WAAW,OAAO;AAC3B,QACE,mBAAmB,oBACnB,QAAQ,SAAS,WACjB,QAAQ,QACR,QAAQ,SACR;AACA,oBAAc,IAAI,SAAS,OAAO,CAAC;AAAA,IACrC;AAAA,EACF;AACA,SAAO,MAAM,OAAO,CAAC,YAAY;AAC/B,QACE,EAAE,mBAAmB,qBACrB,QAAQ,SAAS,WACjB,CAAC,QAAQ;AAET,aAAO;AACT,WAAO,CAAC,cAAc,IAAI,SAAS,OAAO,CAAC,KAAK,QAAQ;AAAA,EAC1D,CAAC;AACH;AAEA,SAAS,SAAS,OAAiC;AACjD,SAAO,GAAG,MAAM,OAAO,OAAO,MAAM,IAAI,IAAI,EAAE,KAAS,MAAM,IAAI;AACnE;",
+  "names": []
+}

package/dist/lib/focus/focus-events.d.ts

@@ -0,0 +1,4 @@
+import type { PibblFocusManager } from './focus-manager.js';
+import type { PibblFocusModality } from './types.js';
+import type { PibblEventTargetRegistration } from '../events/registrations.js';
+export declare function transitionLogicalFocus(manager: PibblFocusManager, requestedNext: PibblEventTargetRegistration | undefined, modality: PibblFocusModality): void;