@pibbl/core 0.0.1

package/dist/lib/events/adapters/drag.js

@@ -0,0 +1,29 @@
+import { getMouseCoordinates } from "../../util/get-mouse-coordinates.js";
+const PIBBL_NATIVE_DRAG_EVENT_TYPES = Object.freeze([
+  "dragstart",
+  "drag",
+  "dragend",
+  "dragenter",
+  "dragleave",
+  "dragover",
+  "drop"
+]);
+const nativeDragEventTypes = new Set(
+  PIBBL_NATIVE_DRAG_EVENT_TYPES
+);
+function isNativeDragEventType(type) {
+  return nativeDragEventTypes.has(type);
+}
+function adaptDragEvent(root, type, event) {
+  if (typeof DragEvent === "undefined" || !(event instanceof DragEvent) || !root.surface.snapshot) {
+    return void 0;
+  }
+  const [x, y] = getMouseCoordinates(event, root);
+  return { type, originalEvent: event, x, y };
+}
+export {
+  PIBBL_NATIVE_DRAG_EVENT_TYPES,
+  adaptDragEvent,
+  isNativeDragEventType
+};
+//# sourceMappingURL=drag.js.map

package/dist/lib/events/adapters/drag.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/lib/events/adapters/drag.ts"],
+  "sourcesContent": ["import type { PibblInstance } from '../../types.js';\nimport { getMouseCoordinates } from '../../util/get-mouse-coordinates.js';\nimport type { PibblEventType } from '../types.js';\n\nexport const PIBBL_NATIVE_DRAG_EVENT_TYPES = Object.freeze([\n  'dragstart',\n  'drag',\n  'dragend',\n  'dragenter',\n  'dragleave',\n  'dragover',\n  'drop',\n] as const satisfies readonly PibblEventType[]);\n\nexport type PibblNativeDragEventType =\n  (typeof PIBBL_NATIVE_DRAG_EVENT_TYPES)[number];\n\nconst nativeDragEventTypes = new Set<PibblEventType>(\n  PIBBL_NATIVE_DRAG_EVENT_TYPES,\n);\n\nexport interface PibblAdaptedDragEvent {\n  readonly type: PibblNativeDragEventType;\n  readonly originalEvent: DragEvent;\n  readonly x: number;\n  readonly y: number;\n}\n\nexport function isNativeDragEventType(\n  type: PibblEventType,\n): type is PibblNativeDragEventType {\n  return nativeDragEventTypes.has(type);\n}\n\nexport function adaptDragEvent(\n  root: PibblInstance,\n  type: PibblNativeDragEventType,\n  event: Event,\n): PibblAdaptedDragEvent | undefined {\n  if (\n    typeof DragEvent === 'undefined' ||\n    !(event instanceof DragEvent) ||\n    !root.surface.snapshot\n  ) {\n    return undefined;\n  }\n  const [x, y] = getMouseCoordinates(event, root);\n  return { type, originalEvent: event, x, y };\n}\n"],
+  "mappings": "AACA,SAAS,2BAA2B;AAG7B,MAAM,gCAAgC,OAAO,OAAO;AAAA,EACzD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAA8C;AAK9C,MAAM,uBAAuB,IAAI;AAAA,EAC/B;AACF;AASO,SAAS,sBACd,MACkC;AAClC,SAAO,qBAAqB,IAAI,IAAI;AACtC;AAEO,SAAS,eACd,MACA,MACA,OACmC;AACnC,MACE,OAAO,cAAc,eACrB,EAAE,iBAAiB,cACnB,CAAC,KAAK,QAAQ,UACd;AACA,WAAO;AAAA,EACT;AACA,QAAM,CAAC,GAAG,CAAC,IAAI,oBAAoB,OAAO,IAAI;AAC9C,SAAO,EAAE,MAAM,eAAe,OAAO,GAAG,EAAE;AAC5C;",
+  "names": []
+}

package/dist/lib/events/adapters/editing.d.ts

@@ -0,0 +1,15 @@
+import type { PibblEventType } from '../types.js';
+export declare const PIBBL_NATIVE_EDITING_EVENT_TYPES: readonly ["beforeinput", "input", "change", "compositionstart", "compositionupdate", "compositionend", "select", "selectionchange"];
+export type PibblNativeEditingEventType = (typeof PIBBL_NATIVE_EDITING_EVENT_TYPES)[number];
+export type PibblAdaptedEditingEvent = {
+    readonly type: 'beforeinput' | 'input';
+    readonly originalEvent: InputEvent;
+} | {
+    readonly type: 'compositionend' | 'compositionstart' | 'compositionupdate';
+    readonly originalEvent: CompositionEvent;
+} | {
+    readonly type: 'change' | 'select' | 'selectionchange';
+    readonly originalEvent: Event;
+};
+export declare function isNativeEditingEventType(type: PibblEventType): type is PibblNativeEditingEventType;
+export declare function adaptEditingEvent(type: PibblNativeEditingEventType, event: Event): PibblAdaptedEditingEvent | undefined;

package/dist/lib/events/adapters/editing.js

