@weasel-js/core 1.9.3 → 1.10.0

package/dist/core/viewport/view.js

@@ -1,6 +1,7 @@
 import { normalizeZoom as e, warnInvalidView as t } from "./zoomBounds.js";
+import { meanScale as n } from "@weasel-js/geom";
 //#region src/core/viewport/view.ts
-function n(e) {
+function r(e) {
 	return {
 		panX: -e.x * e.scale.x + 0,
 		panY: -e.y * e.scale.y + 0,
@@ -10,12 +11,11 @@ function n(e) {
 		}
 	};
 }
-function r(e) {
-	let { x: t, y: n } = e.scale;
-	return t === n ? t : Math.sqrt(t * n);
-}
 function i(e) {
-	let t = a(e.scale.x), n = a(e.scale.y), r = o(e.x), i = o(e.y);
+	return n(e.scale);
+}
+function a(e) {
+	let t = o(e.scale.x), n = o(e.scale.y), r = s(e.x), i = s(e.y);
 	return t === e.scale.x && n === e.scale.y && r === e.x && i === e.y ? e : {
 		x: r,
 		y: i,
@@ -25,13 +25,13 @@ function i(e) {
 		}
 	};
 }
-function a(t) {
+function o(t) {
 	return t < 0 && t > -Infinity ? -e(-t) : e(t);
 }
-function o(e) {
+function s(e) {
 	return Number.isFinite(e) ? e : (t(`a position of ${e}`), 0);
 }
 //#endregion
-export { i as normalizeView, n as viewToTransform, r as viewZoom };
+export { a as normalizeView, r as viewToTransform, i as viewZoom };
 
 //# sourceMappingURL=view.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"view.js","names":["viewToTransform","view","viewZoom","x","y","normalizeView","sx","normalizeAxis","sy","finiteTranslation","s","normalizeZoom","v","warnInvalidView"],"sources":["../../../src/core/viewport/view.ts"],"sourcesContent":["import type { ViewTransform } from './viewTransform';\nimport type { View } from '@weasel-js/routing';\nimport { normalizeZoom, warnInvalidView } from './zoomBounds';\n\n/**\n * `View` is declared in `@weasel-js/routing` — the dispatcher and every\n * viewport action are typed in it. Re-exported here, where core's own call\n * sites have always named it.\n *\n * Core holds the invariant behind the shape: every view the kit keeps is\n * total, so each `scale` axis is finite with a magnitude of at least\n * `ZOOM_FLOOR` and `x` / `y` are finite. A negative axis is a flipped one\n * (y-up), not a degenerate one, and keeps its sign. Canvases, views and\n * animations pass what they are given through {@link normalizeView}, so\n * screen/world conversion never divides by zero.\n *\n * `scale` is always a 2-vector. Input convenience types {@link ZoomFactor}\n * and {@link ZoomBound} let callers pass a scalar when they want both axes\n * treated the same.\n */\nexport type { View };\n\n/**\n * Input convenience for zoom primitives. A `number` is treated as a\n * uniform factor applied to both axes; a `{x, y}` vector applies\n * per-axis factors.\n */\nexport type ZoomFactor = number | { x: number; y: number };\n\n/**\n * Input convenience for zoom-clamp ranges. A `number` is applied as the\n * same bound on both axes; a `{x, y}` vector applies per-axis bounds.\n */\nexport type ZoomBound = number | { x: number; y: number };\n\n/**\n * Bridge `View` into the legacy `ViewTransform` shape so chrome can keep\n * calling `worldToScreen` / `screenToWorld`. `View` and `ViewTransform`\n * use opposite sign conventions for the translation half (`view.x` is\n * camera position; `panX` is canvas translation), so the adapter flips\n * the sign and multiplies by per-axis scale.\n */\nexport function viewToTransform(view: View): ViewTransform {\n  // `+ 0` coerces `-0 → 0` without swallowing NaN (matches viewToMat3).\n  return {\n    panX: -view.x * view.scale.x + 0,\n    panY: -view.y * view.scale.y + 0,\n    zoom: { x: view.scale.x, y: view.scale.y },\n  };\n}\n\n/**\n * How far `view` is zoomed in, as one number — the geometric mean of its two\n * axes, so a uniform view reports its own scale and a stretched one reports\n * the scale that covers the same area.\n *\n * What a `RuleCtx` carries, because the only rule that asks about the\n * viewport asks for a threshold rather than a camera.\n */\nexport function viewZoom(view: View): number {\n  const { x, y } = view.scale;\n  return x === y ? x : Math.sqrt(x * y);\n}\n\n/**\n * `view` inside the invariant {@link View} documents: a zero or non-finite\n * scale axis becomes `ZOOM_FLOOR`, a negative one keeps its sign, and a\n * non-finite translation becomes 0. Returns `view` itself when it already\n * holds, so a valid view keeps its identity.\n */\nexport function normalizeView(view: View): View {\n  const sx = normalizeAxis(view.scale.x);\n  const sy = normalizeAxis(view.scale.y);\n  const x = finiteTranslation(view.x);\n  const y = finiteTranslation(view.y);\n  if (sx === view.scale.x && sy === view.scale.y && x === view.x && y === view.y) return view;\n  return { x, y, scale: { x: sx, y: sy } };\n}\n\nfunction normalizeAxis(s: number): number {\n  return s < 0 && s > -Infinity ? -normalizeZoom(-s) : normalizeZoom(s);\n}\n\nfunction finiteTranslation(v: number): number {\n  if (Number.isFinite(v)) return v;\n  warnInvalidView(`a position of ${v}`);\n  return 0;\n}\n"],"mappings":";;AA0CA,SAAgBA,EAAgB,GAA2B;CAEzD,OAAO;EACL,MAAM,CAACC,EAAK,IAAIA,EAAK,MAAM,IAAI;EAC/B,MAAM,CAACA,EAAK,IAAIA,EAAK,MAAM,IAAI;EAC/B,MAAM;GAAE,GAAGA,EAAK,MAAM;GAAG,GAAGA,EAAK,MAAM;EAAE;CAC3C;AACF;AAUA,SAAgBC,EAAS,GAAoB;CAC3C,IAAM,EAAE,MAAG,SAAMD,EAAK;CACtB,OAAOE,MAAMC,IAAID,IAAI,KAAK,KAAKA,IAAIC,CAAC;AACtC;AAQA,SAAgBC,EAAc,GAAkB;CAC9C,IAAMC,IAAKC,EAAcN,EAAK,MAAM,CAAC,GAC/BO,IAAKD,EAAcN,EAAK,MAAM,CAAC,GAC/BE,IAAIM,EAAkBR,EAAK,CAAC,GAC5BG,IAAIK,EAAkBR,EAAK,CAAC;CAElC,OADIK,MAAOL,EAAK,MAAM,KAAKO,MAAOP,EAAK,MAAM,KAAKE,MAAMF,EAAK,KAAKG,MAAMH,EAAK,IAAUA,IAChF;EAAE;EAAG;EAAG,OAAO;GAAE,GAAGK;GAAI,GAAGE;EAAG;CAAE;AACzC;AAEA,SAASD,EAAc,GAAmB;CACxC,OAAOG,IAAI,KAAKA,IAAI,YAAY,CAACC,EAAc,CAACD,CAAC,IAAIC,EAAcD,CAAC;AACtE;AAEA,SAASD,EAAkB,GAAmB;CAG5C,OAFI,OAAO,SAASG,CAAC,IAAUA,KAC/BC,EAAgB,iBAAiBD,GAAG,GAC7B;AACT"}
+{"version":3,"file":"view.js","names":["normalizeZoom","normalizeZoom$1","viewToTransform","view","viewZoom","meanScale","normalizeView","sx","normalizeAxis","sy","x","finiteTranslation","y","s","v","warnInvalidView"],"sources":["../../../src/core/viewport/view.ts"],"sourcesContent":["import type { ViewTransform } from './viewTransform';\nimport type { View } from '@weasel-js/routing';\nimport { meanScale } from '@weasel-js/geom';\nimport { normalizeZoom, warnInvalidView } from './zoomBounds';\n\n/**\n * Every view the kit keeps is total: each `scale` axis is finite with a\n * magnitude of at least `ZOOM_FLOOR` and `x` / `y` are finite. A negative\n * axis is a flipped one (y-up), not a degenerate one, and keeps its sign.\n * Canvases, views, and animations pass what they are given through\n * {@link normalizeView}, so screen/world conversion never divides by zero.\n */\nexport type { View };\n\n/** A zoom factor: a `number` applies to both axes, a `{x, y}` vector per axis. */\nexport type ZoomFactor = number | { x: number; y: number };\n\n/** A zoom-clamp bound: a `number` applies to both axes, a `{x, y}` vector per axis. */\nexport type ZoomBound = number | { x: number; y: number };\n\n/**\n * Bridge `View` into the legacy `ViewTransform` shape. The two use opposite\n * sign conventions for the translation half: `view.x` is camera position;\n * `panX` is canvas translation.\n */\nexport function viewToTransform(view: View): ViewTransform {\n  // `+ 0` coerces `-0 → 0` without swallowing NaN (matches viewToMat3).\n  return {\n    panX: -view.x * view.scale.x + 0,\n    panY: -view.y * view.scale.y + 0,\n    zoom: { x: view.scale.x, y: view.scale.y },\n  };\n}\n\n/**\n * How far `view` is zoomed in, as one number — the geometric mean of its two\n * axes, so a uniform view reports its own scale and a stretched one reports\n * the scale that covers the same area.\n */\nexport function viewZoom(view: View): number {\n  return meanScale(view.scale);\n}\n\n/**\n * `view` inside the invariant {@link View} documents: a zero or non-finite\n * scale axis becomes `ZOOM_FLOOR`, a negative one keeps its sign, and a\n * non-finite translation becomes 0. Returns `view` itself when it already\n * holds, so a valid view keeps its identity.\n */\nexport function normalizeView(view: View): View {\n  const sx = normalizeAxis(view.scale.x);\n  const sy = normalizeAxis(view.scale.y);\n  const x = finiteTranslation(view.x);\n  const y = finiteTranslation(view.y);\n  if (sx === view.scale.x && sy === view.scale.y && x === view.x && y === view.y) return view;\n  return { x, y, scale: { x: sx, y: sy } };\n}\n\nfunction normalizeAxis(s: number): number {\n  return s < 0 && s > -Infinity ? -normalizeZoom(-s) : normalizeZoom(s);\n}\n\nfunction finiteTranslation(v: number): number {\n  if (Number.isFinite(v)) return v;\n  warnInvalidView(`a position of ${v}`);\n  return 0;\n}\n"],"mappings":";;;AAyBA,SAAgBE,EAAgB,GAA2B;CAEzD,OAAO;EACL,MAAM,CAACC,EAAK,IAAIA,EAAK,MAAM,IAAI;EAC/B,MAAM,CAACA,EAAK,IAAIA,EAAK,MAAM,IAAI;EAC/B,MAAM;GAAE,GAAGA,EAAK,MAAM;GAAG,GAAGA,EAAK,MAAM;EAAE;CAC3C;AACF;AAOA,SAAgBC,EAAS,GAAoB;CAC3C,OAAOC,EAAUF,EAAK,KAAK;AAC7B;AAQA,SAAgBG,EAAc,GAAkB;CAC9C,IAAMC,IAAKC,EAAcL,EAAK,MAAM,CAAC,GAC/BM,IAAKD,EAAcL,EAAK,MAAM,CAAC,GAC/BO,IAAIC,EAAkBR,EAAK,CAAC,GAC5BS,IAAID,EAAkBR,EAAK,CAAC;CAElC,OADII,MAAOJ,EAAK,MAAM,KAAKM,MAAON,EAAK,MAAM,KAAKO,MAAMP,EAAK,KAAKS,MAAMT,EAAK,IAAUA,IAChF;EAAE;EAAG;EAAG,OAAO;GAAE,GAAGI;GAAI,GAAGE;EAAG;CAAE;AACzC;AAEA,SAASD,EAAc,GAAmB;CACxC,OAAOK,IAAI,KAAKA,IAAI,YAAY,CAACb,EAAc,CAACa,CAAC,IAAIb,EAAca,CAAC;AACtE;AAEA,SAASF,EAAkB,GAAmB;CAG5C,OAFI,OAAO,SAASG,CAAC,IAAUA,KAC/BC,EAAgB,iBAAiBD,GAAG,GAC7B;AACT"}

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

@@ -1 +1 @@
-{"version":3,"file":"wheelHandler.js","names":["WHEEL_ZOOM_STEP","wheelZoomFactor","deltaY","wheelZoom","zoomAt","view","anchor","clamp","wheelPan","axis","opts","swapped","screenX","delta","screenY","computeWheelAction","input"],"sources":["../../../src/core/viewport/wheelHandler.ts"],"sourcesContent":["/**\n * The kit's one wheel convention, as pure functions over `View`.\n *\n * ## Modifiers\n * - bare wheel → pan\n * - shift+wheel → horizontal pan (mouse wheels emit only `deltaY`)\n * - Cmd/Ctrl+wheel → zoom, anchored under the pointer. Ctrl also covers the\n *   trackpad pinch, which browsers deliver as ctrl+wheel.\n *\n * ## Coordinates\n * `View.x` / `View.y` are world-space, so a pan delta — screen pixels, as the\n * DOM reports them — is divided by `View.scale` before it lands. The zoom\n * anchor is canvas-local: client coords minus the canvas's bounding rect.\n *\n * `viewport.wheelPan` and `viewport.zoom` are the wired form of these, and\n * call them rather than restating the math.\n */\n\nimport type { View } from './view';\nimport { zoomAt, type ZoomClampOpts } from './zoomAt';\n\n/** Multiplicative zoom applied per 100 px of wheel `deltaY`. */\nexport const WHEEL_ZOOM_STEP = 1.1;\n\n/** A wheel event, decoupled from the DOM `WheelEvent` shape for testability. */\nexport interface WheelInput {\n  deltaX: number;\n  deltaY: number;\n  /** Zoom anchor, canvas-local: client coords minus the canvas's rect. */\n  x: number;\n  y: number;\n  shiftKey?: boolean;\n  ctrlKey?: boolean;\n  metaKey?: boolean;\n}\n\n/** Which axes a wheel pan is allowed to move, and whether `deltaY` is routed\n *  into the x axis (shift+wheel). An axis lock outranks `swapAxis`. */\nexport interface WheelPanOpts {\n  axis?: 'both' | 'x' | 'y';\n  swapAxis?: boolean;\n}\n\n/** Zoom multiplier for one wheel sample. Reciprocal in `deltaY`, so scrolling\n *  a distance and back returns to the scale you started from. */\nexport function wheelZoomFactor(deltaY: number): number {\n  return Math.pow(WHEEL_ZOOM_STEP, -deltaY / 100);\n}\n\n/** Zoom one wheel sample about `anchor` (canvas-local pixels). */\nexport function wheelZoom(\n  view: View,\n  anchor: { x: number; y: number },\n  deltaY: number,\n  clamp?: ZoomClampOpts,\n): View {\n  return zoomAt(view, anchor, wheelZoomFactor(deltaY), clamp);\n}\n\n/** Pan by one wheel sample. `delta` is in screen pixels. */\nexport function wheelPan(\n  view: View,\n  delta: { deltaX: number; deltaY: number },\n  opts: WheelPanOpts = {},\n): View {\n  const axis = opts.axis ?? 'both';\n  const swapped = opts.swapAxis === true;\n  // Shift+wheel wants a horizontal pan, but a mouse wheel only emits deltaY.\n  const screenX = swapped ? (delta.deltaX !== 0 ? delta.deltaX : delta.deltaY) : delta.deltaX;\n  const screenY = swapped ? 0 : delta.deltaY;\n  return {\n    scale: view.scale,\n    x: view.x + (axis === 'y' ? 0 : screenX / view.scale.x),\n    y: view.y + (axis === 'x' ? 0 : screenY / view.scale.y),\n  };\n}\n\n/** Pure reducer: the whole wheel convention in one call. */\nexport function computeWheelAction(\n  view: View,\n  input: WheelInput,\n  clamp?: ZoomClampOpts,\n  opts: Pick<WheelPanOpts, 'axis'> = {},\n): View {\n  if (input.ctrlKey || input.metaKey) {\n    return wheelZoom(view, { x: input.x, y: input.y }, input.deltaY, clamp);\n  }\n  return wheelPan(view, input, { axis: opts.axis, swapAxis: input.shiftKey === true });\n}\n"],"mappings":";;AAsBA,IAAaA,IAAkB;AAuB/B,SAAgBC,EAAgB,GAAwB;CACtD,OAAgBD,MAAiB,CAACE,IAAS;AAC7C;AAGA,SAAgBC,EACd,GACA,GACA,GACA,GACM;CACN,OAAOC,EAAOC,GAAMC,GAAQL,EAAgBC,CAAM,GAAGK,CAAK;AAC5D;AAGA,SAAgBC,EACd,GACA,GACA,IAAqB,CAAC,GAChB;CACN,IAAMC,IAAOC,EAAK,QAAQ,QACpBC,IAAUD,EAAK,aAAa,IAE5BE,IAAUD,KAAWE,EAAM,WAAW,IAAmBA,EAAM,SAArBA,EAAM,QAChDC,IAAUH,IAAU,IAAIE,EAAM;CACpC,OAAO;EACL,OAAOR,EAAK;EACZ,GAAGA,EAAK,KAAKI,MAAS,MAAM,IAAIG,IAAUP,EAAK,MAAM;EACrD,GAAGA,EAAK,KAAKI,MAAS,MAAM,IAAIK,IAAUT,EAAK,MAAM;CACvD;AACF;AAGA,SAAgBU,EACd,GACA,GACA,GACA,IAAmC,CAAC,GAC9B;CAIN,OAHIC,EAAM,WAAWA,EAAM,UAClBb,EAAUE,GAAM;EAAE,GAAGW,EAAM;EAAG,GAAGA,EAAM;CAAE,GAAGA,EAAM,QAAQT,CAAK,IAEjEC,EAASH,GAAMW,GAAO;EAAE,MAAMN,EAAK;EAAM,UAAUM,EAAM,aAAa;CAAK,CAAC;AACrF"}
+{"version":3,"file":"wheelHandler.js","names":["WHEEL_ZOOM_STEP","wheelZoomFactor","deltaY","wheelZoom","zoomAt","view","anchor","clamp","wheelPan","axis","opts","swapped","screenX","delta","screenY","computeWheelAction","input"],"sources":["../../../src/core/viewport/wheelHandler.ts"],"sourcesContent":["/**\n * The kit's one wheel convention, as pure functions over `View`.\n *\n * ## Modifiers\n * - bare wheel → pan\n * - shift+wheel → horizontal pan (mouse wheels emit only `deltaY`)\n * - Cmd/Ctrl+wheel → zoom, anchored under the pointer. Ctrl also covers the\n *   trackpad pinch, which browsers deliver as ctrl+wheel.\n *\n * ## Coordinates\n * `View.x` / `View.y` are world-space, so a pan delta — screen pixels, as the\n * DOM reports them — is divided by `View.scale` before it lands. The zoom\n * anchor is canvas-local: client coords minus the canvas's bounding rect.\n */\n\nimport type { View } from './view';\nimport { zoomAt, type ZoomClampOpts } from './zoomAt';\n\n/** Multiplicative zoom applied per 100 px of wheel `deltaY`. */\nexport const WHEEL_ZOOM_STEP = 1.1;\n\n/** A wheel event, decoupled from the DOM `WheelEvent` shape for testability. */\nexport interface WheelInput {\n  deltaX: number;\n  deltaY: number;\n  /** Zoom anchor, canvas-local: client coords minus the canvas's rect. */\n  x: number;\n  y: number;\n  shiftKey?: boolean;\n  ctrlKey?: boolean;\n  metaKey?: boolean;\n}\n\n/** Which axes a wheel pan is allowed to move, and whether `deltaY` is routed\n *  into the x axis (shift+wheel). An axis lock outranks `swapAxis`. */\nexport interface WheelPanOpts {\n  axis?: 'both' | 'x' | 'y';\n  swapAxis?: boolean;\n}\n\n/** Zoom multiplier for one wheel sample. Reciprocal in `deltaY`, so scrolling\n *  a distance and back returns to the scale you started from. */\nexport function wheelZoomFactor(deltaY: number): number {\n  return Math.pow(WHEEL_ZOOM_STEP, -deltaY / 100);\n}\n\n/** Zoom one wheel sample about `anchor` (canvas-local pixels). */\nexport function wheelZoom(\n  view: View,\n  anchor: { x: number; y: number },\n  deltaY: number,\n  clamp?: ZoomClampOpts,\n): View {\n  return zoomAt(view, anchor, wheelZoomFactor(deltaY), clamp);\n}\n\n/** Pan by one wheel sample. `delta` is in screen pixels. */\nexport function wheelPan(\n  view: View,\n  delta: { deltaX: number; deltaY: number },\n  opts: WheelPanOpts = {},\n): View {\n  const axis = opts.axis ?? 'both';\n  const swapped = opts.swapAxis === true;\n  // Shift+wheel wants a horizontal pan, but a mouse wheel only emits deltaY.\n  const screenX = swapped ? (delta.deltaX !== 0 ? delta.deltaX : delta.deltaY) : delta.deltaX;\n  const screenY = swapped ? 0 : delta.deltaY;\n  return {\n    scale: view.scale,\n    x: view.x + (axis === 'y' ? 0 : screenX / view.scale.x),\n    y: view.y + (axis === 'x' ? 0 : screenY / view.scale.y),\n  };\n}\n\n/** Pure reducer: the whole wheel convention in one call. */\nexport function computeWheelAction(\n  view: View,\n  input: WheelInput,\n  clamp?: ZoomClampOpts,\n  opts: Pick<WheelPanOpts, 'axis'> = {},\n): View {\n  if (input.ctrlKey || input.metaKey) {\n    return wheelZoom(view, { x: input.x, y: input.y }, input.deltaY, clamp);\n  }\n  return wheelPan(view, input, { axis: opts.axis, swapAxis: input.shiftKey === true });\n}\n"],"mappings":";;AAmBA,IAAaA,IAAkB;AAuB/B,SAAgBC,EAAgB,GAAwB;CACtD,OAAgBD,MAAiB,CAACE,IAAS;AAC7C;AAGA,SAAgBC,EACd,GACA,GACA,GACA,GACM;CACN,OAAOC,EAAOC,GAAMC,GAAQL,EAAgBC,CAAM,GAAGK,CAAK;AAC5D;AAGA,SAAgBC,EACd,GACA,GACA,IAAqB,CAAC,GAChB;CACN,IAAMC,IAAOC,EAAK,QAAQ,QACpBC,IAAUD,EAAK,aAAa,IAE5BE,IAAUD,KAAWE,EAAM,WAAW,IAAmBA,EAAM,SAArBA,EAAM,QAChDC,IAAUH,IAAU,IAAIE,EAAM;CACpC,OAAO;EACL,OAAOR,EAAK;EACZ,GAAGA,EAAK,KAAKI,MAAS,MAAM,IAAIG,IAAUP,EAAK,MAAM;EACrD,GAAGA,EAAK,KAAKI,MAAS,MAAM,IAAIK,IAAUT,EAAK,MAAM;CACvD;AACF;AAGA,SAAgBU,EACd,GACA,GACA,GACA,IAAmC,CAAC,GAC9B;CAIN,OAHIC,EAAM,WAAWA,EAAM,UAClBb,EAAUE,GAAM;EAAE,GAAGW,EAAM;EAAG,GAAGA,EAAM;CAAE,GAAGA,EAAM,QAAQT,CAAK,IAEjEC,EAASH,GAAMW,GAAO;EAAE,MAAMN,EAAK;EAAM,UAAUM,EAAM,aAAa;CAAK,CAAC;AACrF"}

package/dist/core/viewport/zoomBounds.js

@@ -1,13 +1,15 @@
+import { ZOOM_FLOOR as e, normalizeZoom as t } from "@weasel-js/geom";
 //#region src/core/viewport/zoomBounds.ts
-var e = .1, t = 8, n = 1e-9;
-function r(e) {
-	return e >= n && e < Infinity ? e : ((!(e > 0) || e === Infinity) && a(`a zoom of ${e}`), n);
+var n = .1, r = 8;
+function i(e) {
+	let n = t(e);
+	return n !== e && (!(e > 0) || e === Infinity) && o(`a zoom of ${e}`), n;
 }
-var i = !1;
-function a(e) {
-	!i && o && (i = !0, console.warn(`[weasel] a view was given ${e} and has been clamped. A view's zoom is always positive and finite, and its position finite; see ZOOM_FLOOR.`));
+var a = !1;
+function o(e) {
+	!a && s && (a = !0, console.warn(`[weasel] a view was given ${e} and has been clamped. A view's zoom is always positive and finite, and its position finite; see ZOOM_FLOOR.`));
 }
-var o = (() => {
+var s = (() => {
 	try {
 		return !1;
 	} catch {
@@ -15,6 +17,6 @@ var o = (() => {
 	}
 })();
 //#endregion
-export { t as DEFAULT_MAX_ZOOM, e as DEFAULT_MIN_ZOOM, n as ZOOM_FLOOR, r as normalizeZoom, a as warnInvalidView };
+export { r as DEFAULT_MAX_ZOOM, n as DEFAULT_MIN_ZOOM, e as ZOOM_FLOOR, i as normalizeZoom, o as warnInvalidView };
 
 //# sourceMappingURL=zoomBounds.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"zoomBounds.js","names":["DEFAULT_MIN_ZOOM","DEFAULT_MAX_ZOOM","ZOOM_FLOOR","normalizeZoom","zoom","warnInvalidView","warned","IS_DEV","what"],"sources":["../../../src/core/viewport/zoomBounds.ts"],"sourcesContent":["/**\n * The kit's system-wide zoom clamp, in `View.scale` units (pixels per world\n * unit): `1` is 100%, `0.1` is 10%, `8` is 800%.\n *\n * Every zoom path defaults from these — `zoomAt`, the `viewport.zoom` and\n * pinch actions, `fitViewToBounds`, `computeWheelAction`. They\n * used to carry two disagreeing pairs, so a fit could legally land at 10x\n * and the next pinch frame would clamp it back to 8x.\n */\nexport const DEFAULT_MIN_ZOOM = 0.1;\n/** Upper end of the kit's default zoom clamp — 800%. See {@link DEFAULT_MIN_ZOOM}. */\nexport const DEFAULT_MAX_ZOOM = 8;\n\n/**\n * The smallest zoom magnitude a view can hold, in `View.scale` units.\n *\n * A view's zoom is always finite and at least this far from 0. Nothing can be\n * drawn or picked through a zoom of 0, and every screen↔world conversion\n * divides by it, so it is ruled out where views are made rather than handled\n * by each conversion. This is validity, not an interaction limit: that is\n * {@link DEFAULT_MIN_ZOOM}, which a consumer may set far below.\n */\nexport const ZOOM_FLOOR = 1e-9;\n\n/**\n * The one rule for a zoom magnitude: a finite number no smaller than\n * {@link ZOOM_FLOOR}. Anything else (0, negative, NaN, ±Infinity) becomes the\n * floor. Dev builds warn once when a zoom that was never valid arrives; a\n * positive zoom that merely undershoots the floor clamps silently.\n */\nexport function normalizeZoom(zoom: number): number {\n  if (zoom >= ZOOM_FLOOR && zoom < Infinity) return zoom;\n  if (!(zoom > 0) || zoom === Infinity) warnInvalidView(`a zoom of ${zoom}`);\n  return ZOOM_FLOOR;\n}\n\nlet warned = false;\n\n/** @internal Once per session, in dev builds only. */\nexport function warnInvalidView(what: string): void {\n  if (warned || !IS_DEV) return;\n  warned = true;\n  console.warn(\n    `[weasel] a view was given ${what} and has been clamped. A view's zoom is ` +\n    'always positive and finite, and its position finite; see ZOOM_FLOOR.',\n  );\n}\n\n/** `import.meta.env.DEV` read through a cast, as in SceneCanvas.tsx. */\nconst IS_DEV: boolean = (() => {\n  try {\n    return Boolean((import.meta as unknown as { env?: { DEV?: boolean } }).env?.DEV);\n  } catch {\n    return false;\n  }\n})();\n"],"mappings":";AASA,IAAaA,IAAmB,IAEnBC,IAAmB,GAWnBC,IAAa;AAQ1B,SAAgBC,EAAc,GAAsB;CAGlD,OAFIC,KAAQF,KAAcE,IAAO,WAAiBA,MAC9C,EAAEA,IAAO,MAAMA,MAAS,aAAUC,EAAgB,aAAaD,GAAM,GAClEF;AACT;AAEA,IAAII,IAAS;AAGb,SAAgBD,EAAgB,GAAoB;CAClD,AAAI,MAAWE,MACf,IAAS,IACT,QAAQ,KACN,6BAA6BC,EAAK,6GAEpC;AACF;AAGA,IAAMD,WAAyB;CAC7B,IAAI;EACF,OAAO,CAAA;CACT,QAAQ;EACN,OAAO;CACT;AACF,EAAA,CAAG"}
+{"version":3,"file":"zoomBounds.js","names":["normalizeZoom","clampToFloor","DEFAULT_MIN_ZOOM","DEFAULT_MAX_ZOOM","normalizeZoom$1","held","normalizeZoom","zoom","warnInvalidView","warned","IS_DEV","what","ZOOM_FLOOR"],"sources":["../../../src/core/viewport/zoomBounds.ts"],"sourcesContent":["import { normalizeZoom as clampToFloor, ZOOM_FLOOR } from '@weasel-js/geom';\n\n/**\n * The kit's system-wide zoom clamp, in `View.scale` units (pixels per world\n * unit): `1` is 100%, `0.1` is 10%, `8` is 800%.\n *\n * Every zoom path defaults from these — `zoomAt`, the `viewport.zoom` and\n * pinch actions, `fitViewToBounds`, `computeWheelAction`. They\n * used to carry two disagreeing pairs, so a fit could legally land at 10x\n * and the next pinch frame would clamp it back to 8x.\n */\nexport const DEFAULT_MIN_ZOOM = 0.1;\n/** Upper end of the kit's default zoom clamp — 800%. See {@link DEFAULT_MIN_ZOOM}. */\nexport const DEFAULT_MAX_ZOOM = 8;\n\nexport { ZOOM_FLOOR };\n\n/**\n * The one rule for a zoom magnitude: a finite number no smaller than\n * {@link ZOOM_FLOOR}. Anything else (0, negative, NaN, ±Infinity) becomes the\n * floor. Dev builds warn once when a zoom that was never valid arrives; a\n * positive zoom that merely undershoots the floor clamps silently.\n */\nexport function normalizeZoom(zoom: number): number {\n  const held = clampToFloor(zoom);\n  if (held !== zoom && (!(zoom > 0) || zoom === Infinity)) warnInvalidView(`a zoom of ${zoom}`);\n  return held;\n}\n\nlet warned = false;\n\n/** @internal Once per session, in dev builds only. */\nexport function warnInvalidView(what: string): void {\n  if (warned || !IS_DEV) return;\n  warned = true;\n  console.warn(\n    `[weasel] a view was given ${what} and has been clamped. A view's zoom is ` +\n    'always positive and finite, and its position finite; see ZOOM_FLOOR.',\n  );\n}\n\n/** `import.meta.env.DEV` read through a cast, as in SceneCanvas.tsx. */\nconst IS_DEV: boolean = (() => {\n  try {\n    return Boolean((import.meta as unknown as { env?: { DEV?: boolean } }).env?.DEV);\n  } catch {\n    return false;\n  }\n})();\n"],"mappings":";;AAWA,IAAaE,IAAmB,IAEnBC,IAAmB;AAUhC,SAAgBH,EAAc,GAAsB;CAClD,IAAMK,IAAOJ,EAAaM,CAAI;CAE9B,OADIF,MAASE,MAAS,EAAEA,IAAO,MAAMA,MAAS,aAAWC,EAAgB,aAAaD,GAAM,GACrFF;AACT;AAEA,IAAII,IAAS;AAGb,SAAgBD,EAAgB,GAAoB;CAClD,AAAI,MAAWE,MACf,IAAS,IACT,QAAQ,KACN,6BAA6BC,EAAK,6GAEpC;AACF;AAGA,IAAMD,WAAyB;CAC7B,IAAI;EACF,OAAO,CAAA;CACT,QAAQ;EACN,OAAO;CACT;AACF,EAAA,CAAG"}

package/dist/{cornerHandles-BCrDp_mH.d.ts → cornerHandles-BEshc4z3.d.ts}

@@ -1,4 +1,4 @@
-import { B as BoundsConstraint, P as PointSnapBehavior } from './types-B_9g6hMM.js';
+import { B as BoundsConstraint, P as PointSnapBehavior } from './clone-2a5hVbBd.js';
 import { Bounds, ResizeAnchor } from '@weasel-js/routing';
 
 /** Option surface for the `resize` action. */
@@ -22,33 +22,20 @@ interface UseResizeOptions<TPose> {
     /** Fired once per `onGestureStart`: `true` when the resize wrote to the
      *  document, `false` on cancel, a behavior abort, or no change. */
     onGestureEnd?: (committed: boolean) => void;
-    /** Optional: expand the incoming id into leaf ids before pose lookups.
-     *  Used for group expansion: when the
-     *  gesture is started against a group id, the kit
-     *  resizes by computing the union AABB of the leaves' origin bounds,
-     *  running the compute pipeline on that union rect (group bounds), and
-     *  remapping each leaf via `geometry.remapBounds(leaf, originGroupBounds,
-     *  proposedGroupBounds)`.
-     *
-     *  When `expandIds` is omitted or returns the original single id, the
-     *  gesture takes the single-leaf path (the leaf's own bounds become both
-     *  the origin and the target of the same `remapBounds` call).
-     *
-     *  Called once at `start()`. Returning `[]` aborts the gesture cleanly. */
+    /** Expand the incoming id into leaf ids, for resizing a group: the kit
+     *  resizes the union AABB of the leaves' bounds and remaps each leaf into
+     *  the result. Called once at `start()`. Returning `[]` aborts the gesture
+     *  cleanly. */
     expandIds?: (ids: string[]) => string[];
     /** Behaviors that operate on world-space anchor points. Fire after
-     *  `behaviors[]` (bounds-frame). Each behavior receives a `PointSnapContext`
-     *  with world-space frame points and returns at most one `PointSnapResult`;
-     *  the hook back-solves the local pose so the chosen frame's world point
-     *  lands on the snap target. First non-null result wins. */
+     *  `behaviors[]`. The first non-null `PointSnapResult` wins, and the pose
+     *  is back-solved so the chosen frame's world point lands on the snap
+     *  target. */
     pointSnapBehaviors?: TPose extends Bounds ? PointSnapBehavior<TPose>[] : never;
     /** Per-node resizability predicate. Returns `false` for nodes that should
-     *  never show resize handles (and thus can't start a resize gesture) — e.g.
-     *  fixed-footprint icons, locked layers. `<SceneCanvas>` folds this over the
-     *  current selection into the `selectionResizable` rule-ctx flag, so the
-     *  default `selection.resize-handles` chrome rule hides handles whenever any
-     *  selected node is non-resizable (which also disables the affordance, since
-     *  visible==hittable). Default: every node resizable. */
+     *  never show resize handles (and thus can't start a resize gesture). The
+     *  handles hide whenever any selected node is non-resizable. Default: every
+     *  node resizable. */
     resizable?: (id: string) => boolean;
 }
 

package/dist/debug/createDebugOverlayLayer.js

@@ -1,35 +1,35 @@
 import { viewToTransform as e } from "../core/viewport/view.js";
 import { worldToScreen as t } from "../core/viewport/viewTransform.js";
 import { rotatePoint as n } from "../interactions/actions/rotate/geometry.js";
-import { textCommandFromRuns as r } from "../features/text/textCommand.js";
-import { DEFAULT_DEBUG_STROKES as i, DEFAULT_DEBUG_THEME as a } from "./defaultTheme.js";
+import { DEFAULT_DEBUG_STROKES as r, DEFAULT_DEBUG_THEME as i } from "./defaultTheme.js";
+import { textCommandFromRuns as a } from "@weasel-js/renderer";
 import { PATH_L as o, PATH_M as s, PATH_Z as c } from "@weasel-js/geom";
 //#region src/debug/createDebugOverlayLayer.ts
-var l = 60;
-function u({ sink: e, config: t }) {
+var l = "debug-overlay", u = 60;
+function d({ sink: e, config: t }) {
 	let n = [];
 	return {
-		id: "debug-overlay",
+		id: l,
 		label: "Debug overlay",
 		space: "screen",
 		alwaysOn: !0,
-		draw: (r, i, a) => (t.fps ? (n.push(typeof performance < "u" ? performance.now() : Date.now()), n.length > l && n.shift()) : n.length > 0 && (n.length = 0), d(e.snapshot(), t, i, a, n))
+		draw: (r, i, a) => (t.fps ? (n.push(typeof performance < "u" ? performance.now() : Date.now()), n.length > u && n.shift()) : n.length > 0 && (n.length = 0), f(e.snapshot(), t, i, a, n))
 	};
 }
-function d(t, n, r, o, s = []) {
+function f(t, n, a, o, s = []) {
 	let c = {
-		...a,
+		...i,
 		...n.theme ?? {}
 	}, l = {
-		...i,
+		...r,
 		...n.strokes ?? {}
-	}, u = t, d = e(r), f = [];
-	return n.viewport && u.viewport && A(f, u.viewport, r, o, c, l), n.hitboxes && _(f, u, r, d, c, l), n.bounds && v(f, u, r, d, c, l), n.handles && y(f, u, d, c, l), n.origins && b(f, u, d, c), n.snap && x(f, u, d, c, l), n.ids && S(f, u, d, c), n.layers && C(f, u, o, c), n.fps && k(f, s, u.frame, c), f;
+	}, u = t, d = e(a), f = [];
+	return n.viewport && u.viewport && j(f, u.viewport, a, o, c, l), n.hitboxes && v(f, u, a, d, c, l), n.bounds && y(f, u, a, d, c, l), n.handles && b(f, u, d, c, l), n.origins && x(f, u, d, c), n.snap && S(f, u, d, c, l), n.ids && C(f, u, d, c), n.layers && w(f, u, o, c), n.fps && A(f, s, u.frame, c), f;
 }
-function f(e, t, n, r = 24) {
-	return p(e, t, n, n, r);
+function p(e, t, n, r = 24) {
+	return m(e, t, n, n, r);
 }
-function p(e, t, n, r, i = 24) {
+function m(e, t, n, r, i = 24) {
 	let a = new Uint8Array(i + 1), l = new Float32Array(i * 2);
 	a[0] = s, l[0] = e + n, l[1] = t;
 	for (let s = 1; s < i; s++) {
@@ -44,7 +44,7 @@ function p(e, t, n, r, i = 24) {
 		fillRule: "nonzero"
 	};
 }
-function m(e, r) {
+function h(e, r) {
 	let i = e.x + e.width / 2, a = e.y + e.height / 2, l = /* @__PURE__ */ new Float32Array(8);
 	return [
 		[e.x, e.y],
@@ -67,7 +67,7 @@ function m(e, r) {
 		fillRule: "nonzero"
 	};
 }
-function h(e, t, n, r) {
+function g(e, t, n, r) {
 	return {
 		kind: "rect",
 		x: e,
@@ -76,46 +76,46 @@ function h(e, t, n, r) {
 		height: r
 	};
 }
-function g(e, t) {
+function _(e, t) {
 	return {
 		paint: {
-			fill: "solid",
+			kind: "solid",
 			color: t
 		},
 		width: e.width,
 		...e.dash && e.dash.length > 0 ? { dash: [...e.dash] } : {}
 	};
 }
-function _(e, n, r, i, a, l) {
+function v(e, n, r, i, a, l) {
 	let u = {
-		fill: "solid",
+		kind: "solid",
 		color: a.hitboxFill
-	}, d = g(l.hitbox, a.hitboxStroke);
+	}, d = _(l.hitbox, a.hitboxStroke);
 	for (let a of n.hitboxes) if (a.shape.kind === "rect" && a.shape.rotation) {
-		let t = m({
+		let t = h({
 			...a.shape,
 			rotation: a.shape.rotation
 		}, i);
 		e.push({
 			kind: "path",
 			path: t,
-			fill: u,
+			fill: { paint: u },
 			stroke: d
 		});
 	} else if (a.shape.kind === "rect") {
 		let [n, o] = t(a.shape.x, a.shape.y, i), s = a.shape.width * r.scale.x, c = a.shape.height * r.scale.y;
 		e.push({
 			kind: "path",
-			path: h(n, o, s, c),
-			fill: u,
+			path: g(n, o, s, c),
+			fill: { paint: u },
 			stroke: d
 		});
 	} else if (a.shape.kind === "circle") {
 		let [n, o] = t(a.shape.cx, a.shape.cy, i), s = a.shape.r * Math.abs(r.scale.x), c = a.shape.r * Math.abs(r.scale.y);
 		e.push({
 			kind: "path",
-			path: p(n, o, s, c),
-			fill: u,
+			path: m(n, o, s, c),
+			fill: { paint: u },
 			stroke: d
 		});
 	} else if (a.shape.kind === "polygon" && a.shape.points.length > 2) {
@@ -133,24 +133,24 @@ function _(e, n, r, i, a, l) {
 				coords: r,
 				fillRule: "nonzero"
 			},
-			fill: u,
+			fill: { paint: u },
 			stroke: d
 		});
 	}
 }
-function v(e, n, r, i, a, o) {
-	let s = g(o.bounds, a.bounds);
+function y(e, n, r, i, a, o) {
+	let s = _(o.bounds, a.bounds);
 	for (let a of n.bounds) {
 		let [n, o] = t(a.bounds.x, a.bounds.y, i), c = a.bounds.width * r.scale.x, l = a.bounds.height * r.scale.y;
 		e.push({
 			kind: "path",
-			path: h(n, o, c, l),
+			path: g(n, o, c, l),
 			stroke: s
 		});
 	}
 }
-function y(e, n, r, i, a) {
-	let c = g(a.handle, i.handle);
+function b(e, n, r, i, a) {
+	let c = _(a.handle, i.handle);
 	for (let i of n.handles) {
 		let [n, a] = t(i.position.x, i.position.y, r), l = {
 			kind: "polygon",
@@ -184,100 +184,100 @@ function y(e, n, r, i, a) {
 		});
 	}
 }
-function b(e, n, r, i) {
+function x(e, n, r, i) {
 	let a = {
-		fill: "solid",
+		kind: "solid",
 		color: i.origin
 	};
 	for (let i of n.origins) {
 		let [n, o] = t(i.point.x, i.point.y, r);
 		e.push({
 			kind: "path",
-			path: f(n, o, 3),
-			fill: a
+			path: p(n, o, 3),
+			fill: { paint: a }
 		});
 	}
 }
-function x(e, n, r, i, a) {
+function S(e, n, r, i, a) {
 	let o = i.snap;
 	for (let i of n.snap) {
 		let [n, s] = t(i.point.x, i.point.y, r), c = {
 			kind: "path",
-			path: f(n, s, 4),
-			...i.accepted ? { fill: {
-				fill: "solid",
+			path: p(n, s, 4),
+			...i.accepted ? { fill: { paint: {
+				kind: "solid",
 				color: o
-			} } : { stroke: g(a.snap, o) }
+			} } } : { stroke: _(a.snap, o) }
 		};
 		e.push(c);
 	}
 }
-function S(e, n, i, a) {
+function C(e, n, r, i) {
 	for (let o of n.bounds) {
-		let [n, s] = t(o.bounds.x, o.bounds.y, i);
-		e.push(r(n + 2, s + 11, [{
+		let [n, s] = t(o.bounds.x, o.bounds.y, r);
+		e.push(a(n + 2, s + 11, [{
 			text: o.id,
-			fill: {
-				fill: "solid",
-				color: a.idText
-			}
+			fill: { paint: {
+				kind: "solid",
+				color: i.idText
+			} }
 		}], {
 			fontFamily: "ui-monospace, Menlo, monospace",
 			fontSize: 10
 		}));
 	}
 }
-function C(e, t, n, i) {
+function w(e, t, n, r) {
 	if (t.layers.length === 0) return;
-	let a = t.layers.map((e) => `[${e.index}] ${e.id} (${e.space})`), o = 0;
-	for (let e of a) o = Math.max(o, e.length * 6.6);
-	let s = o + 12, c = a.length * 14 + 8, l = n.width - s - 8;
+	let i = t.layers.map((e) => `[${e.index}] ${e.id} (${e.space})`), o = 0;
+	for (let e of i) o = Math.max(o, e.length * 6.6);
+	let s = o + 12, c = i.length * 14 + 8, l = n.width - s - 8;
 	e.push({
 		kind: "path",
-		path: h(l, 8, s, c),
-		fill: {
-			fill: "solid",
-			color: i.layerTextBg
-		}
+		path: g(l, 8, s, c),
+		fill: { paint: {
+			kind: "solid",
+			color: r.layerTextBg
+		} }
 	});
-	for (let t = 0; t < a.length; t++) e.push(r(l + 6, 12 + t * 14, [{
-		text: a[t],
-		fill: {
-			fill: "solid",
-			color: i.layerText
-		}
+	for (let t = 0; t < i.length; t++) e.push(a(l + 6, 12 + t * 14, [{
+		text: i[t],
+		fill: { paint: {
+			kind: "solid",
+			color: r.layerText
+		} }
 	}], {
 		fontFamily: "ui-monospace, Menlo, monospace",
 		fontSize: 11
 	}));
 }
-var w = {
+var T = {
 	fontFamily: "ui-monospace, Menlo, monospace",
 	fontSize: 11
-}, T = 6.6, E = 14;
-function D(e, t, n, i, a, o) {
+}, E = 6.6, D = 14;
+function O(e, t, n, r, i, o) {
 	let s = 0;
 	for (let e of t) s = Math.max(s, e.length);
 	e.push({
 		kind: "path",
-		path: h(n, i, s * T + 12, t.length * E + 8),
-		fill: {
-			fill: "solid",
+		path: g(n, r, s * E + 12, t.length * D + 8),
+		fill: { paint: {
+			kind: "solid",
 			color: o
-		}
+		} }
 	});
-	for (let o = 0; o < t.length; o++) e.push(r(n + 6, i + 4 + o * E, [{
+	for (let o = 0; o < t.length; o++) e.push(a(n + 6, r + 4 + o * D, [{
 		text: t[o],
-		fill: {
-			fill: "solid",
-			color: a
-		}
-	}], w));
+		fill: { paint: {
+			kind: "solid",
+			color: i
+		} }
+	}], T));
 }
-function O(e, t, n) {
+function k(e, t, n) {
 	return e.toFixed(n).padStart(t);
 }
-function k(e, t, n, r) {
+function A(e, t, n, r) {
 	let i = t.length >= 2 ? t[t.length - 1] - t[0] : 0, a = i > 0 ? i / (t.length - 1) : null, o = [[
 		"fps",
 		null,
@@ -305,41 +305,41 @@ function k(e, t, n, r) {
 	}
 	let s = 0;
 	for (let [e] of o) s = Math.max(s, e.length);
-	let c = (e, t, n, r) => `${e.padEnd(s)} ${t.padStart(5)} ${n.padStart(7)} ${r}`, l = o.map(([e, t, n, r]) => c(e, t === null ? "" : String(t), n === null ? "—" : O(n, 7, 2), r));
-	n && l.splice(2, 0, c("", "draws", "cpu", "  ")), D(e, l, 8, 8, r.fpsText, r.fpsTextBg);
+	let c = (e, t, n, r) => `${e.padEnd(s)} ${t.padStart(5)} ${n.padStart(7)} ${r}`, l = o.map(([e, t, n, r]) => c(e, t === null ? "" : String(t), n === null ? "—" : k(n, 7, 2), r));
+	n && l.splice(2, 0, c("", "draws", "cpu", "  ")), O(e, l, 8, 8, r.fpsText, r.fpsTextBg);
 }
-function A(n, r, i, a, o, s) {
-	let c = e(i), l = g(s.viewport, o.viewport), { from: u, to: d } = r, [p, m] = t(u.x, u.y, c);
+function j(n, r, i, a, o, s) {
+	let c = e(i), l = _(s.viewport, o.viewport), { from: u, to: d } = r, [f, m] = t(u.x, u.y, c);
 	if (n.push({
 		kind: "path",
-		path: h(p, m, a.width / u.scale.x * i.scale.x, a.height / u.scale.y * i.scale.y),
+		path: g(f, m, a.width / u.scale.x * i.scale.x, a.height / u.scale.y * i.scale.y),
 		stroke: l
 	}), r.anchor) {
-		let [i, a] = t(r.anchor.x, r.anchor.y, e(u)), [d, p] = t(r.anchor.x, r.anchor.y, c);
+		let [i, a] = t(r.anchor.x, r.anchor.y, e(u)), [d, f] = t(r.anchor.x, r.anchor.y, c);
 		n.push({
 			kind: "path",
-			path: f(i, a, 2.5),
-			fill: {
-				fill: "solid",
+			path: p(i, a, 2.5),
+			fill: { paint: {
+				kind: "solid",
 				color: o.viewport
-			}
-		}), Math.hypot(d - i, p - a) > .5 && n.push({
+			} }
+		}), Math.hypot(d - i, f - a) > .5 && n.push({
 			kind: "path",
-			path: M(i, a, d, p),
+			path: N(i, a, d, f),
 			stroke: l
 		}), n.push({
 			kind: "path",
-			path: f(d, p, 6),
-			stroke: g({ width: s.viewport.width }, o.viewport)
+			path: p(d, f, 6),
+			stroke: _({ width: s.viewport.width }, o.viewport)
 		});
 	}
-	D(n, [r.kind === "pan" ? `pan   Δ ${j((u.x - d.x) * d.scale.x)} ${j((u.y - d.y) * d.scale.y)} px` : `zoom  ×${(d.scale.x / u.scale.x).toFixed(3)}  ${u.scale.x.toFixed(3)} → ${d.scale.x.toFixed(3)}`], 8, a.height - E - 16, o.viewport, o.layerTextBg);
+	O(n, [r.kind === "pan" ? `pan   Δ ${M((u.x - d.x) * d.scale.x)} ${M((u.y - d.y) * d.scale.y)} px` : `zoom  ×${(d.scale.x / u.scale.x).toFixed(3)}  ${u.scale.x.toFixed(3)} → ${d.scale.x.toFixed(3)}`], 8, a.height - D - 16, o.viewport, o.layerTextBg);
 }
-function j(e) {
+function M(e) {
 	let t = Math.abs(e) < .05 ? 0 : e;
 	return `${t >= 0 ? "+" : "-"}${Math.abs(t).toFixed(1)}`.padStart(8);
 }
-function M(e, t, n, r) {
+function N(e, t, n, r) {
 	return {
 		kind: "polygon",
 		commands: new Uint8Array([s, o]),
@@ -353,6 +353,6 @@ function M(e, t, n, r) {
 	};
 }
 //#endregion
-export { d as buildDebugOverlayCommands, u as createDebugOverlayLayer };
+export { l as DEBUG_OVERLAY_ID, f as buildDebugOverlayCommands, d as createDebugOverlayLayer };
 
 //# sourceMappingURL=createDebugOverlayLayer.js.map