@pibbl/core 0.0.1

package/dist/lib/events/dispatch.js

@@ -0,0 +1,1078 @@
+import { getInteractionRoot } from "../global-state.js";
+import { batch } from "../signals/graph.js";
+import {
+  adaptClipboardEvent,
+  isNativeClipboardEventType
+} from "./adapters/clipboard.js";
+import {
+  adaptDragEvent,
+  isNativeDragEventType
+} from "./adapters/drag.js";
+import {
+  adaptEditingEvent,
+  isNativeEditingEventType
+} from "./adapters/editing.js";
+import {
+  adaptKeyboardFocusEvent,
+  isNativeKeyboardFocusEventType
+} from "./adapters/keyboard-focus.js";
+import {
+  adaptMouseEvent,
+  isNativeMouseEventType
+} from "./adapters/mouse.js";
+import {
+  adaptPointerEvent,
+  isNativePointerEventType
+} from "./adapters/pointer.js";
+import {
+  adaptTouchEvent,
+  isNativeTouchEventType
+} from "./adapters/touch.js";
+import {
+  adaptWheelEvent,
+  isNativeWheelEventType
+} from "./adapters/wheel.js";
+import { planBoundaryTransitions } from "./boundary-transitions.js";
+import { buildEventPath } from "./event-path.js";
+import {
+  resolveCoordinateOutput,
+  resolveCoordinateTarget
+} from "./hit-test.js";
+import { PibblHitDisposition } from "./paint-entry.js";
+import {
+  dispatchCapturedResolverInput,
+  dispatchResolvedInput,
+  getResolverPointerCapture
+} from "./resolver-input.js";
+import { dispatchEventPath } from "./propagation.js";
+import {
+  activateLogicalPointerCapture,
+  cancelLogicalPointerCapture,
+  consumeLogicalPointerCaptureLoss,
+  getLogicalPointerCapture,
+  processPendingLogicalPointerCapture
+} from "./pointer-capture.js";
+import {
+  releaseTarget
+} from "./registrations.js";
+const cursorDefaultOwnership = /* @__PURE__ */ new WeakMap();
+const pointerHoverTargets = /* @__PURE__ */ new WeakMap();
+const touchTargets = /* @__PURE__ */ new WeakMap();
+const dragHoverTargets = /* @__PURE__ */ new WeakMap();
+const manipulationPointerPresses = /* @__PURE__ */ new WeakMap();
+const pendingManipulationActivations = /* @__PURE__ */ new WeakMap();
+const manipulationActivationRoots = /* @__PURE__ */ new WeakSet();
+function suppressManipulationActivation(instance, pointerId) {
+  const root = getInteractionRoot(instance);
+  retainManipulationActivationState(root);
+  let pending = pendingManipulationActivations.get(root);
+  if (!pending) {
+    pending = /* @__PURE__ */ new Map();
+    pendingManipulationActivations.set(root, pending);
+  }
+  pending.set(pointerId, Object.freeze({
+    pointerPress: manipulationPointerPresses.get(root)?.get(pointerId),
+    mouseDown: root.interaction.primaryDown
+  }));
+}
+function dispatchNativeEvent(instance, type, nativeEvent) {
+  const root = getInteractionRoot(instance);
+  batch(() => {
+    dispatchClassifiedNativeEvent(root, type, nativeEvent);
+    dispatchObservers(root.eventRoot.observers.get(type), nativeEvent);
+  });
+}
+function dispatchToLogicalTarget(type, target, originalEvent, relatedTarget = null, sourceEvent) {
+  if (!target.live) return void 0;
+  return batch(
+    () => dispatchEventPath({
+      type,
+      target,
+      relatedTarget,
+      originalEvent,
+      sourceEvent
+    })
+  );
+}
+function classifyNativeEventType(type) {
+  switch (type) {
+    case "pointerover":
+    case "pointerenter":
+    case "pointerdown":
+    case "pointermove":
+    case "pointerrawupdate":
+    case "pointerup":
+    case "pointercancel":
+    case "pointerout":
+    case "pointerleave":
+    case "gotpointercapture":
+    case "lostpointercapture":
+      return "pointer";
+    case "click":
+    case "dblclick":
+    case "auxclick":
+    case "contextmenu":
+    case "mouseover":
+    case "mouseenter":
+    case "mousedown":
+    case "mousemove":
+    case "mouseup":
+    case "mouseout":
+    case "mouseleave":
+      return "mouse";
+    case "touchstart":
+    case "touchmove":
+    case "touchend":
+    case "touchcancel":
+      return "touch";
+    case "wheel":
+      return "wheel";
+    case "keydown":
+    case "keyup":
+    case "focus":
+    case "blur":
+    case "focusin":
+    case "focusout":
+      return "keyboard-focus";
+    case "beforeinput":
+    case "input":
+    case "change":
+    case "compositionstart":
+    case "compositionupdate":
+    case "compositionend":
+    case "select":
+    case "selectionchange":
+      return "editing";
+    case "copy":
+    case "cut":
+    case "paste":
+      return "clipboard";
+    case "dragstart":
+    case "drag":
+    case "dragend":
+    case "dragenter":
+    case "dragleave":
+    case "dragover":
+    case "drop":
+      return "drag";
+  }
+  return assertNever(type);
+}
+function dispatchClassifiedNativeEvent(root, type, nativeEvent) {
+  const route = classifyNativeEventType(type);
+  switch (route) {
+    case "pointer": {
+      if (!isNativePointerEventType(type)) {
+        throw nativeRouteMismatch(type, route);
+      }
+      const input = adaptPointerEvent(root, type, nativeEvent);
+      if (input) dispatchPointerEvent(root, input);
+      return;
+    }
+    case "mouse": {
+      if (!isNativeMouseEventType(type)) {
+        throw nativeRouteMismatch(type, route);
+      }
+      const input = adaptMouseEvent(root, type, nativeEvent);
+      if (input) dispatchMouseEvent(root, input);
+      return;
+    }
+    case "touch": {
+      if (!isNativeTouchEventType(type)) {
+        throw nativeRouteMismatch(type, route);
+      }
+      const input = adaptTouchEvent(root, type, nativeEvent);
+      if (input) dispatchTouchEvent(root, input);
+      return;
+    }
+    case "wheel": {
+      if (!isNativeWheelEventType(type)) {
+        throw nativeRouteMismatch(type, route);
+      }
+      const input = adaptWheelEvent(root, nativeEvent);
+      if (input) dispatchWheelEvent(root, input);
+      return;
+    }
+    case "keyboard-focus": {
+      if (!isNativeKeyboardFocusEventType(type)) {
+        throw nativeRouteMismatch(type, route);
+      }
+      const input = adaptKeyboardFocusEvent(type, nativeEvent);
+      if (input) dispatchFocusedNativeEvent(root, input);
+      return;
+    }
+    case "editing": {
+      if (!isNativeEditingEventType(type)) {
+        throw nativeRouteMismatch(type, route);
+      }
+      const input = adaptEditingEvent(type, nativeEvent);
+      if (input) dispatchFocusedNativeEvent(root, input);
+      return;
+    }
+    case "clipboard": {
+      if (!isNativeClipboardEventType(type)) {
+        throw nativeRouteMismatch(type, route);
+      }
+      const input = adaptClipboardEvent(type, nativeEvent);
+      if (input) dispatchFocusedNativeEvent(root, input);
+      return;
+    }
+    case "drag": {
+      if (!isNativeDragEventType(type)) {
+        throw nativeRouteMismatch(type, route);
+      }
+      const input = adaptDragEvent(root, type, nativeEvent);
+      if (input) dispatchDragEvent(root, input);
+      return;
+    }
+  }
+  return assertNever(route);
+}
+function dispatchFocusedNativeEvent(root, input) {
+  const installedPolicy = root.eventRoot.focusPolicy;
+  const policy = installedPolicy?.beforeNativeDispatch ? installedPolicy.beforeNativeDispatch(input.type, input.originalEvent) : installedPolicy;
+  const target = policy?.resolveKeyboardTarget();
+  if (!policy || !target || !isLiveNode(root, target)) return;
+  const event = dispatchToLogicalTarget(
+    input.type,
+    target,
+    input.originalEvent
+  );
+  if ((input.type === "keydown" || input.type === "keyup") && event && isLiveNode(root, target) && root.eventRoot.focusPolicy === policy && policy.resolveKeyboardTarget() === target) {
+    policy.afterDispatch(event);
+  }
+}
+function nativeRouteMismatch(type, route) {
+  return new Error(`Pibbl event ${type} is not valid for the ${route} route.`);
+}
+function releaseEventNodeState(instance, node) {
+  const root = getInteractionRoot(instance);
+  releasePointerHoverTarget(root.eventRoot, node);
+  releaseTouchTarget(root.eventRoot, node);
+  releaseDragHoverTarget(root.eventRoot, node);
+  const interaction = root.interaction;
+  if (node.kind === "target" && interaction.hoveredRegion === node) {
+    const canvas = interaction.pointerCanvas;
+    interaction.hoveredRegion = void 0;
+    releaseCursor(root);
+    if (canvas) applyCursor(root, void 0, canvas);
+  }
+  interaction.primaryDown = removeActivationNode(
+    interaction.primaryDown,
+    node
+  );
+  interaction.primaryUp = removeActivationNode(interaction.primaryUp, node);
+  removeActivationNodeFromMap(interaction.auxiliaryDown, node);
+  removeActivationNodeFromMap(interaction.auxiliaryUp, node);
+  if (interaction.clickStreakTarget === node) {
+    interaction.clickStreakTarget = void 0;
+    interaction.clickStreak = 0;
+  }
+}
+function removeInteractionRegion(_instance, region) {
+  releaseTarget(region);
+}
+function refreshInteractionCursor(instance, region) {
+  const root = getInteractionRoot(instance);
+  if (root.interaction.hoveredRegion === region && root.interaction.pointerCanvas) {
+    applyCursor(root, region, root.interaction.pointerCanvas);
+  }
+}
+function updateCursorDefault(instance, cursorDefault) {
+  const root = getInteractionRoot(instance);
+  const existing = cursorDefaultOwnership.get(cursorDefault);
+  if (existing?.root === root) return;
+  releaseCursorDefaultOwnership(cursorDefault);
+  const hub = root.eventRoot.nativeListeners;
+  if (!hub) return;
+  cursorDefaultOwnership.set(cursorDefault, {
+    root,
+    releases: [hub.acquire("mousemove"), hub.acquire("mouseout")]
+  });
+}
+function removeCursorDefault(instance, cursorDefault) {
+  releaseCursorDefaultOwnership(cursorDefault);
+  const root = getInteractionRoot(instance);
+  root.cursorDefaults.delete(cursorDefault);
+  if (root.interaction.cursorDefault === cursorDefault) {
+    const canvas = root.interaction.pointerCanvas;
+    releaseCursor(root);
+    if (canvas) applyCursor(root, root.interaction.hoveredRegion, canvas);
+  }
+}
+function refreshCursorDefault(instance) {
+  const root = getInteractionRoot(instance);
+  const canvas = root.interaction.pointerCanvas;
+  if (canvas) applyCursor(root, root.interaction.hoveredRegion, canvas);
+}
+function dispatchPointerEvent(root, input) {
+  if (input.type !== "gotpointercapture" && input.type !== "lostpointercapture") {
+    processPendingLogicalPointerCapture(
+      root.eventRoot,
+      input.originalEvent.pointerId,
+      (target) => dispatchPointerNode("lostpointercapture", target, input),
+      (target) => dispatchPointerNode("gotpointercapture", target, input)
+    );
+  }
+  switch (input.type) {
+    case "pointerover":
+      dispatchPointerBoundaryEntry(root, input);
+      return;
+    case "pointermove":
+      dispatchPointerMove(root, input);
+      return;
+    case "pointerout":
+      dispatchRootPointerOut(root, input);
+      return;
+    case "pointerdown":
+    case "pointerrawupdate":
+      dispatchPointerCoordinateEvent(root, input);
+      return;
+    case "pointerup":
+      dispatchPointerCoordinateEvent(root, input);
+      deleteManipulationPointerPress(root, input.originalEvent.pointerId);
+      return;
+    case "pointercancel":
+      dispatchPointerCancel(root, input);
+      deleteManipulationPointerPress(root, input.originalEvent.pointerId);
+      return;
+    case "gotpointercapture":
+      dispatchGotPointerCapture(root, input);
+      return;
+    case "lostpointercapture":
+      dispatchLostPointerCapture(root, input);
+      return;
+    case "pointerenter":
+    case "pointerleave":
+      return;
+  }
+}
+function dispatchPointerBoundaryEntry(root, input) {
+  const pointerId = input.originalEvent.pointerId;
+  const previous = livePointerHover(root, pointerId);
+  const next = resolvePointerTarget(root, input);
+  if (previous === next) return;
+  dispatchPointerTransition(root, previous, next, input, false);
+}
+function dispatchPointerMove(root, input) {
+  const pointerId = input.originalEvent.pointerId;
+  const previous = livePointerHover(root, pointerId);
+  const next = resolvePointerTarget(root, input, true);
+  if (previous === next) {
+    if (next) dispatchPointerNode("pointermove", next, input);
+    return;
+  }
+  dispatchPointerTransition(root, previous, next, input, true);
+}
+function dispatchRootPointerOut(root, input) {
+  const pointerId = input.originalEvent.pointerId;
+  const previous = livePointerHover(root, pointerId);
+  dispatchPointerTransition(root, previous, void 0, input, false);
+}
+function dispatchPointerTransition(root, previous, next, input, dispatchMove) {
+  const pointerId = input.originalEvent.pointerId;
+  const oldPath = previous ? buildEventPath(previous) : [];
+  const newPath = next ? buildEventPath(next) : [];
+  const plan = planBoundaryTransitions(oldPath, newPath);
+  const oldLeaf = oldPath.at(-1);
+  const newLeaf = newPath.at(-1);
+  deletePointerHover(root.eventRoot, pointerId);
+  if (oldLeaf?.live) {
+    dispatchPointerNode("pointerout", oldLeaf, input, newLeaf ?? null);
+  }
+  for (const node of plan.exited) {
+    if (node.live) {
+      dispatchPointerNode("pointerleave", node, input, newLeaf ?? null);
+    }
+  }
+  const liveNext = next && isLiveNode(root, next) ? next : void 0;
+  if (!liveNext) return;
+  setPointerHover(root.eventRoot, pointerId, liveNext);
+  dispatchPointerNode("pointerover", liveNext, input, oldLeaf ?? null);
+  if (!isLiveNode(root, liveNext)) return;
+  for (const node of plan.entered) {
+    if (!isLiveNode(root, liveNext)) return;
+    if (node.live) {
+      dispatchPointerNode("pointerenter", node, input, oldLeaf ?? null);
+    }
+  }
+  if (dispatchMove && isLiveNode(root, liveNext)) {
+    dispatchPointerNode("pointermove", liveNext, input);
+  }
+}
+function dispatchPointerCoordinateEvent(root, input) {
+  const policy = root.eventRoot.focusPolicy;
+  const logicalCapture = getLogicalPointerCapture(
+    root.eventRoot,
+    input.originalEvent.pointerId
+  );
+  const coordinateTarget = !logicalCapture || input.press ? input.type === "pointerdown" || input.type === "pointerup" || input.type === "pointercancel" ? resolvePointerInputTarget(root, input) : resolveCoordinateTarget(root.eventRoot, input) : void 0;
+  const target = logicalCapture ?? coordinateTarget;
+  if (input.type === "pointerdown") {
+    recordManipulationPointerPress(root, input.originalEvent.pointerId, coordinateTarget);
+  }
+  const event = target ? dispatchPointerNode(input.type, target, input) : void 0;
+  if (input.press) {
+    dispatchPressDefault(root, policy, {
+      source: "pointer",
+      target: coordinateTarget,
+      event,
+      originalEvent: input.originalEvent,
+      x: input.press.x,
+      y: input.press.y,
+      pointerId: input.press.pointerId,
+      pointerType: input.press.pointerType
+    });
+  }
+}
+function dispatchPointerCancel(root, input) {
+  dispatchPointerCoordinateEvent(root, input);
+  cancelLogicalPointerCapture(
+    root.eventRoot,
+    input.originalEvent.pointerId
+  );
+}
+function dispatchGotPointerCapture(root, input) {
+  const target = activateLogicalPointerCapture(
+    root.eventRoot,
+    input.originalEvent.pointerId
+  );
+  if (target) dispatchPointerNode("gotpointercapture", target, input);
+}
+function dispatchLostPointerCapture(root, input) {
+  const target = consumeLogicalPointerCaptureLoss(
+    root.eventRoot,
+    input.originalEvent.pointerId
+  );
+  if (target) dispatchPointerNode("lostpointercapture", target, input);
+}
+function resolvePointerTarget(root, input, deliverInput = false) {
+  const logicalCapture = getLogicalPointerCapture(
+    root.eventRoot,
+    input.originalEvent.pointerId
+  );
+  if (logicalCapture) return logicalCapture;
+  const resolverCapture = getResolverPointerCapture(
+    root.eventRoot,
+    input.originalEvent.pointerId
+  );
+  if (resolverCapture) {
+    if (deliverInput && input.type === "pointermove") {
+      dispatchCapturedResolverInput(
+        resolverCapture,
+        "pointermove",
+        input,
+        input.originalEvent
+      );
+    }
+    return void 0;
+  }
+  return deliverInput && input.type === "pointermove" ? resolveCoordinateInputTarget(root, input, "pointermove") : resolveCoordinateTarget(root.eventRoot, input);
+}
+function resolvePointerInputTarget(root, input) {
+  const type = input.type;
+  const captured = getResolverPointerCapture(
+    root.eventRoot,
+    input.originalEvent.pointerId
+  );
+  if (captured && (type === "pointerup" || type === "pointercancel")) {
+    dispatchCapturedResolverInput(captured, type, input, input.originalEvent);
+    return void 0;
+  }
+  return resolveCoordinateInputTarget(root, input, type);
+}
+function dispatchPointerNode(type, target, input, relatedTarget = null) {
+  if (!target.live) return void 0;
+  return dispatchEventPath({
+    type,
+    target,
+    relatedTarget,
+    originalEvent: input.originalEvent,
+    x: input.x,
+    y: input.y
+  });
+}
+function livePointerHover(root, pointerId) {
+  const targets = pointerHoverTargets.get(root.eventRoot);
+  const target = targets?.get(pointerId);
+  if (!target || isLiveNode(root, target)) return target;
+  targets?.delete(pointerId);
+  if (targets?.size === 0) pointerHoverTargets.delete(root.eventRoot);
+  return void 0;
+}
+function setPointerHover(eventRoot, pointerId, target) {
+  let targets = pointerHoverTargets.get(eventRoot);
+  if (!targets) {
+    targets = /* @__PURE__ */ new Map();
+    pointerHoverTargets.set(eventRoot, targets);
+  }
+  targets.set(pointerId, target);
+}
+function deletePointerHover(eventRoot, pointerId) {
+  const targets = pointerHoverTargets.get(eventRoot);
+  targets?.delete(pointerId);
+  if (targets?.size === 0) pointerHoverTargets.delete(eventRoot);
+}
+function releasePointerHoverTarget(eventRoot, target) {
+  const targets = pointerHoverTargets.get(eventRoot);
+  if (!targets) return;
+  for (const [pointerId, hovered] of targets) {
+    if (hovered === target) targets.delete(pointerId);
+  }
+  if (targets.size === 0) pointerHoverTargets.delete(eventRoot);
+}
+function dispatchTouchEvent(root, input) {
+  const policy = root.eventRoot.focusPolicy;
+  const groups = /* @__PURE__ */ new Map();
+  const defaultContacts = [];
+  for (const contact of input.changedContacts) {
+    const identifier = contact.touch.identifier;
+    let target;
+    if (input.type === "touchstart") {
+      target = resolveCoordinateTarget(root.eventRoot, contact);
+      if (target) setTouchTarget(root.eventRoot, identifier, target);
+      else deleteTouchTarget(root.eventRoot, identifier);
+    } else {
+      target = liveTouchTarget(root, identifier);
+    }
+    defaultContacts.push({
+      identifier,
+      target: target?.kind === "target" ? target : void 0,
+      x: contact.x,
+      y: contact.y
+    });
+    if (target) {
+      const contacts = groups.get(target);
+      if (contacts) contacts.push(contact);
+      else groups.set(target, [contact]);
+    }
+    if (input.type === "touchend" || input.type === "touchcancel") {
+      deleteTouchTarget(root.eventRoot, identifier);
+    }
+  }
+  for (const [target, contacts] of groups) {
+    if (!isLiveNode(root, target)) continue;
+    const first = contacts[0];
+    dispatchEventPath({
+      type: input.type,
+      target,
+      originalEvent: input.originalEvent,
+      x: first.x,
+      y: first.y
+    });
+  }
+  dispatchTouchDefault(root, policy, {
+    type: input.type,
+    changedContacts: Object.freeze(defaultContacts),
+    activeIdentifiers: Object.freeze(
+      Array.from(input.originalEvent.touches, (touch) => touch.identifier)
+    ),
+    originalEvent: input.originalEvent
+  });
+}
+function liveTouchTarget(root, identifier) {
+  const target = touchTargets.get(root.eventRoot)?.get(identifier);
+  if (!target || isLiveNode(root, target)) return target;
+  deleteTouchTarget(root.eventRoot, identifier);
+  return void 0;
+}
+function setTouchTarget(eventRoot, identifier, target) {
+  let targets = touchTargets.get(eventRoot);
+  if (!targets) {
+    targets = /* @__PURE__ */ new Map();
+    touchTargets.set(eventRoot, targets);
+  }
+  targets.set(identifier, target);
+}
+function deleteTouchTarget(eventRoot, identifier) {
+  const targets = touchTargets.get(eventRoot);
+  targets?.delete(identifier);
+  if (targets?.size === 0) touchTargets.delete(eventRoot);
+}
+function releaseTouchTarget(eventRoot, target) {
+  const targets = touchTargets.get(eventRoot);
+  if (!targets) return;
+  for (const [identifier, owner] of targets) {
+    if (owner === target) targets.delete(identifier);
+  }
+  if (targets.size === 0) touchTargets.delete(eventRoot);
+}
+function dispatchWheelEvent(root, input) {
+  const target = resolveCoordinateInputTarget(root, input, "wheel");
+  if (!target) return;
+  dispatchEventPath({
+    type: "wheel",
+    target,
+    originalEvent: input.originalEvent,
+    x: input.x,
+    y: input.y
+  });
+}
+function dispatchDragEvent(root, input) {
+  switch (input.type) {
+    case "dragenter":
+      reconcileDragTarget(root, input);
+      return;
+    case "dragover": {
+      const target = reconcileDragTarget(root, input);
+      if (target) dispatchDragNode("dragover", target, input);
+      return;
+    }
+    case "dragleave":
+      dispatchDragTransition(
+        root,
+        liveDragHover(root),
+        void 0,
+        input
+      );
+      return;
+    case "drop": {
+      const target = reconcileDragTarget(root, input);
+      if (target) dispatchDragNode("drop", target, input);
+      dragHoverTargets.delete(root.eventRoot);
+      return;
+    }
+    case "dragend":
+      dispatchDragCoordinateEvent(root, input);
+      dragHoverTargets.delete(root.eventRoot);
+      return;
+    case "dragstart":
+    case "drag":
+      dispatchDragCoordinateEvent(root, input);
+      return;
+  }
+  return assertNever(input.type);
+}
+function reconcileDragTarget(root, input) {
+  const previous = liveDragHover(root);
+  const next = resolveCoordinateTarget(root.eventRoot, input);
+  if (previous === next) return next;
+  return dispatchDragTransition(root, previous, next, input);
+}
+function dispatchDragTransition(root, previous, next, input) {
+  const oldPath = previous ? buildEventPath(previous) : [];
+  const newPath = next ? buildEventPath(next) : [];
+  const plan = planBoundaryTransitions(oldPath, newPath);
+  const oldLeaf = oldPath.at(-1);
+  const newLeaf = newPath.at(-1);
+  dragHoverTargets.delete(root.eventRoot);
+  for (const node of plan.exited) {
+    if (node.live) {
+      dispatchDragNode("dragleave", node, input, newLeaf ?? null);
+    }
+  }
+  const liveNext = next && isLiveNode(root, next) ? next : void 0;
+  if (!liveNext) return void 0;
+  dragHoverTargets.set(root.eventRoot, liveNext);
+  for (const node of plan.entered) {
+    if (!isLiveNode(root, liveNext)) {
+      dragHoverTargets.delete(root.eventRoot);
+      return void 0;
+    }
+    if (node.live) {
+      dispatchDragNode("dragenter", node, input, oldLeaf ?? null);
+    }
+  }
+  return isLiveNode(root, liveNext) ? liveNext : void 0;
+}
+function dispatchDragCoordinateEvent(root, input) {
+  const target = resolveCoordinateTarget(root.eventRoot, input);
+  if (target) dispatchDragNode(input.type, target, input);
+}
+function dispatchDragNode(type, target, input, relatedTarget = null) {
+  if (!target.live) return;
+  dispatchEventPath({
+    type,
+    target,
+    relatedTarget,
+    originalEvent: input.originalEvent,
+    x: input.x,
+    y: input.y
+  });
+}
+function liveDragHover(root) {
+  const target = dragHoverTargets.get(root.eventRoot);
+  if (!target || isLiveNode(root, target)) return target;
+  dragHoverTargets.delete(root.eventRoot);
+  return void 0;
+}
+function releaseDragHoverTarget(eventRoot, target) {
+  if (dragHoverTargets.get(eventRoot) === target) {
+    dragHoverTargets.delete(eventRoot);
+  }
+}
+function dispatchMouseEvent(root, input) {
+  switch (input.type) {
+    case "mousemove":
+      dispatchMouseMove(root, input);
+      return;
+    case "mouseout":
+      dispatchRootMouseOut(root, input);
+      return;
+    case "mousedown":
+    case "mouseup":
+      dispatchMouseButton(root, input);
+      return;
+    case "click":
+    case "auxclick":
+      dispatchActivation(root, input, input.type);
+      return;
+    case "dblclick":
+      dispatchDoubleClick(root, input);
+      return;
+    case "contextmenu":
+      dispatchCoordinateEvent(root, input);
+      return;
+    case "mouseover":
+    case "mouseenter":
+    case "mouseleave":
+      return;
+  }
+}
+function dispatchMouseMove(root, input) {
+  const canvas = root.eventRoot.canvas;
+  if (!canvas) return;
+  root.interaction.pointerCanvas = canvas;
+  const previous = liveTarget(root, root.interaction.hoveredRegion);
+  const next = resolveCoordinateTarget(root.eventRoot, input);
+  if (previous === next) {
+    applyCursor(root, next, canvas);
+    if (next) dispatchMouseNode("mousemove", next, input);
+    return;
+  }
+  dispatchMouseTransition(root, previous, next, input, canvas);
+}
+function dispatchRootMouseOut(root, input) {
+  const previous = liveTarget(root, root.interaction.hoveredRegion);
+  root.interaction.pointerCanvas = void 0;
+  dispatchMouseTransition(root, previous, void 0, input, void 0);
+}
+function dispatchMouseTransition(root, previous, next, input, pointerCanvas) {
+  const oldPath = previous ? buildEventPath(previous) : [];
+  const newPath = next ? buildEventPath(next) : [];
+  const plan = planBoundaryTransitions(oldPath, newPath);
+  const oldLeaf = oldPath.at(-1);
+  const newLeaf = newPath.at(-1);
+  root.interaction.hoveredRegion = void 0;
+  releaseCursor(root);
+  if (oldLeaf?.live) {
+    dispatchMouseNode("mouseout", oldLeaf, input, newLeaf ?? null);
+  }
+  for (const node of plan.exited) {
+    if (node.live) dispatchMouseNode("mouseleave", node, input, newLeaf ?? null);
+  }
+  const liveNext = liveTarget(root, next);
+  if (!liveNext) {
+    if (pointerCanvas) applyCursor(root, void 0, pointerCanvas);
+    return;
+  }
+  root.interaction.hoveredRegion = liveNext;
+  if (pointerCanvas) applyCursor(root, liveNext, pointerCanvas);
+  dispatchMouseNode("mouseover", liveNext, input, oldLeaf ?? null);
+  if (!liveTarget(root, liveNext)) return;
+  for (const node of plan.entered) {
+    if (!liveTarget(root, liveNext)) return;
+    if (node.live) dispatchMouseNode("mouseenter", node, input, oldLeaf ?? null);
+  }
+  if (liveTarget(root, liveNext)) {
+    dispatchMouseNode("mousemove", liveNext, input);
+  }
+}
+function dispatchMouseButton(root, input) {
+  const policy = root.eventRoot.focusPolicy;
+  const target = resolveCoordinateTarget(root.eventRoot, input);
+  const path = target ? buildEventPath(target) : void 0;
+  const activation = path ? Object.freeze({
+    button: input.originalEvent.button,
+    path
+  }) : void 0;
+  const button = input.originalEvent.button;
+  if (input.type === "mousedown") {
+    if (button === 0) {
+      root.interaction.primaryDown = activation;
+      root.interaction.primaryUp = void 0;
+    } else {
+      updateActivationMap(root.interaction.auxiliaryDown, button, activation);
+      root.interaction.auxiliaryUp.delete(button);
+    }
+  } else {
+    if (button === 0) {
+      root.interaction.primaryUp = activation;
+    } else {
+      updateActivationMap(root.interaction.auxiliaryUp, button, activation);
+    }
+  }
+  const event = target ? dispatchMouseNode(input.type, target, input) : void 0;
+  if (input.press) {
+    dispatchPressDefault(root, policy, {
+      source: "mouse",
+      target,
+      event,
+      originalEvent: input.originalEvent,
+      x: input.press.x,
+      y: input.press.y
+    });
+  }
+}
+function dispatchActivation(root, input, type) {
+  const interaction = root.interaction;
+  const button = input.originalEvent.button;
+  const down = type === "click" ? interaction.primaryDown : interaction.auxiliaryDown.get(button);
+  const up = type === "click" ? interaction.primaryUp : interaction.auxiliaryUp.get(button);
+  const target = activationTarget(
+    root,
+    down,
+    up,
+    button,
+    type
+  );
+  if (type === "click") {
+    interaction.primaryDown = void 0;
+    interaction.primaryUp = void 0;
+  } else {
+    interaction.auxiliaryDown.delete(button);
+    interaction.auxiliaryUp.delete(button);
+  }
+  const coordinateTarget = type === "click" ? resolveCoordinateInputTarget(root, input, "click") : resolveCoordinateTarget(root.eventRoot, input);
+  if (type === "click" && consumeManipulationActivation(root, down, up, coordinateTarget, input.originalEvent)) {
+    resetClickStreak(root);
+    return;
+  }
+  if (!target || !coordinateTarget || !buildEventPath(coordinateTarget).includes(target)) {
+    if (type === "click") resetClickStreak(root);
+    return;
+  }
+  dispatchMouseNode(type, target, input);
+  if (type !== "click") return;
+  if (!isLiveNode(root, target)) {
+    resetClickStreak(root);
+    return;
+  }
+  if (interaction.clickStreakTarget === target) {
+    interaction.clickStreak++;
+  } else {
+    interaction.clickStreakTarget = target;
+    interaction.clickStreak = 1;
+  }
+}
+function dispatchDoubleClick(root, input) {
+  const target = root.interaction.clickStreakTarget;
+  if (!target || root.interaction.clickStreak < 2 || !isLiveNode(root, target)) {
+    return;
+  }
+  if (!coordinatePathIncludes(root, input, target)) return;
+  dispatchMouseNode("dblclick", target, input);
+}
+function coordinatePathIncludes(root, input, node) {
+  const coordinateTarget = resolveCoordinateTarget(root.eventRoot, input);
+  return Boolean(
+    coordinateTarget && buildEventPath(coordinateTarget).includes(node)
+  );
+}
+function dispatchCoordinateEvent(root, input) {
+  const target = input.type === "contextmenu" ? resolveCoordinateInputTarget(root, input, "contextmenu") : resolveCoordinateTarget(root.eventRoot, input);
+  if (target) dispatchMouseNode(input.type, target, input);
+}
+function resolveCoordinateInputTarget(root, point, type) {
+  const output = resolveCoordinateOutput(root.eventRoot, point);
+  dispatchResolvedInput(output, type, point, point.originalEvent);
+  return output.disposition === PibblHitDisposition.Target ? output.target ?? void 0 : void 0;
+}
+function dispatchMouseNode(type, target, input, relatedTarget = null) {
+  if (!target.live) return void 0;
+  return dispatchEventPath({
+    type,
+    target,
+    relatedTarget,
+    originalEvent: input.originalEvent,
+    x: input.x,
+    y: input.y
+  });
+}
+function dispatchPressDefault(root, policy, input) {
+  if (policy && root.eventRoot.focusPolicy === policy && policy.afterPressDispatch) {
+    policy.afterPressDispatch(input);
+  }
+}
+function dispatchTouchDefault(root, policy, input) {
+  if (policy && root.eventRoot.focusPolicy === policy && policy.afterTouchDispatch) {
+    policy.afterTouchDispatch(input);
+  }
+}
+function activationTarget(root, down, up, button, type) {
+  if (!down || !up || down.button !== button || up.button !== button || (type === "click" ? button !== 0 : button === 0)) {
+    return void 0;
+  }
+  const upNodes = new Set(up.path);
+  for (let index = down.path.length - 1; index >= 0; index--) {
+    const node = down.path[index];
+    if (upNodes.has(node) && isLiveNode(root, node)) return node;
+  }
+  return void 0;
+}
+function isLiveNode(root, node) {
+  if (!node.live || node.owner.eventRoot !== root.eventRoot) return false;
+  if (node.kind === "target") return root.eventRoot.targets.has(node);
+  return root.eventRoot.listenersByComponent.get(node.component.id)?.has(node) ?? false;
+}
+function liveTarget(root, target) {
+  return target && isLiveNode(root, target) ? target : void 0;
+}
+function removeActivationNode(activation, node) {
+  if (!activation?.path.includes(node)) return activation;
+  if (node.kind === "target") return void 0;
+  const path = activation.path.filter((candidate) => candidate !== node);
+  return path.length > 0 ? Object.freeze({ ...activation, path }) : void 0;
+}
+function removeActivationNodeFromMap(activations, node) {
+  for (const [button, activation] of activations) {
+    updateActivationMap(
+      activations,
+      button,
+      removeActivationNode(activation, node)
+    );
+  }
+}
+function updateActivationMap(activations, button, activation) {
+  if (activation) activations.set(button, activation);
+  else activations.delete(button);
+}
+function resetClickStreak(root) {
+  root.interaction.clickStreakTarget = void 0;
+  root.interaction.clickStreak = 0;
+}
+function recordManipulationPointerPress(root, pointerId, target) {
+  retainManipulationActivationState(root);
+  pendingManipulationActivations.get(root)?.delete(pointerId);
+  const press = Object.freeze({
+    path: target ? Object.freeze(buildEventPath(target)) : void 0
+  });
+  let presses = manipulationPointerPresses.get(root);
+  if (!presses) {
+    presses = /* @__PURE__ */ new Map();
+    manipulationPointerPresses.set(root, presses);
+  }
+  presses.set(pointerId, press);
+}
+function deleteManipulationPointerPress(root, pointerId) {
+  const presses = manipulationPointerPresses.get(root);
+  if (!presses) return;
+  presses.delete(pointerId);
+  if (presses.size === 0) manipulationPointerPresses.delete(root);
+}
+function retainManipulationActivationState(root) {
+  if (manipulationActivationRoots.has(root)) return;
+  manipulationActivationRoots.add(root);
+  root.mainTeardowns.add(() => {
+    manipulationPointerPresses.delete(root);
+    pendingManipulationActivations.delete(root);
+    manipulationActivationRoots.delete(root);
+  });
+}
+function consumeManipulationActivation(root, down, up, coordinateTarget, nativeEvent) {
+  const pending = pendingManipulationActivations.get(root);
+  if (!pending) return false;
+  const pointerId = clickPointerId(nativeEvent);
+  if (pointerId !== void 0) {
+    const activation = pending.get(pointerId);
+    if (!activation || !matchesManipulationActivation(activation, down, up, coordinateTarget)) {
+      return false;
+    }
+    deletePendingManipulationActivation(root, pending, pointerId);
+    return true;
+  }
+  let match;
+  for (const [candidatePointerId, activation] of pending) {
+    if (!matchesManipulationActivation(activation, down, up, coordinateTarget)) continue;
+    if (match !== void 0) return false;
+    match = candidatePointerId;
+  }
+  if (match === void 0) return false;
+  deletePendingManipulationActivation(root, pending, match);
+  return true;
+}
+function clickPointerId(nativeEvent) {
+  const pointerId = Reflect.get(nativeEvent, "pointerId");
+  return typeof pointerId === "number" && Number.isFinite(pointerId) ? pointerId : void 0;
+}
+function deletePendingManipulationActivation(root, pending, pointerId) {
+  pending.delete(pointerId);
+  if (pending.size === 0) pendingManipulationActivations.delete(root);
+}
+function matchesManipulationActivation(activation, down, up, coordinateTarget) {
+  if (activation.mouseDown && activation.mouseDown === down) return true;
+  const pointerPath = activation.pointerPress?.path;
+  const pressTarget = pointerPath?.at(-1);
+  if (!pressTarget || !coordinateTarget) return false;
+  const coordinatePath = buildEventPath(coordinateTarget);
+  if (!coordinatePath.includes(pressTarget)) return false;
+  return (!down || down.path.includes(pressTarget)) && (!up || up.path.includes(pressTarget));
+}
+function dispatchObservers(observers, event) {
+  if (!observers) return;
+  for (const observer of Array.from(observers)) {
+    if (!observers.has(observer)) continue;
+    try {
+      observer(event);
+    } catch (error) {
+      try {
+        globalThis.reportError(error);
+      } catch {
+      }
+    }
+  }
+}
+function releaseCursorDefaultOwnership(cursorDefault) {
+  const ownership = cursorDefaultOwnership.get(cursorDefault);
+  if (!ownership) return;
+  cursorDefaultOwnership.delete(cursorDefault);
+  for (const release of ownership.releases) release();
+}
+function applyCursor(instance, region, canvas) {
+  const interaction = instance.interaction;
+  const cursorDefault = region?.cursor ? void 0 : lastCursorDefault(instance);
+  const style = region?.cursor ?? cursorDefault?.style;
+  if (interaction.cursorRegion === region && interaction.cursorDefault === cursorDefault && interaction.cursorCanvas === canvas && interaction.cursorStyle === canvas.style.cursor && style === interaction.cursorStyle) {
+    return;
+  }
+  releaseCursor(instance);
+  if (style && !canvas.style.cursor) {
+    canvas.style.cursor = style;
+    if (canvas.style.cursor) {
+      interaction.cursorRegion = region;
+      interaction.cursorDefault = cursorDefault;
+      interaction.cursorCanvas = canvas;
+      interaction.cursorStyle = canvas.style.cursor;
+    }
+  }
+}
+function lastCursorDefault(instance) {
+  return Array.from(instance.cursorDefaults).at(-1);
+}
+function releaseCursor(instance) {
+  const interaction = instance.interaction;
+  const { cursorCanvas, cursorStyle } = interaction;
+  if (cursorCanvas && cursorStyle && cursorCanvas.style.cursor === cursorStyle) {
+    cursorCanvas.style.removeProperty("cursor");
+  }
+  interaction.cursorRegion = void 0;
+  interaction.cursorDefault = void 0;
+  interaction.cursorCanvas = void 0;
+  interaction.cursorStyle = void 0;
+}
+function assertNever(value) {
+  throw new Error(`Unhandled Pibbl event route: ${String(value)}`);
+}
+export {
+  classifyNativeEventType,
+  dispatchNativeEvent,
+  dispatchToLogicalTarget,
+  refreshCursorDefault,
+  refreshInteractionCursor,
+  releaseEventNodeState,
+  removeCursorDefault,
+  removeInteractionRegion,
+  suppressManipulationActivation,
+  updateCursorDefault
+};
+//# sourceMappingURL=dispatch.js.map