@@ -0,0 +1,41 @@
+const PIBBL_NATIVE_EDITING_EVENT_TYPES = Object.freeze([
+  "beforeinput",
+  "input",
+  "change",
+  "compositionstart",
+  "compositionupdate",
+  "compositionend",
+  "select",
+  "selectionchange"
+]);
+const nativeEditingEventTypes = new Set(
+  PIBBL_NATIVE_EDITING_EVENT_TYPES
+);
+function isNativeEditingEventType(type) {
+  return nativeEditingEventTypes.has(type);
+}
+function adaptEditingEvent(type, event) {
+  switch (type) {
+    case "beforeinput":
+    case "input":
+      return typeof InputEvent !== "undefined" && event instanceof InputEvent ? { type, originalEvent: event } : void 0;
+    case "compositionstart":
+    case "compositionupdate":
+    case "compositionend":
+      return typeof CompositionEvent !== "undefined" && event instanceof CompositionEvent ? { type, originalEvent: event } : void 0;
+    case "change":
+    case "select":
+    case "selectionchange":
+      return { type, originalEvent: event };
+  }
+  return assertNever(type);
+}
+function assertNever(value) {
+  throw new Error(`Unhandled editing event type: ${String(value)}`);
+}
+export {
+  PIBBL_NATIVE_EDITING_EVENT_TYPES,
+  adaptEditingEvent,
+  isNativeEditingEventType
+};
+//# sourceMappingURL=editing.js.map

package/dist/lib/events/adapters/editing.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/lib/events/adapters/editing.ts"],
+  "sourcesContent": ["import type { PibblEventType } from '../types.js';\n\nexport const PIBBL_NATIVE_EDITING_EVENT_TYPES = Object.freeze([\n  'beforeinput',\n  'input',\n  'change',\n  'compositionstart',\n  'compositionupdate',\n  'compositionend',\n  'select',\n  'selectionchange',\n] as const satisfies readonly PibblEventType[]);\n\nexport type PibblNativeEditingEventType =\n  (typeof PIBBL_NATIVE_EDITING_EVENT_TYPES)[number];\n\nconst nativeEditingEventTypes = new Set<PibblEventType>(\n  PIBBL_NATIVE_EDITING_EVENT_TYPES,\n);\n\nexport type PibblAdaptedEditingEvent =\n  | {\n    readonly type: 'beforeinput' | 'input';\n    readonly originalEvent: InputEvent;\n  }\n  | {\n    readonly type:\n      | 'compositionend'\n      | 'compositionstart'\n      | 'compositionupdate';\n    readonly originalEvent: CompositionEvent;\n  }\n  | {\n    readonly type: 'change' | 'select' | 'selectionchange';\n    readonly originalEvent: Event;\n  };\n\nexport function isNativeEditingEventType(\n  type: PibblEventType,\n): type is PibblNativeEditingEventType {\n  return nativeEditingEventTypes.has(type);\n}\n\nexport function adaptEditingEvent(\n  type: PibblNativeEditingEventType,\n  event: Event,\n): PibblAdaptedEditingEvent | undefined {\n  switch (type) {\n    case 'beforeinput':\n    case 'input':\n      return typeof InputEvent !== 'undefined' && event instanceof InputEvent ?\n          { type, originalEvent: event } : undefined;\n    case 'compositionstart':\n    case 'compositionupdate':\n    case 'compositionend':\n      return typeof CompositionEvent !== 'undefined' &&\n        event instanceof CompositionEvent ?\n          { type, originalEvent: event } : undefined;\n    case 'change':\n    case 'select':\n    case 'selectionchange':\n      return { type, originalEvent: event };\n  }\n  return assertNever(type);\n}\n\nfunction assertNever(value: never): never {\n  throw new Error(`Unhandled editing event type: ${String(value)}`);\n}\n"],
+  "mappings": "AAEO,MAAM,mCAAmC,OAAO,OAAO;AAAA,EAC5D;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAA8C;AAK9C,MAAM,0BAA0B,IAAI;AAAA,EAClC;AACF;AAmBO,SAAS,yBACd,MACqC;AACrC,SAAO,wBAAwB,IAAI,IAAI;AACzC;AAEO,SAAS,kBACd,MACA,OACsC;AACtC,UAAQ,MAAM;AAAA,IACZ,KAAK;AAAA,IACL,KAAK;AACH,aAAO,OAAO,eAAe,eAAe,iBAAiB,aACzD,EAAE,MAAM,eAAe,MAAM,IAAI;AAAA,IACvC,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,aAAO,OAAO,qBAAqB,eACjC,iBAAiB,mBACf,EAAE,MAAM,eAAe,MAAM,IAAI;AAAA,IACvC,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,aAAO,EAAE,MAAM,eAAe,MAAM;AAAA,EACxC;AACA,SAAO,YAAY,IAAI;AACzB;AAEA,SAAS,YAAY,OAAqB;AACxC,QAAM,IAAI,MAAM,iCAAiC,OAAO,KAAK,CAAC,EAAE;AAClE;",
+  "names": []
+}

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

@@ -0,0 +1,12 @@
+import type { PibblEventType } from '../types.js';
+export declare const PIBBL_NATIVE_KEYBOARD_FOCUS_EVENT_TYPES: readonly ["keydown", "keyup", "focus", "blur", "focusin", "focusout"];
+export type PibblNativeKeyboardFocusEventType = (typeof PIBBL_NATIVE_KEYBOARD_FOCUS_EVENT_TYPES)[number];
+export type PibblAdaptedKeyboardFocusEvent = {
+    readonly type: 'keydown' | 'keyup';
+    readonly originalEvent: KeyboardEvent;
+} | {
+    readonly type: 'blur' | 'focus' | 'focusin' | 'focusout';
+    readonly originalEvent: FocusEvent;
+};
+export declare function isNativeKeyboardFocusEventType(type: PibblEventType): type is PibblNativeKeyboardFocusEventType;
+export declare function adaptKeyboardFocusEvent(type: PibblNativeKeyboardFocusEventType, event: Event): PibblAdaptedKeyboardFocusEvent | undefined;

