@weasel-js/core 1.10.0 → 1.11.0

package/dist/core/stylus/usePointerStylus.js

@@ -1,8 +1,9 @@
-import { getStylusData as e } from "./stylus.js";
-import { useEffect as t, useRef as n, useState as r } from "react";
-import { useLatest as i } from "@weasel-js/react";
+import { getStylusData } from "./stylus.js";
+import { useEffect, useRef, useState } from "react";
+import { useLatest } from "@weasel-js/react";
+
 //#region src/core/stylus/usePointerStylus.ts
-var a = {
+var IDLE = {
 	pressure: 0,
 	tiltX: 0,
 	tiltY: 0,
@@ -10,42 +11,68 @@ var a = {
 	azimuthAngle: void 0,
 	twist: 0,
 	pointerType: "",
-	isStylus: !1,
-	hovering: !1
+	isStylus: false,
+	hovering: false
 };
-function o(o, s = {}) {
-	let { maxFps: c = 60, stylusOnly: l = !1 } = s, [u, d] = r(a), f = n(-Infinity), p = i({
-		maxFps: c,
-		stylusOnly: l
+/**
+* Subscribe to pointer events on a target element (defaults to `window`)
+* and expose the most recent stylus snapshot.
+*
+* The hook does NOT consume pointerdown / pointerup — leave gesture handling
+* to the dispatcher. Re-renders are throttled by default (`maxFps`); pass
+* `maxFps: Infinity` to get every sample.
+*/
+function usePointerStylus(target, options = {}) {
+	const { maxFps = 60, stylusOnly = false } = options;
+	const [state, setState] = useState(IDLE);
+	const lastCommit = useRef(-Infinity);
+	const optsRef = useLatest({
+		maxFps,
+		stylusOnly
 	});
-	return t(() => {
-		let t = o == null ? window : o instanceof HTMLElement ? o : o.current ?? window, n = (t) => {
-			let n = t, { maxFps: r, stylusOnly: i } = p.current;
-			if (i && n.pointerType !== "pen") return;
-			let a = performance.now(), o = r > 0 && Number.isFinite(r) ? 1e3 / r : 0;
-			o > 0 && a - f.current < o || (f.current = a, d((t) => ({
-				...e(n),
-				hovering: t.hovering
-			})));
-		}, r = (e) => {
-			let t = e;
-			p.current.stylusOnly && t.pointerType !== "pen" || d((e) => ({
-				...e,
-				hovering: !0
+	useEffect(() => {
+		const el = target == null ? window : target instanceof HTMLElement ? target : target.current ?? window;
+		const onMove = (raw) => {
+			const e = raw;
+			const { maxFps, stylusOnly } = optsRef.current;
+			if (stylusOnly && e.pointerType !== "pen") return;
+			const now = performance.now();
+			const minGap = maxFps > 0 && Number.isFinite(maxFps) ? 1e3 / maxFps : 0;
+			if (minGap > 0 && now - lastCommit.current < minGap) return;
+			lastCommit.current = now;
+			setState((prev) => ({
+				...getStylusData(e),
+				hovering: prev.hovering
+			}));
+		};
+		const onEnter = (raw) => {
+			const e = raw;
+			if (optsRef.current.stylusOnly && e.pointerType !== "pen") return;
+			setState((prev) => ({
+				...prev,
+				hovering: true
 			}));
-		}, i = (e) => {
-			let t = e;
-			p.current.stylusOnly && t.pointerType !== "pen" || d((e) => ({
-				...e,
-				hovering: !1
+		};
+		const onLeave = (raw) => {
+			const e = raw;
+			if (optsRef.current.stylusOnly && e.pointerType !== "pen") return;
+			setState((prev) => ({
+				...prev,
+				hovering: false
 			}));
 		};
-		return t.addEventListener("pointermove", n), t.addEventListener("pointerenter", r), t.addEventListener("pointerleave", i), () => {
-			t.removeEventListener("pointermove", n), t.removeEventListener("pointerenter", r), t.removeEventListener("pointerleave", i);
+		el.addEventListener("pointermove", onMove);
+		el.addEventListener("pointerenter", onEnter);
+		el.addEventListener("pointerleave", onLeave);
+		return () => {
+			el.removeEventListener("pointermove", onMove);
+			el.removeEventListener("pointerenter", onEnter);
+			el.removeEventListener("pointerleave", onLeave);
 		};
-	}, [o, p]), u;
+	}, [target, optsRef]);
+	return state;
 }
-//#endregion
-export { o as usePointerStylus };
 
+//#endregion
+export { usePointerStylus };
 //# sourceMappingURL=usePointerStylus.js.map

package/dist/core/stylus/usePointerStylus.js.map

@@ -1 +1 @@
-{"version":3,"file":"usePointerStylus.js","names":["IDLE","usePointerStylus","options","state","setState","useState","lastCommit","useRef","optsRef","useLatest","useEffect","el","target","onMove","e","raw","stylusOnly","now","minGap","maxFps","getStylusData","prev","onEnter","onLeave"],"sources":["../../../src/core/stylus/usePointerStylus.ts"],"sourcesContent":["import { useEffect, useRef, useState, type RefObject } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { getStylusData, type StylusData } from './stylus';\n\n/** State exposed by `usePointerStylus` — the most recent stylus snapshot\n *  plus a `hovering` flag. */\nexport interface PointerStylusState extends StylusData {\n  /** True between `pointerenter` and `pointerleave` events on the target\n   *  element. iPad Safari fires these for Apple Pencil hover, so this is\n   *  true while the pen is near the glass without contact. */\n  hovering: boolean;\n}\n\nconst IDLE: PointerStylusState = {\n  pressure: 0,\n  tiltX: 0,\n  tiltY: 0,\n  altitudeAngle: undefined,\n  azimuthAngle: undefined,\n  twist: 0,\n  pointerType: '',\n  isStylus: false,\n  hovering: false,\n};\n\n/** Options for `usePointerStylus`. */\nexport interface UsePointerStylusOptions {\n  /** Throttle re-renders to ≈this many state updates per second. The latest\n   *  sample is always kept; intermediates are dropped. Default 60. Set to\n   *  `Infinity` (or 0) to emit every move. */\n  maxFps?: number;\n  /** When true, only emit updates while `pointerType === 'pen'`. Default\n   *  false. */\n  stylusOnly?: boolean;\n}\n\n/**\n * Subscribe to pointer events on a target element (defaults to `window`)\n * and expose the most recent stylus snapshot.\n *\n * The hook does NOT consume pointerdown / pointerup — leave gesture handling\n * to the dispatcher. Re-renders are throttled by default (`maxFps`); pass\n * `maxFps: Infinity` to get every sample.\n */\nexport function usePointerStylus(\n  target?: RefObject<HTMLElement | null> | HTMLElement | null,\n  options: UsePointerStylusOptions = {},\n): PointerStylusState {\n  const { maxFps = 60, stylusOnly = false } = options;\n  const [state, setState] = useState<PointerStylusState>(IDLE);\n  // Track the last commit time to throttle. A ref avoids re-creating the\n  // listener every render and avoids stale-closure read of an outer `let`.\n  const lastCommit = useRef(-Infinity);\n  const optsRef = useLatest({ maxFps, stylusOnly });\n\n  useEffect(() => {\n    const el: EventTarget =\n      target == null\n        ? window\n        : target instanceof HTMLElement\n          ? target\n          : target.current ?? window;\n\n    const onMove = (raw: Event) => {\n      const e = raw as PointerEvent;\n      const { maxFps, stylusOnly } = optsRef.current;\n      if (stylusOnly && e.pointerType !== 'pen') return;\n      const now = performance.now();\n      const minGap = maxFps > 0 && Number.isFinite(maxFps) ? 1000 / maxFps : 0;\n      if (minGap > 0 && now - lastCommit.current < minGap) return;\n      lastCommit.current = now;\n      setState((prev) => ({ ...getStylusData(e), hovering: prev.hovering }));\n    };\n    const onEnter = (raw: Event) => {\n      const e = raw as PointerEvent;\n      if (optsRef.current.stylusOnly && e.pointerType !== 'pen') return;\n      setState((prev) => ({ ...prev, hovering: true }));\n    };\n    const onLeave = (raw: Event) => {\n      const e = raw as PointerEvent;\n      if (optsRef.current.stylusOnly && e.pointerType !== 'pen') return;\n      setState((prev) => ({ ...prev, hovering: false }));\n    };\n\n    el.addEventListener('pointermove', onMove);\n    el.addEventListener('pointerenter', onEnter);\n    el.addEventListener('pointerleave', onLeave);\n    return () => {\n      el.removeEventListener('pointermove', onMove);\n      el.removeEventListener('pointerenter', onEnter);\n      el.removeEventListener('pointerleave', onLeave);\n    };\n  }, [target, optsRef]);\n\n  return state;\n}\n"],"mappings":";;;;AAaA,IAAMA,IAA2B;CAC/B,UAAU;CACV,OAAO;CACP,OAAO;CACP,eAAe,KAAA;CACf,cAAc,KAAA;CACd,OAAO;CACP,aAAa;CACb,UAAU;CACV,UAAU;AACZ;AAqBA,SAAgBC,EACd,GACA,IAAmC,CAAC,GAChB;CACpB,IAAM,EAAE,YAAS,IAAI,gBAAa,OAAUC,GACtC,CAACC,GAAOC,KAAYC,EAA6BL,CAAI,GAGrDM,IAAaC,EAAO,SAAS,GAC7BC,IAAUC,EAAU;EAAE;EAAQ;CAAW,CAAC;CAyChD,OAvCAC,QAAgB;EACd,IAAMC,IACJC,KAAU,OACN,SACAA,aAAkB,cAChBA,IACAA,EAAO,WAAW,QAEpBC,KAAU,MAAe;GAC7B,IAAMC,IAAIC,GACJ,EAAE,WAAQ,kBAAeP,EAAQ;GACvC,IAAIQ,KAAcF,EAAE,gBAAgB,OAAO;GAC3C,IAAMG,IAAM,YAAY,IAAI,GACtBC,IAASC,IAAS,KAAK,OAAO,SAASA,CAAM,IAAI,MAAOA,IAAS;GACvE,AAAID,IAAS,KAAKD,IAAMX,EAAW,UAAUY,MAC7C,EAAW,UAAUD,GACrBb,GAAU,OAAU;IAAE,GAAGgB,EAAcN,CAAC;IAAG,UAAUO,EAAK;GAAS,EAAE;EACvE,GACMC,KAAW,MAAe;GAC9B,IAAMR,IAAIC;GACV,AAAIP,EAAQ,QAAQ,cAAcM,EAAE,gBAAgB,SACpDV,GAAU,OAAU;IAAE,GAAGiB;IAAM,UAAU;GAAK,EAAE;EAClD,GACME,KAAW,MAAe;GAC9B,IAAMT,IAAIC;GACV,AAAIP,EAAQ,QAAQ,cAAcM,EAAE,gBAAgB,SACpDV,GAAU,OAAU;IAAE,GAAGiB;IAAM,UAAU;GAAM,EAAE;EACnD;EAKA,OAHAV,EAAG,iBAAiB,eAAeE,CAAM,GACzCF,EAAG,iBAAiB,gBAAgBW,CAAO,GAC3CX,EAAG,iBAAiB,gBAAgBY,CAAO,SAC9B;GAGX,AAFAZ,EAAG,oBAAoB,eAAeE,CAAM,GAC5CF,EAAG,oBAAoB,gBAAgBW,CAAO,GAC9CX,EAAG,oBAAoB,gBAAgBY,CAAO;EAChD;CACF,GAAG,CAACX,GAAQJ,CAAO,CAAC,GAEbL;AACT"}
+{"version":3,"file":"usePointerStylus.js","names":[],"sources":["../../../src/core/stylus/usePointerStylus.ts"],"sourcesContent":["import { useEffect, useRef, useState, type RefObject } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { getStylusData, type StylusData } from './stylus';\n\n/** State exposed by `usePointerStylus` — the most recent stylus snapshot\n *  plus a `hovering` flag. */\nexport interface PointerStylusState extends StylusData {\n  /** True between `pointerenter` and `pointerleave` events on the target\n   *  element. iPad Safari fires these for Apple Pencil hover, so this is\n   *  true while the pen is near the glass without contact. */\n  hovering: boolean;\n}\n\nconst IDLE: PointerStylusState = {\n  pressure: 0,\n  tiltX: 0,\n  tiltY: 0,\n  altitudeAngle: undefined,\n  azimuthAngle: undefined,\n  twist: 0,\n  pointerType: '',\n  isStylus: false,\n  hovering: false,\n};\n\n/** Options for `usePointerStylus`. */\nexport interface UsePointerStylusOptions {\n  /** Throttle re-renders to ≈this many state updates per second. The latest\n   *  sample is always kept; intermediates are dropped. Default 60. Set to\n   *  `Infinity` (or 0) to emit every move. */\n  maxFps?: number;\n  /** When true, only emit updates while `pointerType === 'pen'`. Default\n   *  false. */\n  stylusOnly?: boolean;\n}\n\n/**\n * Subscribe to pointer events on a target element (defaults to `window`)\n * and expose the most recent stylus snapshot.\n *\n * The hook does NOT consume pointerdown / pointerup — leave gesture handling\n * to the dispatcher. Re-renders are throttled by default (`maxFps`); pass\n * `maxFps: Infinity` to get every sample.\n */\nexport function usePointerStylus(\n  target?: RefObject<HTMLElement | null> | HTMLElement | null,\n  options: UsePointerStylusOptions = {},\n): PointerStylusState {\n  const { maxFps = 60, stylusOnly = false } = options;\n  const [state, setState] = useState<PointerStylusState>(IDLE);\n  // Track the last commit time to throttle. A ref avoids re-creating the\n  // listener every render and avoids stale-closure read of an outer `let`.\n  const lastCommit = useRef(-Infinity);\n  const optsRef = useLatest({ maxFps, stylusOnly });\n\n  useEffect(() => {\n    const el: EventTarget =\n      target == null\n        ? window\n        : target instanceof HTMLElement\n          ? target\n          : target.current ?? window;\n\n    const onMove = (raw: Event) => {\n      const e = raw as PointerEvent;\n      const { maxFps, stylusOnly } = optsRef.current;\n      if (stylusOnly && e.pointerType !== 'pen') return;\n      const now = performance.now();\n      const minGap = maxFps > 0 && Number.isFinite(maxFps) ? 1000 / maxFps : 0;\n      if (minGap > 0 && now - lastCommit.current < minGap) return;\n      lastCommit.current = now;\n      setState((prev) => ({ ...getStylusData(e), hovering: prev.hovering }));\n    };\n    const onEnter = (raw: Event) => {\n      const e = raw as PointerEvent;\n      if (optsRef.current.stylusOnly && e.pointerType !== 'pen') return;\n      setState((prev) => ({ ...prev, hovering: true }));\n    };\n    const onLeave = (raw: Event) => {\n      const e = raw as PointerEvent;\n      if (optsRef.current.stylusOnly && e.pointerType !== 'pen') return;\n      setState((prev) => ({ ...prev, hovering: false }));\n    };\n\n    el.addEventListener('pointermove', onMove);\n    el.addEventListener('pointerenter', onEnter);\n    el.addEventListener('pointerleave', onLeave);\n    return () => {\n      el.removeEventListener('pointermove', onMove);\n      el.removeEventListener('pointerenter', onEnter);\n      el.removeEventListener('pointerleave', onLeave);\n    };\n  }, [target, optsRef]);\n\n  return state;\n}\n"],"mappings":";;;;;AAaA,IAAM,OAA2B;CAC/B,UAAU;CACV,OAAO;CACP,OAAO;CACP,eAAe;CACf,cAAc;CACd,OAAO;CACP,aAAa;CACb,UAAU;CACV,UAAU;AACZ;;;;;;;;;AAqBA,SAAgB,iBACd,QACA,UAAmC,CAAC,GAChB;CACpB,MAAM,EAAE,SAAS,IAAI,aAAa,UAAU;CAC5C,MAAM,CAAC,OAAO,YAAY,SAA6B,IAAI;CAG3D,MAAM,aAAa,OAAO,SAAS;CACnC,MAAM,UAAU,UAAU;EAAE;EAAQ;CAAW,CAAC;CAEhD,gBAAgB;EACd,MAAM,KACJ,UAAU,OACN,SACA,kBAAkB,cAChB,SACA,OAAO,WAAW;EAE1B,MAAM,UAAU,QAAe;GAC7B,MAAM,IAAI;GACV,MAAM,EAAE,QAAQ,eAAe,QAAQ;GACvC,IAAI,cAAc,EAAE,gBAAgB,OAAO;GAC3C,MAAM,MAAM,YAAY,IAAI;GAC5B,MAAM,SAAS,SAAS,KAAK,OAAO,SAAS,MAAM,IAAI,MAAO,SAAS;GACvE,IAAI,SAAS,KAAK,MAAM,WAAW,UAAU,QAAQ;GACrD,WAAW,UAAU;GACrB,UAAU,UAAU;IAAE,GAAG,cAAc,CAAC;IAAG,UAAU,KAAK;GAAS,EAAE;EACvE;EACA,MAAM,WAAW,QAAe;GAC9B,MAAM,IAAI;GACV,IAAI,QAAQ,QAAQ,cAAc,EAAE,gBAAgB,OAAO;GAC3D,UAAU,UAAU;IAAE,GAAG;IAAM,UAAU;GAAK,EAAE;EAClD;EACA,MAAM,WAAW,QAAe;GAC9B,MAAM,IAAI;GACV,IAAI,QAAQ,QAAQ,cAAc,EAAE,gBAAgB,OAAO;GAC3D,UAAU,UAAU;IAAE,GAAG;IAAM,UAAU;GAAM,EAAE;EACnD;EAEA,GAAG,iBAAiB,eAAe,MAAM;EACzC,GAAG,iBAAiB,gBAAgB,OAAO;EAC3C,GAAG,iBAAiB,gBAAgB,OAAO;EAC3C,aAAa;GACX,GAAG,oBAAoB,eAAe,MAAM;GAC5C,GAAG,oBAAoB,gBAAgB,OAAO;GAC9C,GAAG,oBAAoB,gBAAgB,OAAO;EAChD;CACF,GAAG,CAAC,QAAQ,OAAO,CAAC;CAEpB,OAAO;AACT"}

package/dist/core/usePaintKinds.js

@@ -1,17 +1,27 @@
-import { getPaintKind as e, listGradientKinds as t, listPaintKinds as n, paintKindRegistry as r } from "./paint/paintKinds.js";
-import { useCallback as i, useSyncExternalStore as a } from "react";
+import { getPaintKind, listGradientKinds, listPaintKinds, paintKindRegistry } from "./paint/paintKinds.js";
+import { useCallback, useSyncExternalStore } from "react";
+
 //#region src/core/usePaintKinds.ts
-function o() {
-	return a(r.subscribe, n, n);
+/** Every registered paint kind, as {@link listPaintKinds} returns it,
+*  re-rendering the caller whenever a kind is registered or removed. */
+function usePaintKinds() {
+	return useSyncExternalStore(paintKindRegistry.subscribe, listPaintKinds, listPaintKinds);
 }
-function s() {
-	return a(r.subscribe, t, t);
+/** Every registered gradient kind, as {@link listGradientKinds} returns it,
+*  re-rendering the caller whenever a kind is registered or removed. */
+function useGradientKinds() {
+	return useSyncExternalStore(paintKindRegistry.subscribe, listGradientKinds, listGradientKinds);
 }
-function c(t) {
-	let n = i(() => e(t), [t]);
-	return a(r.subscribe, n, n);
+/**
+* The entry for `kind`, as {@link getPaintKind} returns it — `undefined` until
+* it is registered, and the new entry once it is. A kind with a loader starts
+* loading on the first read.
+*/
+function usePaintKind(kind) {
+	const read = useCallback(() => getPaintKind(kind), [kind]);
+	return useSyncExternalStore(paintKindRegistry.subscribe, read, read);
 }
-//#endregion
-export { s as useGradientKinds, c as usePaintKind, o as usePaintKinds };
 
+//#endregion
+export { useGradientKinds, usePaintKind, usePaintKinds };
 //# sourceMappingURL=usePaintKinds.js.map

package/dist/core/usePaintKinds.js.map

@@ -1 +1 @@
-{"version":3,"file":"usePaintKinds.js","names":["usePaintKinds","useSyncExternalStore","paintKindRegistry","listPaintKinds","useGradientKinds","listGradientKinds","usePaintKind","read","useCallback","getPaintKind","kind"],"sources":["../../src/core/usePaintKinds.ts"],"sourcesContent":["import { useCallback, useSyncExternalStore } from 'react';\nimport {\n  getPaintKind, listGradientKinds, listPaintKinds, paintKindRegistry,\n} from 'core/paint/paintKinds';\nimport type { PaintKindEntry } from 'core/paint/paintKindEntry';\n\n/** Every registered paint kind, as {@link listPaintKinds} returns it,\n *  re-rendering the caller whenever a kind is registered or removed. */\nexport function usePaintKinds(): readonly PaintKindEntry[] {\n  return useSyncExternalStore(paintKindRegistry.subscribe, listPaintKinds, listPaintKinds);\n}\n\n/** Every registered gradient kind, as {@link listGradientKinds} returns it,\n *  re-rendering the caller whenever a kind is registered or removed. */\nexport function useGradientKinds(): readonly PaintKindEntry[] {\n  return useSyncExternalStore(paintKindRegistry.subscribe, listGradientKinds, listGradientKinds);\n}\n\n/**\n * The entry for `kind`, as {@link getPaintKind} returns it — `undefined` until\n * it is registered, and the new entry once it is. A kind with a loader starts\n * loading on the first read.\n */\nexport function usePaintKind(kind: string | undefined): PaintKindEntry | undefined {\n  const read = useCallback(() => getPaintKind(kind), [kind]);\n  return useSyncExternalStore(paintKindRegistry.subscribe, read, read);\n}\n"],"mappings":";;;AAQA,SAAgBA,IAA2C;CACzD,OAAOC,EAAqBC,EAAkB,WAAWC,GAAgBA,CAAc;AACzF;AAIA,SAAgBC,IAA8C;CAC5D,OAAOH,EAAqBC,EAAkB,WAAWG,GAAmBA,CAAiB;AAC/F;AAOA,SAAgBC,EAAa,GAAsD;CACjF,IAAMC,IAAOC,QAAkBC,EAAaC,CAAI,GAAG,CAACA,CAAI,CAAC;CACzD,OAAOT,EAAqBC,EAAkB,WAAWK,GAAMA,CAAI;AACrE"}
+{"version":3,"file":"usePaintKinds.js","names":[],"sources":["../../src/core/usePaintKinds.ts"],"sourcesContent":["import { useCallback, useSyncExternalStore } from 'react';\nimport {\n  getPaintKind, listGradientKinds, listPaintKinds, paintKindRegistry,\n} from 'core/paint/paintKinds';\nimport type { PaintKindEntry } from 'core/paint/paintKindEntry';\n\n/** Every registered paint kind, as {@link listPaintKinds} returns it,\n *  re-rendering the caller whenever a kind is registered or removed. */\nexport function usePaintKinds(): readonly PaintKindEntry[] {\n  return useSyncExternalStore(paintKindRegistry.subscribe, listPaintKinds, listPaintKinds);\n}\n\n/** Every registered gradient kind, as {@link listGradientKinds} returns it,\n *  re-rendering the caller whenever a kind is registered or removed. */\nexport function useGradientKinds(): readonly PaintKindEntry[] {\n  return useSyncExternalStore(paintKindRegistry.subscribe, listGradientKinds, listGradientKinds);\n}\n\n/**\n * The entry for `kind`, as {@link getPaintKind} returns it — `undefined` until\n * it is registered, and the new entry once it is. A kind with a loader starts\n * loading on the first read.\n */\nexport function usePaintKind(kind: string | undefined): PaintKindEntry | undefined {\n  const read = useCallback(() => getPaintKind(kind), [kind]);\n  return useSyncExternalStore(paintKindRegistry.subscribe, read, read);\n}\n"],"mappings":";;;;;;AAQA,SAAgB,gBAA2C;CACzD,OAAO,qBAAqB,kBAAkB,WAAW,gBAAgB,cAAc;AACzF;;;AAIA,SAAgB,mBAA8C;CAC5D,OAAO,qBAAqB,kBAAkB,WAAW,mBAAmB,iBAAiB;AAC/F;;;;;;AAOA,SAAgB,aAAa,MAAsD;CACjF,MAAM,OAAO,kBAAkB,aAAa,IAAI,GAAG,CAAC,IAAI,CAAC;CACzD,OAAO,qBAAqB,kBAAkB,WAAW,MAAM,IAAI;AACrE"}

package/dist/core/viewport/clampView.js

@@ -1,24 +1,40 @@
 //#region src/core/viewport/clampView.ts
-function e(e, t, n) {
-	let r = Math.abs(n.width / e.scale.x), i = Math.abs(n.height / e.scale.y), a = e.scale.x < 0, o = e.scale.y < 0, s;
-	if (r >= t.width) s = t.x + (t.width - r) / 2 + (a ? r : 0);
+/**
+* Clamp a `View` so the visible world rect stays within `bounds`.
+*
+* Visible world rect = `[view.x, view.x + canvas.width / view.scale.x]` ×
+* `[view.y, view.y + canvas.height / view.scale.y]`.
+*
+* If the visible rect is larger than `bounds` along an axis (zoomed out
+* past the bounds extent), the view is centered on that axis so bounds
+* sits in the middle of the canvas.
+*/
+function clampView(view, bounds, canvas) {
+	const visW = Math.abs(canvas.width / view.scale.x);
+	const visH = Math.abs(canvas.height / view.scale.y);
+	const flipX = view.scale.x < 0;
+	const flipY = view.scale.y < 0;
+	let x;
+	if (visW >= bounds.width) x = bounds.x + (bounds.width - visW) / 2 + (flipX ? visW : 0);
 	else {
-		let n = a ? t.x + r : t.x, i = a ? t.x + t.width : t.x + t.width - r;
-		s = e.x < n ? n : e.x > i ? i : e.x;
+		const minX = flipX ? bounds.x + visW : bounds.x;
+		const maxX = flipX ? bounds.x + bounds.width : bounds.x + bounds.width - visW;
+		x = view.x < minX ? minX : view.x > maxX ? maxX : view.x;
 	}
-	let c;
-	if (i >= t.height) c = t.y + (t.height - i) / 2 + (o ? i : 0);
+	let y;
+	if (visH >= bounds.height) y = bounds.y + (bounds.height - visH) / 2 + (flipY ? visH : 0);
 	else {
-		let n = o ? t.y + i : t.y, r = o ? t.y + t.height : t.y + t.height - i;
-		c = e.y < n ? n : e.y > r ? r : e.y;
+		const minY = flipY ? bounds.y + visH : bounds.y;
+		const maxY = flipY ? bounds.y + bounds.height : bounds.y + bounds.height - visH;
+		y = view.y < minY ? minY : view.y > maxY ? maxY : view.y;
 	}
-	return s === e.x && c === e.y ? e : {
-		x: s,
-		y: c,
-		scale: e.scale
+	return x === view.x && y === view.y ? view : {
+		x,
+		y,
+		scale: view.scale
 	};
 }
-//#endregion
-export { e as clampView };
 
+//#endregion
+export { clampView };
 //# sourceMappingURL=clampView.js.map

package/dist/core/viewport/clampView.js.map

@@ -1 +1 @@
-{"version":3,"file":"clampView.js","names":["clampView","visW","canvas","view","visH","flipX","flipY","x","bounds","minX","maxX","y","minY","maxY"],"sources":["../../../src/core/viewport/clampView.ts"],"sourcesContent":["import type { View } from './view';\n\n/** The world rect a view is not allowed to show outside of. */\nexport interface ClampBounds {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** Canvas dimensions in CSS pixels — needed to know how much world a view\n *  actually shows. */\nexport interface CanvasSize {\n  width: number;\n  height: number;\n}\n\n/**\n * Clamp a `View` so the visible world rect stays within `bounds`.\n *\n * Visible world rect = `[view.x, view.x + canvas.width / view.scale.x]` ×\n * `[view.y, view.y + canvas.height / view.scale.y]`.\n *\n * If the visible rect is larger than `bounds` along an axis (zoomed out\n * past the bounds extent), the view is centered on that axis so bounds\n * sits in the middle of the canvas.\n */\nexport function clampView(view: View, bounds: ClampBounds, canvas: CanvasSize): View {\n  // A negative scale is a flipped axis, so the visible rect runs the other way\n  // from `view.x`/`view.y`: its extent is the magnitude, and the anchor is the\n  // rect's far edge rather than its near one.\n  const visW = Math.abs(canvas.width / view.scale.x);\n  const visH = Math.abs(canvas.height / view.scale.y);\n  const flipX = view.scale.x < 0;\n  const flipY = view.scale.y < 0;\n\n  let x: number;\n  if (visW >= bounds.width) {\n    x = bounds.x + (bounds.width - visW) / 2 + (flipX ? visW : 0);\n  } else {\n    const minX = flipX ? bounds.x + visW : bounds.x;\n    const maxX = flipX ? bounds.x + bounds.width : bounds.x + bounds.width - visW;\n    x = view.x < minX ? minX : view.x > maxX ? maxX : view.x;\n  }\n\n  let y: number;\n  if (visH >= bounds.height) {\n    y = bounds.y + (bounds.height - visH) / 2 + (flipY ? visH : 0);\n  } else {\n    const minY = flipY ? bounds.y + visH : bounds.y;\n    const maxY = flipY ? bounds.y + bounds.height : bounds.y + bounds.height - visH;\n    y = view.y < minY ? minY : view.y > maxY ? maxY : view.y;\n  }\n\n  return x === view.x && y === view.y ? view : { x, y, scale: view.scale };\n}\n"],"mappings":";AA2BA,SAAgBA,EAAU,GAAY,GAAqB,GAA0B;CAInF,IAAMC,IAAO,KAAK,IAAIC,EAAO,QAAQC,EAAK,MAAM,CAAC,GAC3CC,IAAO,KAAK,IAAIF,EAAO,SAASC,EAAK,MAAM,CAAC,GAC5CE,IAAQF,EAAK,MAAM,IAAI,GACvBG,IAAQH,EAAK,MAAM,IAAI,GAEzBI;CACJ,IAAIN,KAAQO,EAAO,OACjB,IAAIA,EAAO,KAAKA,EAAO,QAAQP,KAAQ,KAAKI,IAAQJ,IAAO;MACtD;EACL,IAAMQ,IAAOJ,IAAQG,EAAO,IAAIP,IAAOO,EAAO,GACxCE,IAAOL,IAAQG,EAAO,IAAIA,EAAO,QAAQA,EAAO,IAAIA,EAAO,QAAQP;EACzE,IAAIE,EAAK,IAAIM,IAAOA,IAAON,EAAK,IAAIO,IAAOA,IAAOP,EAAK;CACzD;CAEA,IAAIQ;CACJ,IAAIP,KAAQI,EAAO,QACjB,IAAIA,EAAO,KAAKA,EAAO,SAASJ,KAAQ,KAAKE,IAAQF,IAAO;MACvD;EACL,IAAMQ,IAAON,IAAQE,EAAO,IAAIJ,IAAOI,EAAO,GACxCK,IAAOP,IAAQE,EAAO,IAAIA,EAAO,SAASA,EAAO,IAAIA,EAAO,SAASJ;EAC3E,IAAID,EAAK,IAAIS,IAAOA,IAAOT,EAAK,IAAIU,IAAOA,IAAOV,EAAK;CACzD;CAEA,OAAOI,MAAMJ,EAAK,KAAKQ,MAAMR,EAAK,IAAIA,IAAO;EAAE;EAAG;EAAG,OAAOA,EAAK;CAAM;AACzE"}
+{"version":3,"file":"clampView.js","names":[],"sources":["../../../src/core/viewport/clampView.ts"],"sourcesContent":["import type { View } from './view';\n\n/** The world rect a view is not allowed to show outside of. */\nexport interface ClampBounds {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** Canvas dimensions in CSS pixels — needed to know how much world a view\n *  actually shows. */\nexport interface CanvasSize {\n  width: number;\n  height: number;\n}\n\n/**\n * Clamp a `View` so the visible world rect stays within `bounds`.\n *\n * Visible world rect = `[view.x, view.x + canvas.width / view.scale.x]` ×\n * `[view.y, view.y + canvas.height / view.scale.y]`.\n *\n * If the visible rect is larger than `bounds` along an axis (zoomed out\n * past the bounds extent), the view is centered on that axis so bounds\n * sits in the middle of the canvas.\n */\nexport function clampView(view: View, bounds: ClampBounds, canvas: CanvasSize): View {\n  // A negative scale is a flipped axis, so the visible rect runs the other way\n  // from `view.x`/`view.y`: its extent is the magnitude, and the anchor is the\n  // rect's far edge rather than its near one.\n  const visW = Math.abs(canvas.width / view.scale.x);\n  const visH = Math.abs(canvas.height / view.scale.y);\n  const flipX = view.scale.x < 0;\n  const flipY = view.scale.y < 0;\n\n  let x: number;\n  if (visW >= bounds.width) {\n    x = bounds.x + (bounds.width - visW) / 2 + (flipX ? visW : 0);\n  } else {\n    const minX = flipX ? bounds.x + visW : bounds.x;\n    const maxX = flipX ? bounds.x + bounds.width : bounds.x + bounds.width - visW;\n    x = view.x < minX ? minX : view.x > maxX ? maxX : view.x;\n  }\n\n  let y: number;\n  if (visH >= bounds.height) {\n    y = bounds.y + (bounds.height - visH) / 2 + (flipY ? visH : 0);\n  } else {\n    const minY = flipY ? bounds.y + visH : bounds.y;\n    const maxY = flipY ? bounds.y + bounds.height : bounds.y + bounds.height - visH;\n    y = view.y < minY ? minY : view.y > maxY ? maxY : view.y;\n  }\n\n  return x === view.x && y === view.y ? view : { x, y, scale: view.scale };\n}\n"],"mappings":";;;;;;;;;;;AA2BA,SAAgB,UAAU,MAAY,QAAqB,QAA0B;CAInF,MAAM,OAAO,KAAK,IAAI,OAAO,QAAQ,KAAK,MAAM,CAAC;CACjD,MAAM,OAAO,KAAK,IAAI,OAAO,SAAS,KAAK,MAAM,CAAC;CAClD,MAAM,QAAQ,KAAK,MAAM,IAAI;CAC7B,MAAM,QAAQ,KAAK,MAAM,IAAI;CAE7B,IAAI;CACJ,IAAI,QAAQ,OAAO,OACjB,IAAI,OAAO,KAAK,OAAO,QAAQ,QAAQ,KAAK,QAAQ,OAAO;MACtD;EACL,MAAM,OAAO,QAAQ,OAAO,IAAI,OAAO,OAAO;EAC9C,MAAM,OAAO,QAAQ,OAAO,IAAI,OAAO,QAAQ,OAAO,IAAI,OAAO,QAAQ;EACzE,IAAI,KAAK,IAAI,OAAO,OAAO,KAAK,IAAI,OAAO,OAAO,KAAK;CACzD;CAEA,IAAI;CACJ,IAAI,QAAQ,OAAO,QACjB,IAAI,OAAO,KAAK,OAAO,SAAS,QAAQ,KAAK,QAAQ,OAAO;MACvD;EACL,MAAM,OAAO,QAAQ,OAAO,IAAI,OAAO,OAAO;EAC9C,MAAM,OAAO,QAAQ,OAAO,IAAI,OAAO,SAAS,OAAO,IAAI,OAAO,SAAS;EAC3E,IAAI,KAAK,IAAI,OAAO,OAAO,KAAK,IAAI,OAAO,OAAO,KAAK;CACzD;CAEA,OAAO,MAAM,KAAK,KAAK,MAAM,KAAK,IAAI,OAAO;EAAE;EAAG;EAAG,OAAO,KAAK;CAAM;AACzE"}

package/dist/core/viewport/clientToWorld.js

@@ -1,8 +1,19 @@
 //#region src/core/viewport/clientToWorld.ts
-function e(e, t, n, r) {
-	return [(e - n.left) / r.scale.x + r.x, (t - n.top) / r.scale.y + r.y];
+/**
+* Map a browser client coord pair to world coords.
+*
+* @param clientX  - `event.clientX`
+* @param clientY  - `event.clientY`
+* @param origin   - client-space origin of the surface `view` is a camera on.
+*   For a whole canvas that is its bounding rect. For a viewport node it is
+*   the canvas rect offset by the viewport's own rect, so the same call maps
+*   into that viewport's inner world.
+* @param view     - current viewport transform
+*/
+function clientToWorld(clientX, clientY, origin, view) {
+	return [(clientX - origin.left) / view.scale.x + view.x, (clientY - origin.top) / view.scale.y + view.y];
 }
-//#endregion
-export { e as clientToWorld };
 
+//#endregion
+export { clientToWorld };
 //# sourceMappingURL=clientToWorld.js.map

package/dist/core/viewport/clientToWorld.js.map

@@ -1 +1 @@
-{"version":3,"file":"clientToWorld.js","names":["clientToWorld","clientX","origin","view","clientY"],"sources":["../../../src/core/viewport/clientToWorld.ts"],"sourcesContent":["/**\n * Convert client coords directly to world coords by subtracting the canvas\n * rect origin and then applying the inverse view transform.\n *\n * This is the composition of `clientToCanvas` + the view-inverse half of\n * `screenToWorld`, but expressed against the `ViewLike` shape used by\n * `SceneCanvas` (`{ scale: { x, y }, x, y }`) rather than the\n * `ViewTransform` shape used by `screenToWorld` (`{ panX, panY, zoom }`).\n */\nexport interface ViewLike {\n  scale: { x: number; y: number };\n  x: number;\n  y: number;\n}\n\n/**\n * Map a browser client coord pair to world coords.\n *\n * @param clientX  - `event.clientX`\n * @param clientY  - `event.clientY`\n * @param origin   - client-space origin of the surface `view` is a camera on.\n *   For a whole canvas that is its bounding rect. For a viewport node it is\n *   the canvas rect offset by the viewport's own rect, so the same call maps\n *   into that viewport's inner world.\n * @param view     - current viewport transform\n */\nexport function clientToWorld(\n  clientX: number,\n  clientY: number,\n  origin: { left: number; top: number },\n  view: ViewLike,\n): [number, number] {\n  return [\n    (clientX - origin.left) / view.scale.x + view.x,\n    (clientY - origin.top) / view.scale.y + view.y,\n  ];\n}\n"],"mappings":";AA0BA,SAAgBA,EACd,GACA,GACA,GACA,GACkB;CAClB,OAAO,EACJC,IAAUC,EAAO,QAAQC,EAAK,MAAM,IAAIA,EAAK,IAC7CC,IAAUF,EAAO,OAAOC,EAAK,MAAM,IAAIA,EAAK,CAC/C;AACF"}
+{"version":3,"file":"clientToWorld.js","names":[],"sources":["../../../src/core/viewport/clientToWorld.ts"],"sourcesContent":["/**\n * Convert client coords directly to world coords by subtracting the canvas\n * rect origin and then applying the inverse view transform.\n *\n * This is the composition of `clientToCanvas` + the view-inverse half of\n * `screenToWorld`, but expressed against the `ViewLike` shape used by\n * `SceneCanvas` (`{ scale: { x, y }, x, y }`) rather than the\n * `ViewTransform` shape used by `screenToWorld` (`{ panX, panY, zoom }`).\n */\nexport interface ViewLike {\n  scale: { x: number; y: number };\n  x: number;\n  y: number;\n}\n\n/**\n * Map a browser client coord pair to world coords.\n *\n * @param clientX  - `event.clientX`\n * @param clientY  - `event.clientY`\n * @param origin   - client-space origin of the surface `view` is a camera on.\n *   For a whole canvas that is its bounding rect. For a viewport node it is\n *   the canvas rect offset by the viewport's own rect, so the same call maps\n *   into that viewport's inner world.\n * @param view     - current viewport transform\n */\nexport function clientToWorld(\n  clientX: number,\n  clientY: number,\n  origin: { left: number; top: number },\n  view: ViewLike,\n): [number, number] {\n  return [\n    (clientX - origin.left) / view.scale.x + view.x,\n    (clientY - origin.top) / view.scale.y + view.y,\n  ];\n}\n"],"mappings":";;;;;;;;;;;;AA0BA,SAAgB,cACd,SACA,SACA,QACA,MACkB;CAClB,OAAO,EACJ,UAAU,OAAO,QAAQ,KAAK,MAAM,IAAI,KAAK,IAC7C,UAAU,OAAO,OAAO,KAAK,MAAM,IAAI,KAAK,CAC/C;AACF"}

package/dist/core/viewport/createVelocityTracker.js

@@ -1,39 +1,43 @@
 //#region src/core/viewport/createVelocityTracker.ts
-function e() {
-	let e = [];
+/** Hook-free velocity tracker. `useVelocityTracker` wraps one of these; the
+*  action layer builds its own, because an Action descriptor is a static
+*  object and cannot call hooks. */
+function createVelocityTracker() {
+	let samples = [];
 	return {
-		record(t, n, r) {
-			e.push({
-				dx: t,
-				dy: n,
-				t: r
+		record(dx, dy, t) {
+			samples.push({
+				dx,
+				dy,
+				t
 			});
-			let i = r - 100;
-			e = e.filter((e) => e.t >= i);
+			const cutoff = t - 100;
+			samples = samples.filter((s) => s.t >= cutoff);
 		},
 		getVelocity() {
-			let t = e;
-			if (t.length < 2) return {
+			const s = samples;
+			if (s.length < 2) return {
 				vx: 0,
 				vy: 0
 			};
-			let n = t[t.length - 1].t - t[0].t;
-			if (n === 0) return {
+			const dt = s[s.length - 1].t - s[0].t;
+			if (dt === 0) return {
 				vx: 0,
 				vy: 0
 			};
-			let r = t.slice(1).reduce((e, t) => e + t.dx, 0), i = t.slice(1).reduce((e, t) => e + t.dy, 0);
+			const totalDx = s.slice(1).reduce((acc, p) => acc + p.dx, 0);
+			const totalDy = s.slice(1).reduce((acc, p) => acc + p.dy, 0);
 			return {
-				vx: r / n,
-				vy: i / n
+				vx: totalDx / dt,
+				vy: totalDy / dt
 			};
 		},
 		reset() {
-			e = [];
+			samples = [];
 		}
 	};
 }
-//#endregion
-export { e as createVelocityTracker };
 
+//#endregion
+export { createVelocityTracker };
 //# sourceMappingURL=createVelocityTracker.js.map

package/dist/core/viewport/createVelocityTracker.js.map

@@ -1 +1 @@
-{"version":3,"file":"createVelocityTracker.js","names":["createVelocityTracker","samples","cutoff","t","s","dt","totalDx","acc","p","totalDy"],"sources":["../../../src/core/viewport/createVelocityTracker.ts"],"sourcesContent":["interface Sample { dx: number; dy: number; t: number }\n\n/** Records recent deltas and reports the current velocity, averaged over the\n *  last 100ms — the throw speed a momentum decay starts from. */\nexport interface VelocityTracker {\n  record(dx: number, dy: number, t: number): void;\n  getVelocity(): { vx: number; vy: number };\n  reset(): void;\n}\n\n/** Hook-free velocity tracker. `useVelocityTracker` wraps one of these; the\n *  action layer builds its own, because an Action descriptor is a static\n *  object and cannot call hooks. */\nexport function createVelocityTracker(): VelocityTracker {\n  let samples: Sample[] = [];\n  return {\n    record(dx, dy, t) {\n      samples.push({ dx, dy, t });\n      const cutoff = t - 100;\n      samples = samples.filter(s => s.t >= cutoff);\n    },\n    getVelocity() {\n      const s = samples;\n      if (s.length < 2) return { vx: 0, vy: 0 };\n      const dt = s[s.length - 1].t - s[0].t;\n      if (dt === 0) return { vx: 0, vy: 0 };\n      const totalDx = s.slice(1).reduce((acc, p) => acc + p.dx, 0);\n      const totalDy = s.slice(1).reduce((acc, p) => acc + p.dy, 0);\n      return { vx: totalDx / dt, vy: totalDy / dt };\n    },\n    reset() { samples = []; },\n  };\n}\n"],"mappings":";AAaA,SAAgBA,IAAyC;CACvD,IAAIC,IAAoB,CAAC;CACzB,OAAO;EACL,OAAO,GAAI,GAAI,GAAG;GAChB,EAAQ,KAAK;IAAE;IAAI;IAAI;GAAE,CAAC;GAC1B,IAAMC,IAASC,IAAI;GACnB,IAAUF,EAAQ,QAAO,MAAKG,EAAE,KAAKF,CAAM;EAC7C;EACA,cAAc;GACZ,IAAME,IAAIH;GACV,IAAIG,EAAE,SAAS,GAAG,OAAO;IAAE,IAAI;IAAG,IAAI;GAAE;GACxC,IAAMC,IAAKD,EAAEA,EAAE,SAAS,EAAE,CAAC,IAAIA,EAAE,EAAE,CAAC;GACpC,IAAIC,MAAO,GAAG,OAAO;IAAE,IAAI;IAAG,IAAI;GAAE;GACpC,IAAMC,IAAUF,EAAE,MAAM,CAAC,CAAC,CAAC,QAAQ,GAAK,MAAMG,IAAMC,EAAE,IAAI,CAAC,GACrDC,IAAUL,EAAE,MAAM,CAAC,CAAC,CAAC,QAAQ,GAAK,MAAMG,IAAMC,EAAE,IAAI,CAAC;GAC3D,OAAO;IAAE,IAAIF,IAAUD;IAAI,IAAII,IAAUJ;GAAG;EAC9C;EACA,QAAQ;GAAE,IAAU,CAAC;EAAG;CAC1B;AACF"}
+{"version":3,"file":"createVelocityTracker.js","names":[],"sources":["../../../src/core/viewport/createVelocityTracker.ts"],"sourcesContent":["interface Sample { dx: number; dy: number; t: number }\n\n/** Records recent deltas and reports the current velocity, averaged over the\n *  last 100ms — the throw speed a momentum decay starts from. */\nexport interface VelocityTracker {\n  record(dx: number, dy: number, t: number): void;\n  getVelocity(): { vx: number; vy: number };\n  reset(): void;\n}\n\n/** Hook-free velocity tracker. `useVelocityTracker` wraps one of these; the\n *  action layer builds its own, because an Action descriptor is a static\n *  object and cannot call hooks. */\nexport function createVelocityTracker(): VelocityTracker {\n  let samples: Sample[] = [];\n  return {\n    record(dx, dy, t) {\n      samples.push({ dx, dy, t });\n      const cutoff = t - 100;\n      samples = samples.filter(s => s.t >= cutoff);\n    },\n    getVelocity() {\n      const s = samples;\n      if (s.length < 2) return { vx: 0, vy: 0 };\n      const dt = s[s.length - 1].t - s[0].t;\n      if (dt === 0) return { vx: 0, vy: 0 };\n      const totalDx = s.slice(1).reduce((acc, p) => acc + p.dx, 0);\n      const totalDy = s.slice(1).reduce((acc, p) => acc + p.dy, 0);\n      return { vx: totalDx / dt, vy: totalDy / dt };\n    },\n    reset() { samples = []; },\n  };\n}\n"],"mappings":";;;;AAaA,SAAgB,wBAAyC;CACvD,IAAI,UAAoB,CAAC;CACzB,OAAO;EACL,OAAO,IAAI,IAAI,GAAG;GAChB,QAAQ,KAAK;IAAE;IAAI;IAAI;GAAE,CAAC;GAC1B,MAAM,SAAS,IAAI;GACnB,UAAU,QAAQ,QAAO,MAAK,EAAE,KAAK,MAAM;EAC7C;EACA,cAAc;GACZ,MAAM,IAAI;GACV,IAAI,EAAE,SAAS,GAAG,OAAO;IAAE,IAAI;IAAG,IAAI;GAAE;GACxC,MAAM,KAAK,EAAE,EAAE,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC;GACpC,IAAI,OAAO,GAAG,OAAO;IAAE,IAAI;IAAG,IAAI;GAAE;GACpC,MAAM,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC,QAAQ,KAAK,MAAM,MAAM,EAAE,IAAI,CAAC;GAC3D,MAAM,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC,QAAQ,KAAK,MAAM,MAAM,EAAE,IAAI,CAAC;GAC3D,OAAO;IAAE,IAAI,UAAU;IAAI,IAAI,UAAU;GAAG;EAC9C;EACA,QAAQ;GAAE,UAAU,CAAC;EAAG;CAC1B;AACF"}

package/dist/core/viewport/fitToBounds.js

@@ -1,18 +1,35 @@
-import { normalizeZoom as e } from "./zoomBounds.js";
+import { normalizeZoom } from "./zoomBounds.js";
+
 //#region src/core/viewport/fitToBounds.ts
-function t(t, n, r, i, a) {
-	let o = Math.min(t / r, n / i), s = a?.min ?? -Infinity, c = a?.max ?? Infinity;
-	return e(Math.min(c, Math.max(s, o)));
+/**
+* Compute the largest uniform zoom (px per content-unit) that fits a content
+* rect of `contentW x contentH` (in content units) into a viewport rect of
+* `availW x availH` (in pixels).
+*
+* `clamp` optionally bounds the resulting zoom to [min, max].
+*/
+function fitZoom(availW, availH, contentW, contentH, clamp) {
+	const raw = Math.min(availW / contentW, availH / contentH);
+	const min = clamp?.min ?? -Infinity;
+	const max = clamp?.max ?? Infinity;
+	return normalizeZoom(Math.min(max, Math.max(min, raw)));
 }
-function n(e, n, r, i, a = 0, o) {
-	let s = t(Math.max(1, e - a * 2), Math.max(1, n - a * 2), r, i, o), c = r * s, l = i * s;
+/**
+* Compute zoom + pan that centers `contentW x contentH` (content units) inside
+* a `viewportW x viewportH` (pixel) rect. `paddingPx` is uniform pixel padding
+* on every side.
+*/
+function fitToBounds(viewportW, viewportH, contentW, contentH, paddingPx = 0, clamp) {
+	const zoom = fitZoom(Math.max(1, viewportW - paddingPx * 2), Math.max(1, viewportH - paddingPx * 2), contentW, contentH, clamp);
+	const contentPxW = contentW * zoom;
+	const contentPxH = contentH * zoom;
 	return {
-		zoom: s,
-		panX: (e - c) / 2,
-		panY: (n - l) / 2
+		zoom,
+		panX: (viewportW - contentPxW) / 2,
+		panY: (viewportH - contentPxH) / 2
 	};
 }
-//#endregion
-export { n as fitToBounds, t as fitZoom };
 
+//#endregion
+export { fitToBounds, fitZoom };
 //# sourceMappingURL=fitToBounds.js.map

package/dist/core/viewport/fitToBounds.js.map

@@ -1 +1 @@
-{"version":3,"file":"fitToBounds.js","names":["fitZoom","raw","availW","contentW","availH","contentH","min","clamp","max","normalizeZoom","fitToBounds","zoom","viewportW","paddingPx","viewportH","contentPxW","contentPxH"],"sources":["../../../src/core/viewport/fitToBounds.ts"],"sourcesContent":["import { normalizeZoom } from './zoomBounds';\n\n/**\n * Compute the largest uniform zoom (px per content-unit) that fits a content\n * rect of `contentW x contentH` (in content units) into a viewport rect of\n * `availW x availH` (in pixels).\n *\n * `clamp` optionally bounds the resulting zoom to [min, max].\n */\nexport function fitZoom(\n  availW: number,\n  availH: number,\n  contentW: number,\n  contentH: number,\n  clamp?: { min?: number; max?: number },\n): number {\n  const raw = Math.min(availW / contentW, availH / contentH);\n  const min = clamp?.min ?? -Infinity;\n  const max = clamp?.max ?? Infinity;\n  return normalizeZoom(Math.min(max, Math.max(min, raw)));\n}\n\n/**\n * Compute zoom + pan that centers `contentW x contentH` (content units) inside\n * a `viewportW x viewportH` (pixel) rect. `paddingPx` is uniform pixel padding\n * on every side.\n */\nexport function fitToBounds(\n  viewportW: number,\n  viewportH: number,\n  contentW: number,\n  contentH: number,\n  paddingPx = 0,\n  clamp?: { min?: number; max?: number },\n): { zoom: number; panX: number; panY: number } {\n  const availW = Math.max(1, viewportW - paddingPx * 2);\n  const availH = Math.max(1, viewportH - paddingPx * 2);\n  const zoom = fitZoom(availW, availH, contentW, contentH, clamp);\n  const contentPxW = contentW * zoom;\n  const contentPxH = contentH * zoom;\n  return {\n    zoom,\n    panX: (viewportW - contentPxW) / 2,\n    panY: (viewportH - contentPxH) / 2,\n  };\n}\n"],"mappings":";;AASA,SAAgBA,EACd,GACA,GACA,GACA,GACA,GACQ;CACR,IAAMC,IAAM,KAAK,IAAIC,IAASC,GAAUC,IAASC,CAAQ,GACnDC,IAAMC,GAAO,OAAO,WACpBC,IAAMD,GAAO,OAAO;CAC1B,OAAOE,EAAc,KAAK,IAAID,GAAK,KAAK,IAAIF,GAAKL,CAAG,CAAC,CAAC;AACxD;AAOA,SAAgBS,EACd,GACA,GACA,GACA,GACA,IAAY,GACZ,GAC8C;CAG9C,IAAMC,IAAOX,EAFE,KAAK,IAAI,GAAGY,IAAYC,IAAY,CAE9B,GADN,KAAK,IAAI,GAAGC,IAAYD,IAAY,CACtB,GAAQV,GAAUE,GAAUE,CAAK,GACxDQ,IAAaZ,IAAWQ,GACxBK,IAAaX,IAAWM;CAC9B,OAAO;EACL;EACA,OAAOC,IAAYG,KAAc;EACjC,OAAOD,IAAYE,KAAc;CACnC;AACF"}
+{"version":3,"file":"fitToBounds.js","names":[],"sources":["../../../src/core/viewport/fitToBounds.ts"],"sourcesContent":["import { normalizeZoom } from './zoomBounds';\n\n/**\n * Compute the largest uniform zoom (px per content-unit) that fits a content\n * rect of `contentW x contentH` (in content units) into a viewport rect of\n * `availW x availH` (in pixels).\n *\n * `clamp` optionally bounds the resulting zoom to [min, max].\n */\nexport function fitZoom(\n  availW: number,\n  availH: number,\n  contentW: number,\n  contentH: number,\n  clamp?: { min?: number; max?: number },\n): number {\n  const raw = Math.min(availW / contentW, availH / contentH);\n  const min = clamp?.min ?? -Infinity;\n  const max = clamp?.max ?? Infinity;\n  return normalizeZoom(Math.min(max, Math.max(min, raw)));\n}\n\n/**\n * Compute zoom + pan that centers `contentW x contentH` (content units) inside\n * a `viewportW x viewportH` (pixel) rect. `paddingPx` is uniform pixel padding\n * on every side.\n */\nexport function fitToBounds(\n  viewportW: number,\n  viewportH: number,\n  contentW: number,\n  contentH: number,\n  paddingPx = 0,\n  clamp?: { min?: number; max?: number },\n): { zoom: number; panX: number; panY: number } {\n  const availW = Math.max(1, viewportW - paddingPx * 2);\n  const availH = Math.max(1, viewportH - paddingPx * 2);\n  const zoom = fitZoom(availW, availH, contentW, contentH, clamp);\n  const contentPxW = contentW * zoom;\n  const contentPxH = contentH * zoom;\n  return {\n    zoom,\n    panX: (viewportW - contentPxW) / 2,\n    panY: (viewportH - contentPxH) / 2,\n  };\n}\n"],"mappings":";;;;;;;;;;AASA,SAAgB,QACd,QACA,QACA,UACA,UACA,OACQ;CACR,MAAM,MAAM,KAAK,IAAI,SAAS,UAAU,SAAS,QAAQ;CACzD,MAAM,MAAM,OAAO,OAAO;CAC1B,MAAM,MAAM,OAAO,OAAO;CAC1B,OAAO,cAAc,KAAK,IAAI,KAAK,KAAK,IAAI,KAAK,GAAG,CAAC,CAAC;AACxD;;;;;;AAOA,SAAgB,YACd,WACA,WACA,UACA,UACA,YAAY,GACZ,OAC8C;CAG9C,MAAM,OAAO,QAFE,KAAK,IAAI,GAAG,YAAY,YAAY,CAE9B,GADN,KAAK,IAAI,GAAG,YAAY,YAAY,CACtB,GAAQ,UAAU,UAAU,KAAK;CAC9D,MAAM,aAAa,WAAW;CAC9B,MAAM,aAAa,WAAW;CAC9B,OAAO;EACL;EACA,OAAO,YAAY,cAAc;EACjC,OAAO,YAAY,cAAc;CACnC;AACF"}

package/dist/core/viewport/fitViewToBounds.js

@@ -1,36 +1,62 @@
-import { DEFAULT_MAX_ZOOM as e, DEFAULT_MIN_ZOOM as t, normalizeZoom as n } from "./zoomBounds.js";
+import { DEFAULT_MAX_ZOOM, DEFAULT_MIN_ZOOM, normalizeZoom } from "./zoomBounds.js";
+
 //#region src/core/viewport/fitViewToBounds.ts
-function r(r, i, a, o = {}) {
-	let { padding: s = 16, maxScale: c = e, minScale: l = t } = o;
-	if (r.width <= 0 || r.height <= 0) return console.warn("[weasel] fitViewToBounds: bounds has zero or negative area; returning currentView unchanged.", r), a;
-	if (i.width <= 0 || i.height <= 0) return console.warn("[weasel] fitViewToBounds: viewport has zero or negative area; returning currentView unchanged.", i), a;
-	let u = Math.max(1, i.width - s * 2), d = Math.max(1, i.height - s * 2), f = u / r.width, p = d / r.height, m, h;
-	switch (o.mode ?? "contain") {
+/**
+* Compute the target {@link View} that fits `bounds` (world space) inside
+* `viewportDims` (CSS px). The bounds are centered in the viewport with
+* uniform padding on all sides; the resulting scale is clamped to the
+* configured min/max.
+*
+* Empty / zero-sized bounds or viewports cannot be fit — in that case this
+* returns `currentView` unchanged and logs a `console.warn`.
+*/
+function fitViewToBounds(bounds, viewportDims, currentView, opts = {}) {
+	const { padding = 16, maxScale = DEFAULT_MAX_ZOOM, minScale = DEFAULT_MIN_ZOOM } = opts;
+	if (bounds.width <= 0 || bounds.height <= 0) {
+		console.warn("[weasel] fitViewToBounds: bounds has zero or negative area; returning currentView unchanged.", bounds);
+		return currentView;
+	}
+	if (viewportDims.width <= 0 || viewportDims.height <= 0) {
+		console.warn("[weasel] fitViewToBounds: viewport has zero or negative area; returning currentView unchanged.", viewportDims);
+		return currentView;
+	}
+	const availW = Math.max(1, viewportDims.width - padding * 2);
+	const availH = Math.max(1, viewportDims.height - padding * 2);
+	const sx = availW / bounds.width;
+	const sy = availH / bounds.height;
+	let rawX;
+	let rawY;
+	switch (opts.mode ?? "contain") {
 		case "fill": {
-			let e = Math.max(f, p);
-			m = e, h = e;
+			const u = Math.max(sx, sy);
+			rawX = u;
+			rawY = u;
 			break;
 		}
 		case "stretch":
-			m = f, h = p;
+			rawX = sx;
+			rawY = sy;
 			break;
 		default: {
-			let e = Math.min(f, p);
-			m = e, h = e;
+			const u = Math.min(sx, sy);
+			rawX = u;
+			rawY = u;
 			break;
 		}
 	}
-	let g = n(Math.min(c, Math.max(l, m))), _ = n(Math.min(c, Math.max(l, h))), v = (e, t, n, r, i) => o.anchor === "start" && t * i > n + 1e-9 ? e - s / i : e + t / 2 - r / (2 * i);
+	const scaleX = normalizeZoom(Math.min(maxScale, Math.max(minScale, rawX)));
+	const scaleY = normalizeZoom(Math.min(maxScale, Math.max(minScale, rawY)));
+	const place = (start, size, avail, viewport, scale) => opts.anchor === "start" && size * scale > avail + 1e-9 ? start - padding / scale : start + size / 2 - viewport / (2 * scale);
 	return {
-		x: v(r.x, r.width, u, i.width, g),
-		y: v(r.y, r.height, d, i.height, _),
+		x: place(bounds.x, bounds.width, availW, viewportDims.width, scaleX),
+		y: place(bounds.y, bounds.height, availH, viewportDims.height, scaleY),
 		scale: {
-			x: g,
-			y: _
+			x: scaleX,
+			y: scaleY
 		}
 	};
 }
-//#endregion
-export { r as fitViewToBounds };
 
+//#endregion
+export { fitViewToBounds };
 //# sourceMappingURL=fitViewToBounds.js.map

package/dist/core/viewport/fitViewToBounds.js.map

@@ -1 +1 @@
-{"version":3,"file":"fitViewToBounds.js","names":["fitViewToBounds","DEFAULT_MAX_ZOOM","DEFAULT_MIN_ZOOM","opts","bounds","currentView","viewportDims","availW","padding","availH","sx","sy","rawX","rawY","u","scaleX","normalizeZoom","maxScale","minScale","scaleY","place","size","scale","avail","start","viewport"],"sources":["../../../src/core/viewport/fitViewToBounds.ts"],"sourcesContent":["import type { View } from './view';\nimport { DEFAULT_MIN_ZOOM, DEFAULT_MAX_ZOOM, normalizeZoom } from './zoomBounds';\n\nimport type { Bounds } from '@weasel-js/routing';\nexport type { Bounds };\n\n/** Pixel dimensions of the canvas viewport. */\nexport interface ViewportDims {\n  width: number;\n  height: number;\n}\n\n/** Options for {@link fitViewToBounds}. */\nexport interface FitViewToBoundsOptions {\n  /** Inset (in CSS px) around the bounds. Default 16. */\n  padding?: number;\n  /** Defaults to the kit-wide max zoom (`DEFAULT_MAX_ZOOM`). */\n  maxScale?: number;\n  /** Defaults to the kit-wide min zoom (`DEFAULT_MIN_ZOOM`). */\n  minScale?: number;\n  /**\n   * Fit mode:\n   * - `'contain'` (default): uniform scale = `min(availW/w, availH/h)`. Bounds fit entirely; one axis has letterboxing.\n   * - `'fill'`: uniform scale = `max(...)`. Bounds overflow viewport on one axis.\n   * - `'stretch'`: per-axis scale. Bounds match viewport exactly; scale is non-uniform.\n   */\n  mode?: 'contain' | 'fill' | 'stretch';\n  /**\n   * Where bounds that overflow the viewport on an axis sit, which happens when\n   * `minScale` stops the fit or `mode` is `'fill'`. `'center'` (default) shows\n   * their middle; `'start'` shows their left or top edge, inset by `padding`.\n   * An axis that fits is centered either way.\n   */\n  anchor?: 'center' | 'start';\n}\n\n/**\n * Compute the target {@link View} that fits `bounds` (world space) inside\n * `viewportDims` (CSS px). The bounds are centered in the viewport with\n * uniform padding on all sides; the resulting scale is clamped to the\n * configured min/max.\n *\n * Empty / zero-sized bounds or viewports cannot be fit — in that case this\n * returns `currentView` unchanged and logs a `console.warn`.\n */\nexport function fitViewToBounds(\n  bounds: Bounds,\n  viewportDims: ViewportDims,\n  currentView: View,\n  opts: FitViewToBoundsOptions = {},\n): View {\n  const { padding = 16, maxScale = DEFAULT_MAX_ZOOM, minScale = DEFAULT_MIN_ZOOM } = opts;\n\n  if (bounds.width <= 0 || bounds.height <= 0) {\n    console.warn('[weasel] fitViewToBounds: bounds has zero or negative area; returning currentView unchanged.', bounds);\n    return currentView;\n  }\n  if (viewportDims.width <= 0 || viewportDims.height <= 0) {\n    console.warn('[weasel] fitViewToBounds: viewport has zero or negative area; returning currentView unchanged.', viewportDims);\n    return currentView;\n  }\n\n  const availW = Math.max(1, viewportDims.width - padding * 2);\n  const availH = Math.max(1, viewportDims.height - padding * 2);\n  const sx = availW / bounds.width;\n  const sy = availH / bounds.height;\n\n  let rawX: number;\n  let rawY: number;\n  switch (opts.mode ?? 'contain') {\n    case 'fill': {\n      const u = Math.max(sx, sy);\n      rawX = u;\n      rawY = u;\n      break;\n    }\n    case 'stretch':\n      rawX = sx;\n      rawY = sy;\n      break;\n    case 'contain':\n    default: {\n      const u = Math.min(sx, sy);\n      rawX = u;\n      rawY = u;\n      break;\n    }\n  }\n  const scaleX = normalizeZoom(Math.min(maxScale, Math.max(minScale, rawX)));\n  const scaleY = normalizeZoom(Math.min(maxScale, Math.max(minScale, rawY)));\n\n  // screenCenter = (worldCenter - view.x) * scale, solved for view.x.\n  const place = (start: number, size: number, avail: number, viewport: number, scale: number) =>\n    opts.anchor === 'start' && size * scale > avail + 1e-9\n      ? start - padding / scale\n      : start + size / 2 - viewport / (2 * scale);\n  return {\n    x: place(bounds.x, bounds.width, availW, viewportDims.width, scaleX),\n    y: place(bounds.y, bounds.height, availH, viewportDims.height, scaleY),\n    scale: { x: scaleX, y: scaleY },\n  };\n}\n"],"mappings":";;AA6CA,SAAgBA,EACd,GACA,GACA,GACA,IAA+B,CAAC,GAC1B;CACN,IAAM,EAAE,aAAU,IAAI,cAAWC,GAAkB,cAAWC,MAAqBC;CAEnF,IAAIC,EAAO,SAAS,KAAKA,EAAO,UAAU,GAExC,OADA,QAAQ,KAAK,gGAAgGA,CAAM,GAC5GC;CAET,IAAIC,EAAa,SAAS,KAAKA,EAAa,UAAU,GAEpD,OADA,QAAQ,KAAK,kGAAkGA,CAAY,GACpHD;CAGT,IAAME,IAAS,KAAK,IAAI,GAAGD,EAAa,QAAQE,IAAU,CAAC,GACrDC,IAAS,KAAK,IAAI,GAAGH,EAAa,SAASE,IAAU,CAAC,GACtDE,IAAKH,IAASH,EAAO,OACrBO,IAAKF,IAASL,EAAO,QAEvBQ,GACAC;CACJ,QAAQV,EAAK,QAAQ,WAArB;EACE,KAAK,QAAQ;GACX,IAAMW,IAAI,KAAK,IAAIJ,GAAIC,CAAE;GAEzB,AADA,IAAOG,GACP,IAAOA;GACP;EACF;EACA,KAAK;GAEH,AADA,IAAOJ,GACP,IAAOC;GACP;EAEF,SAAS;GACP,IAAMG,IAAI,KAAK,IAAIJ,GAAIC,CAAE;GAEzB,AADA,IAAOG,GACP,IAAOA;GACP;EACF;CACF;CACA,IAAMC,IAASC,EAAc,KAAK,IAAIC,GAAU,KAAK,IAAIC,GAAUN,CAAI,CAAC,CAAC,GACnEO,IAASH,EAAc,KAAK,IAAIC,GAAU,KAAK,IAAIC,GAAUL,CAAI,CAAC,CAAC,GAGnEO,KAAS,GAAe,GAAc,GAAe,GAAkB,MAC3EjB,EAAK,WAAW,WAAWkB,IAAOC,IAAQC,IAAQ,OAC9CC,IAAQhB,IAAUc,IAClBE,IAAQH,IAAO,IAAII,KAAY,IAAIH;CACzC,OAAO;EACL,GAAGF,EAAMhB,EAAO,GAAGA,EAAO,OAAOG,GAAQD,EAAa,OAAOS,CAAM;EACnE,GAAGK,EAAMhB,EAAO,GAAGA,EAAO,QAAQK,GAAQH,EAAa,QAAQa,CAAM;EACrE,OAAO;GAAE,GAAGJ;GAAQ,GAAGI;EAAO;CAChC;AACF"}
+{"version":3,"file":"fitViewToBounds.js","names":[],"sources":["../../../src/core/viewport/fitViewToBounds.ts"],"sourcesContent":["import type { View } from './view';\nimport { DEFAULT_MIN_ZOOM, DEFAULT_MAX_ZOOM, normalizeZoom } from './zoomBounds';\n\nimport type { FramedBox as Bounds } from '@weasel-js/geom';\nexport type { Bounds };\n\n/** Pixel dimensions of the canvas viewport. */\nexport interface ViewportDims {\n  width: number;\n  height: number;\n}\n\n/** Options for {@link fitViewToBounds}. */\nexport interface FitViewToBoundsOptions {\n  /** Inset (in CSS px) around the bounds. Default 16. */\n  padding?: number;\n  /** Defaults to the kit-wide max zoom (`DEFAULT_MAX_ZOOM`). */\n  maxScale?: number;\n  /** Defaults to the kit-wide min zoom (`DEFAULT_MIN_ZOOM`). */\n  minScale?: number;\n  /**\n   * Fit mode:\n   * - `'contain'` (default): uniform scale = `min(availW/w, availH/h)`. Bounds fit entirely; one axis has letterboxing.\n   * - `'fill'`: uniform scale = `max(...)`. Bounds overflow viewport on one axis.\n   * - `'stretch'`: per-axis scale. Bounds match viewport exactly; scale is non-uniform.\n   */\n  mode?: 'contain' | 'fill' | 'stretch';\n  /**\n   * Where bounds that overflow the viewport on an axis sit, which happens when\n   * `minScale` stops the fit or `mode` is `'fill'`. `'center'` (default) shows\n   * their middle; `'start'` shows their left or top edge, inset by `padding`.\n   * An axis that fits is centered either way.\n   */\n  anchor?: 'center' | 'start';\n}\n\n/**\n * Compute the target {@link View} that fits `bounds` (world space) inside\n * `viewportDims` (CSS px). The bounds are centered in the viewport with\n * uniform padding on all sides; the resulting scale is clamped to the\n * configured min/max.\n *\n * Empty / zero-sized bounds or viewports cannot be fit — in that case this\n * returns `currentView` unchanged and logs a `console.warn`.\n */\nexport function fitViewToBounds(\n  bounds: Bounds,\n  viewportDims: ViewportDims,\n  currentView: View,\n  opts: FitViewToBoundsOptions = {},\n): View {\n  const { padding = 16, maxScale = DEFAULT_MAX_ZOOM, minScale = DEFAULT_MIN_ZOOM } = opts;\n\n  if (bounds.width <= 0 || bounds.height <= 0) {\n    console.warn('[weasel] fitViewToBounds: bounds has zero or negative area; returning currentView unchanged.', bounds);\n    return currentView;\n  }\n  if (viewportDims.width <= 0 || viewportDims.height <= 0) {\n    console.warn('[weasel] fitViewToBounds: viewport has zero or negative area; returning currentView unchanged.', viewportDims);\n    return currentView;\n  }\n\n  const availW = Math.max(1, viewportDims.width - padding * 2);\n  const availH = Math.max(1, viewportDims.height - padding * 2);\n  const sx = availW / bounds.width;\n  const sy = availH / bounds.height;\n\n  let rawX: number;\n  let rawY: number;\n  switch (opts.mode ?? 'contain') {\n    case 'fill': {\n      const u = Math.max(sx, sy);\n      rawX = u;\n      rawY = u;\n      break;\n    }\n    case 'stretch':\n      rawX = sx;\n      rawY = sy;\n      break;\n    case 'contain':\n    default: {\n      const u = Math.min(sx, sy);\n      rawX = u;\n      rawY = u;\n      break;\n    }\n  }\n  const scaleX = normalizeZoom(Math.min(maxScale, Math.max(minScale, rawX)));\n  const scaleY = normalizeZoom(Math.min(maxScale, Math.max(minScale, rawY)));\n\n  // screenCenter = (worldCenter - view.x) * scale, solved for view.x.\n  const place = (start: number, size: number, avail: number, viewport: number, scale: number) =>\n    opts.anchor === 'start' && size * scale > avail + 1e-9\n      ? start - padding / scale\n      : start + size / 2 - viewport / (2 * scale);\n  return {\n    x: place(bounds.x, bounds.width, availW, viewportDims.width, scaleX),\n    y: place(bounds.y, bounds.height, availH, viewportDims.height, scaleY),\n    scale: { x: scaleX, y: scaleY },\n  };\n}\n"],"mappings":";;;;;;;;;;;;AA6CA,SAAgB,gBACd,QACA,cACA,aACA,OAA+B,CAAC,GAC1B;CACN,MAAM,EAAE,UAAU,IAAI,WAAW,kBAAkB,WAAW,qBAAqB;CAEnF,IAAI,OAAO,SAAS,KAAK,OAAO,UAAU,GAAG;EAC3C,QAAQ,KAAK,gGAAgG,MAAM;EACnH,OAAO;CACT;CACA,IAAI,aAAa,SAAS,KAAK,aAAa,UAAU,GAAG;EACvD,QAAQ,KAAK,kGAAkG,YAAY;EAC3H,OAAO;CACT;CAEA,MAAM,SAAS,KAAK,IAAI,GAAG,aAAa,QAAQ,UAAU,CAAC;CAC3D,MAAM,SAAS,KAAK,IAAI,GAAG,aAAa,SAAS,UAAU,CAAC;CAC5D,MAAM,KAAK,SAAS,OAAO;CAC3B,MAAM,KAAK,SAAS,OAAO;CAE3B,IAAI;CACJ,IAAI;CACJ,QAAQ,KAAK,QAAQ,WAArB;EACE,KAAK,QAAQ;GACX,MAAM,IAAI,KAAK,IAAI,IAAI,EAAE;GACzB,OAAO;GACP,OAAO;GACP;EACF;EACA,KAAK;GACH,OAAO;GACP,OAAO;GACP;EAEF,SAAS;GACP,MAAM,IAAI,KAAK,IAAI,IAAI,EAAE;GACzB,OAAO;GACP,OAAO;GACP;EACF;CACF;CACA,MAAM,SAAS,cAAc,KAAK,IAAI,UAAU,KAAK,IAAI,UAAU,IAAI,CAAC,CAAC;CACzE,MAAM,SAAS,cAAc,KAAK,IAAI,UAAU,KAAK,IAAI,UAAU,IAAI,CAAC,CAAC;CAGzE,MAAM,SAAS,OAAe,MAAc,OAAe,UAAkB,UAC3E,KAAK,WAAW,WAAW,OAAO,QAAQ,QAAQ,OAC9C,QAAQ,UAAU,QAClB,QAAQ,OAAO,IAAI,YAAY,IAAI;CACzC,OAAO;EACL,GAAG,MAAM,OAAO,GAAG,OAAO,OAAO,QAAQ,aAAa,OAAO,MAAM;EACnE,GAAG,MAAM,OAAO,GAAG,OAAO,QAAQ,QAAQ,aAAa,QAAQ,MAAM;EACrE,OAAO;GAAE,GAAG;GAAQ,GAAG;EAAO;CAChC;AACF"}