package/dist/lib/events/adapters/keyboard-focus.js

@@ -0,0 +1,36 @@
+const PIBBL_NATIVE_KEYBOARD_FOCUS_EVENT_TYPES = Object.freeze([
+  "keydown",
+  "keyup",
+  "focus",
+  "blur",
+  "focusin",
+  "focusout"
+]);
+const nativeKeyboardFocusEventTypes = new Set(
+  PIBBL_NATIVE_KEYBOARD_FOCUS_EVENT_TYPES
+);
+function isNativeKeyboardFocusEventType(type) {
+  return nativeKeyboardFocusEventTypes.has(type);
+}
+function adaptKeyboardFocusEvent(type, event) {
+  switch (type) {
+    case "keydown":
+    case "keyup":
+      return typeof KeyboardEvent !== "undefined" && event instanceof KeyboardEvent ? { type, originalEvent: event } : void 0;
+    case "blur":
+    case "focus":
+    case "focusin":
+    case "focusout":
+      return typeof FocusEvent !== "undefined" && event instanceof FocusEvent ? { type, originalEvent: event } : void 0;
+  }
+  return assertNever(type);
+}
+function assertNever(value) {
+  throw new Error(`Unhandled keyboard/focus event type: ${String(value)}`);
+}
+export {
+  PIBBL_NATIVE_KEYBOARD_FOCUS_EVENT_TYPES,
+  adaptKeyboardFocusEvent,
+  isNativeKeyboardFocusEventType
+};
+//# sourceMappingURL=keyboard-focus.js.map

package/dist/lib/events/adapters/keyboard-focus.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/lib/events/adapters/keyboard-focus.ts"],
+  "sourcesContent": ["import type { PibblEventType } from '../types.js';\n\nexport const PIBBL_NATIVE_KEYBOARD_FOCUS_EVENT_TYPES = Object.freeze([\n  'keydown',\n  'keyup',\n  'focus',\n  'blur',\n  'focusin',\n  'focusout',\n] as const satisfies readonly PibblEventType[]);\n\nexport type PibblNativeKeyboardFocusEventType =\n  (typeof PIBBL_NATIVE_KEYBOARD_FOCUS_EVENT_TYPES)[number];\n\nconst nativeKeyboardFocusEventTypes = new Set<PibblEventType>(\n  PIBBL_NATIVE_KEYBOARD_FOCUS_EVENT_TYPES,\n);\n\nexport type PibblAdaptedKeyboardFocusEvent =\n  | {\n    readonly type: 'keydown' | 'keyup';\n    readonly originalEvent: KeyboardEvent;\n  }\n  | {\n    readonly type: 'blur' | 'focus' | 'focusin' | 'focusout';\n    readonly originalEvent: FocusEvent;\n  };\n\nexport function isNativeKeyboardFocusEventType(\n  type: PibblEventType,\n): type is PibblNativeKeyboardFocusEventType {\n  return nativeKeyboardFocusEventTypes.has(type);\n}\n\nexport function adaptKeyboardFocusEvent(\n  type: PibblNativeKeyboardFocusEventType,\n  event: Event,\n): PibblAdaptedKeyboardFocusEvent | undefined {\n  switch (type) {\n    case 'keydown':\n    case 'keyup':\n      return typeof KeyboardEvent !== 'undefined' &&\n        event instanceof KeyboardEvent ?\n          { type, originalEvent: event } : undefined;\n    case 'blur':\n    case 'focus':\n    case 'focusin':\n    case 'focusout':\n      return typeof FocusEvent !== 'undefined' && event instanceof FocusEvent ?\n          { type, originalEvent: event } : undefined;\n  }\n  return assertNever(type);\n}\n\nfunction assertNever(value: never): never {\n  throw new Error(`Unhandled keyboard/focus event type: ${String(value)}`);\n}\n"],
+  "mappings": "AAEO,MAAM,0CAA0C,OAAO,OAAO;AAAA,EACnE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAA8C;AAK9C,MAAM,gCAAgC,IAAI;AAAA,EACxC;AACF;AAYO,SAAS,+BACd,MAC2C;AAC3C,SAAO,8BAA8B,IAAI,IAAI;AAC/C;AAEO,SAAS,wBACd,MACA,OAC4C;AAC5C,UAAQ,MAAM;AAAA,IACZ,KAAK;AAAA,IACL,KAAK;AACH,aAAO,OAAO,kBAAkB,eAC9B,iBAAiB,gBACf,EAAE,MAAM,eAAe,MAAM,IAAI;AAAA,IACvC,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,aAAO,OAAO,eAAe,eAAe,iBAAiB,aACzD,EAAE,MAAM,eAAe,MAAM,IAAI;AAAA,EACzC;AACA,SAAO,YAAY,IAAI;AACzB;AAEA,SAAS,YAAY,OAAqB;AACxC,QAAM,IAAI,MAAM,wCAAwC,OAAO,KAAK,CAAC,EAAE;AACzE;",
+  "names": []
+}

package/dist/lib/events/adapters/mouse.d.ts

@@ -0,0 +1,17 @@
+import type { PibblInstance } from '../../types.js';
+import type { PibblEventType } from '../types.js';
+export declare const PIBBL_NATIVE_MOUSE_EVENT_TYPES: readonly ["click", "dblclick", "auxclick", "contextmenu", "mouseover", "mouseenter", "mousedown", "mousemove", "mouseup", "mouseout", "mouseleave"];
+export type PibblNativeMouseEventType = (typeof PIBBL_NATIVE_MOUSE_EVENT_TYPES)[number];
+export interface PibblAdaptedMouseEvent {
+    readonly type: PibblNativeMouseEventType;
+    readonly originalEvent: MouseEvent;
+    readonly x: number;
+    readonly y: number;
+    readonly press: PibblAdaptedMousePress | undefined;
+}
+export interface PibblAdaptedMousePress {
+    readonly x: number;
+    readonly y: number;
+}
+export declare function isNativeMouseEventType(type: PibblEventType): type is PibblNativeMouseEventType;
+export declare function adaptMouseEvent(root: PibblInstance, type: PibblNativeMouseEventType, event: Event): PibblAdaptedMouseEvent | undefined;

package/dist/lib/events/adapters/mouse.js

@@ -0,0 +1,32 @@
+import { getMouseCoordinates } from "../../util/get-mouse-coordinates.js";
+const PIBBL_NATIVE_MOUSE_EVENT_TYPES = Object.freeze([
+  "click",
+  "dblclick",
+  "auxclick",
+  "contextmenu",
+  "mouseover",
+  "mouseenter",
+  "mousedown",
+  "mousemove",
+  "mouseup",
+  "mouseout",
+  "mouseleave"
+]);
+const nativeMouseEventTypes = new Set(
+  PIBBL_NATIVE_MOUSE_EVENT_TYPES
+);
+function isNativeMouseEventType(type) {
+  return nativeMouseEventTypes.has(type);
+}
+function adaptMouseEvent(root, type, event) {
+  if (!(event instanceof MouseEvent) || !root.surface.snapshot) return void 0;
+  const [x, y] = getMouseCoordinates(event, root);
+  const press = type === "mousedown" && event.button === 0 ? { x, y } : void 0;
+  return { type, originalEvent: event, x, y, press };
+}
+export {
+  PIBBL_NATIVE_MOUSE_EVENT_TYPES,
+  adaptMouseEvent,
+  isNativeMouseEventType
+};
+//# sourceMappingURL=mouse.js.map

package/dist/lib/events/adapters/mouse.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/lib/events/adapters/mouse.ts"],
+  "sourcesContent": ["import type { PibblInstance } from '../../types.js';\nimport { getMouseCoordinates } from '../../util/get-mouse-coordinates.js';\nimport type { PibblEventType } from '../types.js';\n\nexport const PIBBL_NATIVE_MOUSE_EVENT_TYPES = Object.freeze([\n  'click',\n  'dblclick',\n  'auxclick',\n  'contextmenu',\n  'mouseover',\n  'mouseenter',\n  'mousedown',\n  'mousemove',\n  'mouseup',\n  'mouseout',\n  'mouseleave',\n] as const satisfies readonly PibblEventType[]);\n\nexport type PibblNativeMouseEventType =\n  (typeof PIBBL_NATIVE_MOUSE_EVENT_TYPES)[number];\n\nconst nativeMouseEventTypes = new Set<PibblEventType>(\n  PIBBL_NATIVE_MOUSE_EVENT_TYPES,\n);\n\nexport interface PibblAdaptedMouseEvent {\n  readonly type: PibblNativeMouseEventType;\n  readonly originalEvent: MouseEvent;\n  readonly x: number;\n  readonly y: number;\n  readonly press: PibblAdaptedMousePress | undefined;\n}\n\nexport interface PibblAdaptedMousePress {\n  readonly x: number;\n  readonly y: number;\n}\n\nexport function isNativeMouseEventType(\n  type: PibblEventType,\n): type is PibblNativeMouseEventType {\n  return nativeMouseEventTypes.has(type);\n}\n\nexport function adaptMouseEvent(\n  root: PibblInstance,\n  type: PibblNativeMouseEventType,\n  event: Event,\n): PibblAdaptedMouseEvent | undefined {\n  if (!(event instanceof MouseEvent) || !root.surface.snapshot) return undefined;\n  const [x, y] = getMouseCoordinates(event, root);\n  const press = type === 'mousedown' && event.button === 0 ? { x, y } : undefined;\n  return { type, originalEvent: event, x, y, press };\n}\n"],
+  "mappings": "AACA,SAAS,2BAA2B;AAG7B,MAAM,iCAAiC,OAAO,OAAO;AAAA,EAC1D;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAA8C;AAK9C,MAAM,wBAAwB,IAAI;AAAA,EAChC;AACF;AAeO,SAAS,uBACd,MACmC;AACnC,SAAO,sBAAsB,IAAI,IAAI;AACvC;AAEO,SAAS,gBACd,MACA,MACA,OACoC;AACpC,MAAI,EAAE,iBAAiB,eAAe,CAAC,KAAK,QAAQ,SAAU,QAAO;AACrE,QAAM,CAAC,GAAG,CAAC,IAAI,oBAAoB,OAAO,IAAI;AAC9C,QAAM,QAAQ,SAAS,eAAe,MAAM,WAAW,IAAI,EAAE,GAAG,EAAE,IAAI;AACtE,SAAO,EAAE,MAAM,eAAe,OAAO,GAAG,GAAG,MAAM;AACnD;",
+  "names": []
+}

package/dist/lib/events/adapters/pointer.d.ts

@@ -0,0 +1,19 @@
+import type { PibblInstance } from '../../types.js';
+import type { PibblEventType } from '../types.js';
+export declare const PIBBL_NATIVE_POINTER_EVENT_TYPES: readonly ["pointerover", "pointerenter", "pointerdown", "pointermove", "pointerrawupdate", "pointerup", "pointercancel", "pointerout", "pointerleave", "gotpointercapture", "lostpointercapture"];
+export type PibblNativePointerEventType = (typeof PIBBL_NATIVE_POINTER_EVENT_TYPES)[number];
+export interface PibblAdaptedPointerEvent {
+    readonly type: PibblNativePointerEventType;
+    readonly originalEvent: PointerEvent;
+    readonly x: number;
+    readonly y: number;
+    readonly press: PibblAdaptedPointerPress | undefined;
+}
+export interface PibblAdaptedPointerPress {
+    readonly pointerId: number;
+    readonly pointerType: 'mouse' | 'pen' | 'touch';
+    readonly x: number;
+    readonly y: number;
+}
+export declare function isNativePointerEventType(type: PibblEventType): type is PibblNativePointerEventType;
+export declare function adaptPointerEvent(root: PibblInstance, type: PibblNativePointerEventType, event: Event): PibblAdaptedPointerEvent | undefined;

package/dist/lib/events/adapters/pointer.js

@@ -0,0 +1,40 @@
+import { getMouseCoordinates } from "../../util/get-mouse-coordinates.js";
+const PIBBL_NATIVE_POINTER_EVENT_TYPES = Object.freeze([
+  "pointerover",
+  "pointerenter",
+  "pointerdown",
+  "pointermove",
+  "pointerrawupdate",
+  "pointerup",
+  "pointercancel",
+  "pointerout",
+  "pointerleave",
+  "gotpointercapture",
+  "lostpointercapture"
+]);
+const nativePointerEventTypes = new Set(
+  PIBBL_NATIVE_POINTER_EVENT_TYPES
+);
+function isNativePointerEventType(type) {
+  return nativePointerEventTypes.has(type);
+}
+function adaptPointerEvent(root, type, event) {
+  if (typeof PointerEvent === "undefined" || !(event instanceof PointerEvent) || !root.surface.snapshot) {
+    return void 0;
+  }
+  const [x, y] = getMouseCoordinates(event, root);
+  const pointerType = event.pointerType;
+  const press = type === "pointerdown" && event.isPrimary && event.button === 0 && (pointerType === "mouse" || pointerType === "pen" || pointerType === "touch") ? {
+    pointerId: event.pointerId,
+    pointerType,
+    x,
+    y
+  } : void 0;
+  return { type, originalEvent: event, x, y, press };
+}
+export {
+  PIBBL_NATIVE_POINTER_EVENT_TYPES,
+  adaptPointerEvent,
+  isNativePointerEventType
+};
+//# sourceMappingURL=pointer.js.map

package/dist/lib/events/adapters/pointer.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/lib/events/adapters/pointer.ts"],
+  "sourcesContent": ["import type { PibblInstance } from '../../types.js';\nimport { getMouseCoordinates } from '../../util/get-mouse-coordinates.js';\nimport type { PibblEventType } from '../types.js';\n\nexport const PIBBL_NATIVE_POINTER_EVENT_TYPES = Object.freeze([\n  'pointerover',\n  'pointerenter',\n  'pointerdown',\n  'pointermove',\n  'pointerrawupdate',\n  'pointerup',\n  'pointercancel',\n  'pointerout',\n  'pointerleave',\n  'gotpointercapture',\n  'lostpointercapture',\n] as const satisfies readonly PibblEventType[]);\n\nexport type PibblNativePointerEventType =\n  (typeof PIBBL_NATIVE_POINTER_EVENT_TYPES)[number];\n\nconst nativePointerEventTypes = new Set<PibblEventType>(\n  PIBBL_NATIVE_POINTER_EVENT_TYPES,\n);\n\nexport interface PibblAdaptedPointerEvent {\n  readonly type: PibblNativePointerEventType;\n  readonly originalEvent: PointerEvent;\n  readonly x: number;\n  readonly y: number;\n  readonly press: PibblAdaptedPointerPress | undefined;\n}\n\nexport interface PibblAdaptedPointerPress {\n  readonly pointerId: number;\n  readonly pointerType: 'mouse' | 'pen' | 'touch';\n  readonly x: number;\n  readonly y: number;\n}\n\nexport function isNativePointerEventType(\n  type: PibblEventType,\n): type is PibblNativePointerEventType {\n  return nativePointerEventTypes.has(type);\n}\n\nexport function adaptPointerEvent(\n  root: PibblInstance,\n  type: PibblNativePointerEventType,\n  event: Event,\n): PibblAdaptedPointerEvent | undefined {\n  if (\n    typeof PointerEvent === 'undefined' ||\n    !(event instanceof PointerEvent) ||\n    !root.surface.snapshot\n  ) {\n    return undefined;\n  }\n  const [x, y] = getMouseCoordinates(event, root);\n  const pointerType = event.pointerType;\n  const press: PibblAdaptedPointerPress | undefined = type === 'pointerdown' &&\n      event.isPrimary &&\n      event.button === 0 &&\n      (pointerType === 'mouse' || pointerType === 'pen' || pointerType === 'touch') ?\n    {\n      pointerId: event.pointerId,\n      pointerType: pointerType as PibblAdaptedPointerPress['pointerType'],\n      x,\n      y,\n    } : undefined;\n  return { type, originalEvent: event, x, y, press };\n}\n"],
+  "mappings": "AACA,SAAS,2BAA2B;AAG7B,MAAM,mCAAmC,OAAO,OAAO;AAAA,EAC5D;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAA8C;AAK9C,MAAM,0BAA0B,IAAI;AAAA,EAClC;AACF;AAiBO,SAAS,yBACd,MACqC;AACrC,SAAO,wBAAwB,IAAI,IAAI;AACzC;AAEO,SAAS,kBACd,MACA,MACA,OACsC;AACtC,MACE,OAAO,iBAAiB,eACxB,EAAE,iBAAiB,iBACnB,CAAC,KAAK,QAAQ,UACd;AACA,WAAO;AAAA,EACT;AACA,QAAM,CAAC,GAAG,CAAC,IAAI,oBAAoB,OAAO,IAAI;AAC9C,QAAM,cAAc,MAAM;AAC1B,QAAM,QAA8C,SAAS,iBACzD,MAAM,aACN,MAAM,WAAW,MAChB,gBAAgB,WAAW,gBAAgB,SAAS,gBAAgB,WACvE;AAAA,IACE,WAAW,MAAM;AAAA,IACjB;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AACN,SAAO,EAAE,MAAM,eAAe,OAAO,GAAG,GAAG,MAAM;AACnD;",
+  "names": []
+}

package/dist/lib/events/adapters/touch.d.ts

@@ -0,0 +1,16 @@
+import type { PibblInstance } from '../../types.js';
+import type { PibblEventType } from '../types.js';
+export declare const PIBBL_NATIVE_TOUCH_EVENT_TYPES: readonly ["touchstart", "touchmove", "touchend", "touchcancel"];
+export type PibblNativeTouchEventType = (typeof PIBBL_NATIVE_TOUCH_EVENT_TYPES)[number];
+export interface PibblAdaptedTouchContact {
+    readonly touch: Touch;
+    readonly x: number;
+    readonly y: number;
+}
+export interface PibblAdaptedTouchEvent {
+    readonly type: PibblNativeTouchEventType;
+    readonly originalEvent: TouchEvent;
+    readonly changedContacts: readonly PibblAdaptedTouchContact[];
+}
+export declare function isNativeTouchEventType(type: PibblEventType): type is PibblNativeTouchEventType;
+export declare function adaptTouchEvent(root: PibblInstance, type: PibblNativeTouchEventType, event: Event): PibblAdaptedTouchEvent | undefined;

package/dist/lib/events/adapters/touch.js

@@ -0,0 +1,36 @@
+import { getMouseCoordinates } from "../../util/get-mouse-coordinates.js";
+const PIBBL_NATIVE_TOUCH_EVENT_TYPES = Object.freeze([
+  "touchstart",
+  "touchmove",
+  "touchend",
+  "touchcancel"
+]);
+const nativeTouchEventTypes = new Set(
+  PIBBL_NATIVE_TOUCH_EVENT_TYPES
+);
+function isNativeTouchEventType(type) {
+  return nativeTouchEventTypes.has(type);
+}
+function adaptTouchEvent(root, type, event) {
+  if (typeof TouchEvent === "undefined" || !(event instanceof TouchEvent) || !root.surface.snapshot) {
+    return void 0;
+  }
+  const changedContacts = Array.from(event.changedTouches, (touch) => {
+    const [x, y] = getMouseCoordinates(
+      touch,
+      root
+    );
+    return { touch, x, y };
+  });
+  return {
+    type,
+    originalEvent: event,
+    changedContacts: Object.freeze(changedContacts)
+  };
+}
+export {
+  PIBBL_NATIVE_TOUCH_EVENT_TYPES,
+  adaptTouchEvent,
+  isNativeTouchEventType
+};
+//# sourceMappingURL=touch.js.map

package/dist/lib/events/adapters/touch.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/lib/events/adapters/touch.ts"],
+  "sourcesContent": ["import type { PibblInstance } from '../../types.js';\nimport { getMouseCoordinates } from '../../util/get-mouse-coordinates.js';\nimport type { PibblEventType } from '../types.js';\n\nexport const PIBBL_NATIVE_TOUCH_EVENT_TYPES = Object.freeze([\n  'touchstart',\n  'touchmove',\n  'touchend',\n  'touchcancel',\n] as const satisfies readonly PibblEventType[]);\n\nexport type PibblNativeTouchEventType =\n  (typeof PIBBL_NATIVE_TOUCH_EVENT_TYPES)[number];\n\nconst nativeTouchEventTypes = new Set<PibblEventType>(\n  PIBBL_NATIVE_TOUCH_EVENT_TYPES,\n);\n\nexport interface PibblAdaptedTouchContact {\n  readonly touch: Touch;\n  readonly x: number;\n  readonly y: number;\n}\n\nexport interface PibblAdaptedTouchEvent {\n  readonly type: PibblNativeTouchEventType;\n  readonly originalEvent: TouchEvent;\n  readonly changedContacts: readonly PibblAdaptedTouchContact[];\n}\n\nexport function isNativeTouchEventType(\n  type: PibblEventType,\n): type is PibblNativeTouchEventType {\n  return nativeTouchEventTypes.has(type);\n}\n\nexport function adaptTouchEvent(\n  root: PibblInstance,\n  type: PibblNativeTouchEventType,\n  event: Event,\n): PibblAdaptedTouchEvent | undefined {\n  if (\n    typeof TouchEvent === 'undefined' ||\n    !(event instanceof TouchEvent) ||\n    !root.surface.snapshot\n  ) {\n    return undefined;\n  }\n  const changedContacts = Array.from(event.changedTouches, touch => {\n    const [x, y] = getMouseCoordinates(\n      touch as unknown as MouseEvent,\n      root,\n    );\n    return { touch, x, y };\n  });\n  return {\n    type,\n    originalEvent: event,\n    changedContacts: Object.freeze(changedContacts),\n  };\n}\n"],
+  "mappings": "AACA,SAAS,2BAA2B;AAG7B,MAAM,iCAAiC,OAAO,OAAO;AAAA,EAC1D;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAA8C;AAK9C,MAAM,wBAAwB,IAAI;AAAA,EAChC;AACF;AAcO,SAAS,uBACd,MACmC;AACnC,SAAO,sBAAsB,IAAI,IAAI;AACvC;AAEO,SAAS,gBACd,MACA,MACA,OACoC;AACpC,MACE,OAAO,eAAe,eACtB,EAAE,iBAAiB,eACnB,CAAC,KAAK,QAAQ,UACd;AACA,WAAO;AAAA,EACT;AACA,QAAM,kBAAkB,MAAM,KAAK,MAAM,gBAAgB,WAAS;AAChE,UAAM,CAAC,GAAG,CAAC,IAAI;AAAA,MACb;AAAA,MACA;AAAA,IACF;AACA,WAAO,EAAE,OAAO,GAAG,EAAE;AAAA,EACvB,CAAC;AACD,SAAO;AAAA,IACL;AAAA,IACA,eAAe;AAAA,IACf,iBAAiB,OAAO,OAAO,eAAe;AAAA,EAChD;AACF;",
+  "names": []
+}

package/dist/lib/events/adapters/wheel.d.ts

@@ -0,0 +1,10 @@
+import type { PibblInstance } from '../../types.js';
+import type { PibblEventType } from '../types.js';
+export interface PibblAdaptedWheelEvent {
+    readonly type: 'wheel';
+    readonly originalEvent: WheelEvent;
+    readonly x: number;
+    readonly y: number;
+}
+export declare function isNativeWheelEventType(type: PibblEventType): type is 'wheel';
+export declare function adaptWheelEvent(root: PibblInstance, event: Event): PibblAdaptedWheelEvent | undefined;

package/dist/lib/events/adapters/wheel.js

@@ -0,0 +1,16 @@
+import { getMouseCoordinates } from "../../util/get-mouse-coordinates.js";
+function isNativeWheelEventType(type) {
+  return type === "wheel";
+}
+function adaptWheelEvent(root, event) {
+  if (typeof WheelEvent === "undefined" || !(event instanceof WheelEvent) || !root.surface.snapshot) {
+    return void 0;
+  }
+  const [x, y] = getMouseCoordinates(event, root);
+  return { type: "wheel", originalEvent: event, x, y };
+}
+export {
+  adaptWheelEvent,
+  isNativeWheelEventType
+};
+//# sourceMappingURL=wheel.js.map

package/dist/lib/events/adapters/wheel.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/lib/events/adapters/wheel.ts"],
+  "sourcesContent": ["import type { PibblInstance } from '../../types.js';\nimport { getMouseCoordinates } from '../../util/get-mouse-coordinates.js';\nimport type { PibblEventType } from '../types.js';\n\nexport interface PibblAdaptedWheelEvent {\n  readonly type: 'wheel';\n  readonly originalEvent: WheelEvent;\n  readonly x: number;\n  readonly y: number;\n}\n\nexport function isNativeWheelEventType(\n  type: PibblEventType,\n): type is 'wheel' {\n  return type === 'wheel';\n}\n\nexport function adaptWheelEvent(\n  root: PibblInstance,\n  event: Event,\n): PibblAdaptedWheelEvent | undefined {\n  if (\n    typeof WheelEvent === 'undefined' ||\n    !(event instanceof WheelEvent) ||\n    !root.surface.snapshot\n  ) {\n    return undefined;\n  }\n  const [x, y] = getMouseCoordinates(event, root);\n  return { type: 'wheel', originalEvent: event, x, y };\n}\n"],
+  "mappings": "AACA,SAAS,2BAA2B;AAU7B,SAAS,uBACd,MACiB;AACjB,SAAO,SAAS;AAClB;AAEO,SAAS,gBACd,MACA,OACoC;AACpC,MACE,OAAO,eAAe,eACtB,EAAE,iBAAiB,eACnB,CAAC,KAAK,QAAQ,UACd;AACA,WAAO;AAAA,EACT;AACA,QAAM,CAAC,GAAG,CAAC,IAAI,oBAAoB,OAAO,IAAI;AAC9C,SAAO,EAAE,MAAM,SAAS,eAAe,OAAO,GAAG,EAAE;AACrD;",
+  "names": []
+}

package/dist/lib/events/boundary-transitions.d.ts

@@ -0,0 +1,9 @@
+import type { PibblEventNode } from './registrations.js';
+export interface PibblBoundaryTransitionPlan {
+    readonly commonPrefixLength: number;
+    /** Nodes exited from leaf toward the nearest exclusive ancestor. */
+    readonly exited: readonly PibblEventNode[];
+    /** Nodes entered from the nearest exclusive ancestor toward the leaf. */
+    readonly entered: readonly PibblEventNode[];
+}
+export declare function planBoundaryTransitions(oldPath: readonly PibblEventNode[], newPath: readonly PibblEventNode[]): PibblBoundaryTransitionPlan;

package/dist/lib/events/boundary-transitions.js

@@ -0,0 +1,16 @@
+function planBoundaryTransitions(oldPath, newPath) {
+  let commonPrefixLength = 0;
+  const length = Math.min(oldPath.length, newPath.length);
+  while (commonPrefixLength < length && oldPath[commonPrefixLength] === newPath[commonPrefixLength]) {
+    commonPrefixLength++;
+  }
+  return {
+    commonPrefixLength,
+    exited: Object.freeze(oldPath.slice(commonPrefixLength).reverse()),
+    entered: Object.freeze(newPath.slice(commonPrefixLength))
+  };
+}
+export {
+  planBoundaryTransitions
+};
+//# sourceMappingURL=boundary-transitions.js.map

package/dist/lib/events/boundary-transitions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/events/boundary-transitions.ts"],
+  "sourcesContent": ["import type { PibblEventNode } from './registrations.js';\n\nexport interface PibblBoundaryTransitionPlan {\n  readonly commonPrefixLength: number;\n  /** Nodes exited from leaf toward the nearest exclusive ancestor. */\n  readonly exited: readonly PibblEventNode[];\n  /** Nodes entered from the nearest exclusive ancestor toward the leaf. */\n  readonly entered: readonly PibblEventNode[];\n}\n\nexport function planBoundaryTransitions(\n  oldPath: readonly PibblEventNode[],\n  newPath: readonly PibblEventNode[],\n): PibblBoundaryTransitionPlan {\n  let commonPrefixLength = 0;\n  const length = Math.min(oldPath.length, newPath.length);\n  while (\n    commonPrefixLength < length &&\n    oldPath[commonPrefixLength] === newPath[commonPrefixLength]\n  ) {\n    commonPrefixLength++;\n  }\n  return {\n    commonPrefixLength,\n    exited: Object.freeze(oldPath.slice(commonPrefixLength).reverse()),\n    entered: Object.freeze(newPath.slice(commonPrefixLength)),\n  };\n}\n"],
+  "mappings": "AAUO,SAAS,wBACd,SACA,SAC6B;AAC7B,MAAI,qBAAqB;AACzB,QAAM,SAAS,KAAK,IAAI,QAAQ,QAAQ,QAAQ,MAAM;AACtD,SACE,qBAAqB,UACrB,QAAQ,kBAAkB,MAAM,QAAQ,kBAAkB,GAC1D;AACA;AAAA,EACF;AACA,SAAO;AAAA,IACL;AAAA,IACA,QAAQ,OAAO,OAAO,QAAQ,MAAM,kBAAkB,EAAE,QAAQ,CAAC;AAAA,IACjE,SAAS,OAAO,OAAO,QAAQ,MAAM,kBAAkB,CAAC;AAAA,EAC1D;AACF;",
+  "names": []
+}

package/dist/lib/events/dispatch.d.ts

@@ -0,0 +1,21 @@
+import type { PibblCursorDefault, PibblInstance, PibblInteractionRegion } from '../types.js';
+import type { PibblOriginalEvent } from './event-facade.js';
+import { type PibblEventNode } from './registrations.js';
+import type { PibblEventMap, PibblEventType } from './types.js';
+/**
+ * Prevents a manipulation gesture from becoming a Canvas activation. This is
+ * deliberately an internal controller seam: applications continue to receive
+ * ordinary pointer and mouse events through the public event surface.
+ */
+export declare function suppressManipulationActivation(instance: PibblInstance, pointerId: number): void;
+export type PibblNativeEventRoute = 'clipboard' | 'drag' | 'editing' | 'keyboard-focus' | 'mouse' | 'pointer' | 'touch' | 'wheel';
+export declare function dispatchNativeEvent(instance: PibblInstance, type: PibblEventType, nativeEvent: Event): void;
+export declare function dispatchToLogicalTarget<K extends PibblEventType>(type: K, target: PibblEventNode, originalEvent: PibblOriginalEvent<K>, relatedTarget?: PibblEventNode | null, sourceEvent?: Event): PibblEventMap[K] | undefined;
+export declare function classifyNativeEventType(type: PibblEventType): PibblNativeEventRoute;
+/** Clears dispatch-owned references before a logical node becomes dead. */
+export declare function releaseEventNodeState(instance: PibblInstance, node: PibblEventNode): void;
+export declare function removeInteractionRegion(_instance: PibblInstance, region: PibblInteractionRegion): void;
+export declare function refreshInteractionCursor(instance: PibblInstance, region: PibblInteractionRegion): void;
+export declare function updateCursorDefault(instance: PibblInstance, cursorDefault: PibblCursorDefault): void;
+export declare function removeCursorDefault(instance: PibblInstance, cursorDefault: PibblCursorDefault): void;
+export declare function refreshCursorDefault(instance: PibblInstance): void;