@pibbl/core 0.0.1

package/dist/lib/manipulation/solve.js

@@ -0,0 +1,563 @@
+import { assertFiniteBox, assertFinitePoint, freezeBox } from "./geometry.js";
+import {
+  assertFiniteOrigin,
+  assertPositiveFiniteStep,
+  isSnapActive,
+  snapToLattice
+} from "./snap.js";
+function solveManipulation(input) {
+  assertFiniteBox(input.initial, "initial");
+  assertFinitePoint(input.initialPoint, "initialPoint");
+  assertFinitePoint(input.currentPoint, "currentPoint");
+  validateConfiguredSnaps(input);
+  if (!Number.isFinite(input.initialRotation ?? 0))
+    throw new Error("initialRotation must be finite.");
+  switch (input.operation) {
+    case "move":
+      return solveMove(input);
+    case "resize":
+      return solveResize(input);
+    case "rotate":
+      return solveRotation(input);
+  }
+}
+function solveMove(input) {
+  const { initial } = input;
+  const axis = input.move?.axis ?? "both";
+  if (input.move?.bounds) {
+    assertFiniteBox(input.move.bounds, "move.bounds");
+    if (!containsRotated(input.move.bounds, initial, input.initialRotation ?? 0))
+      throw new Error("Move bounds must contain the initial box.");
+  }
+  const deltaX = input.currentPoint.x - input.initialPoint.x;
+  const deltaY = input.currentPoint.y - input.initialPoint.y;
+  const proposed = freezeBox({
+    ...initial,
+    left: axis === "y" ? initial.left : initial.left + deltaX,
+    top: axis === "x" ? initial.top : initial.top + deltaY
+  });
+  const snap = input.move?.snap;
+  const snapActive = snap !== void 0 && isSnapActive(snap.enabled, snap.when, input.modifiers);
+  if (!snapActive)
+    return result(
+      proposed,
+      clampMoveToBounds(
+        proposed,
+        input.move?.bounds,
+        input.initialRotation ?? 0
+      ),
+      false,
+      true,
+      input.initialRotation
+    );
+  const [stepX, stepY] = moveSteps(snap);
+  const origin = snap.origin;
+  const applied = freezeBox({
+    ...proposed,
+    left: axis === "y" ? proposed.left : snapToLattice(proposed.left, stepX, origin?.x ?? 0),
+    top: axis === "x" ? proposed.top : snapToLattice(proposed.top, stepY, origin?.y ?? 0)
+  });
+  const bounded = clampMoveToBounds(
+    applied,
+    input.move?.bounds,
+    input.initialRotation ?? 0
+  );
+  return result(
+    proposed,
+    bounded,
+    true,
+    boxesEqual(applied, bounded),
+    input.initialRotation
+  );
+}
+function solveResize(input) {
+  const handle = input.handle;
+  if (!handle) throw new Error("Resize manipulation requires a handle.");
+  const rotation = input.initialRotation ?? 0;
+  if (!Number.isFinite(rotation))
+    throw new Error("initialRotation must be finite.");
+  if (input.resize?.snap?.target === "grid" && rotation !== 0)
+    throw new Error("Grid resize snapping requires an unrotated box.");
+  const raw = resizeFromPoint(
+    input.initial,
+    handle,
+    rotateInverse(
+      {
+        x: input.currentPoint.x - input.initialPoint.x,
+        y: input.currentPoint.y - input.initialPoint.y
+      },
+      rotation
+    )
+  );
+  const proposed = resizeFromDimensionsRotated(
+    input.initial,
+    handle,
+    raw.width,
+    raw.height,
+    rotation
+  );
+  const ratio = activeRatio(input.initial, input.resize, input.modifiers);
+  const changesWidth = handle.includes("left") || handle.includes("right");
+  const changesHeight = handle.includes("top") || handle.includes("bottom");
+  const constraints = resolvedResizeConstraints(input.resize);
+  if (ratio === void 0) {
+    if (!changesWidth) {
+      if (input.initial.width < constraints.minWidth || input.initial.width > constraints.maxWidth)
+        throw new Error(
+          "Resize width constraints conflict with the fixed dimension."
+        );
+      constraints.minWidth = constraints.maxWidth = input.initial.width;
+    }
+    if (!changesHeight) {
+      if (input.initial.height < constraints.minHeight || input.initial.height > constraints.maxHeight)
+        throw new Error(
+          "Resize height constraints conflict with the fixed dimension."
+        );
+      constraints.minHeight = constraints.maxHeight = input.initial.height;
+    }
+  }
+  const snap = input.resize?.snap;
+  const snapActive = snap !== void 0 && isSnapActive(snap.enabled, snap.when, input.modifiers);
+  let width = raw.width;
+  let height = raw.height;
+  if (ratio !== void 0) {
+    const widthDrives = changesWidth && (!changesHeight || Math.abs(raw.width / input.initial.width - 1) >= Math.abs(raw.height / input.initial.height - 1));
+    if (snapActive) {
+      const snapped = snapResize(input.initial, raw, handle, snap);
+      if (widthDrives) width = snapped.width;
+      else height = snapped.height;
+    }
+    if (widthDrives) height = width / ratio;
+    else width = height * ratio;
+  } else if (snapActive) {
+    const snapped = snapResize(input.initial, raw, handle, snap);
+    width = snapped.width;
+    height = snapped.height;
+  }
+  const bounded = constrainDimensions(
+    input.initial,
+    handle,
+    { width, height },
+    rotation,
+    input.resize?.bounds,
+    ratio,
+    constraints
+  );
+  const applied = resizeFromDimensionsRotated(
+    input.initial,
+    handle,
+    bounded.width,
+    bounded.height,
+    rotation
+  );
+  const onLattice = (value, step, origin = 0) => Math.abs(value - snapToLattice(value, step, origin)) <= 1e-9 * Math.max(1, Math.abs(value));
+  let snapSatisfied = true;
+  if (snapActive) {
+    if (snap.target === "grid") {
+      const grid = snap;
+      const [stepX, stepY] = gridSteps(grid);
+      snapSatisfied = (!changesWidth || onLattice(
+        handle.includes("left") ? applied.left : applied.left + applied.width,
+        stepX,
+        grid.origin?.x
+      )) && (!changesHeight || onLattice(
+        handle.includes("top") ? applied.top : applied.top + applied.height,
+        stepY,
+        grid.origin?.y
+      ));
+    } else {
+      const [stepWidth, stepHeight] = sizeSteps(
+        snap
+      );
+      snapSatisfied = (!(changesWidth || ratio !== void 0) || onLattice(applied.width, stepWidth)) && (!(changesHeight || ratio !== void 0) || onLattice(applied.height, stepHeight));
+    }
+  }
+  return result(proposed, applied, snapActive, snapSatisfied, rotation);
+}
+function solveRotation(input) {
+  const initialRotation = input.initialRotation ?? 0;
+  const delta = input.rotationDelta ?? 0;
+  if (!Number.isFinite(initialRotation) || !Number.isFinite(delta)) {
+    throw new Error("Rotation values must be finite.");
+  }
+  const proposedRotation = initialRotation + delta;
+  const snap = input.rotate?.snap;
+  const snapActive = snap !== void 0 && isSnapActive(snap.enabled, snap.when, input.modifiers);
+  const appliedRotation = snapActive ? snapToLattice(proposedRotation, snap.step, snap.origin ?? 0) : proposedRotation;
+  return result(
+    input.initial,
+    input.initial,
+    snapActive,
+    true,
+    initialRotation,
+    proposedRotation,
+    appliedRotation
+  );
+}
+function resizeFromPoint(initial, handle, delta) {
+  const movesLeft = handle.includes("left");
+  const movesRight = handle.includes("right");
+  const movesTop = handle.includes("top");
+  const movesBottom = handle.includes("bottom");
+  return freezeBox({
+    left: movesLeft ? initial.left + delta.x : initial.left,
+    top: movesTop ? initial.top + delta.y : initial.top,
+    width: initial.width + (movesRight ? delta.x : 0) - (movesLeft ? delta.x : 0),
+    height: initial.height + (movesBottom ? delta.y : 0) - (movesTop ? delta.y : 0)
+  });
+}
+function resizeFromDimensions(initial, handle, width, height) {
+  return freezeBox({
+    left: handle.includes("left") ? initial.left + initial.width - width : initial.left,
+    top: handle.includes("top") ? initial.top + initial.height - height : initial.top,
+    width,
+    height
+  });
+}
+function snapResize(initial, proposed, handle, snap) {
+  if (snap.target === "grid") {
+    const [stepX, stepY] = gridSteps(snap);
+    const origin = snap.origin;
+    const movesLeft = handle.includes("left");
+    const movesTop = handle.includes("top");
+    const edgeX = movesLeft ? proposed.left : proposed.left + proposed.width;
+    const edgeY = movesTop ? proposed.top : proposed.top + proposed.height;
+    const snappedEdgeX = snapToLattice(edgeX, stepX, origin?.x ?? 0);
+    const snappedEdgeY = snapToLattice(edgeY, stepY, origin?.y ?? 0);
+    const width = !(handle.includes("left") || handle.includes("right")) ? initial.width : movesLeft ? initial.left + initial.width - snappedEdgeX : snappedEdgeX - initial.left;
+    const height = !(handle.includes("top") || handle.includes("bottom")) ? initial.height : movesTop ? initial.top + initial.height - snappedEdgeY : snappedEdgeY - initial.top;
+    return resizeFromDimensions(initial, handle, width, height);
+  }
+  const [stepWidth, stepHeight] = sizeSteps(snap);
+  return resizeFromDimensions(
+    proposed,
+    handle,
+    handle.includes("left") || handle.includes("right") ? snapToLattice(proposed.width, stepWidth) : proposed.width,
+    handle.includes("top") || handle.includes("bottom") ? snapToLattice(proposed.height, stepHeight) : proposed.height
+  );
+}
+function moveSteps(snap) {
+  return typeof snap.step === "number" ? [snap.step, snap.step] : [snap.step.x, snap.step.y];
+}
+function sizeSteps(snap) {
+  return typeof snap.step === "number" ? [snap.step, snap.step] : [snap.step.width, snap.step.height];
+}
+function gridSteps(snap) {
+  return typeof snap.step === "number" ? [snap.step, snap.step] : [snap.step.x, snap.step.y];
+}
+function resolvedResizeConstraints(options) {
+  for (const name of [
+    "minWidth",
+    "minHeight",
+    "maxWidth",
+    "maxHeight"
+  ]) {
+    const value = options?.[name];
+    if (value !== void 0 && (!Number.isFinite(value) || value <= 0))
+      throw new Error(`${name} must be positive and finite.`);
+  }
+  const minWidth = options?.minWidth ?? 1;
+  const minHeight = options?.minHeight ?? 1;
+  const maxWidth = options?.maxWidth ?? Number.POSITIVE_INFINITY;
+  const maxHeight = options?.maxHeight ?? Number.POSITIVE_INFINITY;
+  for (const [name, value] of Object.entries({
+    minWidth,
+    minHeight,
+    maxWidth,
+    maxHeight
+  })) {
+    if (!Number.isFinite(value) && value !== Number.POSITIVE_INFINITY) {
+      throw new Error(`${name} must be finite, received ${value}`);
+    }
+  }
+  if (minWidth <= 0 || minHeight <= 0 || maxWidth <= 0 || maxHeight <= 0) {
+    throw new Error("Resize constraints must be greater than zero.");
+  }
+  if (minWidth > maxWidth || minHeight > maxHeight) {
+    throw new Error(
+      "Resize minimum dimensions must not exceed maximum dimensions."
+    );
+  }
+  return { minWidth, minHeight, maxWidth, maxHeight };
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function clampMoveToBounds(box, bounds, rotation = 0) {
+  if (!bounds) return box;
+  assertFiniteBox(bounds, "move.bounds");
+  const corners = rotatedCorners(box, rotation);
+  const minX = Math.min(...corners.map((point) => point.x));
+  const maxX = Math.max(...corners.map((point) => point.x));
+  const minY = Math.min(...corners.map((point) => point.y));
+  const maxY = Math.max(...corners.map((point) => point.y));
+  if (maxX - minX > bounds.width || maxY - minY > bounds.height)
+    throw new Error("Move bounds cannot contain the initial box.");
+  return freezeBox({
+    ...box,
+    left: box.left + clamp(0, bounds.left - minX, bounds.left + bounds.width - maxX),
+    top: box.top + clamp(0, bounds.top - minY, bounds.top + bounds.height - maxY)
+  });
+}
+function activeRatio(initial, options, modifiers) {
+  const aspect = options?.aspectRatio;
+  if (!aspect) return void 0;
+  const ratio = aspect.value === "initial" ? initial.width / initial.height : aspect.value;
+  if (!Number.isFinite(ratio) || ratio <= 0)
+    throw new Error(
+      "Resize aspect ratio must be finite and greater than zero."
+    );
+  return isSnapActive(true, aspect.when, modifiers) ? ratio : void 0;
+}
+function rotateInverse(point, radians) {
+  const cosine = Math.cos(radians);
+  const sine = Math.sin(radians);
+  return {
+    x: point.x * cosine + point.y * sine,
+    y: -point.x * sine + point.y * cosine
+  };
+}
+function resizeFromDimensionsRotated(initial, handle, width, height, radians) {
+  const oldCenter = {
+    x: initial.left + initial.width / 2,
+    y: initial.top + initial.height / 2
+  };
+  const opposite = {
+    x: handle.includes("left") ? initial.width / 2 : handle.includes("right") ? -initial.width / 2 : 0,
+    y: handle.includes("top") ? initial.height / 2 : handle.includes("bottom") ? -initial.height / 2 : 0
+  };
+  const cosine = Math.cos(radians);
+  const sine = Math.sin(radians);
+  const anchor = {
+    x: oldCenter.x + opposite.x * cosine - opposite.y * sine,
+    y: oldCenter.y + opposite.x * sine + opposite.y * cosine
+  };
+  const nextOpposite = {
+    x: handle.includes("left") ? width / 2 : handle.includes("right") ? -width / 2 : 0,
+    y: handle.includes("top") ? height / 2 : handle.includes("bottom") ? -height / 2 : 0
+  };
+  const center = {
+    x: anchor.x - (nextOpposite.x * cosine - nextOpposite.y * sine),
+    y: anchor.y - (nextOpposite.x * sine + nextOpposite.y * cosine)
+  };
+  return freezeBox({
+    left: center.x - width / 2,
+    top: center.y - height / 2,
+    width,
+    height
+  });
+}
+function constrainDimensions(initial, handle, proposed, rotation, bounds, ratio, constraints) {
+  if (!Number.isFinite(proposed.width) || !Number.isFinite(proposed.height))
+    throw new Error("Resize geometry exceeds finite coordinates.");
+  if (bounds) {
+    assertFiniteBox(bounds, "resize.bounds");
+    if (!containsRotated(bounds, initial, rotation))
+      throw new Error("Resize bounds must contain the initial box.");
+  }
+  if (ratio !== void 0) {
+    let minimum = Math.max(constraints.minWidth, constraints.minHeight * ratio);
+    let maximum = Math.min(constraints.maxWidth, constraints.maxHeight * ratio);
+    for (const plane of bounds ? boundsPlanes(initial, handle, rotation, bounds) : []) {
+      const slope = plane.a + plane.b / ratio;
+      if (Math.abs(slope) < 1e-12) {
+        if (plane.c < -1e-9)
+          throw new Error("Resize bounds have no feasible ratio.");
+      } else if (slope > 0) maximum = Math.min(maximum, plane.c / slope);
+      else minimum = Math.max(minimum, plane.c / slope);
+    }
+    if (minimum > maximum)
+      throw new Error(
+        "Resize constraints cannot satisfy the aspect ratio and bounds."
+      );
+    const width = clamp(proposed.width, minimum, maximum);
+    return { width, height: width / ratio };
+  }
+  if (bounds)
+    return projectSizeToBounds(
+      initial,
+      handle,
+      proposed,
+      rotation,
+      bounds,
+      constraints
+    );
+  return {
+    width: clamp(proposed.width, constraints.minWidth, constraints.maxWidth),
+    height: clamp(
+      proposed.height,
+      constraints.minHeight,
+      constraints.maxHeight
+    )
+  };
+}
+function projectSizeToBounds(initial, handle, proposed, rotation, bounds, constraints) {
+  const maximumWidth = Number.isFinite(constraints.maxWidth) ? constraints.maxWidth : Math.max(initial.width, bounds.width + bounds.height);
+  const maximumHeight = Number.isFinite(constraints.maxHeight) ? constraints.maxHeight : Math.max(initial.height, bounds.width + bounds.height);
+  let polygon = [
+    { width: constraints.minWidth, height: constraints.minHeight },
+    { width: maximumWidth, height: constraints.minHeight },
+    { width: maximumWidth, height: maximumHeight },
+    { width: constraints.minWidth, height: maximumHeight }
+  ];
+  const planes = boundsPlanes(initial, handle, rotation, bounds);
+  for (const plane of planes) polygon = clipPolygon(polygon, plane);
+  if (polygon.length === 0)
+    throw new Error("Resize bounds have no feasible size region.");
+  return closestPointInPolygon(
+    { width: proposed.width, height: proposed.height },
+    polygon
+  );
+}
+function boundsPlanes(initial, handle, rotation, bounds) {
+  const zero = resizeFromDimensionsRotated(initial, handle, 0, 0, rotation);
+  const unitWidth = resizeFromDimensionsRotated(
+    initial,
+    handle,
+    1,
+    0,
+    rotation
+  );
+  const unitHeight = resizeFromDimensionsRotated(
+    initial,
+    handle,
+    0,
+    1,
+    rotation
+  );
+  const planes = [];
+  const zeroCorners = rotatedCorners(zero, rotation);
+  const widthCorners = rotatedCorners(unitWidth, rotation);
+  const heightCorners = rotatedCorners(unitHeight, rotation);
+  for (let index = 0; index < 4; index++) {
+    for (const [coordinate, lower, upper] of [
+      ["x", bounds.left, bounds.left + bounds.width],
+      ["y", bounds.top, bounds.top + bounds.height]
+    ]) {
+      const constant = zeroCorners[index][coordinate];
+      const a = widthCorners[index][coordinate] - constant;
+      const b = heightCorners[index][coordinate] - constant;
+      planes.push(
+        { a, b, c: upper - constant },
+        { a: -a, b: -b, c: constant - lower }
+      );
+    }
+  }
+  return planes;
+}
+function clipPolygon(points, plane) {
+  const output = [];
+  for (let index = 0; index < points.length; index++) {
+    const from = points[index];
+    const to = points[(index + 1) % points.length];
+    const fromValue = plane.a * from.width + plane.b * from.height - plane.c;
+    const toValue = plane.a * to.width + plane.b * to.height - plane.c;
+    if (fromValue <= 0) output.push(from);
+    if (fromValue <= 0 !== toValue <= 0) {
+      const t = fromValue / (fromValue - toValue);
+      output.push({
+        width: from.width + (to.width - from.width) * t,
+        height: from.height + (to.height - from.height) * t
+      });
+    }
+  }
+  return output;
+}
+function closestPointInPolygon(point, polygon) {
+  const area = polygon.reduce((sum, candidate, index) => {
+    const next = polygon[(index + 1) % polygon.length];
+    return sum + candidate.width * next.height - next.width * candidate.height;
+  }, 0);
+  if (Math.abs(area) > 1e-12 && polygon.every((candidate, index) => {
+    const next = polygon[(index + 1) % polygon.length];
+    return (next.width - candidate.width) * (point.height - candidate.height) - (next.height - candidate.height) * (point.width - candidate.width) >= -1e-9;
+  }))
+    return point;
+  let best = polygon[0];
+  let distance = Number.POSITIVE_INFINITY;
+  for (let index = 0; index < polygon.length; index++) {
+    const from = polygon[index];
+    const to = polygon[(index + 1) % polygon.length];
+    const dx = to.width - from.width;
+    const dy = to.height - from.height;
+    const scale = dx === 0 && dy === 0 ? 0 : clamp(
+      ((point.width - from.width) * dx + (point.height - from.height) * dy) / (dx * dx + dy * dy),
+      0,
+      1
+    );
+    const candidate = {
+      width: from.width + dx * scale,
+      height: from.height + dy * scale
+    };
+    const nextDistance = (candidate.width - point.width) ** 2 + (candidate.height - point.height) ** 2;
+    if (nextDistance < distance || nextDistance === distance && (candidate.width > best.width || candidate.width === best.width && candidate.height > best.height)) {
+      best = candidate;
+      distance = nextDistance;
+    }
+  }
+  return best;
+}
+function containsRotated(bounds, box, radians) {
+  return rotatedCorners(box, radians).every(
+    (point) => point.x >= bounds.left && point.x <= bounds.left + bounds.width && point.y >= bounds.top && point.y <= bounds.top + bounds.height
+  );
+}
+function rotatedCorners(box, radians) {
+  const center = { x: box.left + box.width / 2, y: box.top + box.height / 2 };
+  const cosine = Math.cos(radians);
+  const sine = Math.sin(radians);
+  return [
+    [-box.width / 2, -box.height / 2],
+    [box.width / 2, -box.height / 2],
+    [box.width / 2, box.height / 2],
+    [-box.width / 2, box.height / 2]
+  ].map(([x, y]) => ({
+    x: center.x + x * cosine - y * sine,
+    y: center.y + x * sine + y * cosine
+  }));
+}
+function validateConfiguredSnaps(input) {
+  const check = (step, origin, label) => {
+    for (const [name, value] of Object.entries(
+      typeof step === "number" ? { value: step } : step
+    ))
+      assertPositiveFiniteStep(value, `${label}.${name}`);
+    for (const [name, value] of Object.entries(origin ?? {}))
+      if (value !== void 0)
+        assertFiniteOrigin(value, `${label}.origin.${name}`);
+  };
+  if (input.move?.snap)
+    check(input.move.snap.step, input.move.snap.origin, "move.snap.step");
+  if (input.resize?.snap)
+    check(
+      input.resize.snap.step,
+      input.resize.snap.target === "grid" ? input.resize.snap.origin : void 0,
+      "resize.snap.step"
+    );
+  if (input.rotate?.snap)
+    check(
+      input.rotate.snap.step,
+      { value: input.rotate.snap.origin },
+      "rotate.snap.step"
+    );
+}
+function boxesEqual(left, right) {
+  return left.left === right.left && left.top === right.top && left.width === right.width && left.height === right.height;
+}
+function result(proposed, applied, snapActive, snapSatisfied, initialRotation = 0, proposedRotation = initialRotation, appliedRotation = proposedRotation) {
+  assertFiniteBox(applied, "applied");
+  if (!Number.isFinite(proposedRotation) || !Number.isFinite(appliedRotation))
+    throw new Error("Rotation exceeds finite coordinates.");
+  return Object.freeze({
+    proposed,
+    applied,
+    snapActive,
+    snapSatisfied,
+    proposedRotation,
+    appliedRotation
+  });
+}
+export {
+  solveManipulation
+};
+//# sourceMappingURL=solve.js.map

package/dist/lib/manipulation/solve.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/manipulation/solve.ts"],
+  "sourcesContent": ["import { assertFiniteBox, assertFinitePoint, freezeBox } from \"./geometry.js\";\nimport {\n  assertFiniteOrigin,\n  assertPositiveFiniteStep,\n  isSnapActive,\n  snapToLattice,\n} from \"./snap.js\";\nimport type {\n  PibblManipulationBox,\n  PibblManipulationMoveSnap,\n  PibblManipulationResizeOptions,\n  PibblManipulationResizeGridSnap,\n  PibblManipulationResizeSizeSnap,\n  PibblResizePosition,\n  ManipulationSolveInput,\n  ManipulationSolveResult,\n} from \"./types.js\";\n\nexport function solveManipulation(\n  input: ManipulationSolveInput,\n): ManipulationSolveResult {\n  assertFiniteBox(input.initial, \"initial\");\n  assertFinitePoint(input.initialPoint, \"initialPoint\");\n  assertFinitePoint(input.currentPoint, \"currentPoint\");\n  validateConfiguredSnaps(input);\n  if (!Number.isFinite(input.initialRotation ?? 0))\n    throw new Error(\"initialRotation must be finite.\");\n\n  switch (input.operation) {\n    case \"move\":\n      return solveMove(input);\n    case \"resize\":\n      return solveResize(input);\n    case \"rotate\":\n      return solveRotation(input);\n  }\n}\n\nfunction solveMove(input: ManipulationSolveInput): ManipulationSolveResult {\n  const { initial } = input;\n  const axis = input.move?.axis ?? \"both\";\n  if (input.move?.bounds) {\n    assertFiniteBox(input.move.bounds, \"move.bounds\");\n    if (\n      !containsRotated(input.move.bounds, initial, input.initialRotation ?? 0)\n    )\n      throw new Error(\"Move bounds must contain the initial box.\");\n  }\n  const deltaX = input.currentPoint.x - input.initialPoint.x;\n  const deltaY = input.currentPoint.y - input.initialPoint.y;\n  const proposed = freezeBox({\n    ...initial,\n    left: axis === \"y\" ? initial.left : initial.left + deltaX,\n    top: axis === \"x\" ? initial.top : initial.top + deltaY,\n  });\n  const snap = input.move?.snap;\n  const snapActive =\n    snap !== undefined &&\n    isSnapActive(snap.enabled, snap.when, input.modifiers);\n  if (!snapActive)\n    return result(\n      proposed,\n      clampMoveToBounds(\n        proposed,\n        input.move?.bounds,\n        input.initialRotation ?? 0,\n      ),\n      false,\n      true,\n      input.initialRotation,\n    );\n\n  const [stepX, stepY] = moveSteps(snap!);\n  const origin = snap!.origin;\n  const applied = freezeBox({\n    ...proposed,\n    left:\n      axis === \"y\"\n        ? proposed.left\n        : snapToLattice(proposed.left, stepX, origin?.x ?? 0),\n    top:\n      axis === \"x\"\n        ? proposed.top\n        : snapToLattice(proposed.top, stepY, origin?.y ?? 0),\n  });\n  const bounded = clampMoveToBounds(\n    applied,\n    input.move?.bounds,\n    input.initialRotation ?? 0,\n  );\n  return result(\n    proposed,\n    bounded,\n    true,\n    boxesEqual(applied, bounded),\n    input.initialRotation,\n  );\n}\n\nfunction solveResize(input: ManipulationSolveInput): ManipulationSolveResult {\n  const handle = input.handle;\n  if (!handle) throw new Error(\"Resize manipulation requires a handle.\");\n  const rotation = input.initialRotation ?? 0;\n  if (!Number.isFinite(rotation))\n    throw new Error(\"initialRotation must be finite.\");\n  if (input.resize?.snap?.target === \"grid\" && rotation !== 0)\n    throw new Error(\"Grid resize snapping requires an unrotated box.\");\n  const raw = resizeFromPoint(\n    input.initial,\n    handle,\n    rotateInverse(\n      {\n        x: input.currentPoint.x - input.initialPoint.x,\n        y: input.currentPoint.y - input.initialPoint.y,\n      },\n      rotation,\n    ),\n  );\n  const proposed = resizeFromDimensionsRotated(\n    input.initial,\n    handle,\n    raw.width,\n    raw.height,\n    rotation,\n  );\n  const ratio = activeRatio(input.initial, input.resize, input.modifiers);\n  const changesWidth = handle.includes(\"left\") || handle.includes(\"right\");\n  const changesHeight = handle.includes(\"top\") || handle.includes(\"bottom\");\n  const constraints = resolvedResizeConstraints(input.resize);\n  if (ratio === undefined) {\n    if (!changesWidth) {\n      if (\n        input.initial.width < constraints.minWidth ||\n        input.initial.width > constraints.maxWidth\n      )\n        throw new Error(\n          \"Resize width constraints conflict with the fixed dimension.\",\n        );\n      constraints.minWidth = constraints.maxWidth = input.initial.width;\n    }\n    if (!changesHeight) {\n      if (\n        input.initial.height < constraints.minHeight ||\n        input.initial.height > constraints.maxHeight\n      )\n        throw new Error(\n          \"Resize height constraints conflict with the fixed dimension.\",\n        );\n      constraints.minHeight = constraints.maxHeight = input.initial.height;\n    }\n  }\n  const snap = input.resize?.snap;\n  const snapActive =\n    snap !== undefined &&\n    isSnapActive(snap.enabled, snap.when, input.modifiers);\n  let width = raw.width;\n  let height = raw.height;\n  if (ratio !== undefined) {\n    const widthDrives =\n      changesWidth &&\n      (!changesHeight ||\n        Math.abs(raw.width / input.initial.width - 1) >=\n          Math.abs(raw.height / input.initial.height - 1));\n    if (snapActive) {\n      const snapped = snapResize(input.initial, raw, handle, snap!);\n      if (widthDrives) width = snapped.width;\n      else height = snapped.height;\n    }\n    if (widthDrives) height = width / ratio;\n    else width = height * ratio;\n  } else if (snapActive) {\n    const snapped = snapResize(input.initial, raw, handle, snap!);\n    width = snapped.width;\n    height = snapped.height;\n  }\n  const bounded = constrainDimensions(\n    input.initial,\n    handle,\n    { width, height },\n    rotation,\n    input.resize?.bounds,\n    ratio,\n    constraints,\n  );\n  const applied = resizeFromDimensionsRotated(\n    input.initial,\n    handle,\n    bounded.width,\n    bounded.height,\n    rotation,\n  );\n  const onLattice = (value: number, step: number, origin = 0) =>\n    Math.abs(value - snapToLattice(value, step, origin)) <=\n    1e-9 * Math.max(1, Math.abs(value));\n  let snapSatisfied = true;\n  if (snapActive) {\n    if (snap!.target === \"grid\") {\n      const grid = snap as PibblManipulationResizeGridSnap;\n      const [stepX, stepY] = gridSteps(grid);\n      snapSatisfied =\n        (!changesWidth ||\n          onLattice(\n            handle.includes(\"left\")\n              ? applied.left\n              : applied.left + applied.width,\n            stepX,\n            grid.origin?.x,\n          )) &&\n        (!changesHeight ||\n          onLattice(\n            handle.includes(\"top\") ? applied.top : applied.top + applied.height,\n            stepY,\n            grid.origin?.y,\n          ));\n    } else {\n      const [stepWidth, stepHeight] = sizeSteps(\n        snap as PibblManipulationResizeSizeSnap,\n      );\n      snapSatisfied =\n        (!(changesWidth || ratio !== undefined) ||\n          onLattice(applied.width, stepWidth)) &&\n        (!(changesHeight || ratio !== undefined) ||\n          onLattice(applied.height, stepHeight));\n    }\n  }\n  return result(proposed, applied, snapActive, snapSatisfied, rotation);\n}\n\nfunction solveRotation(input: ManipulationSolveInput): ManipulationSolveResult {\n  const initialRotation = input.initialRotation ?? 0;\n  const delta = input.rotationDelta ?? 0;\n  if (!Number.isFinite(initialRotation) || !Number.isFinite(delta)) {\n    throw new Error(\"Rotation values must be finite.\");\n  }\n  const proposedRotation = initialRotation + delta;\n  const snap = input.rotate?.snap;\n  const snapActive =\n    snap !== undefined &&\n    isSnapActive(snap.enabled, snap.when, input.modifiers);\n  const appliedRotation = snapActive\n    ? snapToLattice(proposedRotation, snap!.step, snap!.origin ?? 0)\n    : proposedRotation;\n  return result(\n    input.initial,\n    input.initial,\n    snapActive,\n    true,\n    initialRotation,\n    proposedRotation,\n    appliedRotation,\n  );\n}\n\nfunction resizeFromPoint(\n  initial: PibblManipulationBox,\n  handle: PibblResizePosition,\n  delta: Readonly<{ x: number; y: number }>,\n): PibblManipulationBox {\n  const movesLeft = handle.includes(\"left\");\n  const movesRight = handle.includes(\"right\");\n  const movesTop = handle.includes(\"top\");\n  const movesBottom = handle.includes(\"bottom\");\n  return freezeBox({\n    left: movesLeft ? initial.left + delta.x : initial.left,\n    top: movesTop ? initial.top + delta.y : initial.top,\n    width:\n      initial.width + (movesRight ? delta.x : 0) - (movesLeft ? delta.x : 0),\n    height:\n      initial.height + (movesBottom ? delta.y : 0) - (movesTop ? delta.y : 0),\n  });\n}\n\nfunction resizeFromDimensions(\n  initial: PibblManipulationBox,\n  handle: PibblResizePosition,\n  width: number,\n  height: number,\n): PibblManipulationBox {\n  return freezeBox({\n    left: handle.includes(\"left\")\n      ? initial.left + initial.width - width\n      : initial.left,\n    top: handle.includes(\"top\")\n      ? initial.top + initial.height - height\n      : initial.top,\n    width,\n    height,\n  });\n}\n\nfunction snapResize(\n  initial: PibblManipulationBox,\n  proposed: PibblManipulationBox,\n  handle: PibblResizePosition,\n  snap: PibblManipulationResizeSizeSnap | PibblManipulationResizeGridSnap,\n): PibblManipulationBox {\n  if (snap.target === \"grid\") {\n    const [stepX, stepY] = gridSteps(snap);\n    const origin = snap.origin;\n    const movesLeft = handle.includes(\"left\");\n    const movesTop = handle.includes(\"top\");\n    const edgeX = movesLeft ? proposed.left : proposed.left + proposed.width;\n    const edgeY = movesTop ? proposed.top : proposed.top + proposed.height;\n    const snappedEdgeX = snapToLattice(edgeX, stepX, origin?.x ?? 0);\n    const snappedEdgeY = snapToLattice(edgeY, stepY, origin?.y ?? 0);\n    const width = !(handle.includes(\"left\") || handle.includes(\"right\"))\n      ? initial.width\n      : movesLeft\n        ? initial.left + initial.width - snappedEdgeX\n        : snappedEdgeX - initial.left;\n    const height = !(handle.includes(\"top\") || handle.includes(\"bottom\"))\n      ? initial.height\n      : movesTop\n        ? initial.top + initial.height - snappedEdgeY\n        : snappedEdgeY - initial.top;\n    return resizeFromDimensions(initial, handle, width, height);\n  }\n  const [stepWidth, stepHeight] = sizeSteps(snap);\n  return resizeFromDimensions(\n    proposed,\n    handle,\n    handle.includes(\"left\") || handle.includes(\"right\")\n      ? snapToLattice(proposed.width, stepWidth)\n      : proposed.width,\n    handle.includes(\"top\") || handle.includes(\"bottom\")\n      ? snapToLattice(proposed.height, stepHeight)\n      : proposed.height,\n  );\n}\n\nfunction moveSteps(snap: PibblManipulationMoveSnap): readonly [number, number] {\n  return typeof snap.step === \"number\"\n    ? [snap.step, snap.step]\n    : [snap.step.x, snap.step.y];\n}\n\nfunction sizeSteps(\n  snap: PibblManipulationResizeSizeSnap,\n): readonly [number, number] {\n  return typeof snap.step === \"number\"\n    ? [snap.step, snap.step]\n    : [snap.step.width, snap.step.height];\n}\n\nfunction gridSteps(\n  snap: PibblManipulationResizeGridSnap,\n): readonly [number, number] {\n  return typeof snap.step === \"number\"\n    ? [snap.step, snap.step]\n    : [snap.step.x, snap.step.y];\n}\n\nfunction resolvedResizeConstraints(\n  options: PibblManipulationResizeOptions | undefined,\n): {\n  minWidth: number;\n  minHeight: number;\n  maxWidth: number;\n  maxHeight: number;\n} {\n  for (const name of [\n    \"minWidth\",\n    \"minHeight\",\n    \"maxWidth\",\n    \"maxHeight\",\n  ] as const) {\n    const value = options?.[name];\n    if (value !== undefined && (!Number.isFinite(value) || value <= 0))\n      throw new Error(`${name} must be positive and finite.`);\n  }\n  const minWidth = options?.minWidth ?? 1;\n  const minHeight = options?.minHeight ?? 1;\n  const maxWidth = options?.maxWidth ?? Number.POSITIVE_INFINITY;\n  const maxHeight = options?.maxHeight ?? Number.POSITIVE_INFINITY;\n  for (const [name, value] of Object.entries({\n    minWidth,\n    minHeight,\n    maxWidth,\n    maxHeight,\n  })) {\n    if (!Number.isFinite(value) && value !== Number.POSITIVE_INFINITY) {\n      throw new Error(`${name} must be finite, received ${value}`);\n    }\n  }\n  if (minWidth <= 0 || minHeight <= 0 || maxWidth <= 0 || maxHeight <= 0) {\n    throw new Error(\"Resize constraints must be greater than zero.\");\n  }\n  if (minWidth > maxWidth || minHeight > maxHeight) {\n    throw new Error(\n      \"Resize minimum dimensions must not exceed maximum dimensions.\",\n    );\n  }\n  return { minWidth, minHeight, maxWidth, maxHeight };\n}\n\nfunction clamp(value: number, min: number, max: number): number {\n  return Math.min(max, Math.max(min, value));\n}\n\nfunction clampMoveToBounds(\n  box: PibblManipulationBox,\n  bounds: PibblManipulationBox | undefined,\n  rotation = 0,\n): PibblManipulationBox {\n  if (!bounds) return box;\n  assertFiniteBox(bounds, \"move.bounds\");\n  const corners = rotatedCorners(box, rotation);\n  const minX = Math.min(...corners.map((point) => point.x));\n  const maxX = Math.max(...corners.map((point) => point.x));\n  const minY = Math.min(...corners.map((point) => point.y));\n  const maxY = Math.max(...corners.map((point) => point.y));\n  if (maxX - minX > bounds.width || maxY - minY > bounds.height)\n    throw new Error(\"Move bounds cannot contain the initial box.\");\n  return freezeBox({\n    ...box,\n    left:\n      box.left +\n      clamp(0, bounds.left - minX, bounds.left + bounds.width - maxX),\n    top:\n      box.top + clamp(0, bounds.top - minY, bounds.top + bounds.height - maxY),\n  });\n}\n\nfunction activeRatio(\n  initial: PibblManipulationBox,\n  options: PibblManipulationResizeOptions | undefined,\n  modifiers: ManipulationSolveInput[\"modifiers\"],\n): number | undefined {\n  const aspect = options?.aspectRatio;\n  if (!aspect) return undefined;\n  const ratio =\n    aspect.value === \"initial\" ? initial.width / initial.height : aspect.value;\n  if (!Number.isFinite(ratio) || ratio <= 0)\n    throw new Error(\n      \"Resize aspect ratio must be finite and greater than zero.\",\n    );\n  return isSnapActive(true, aspect.when, modifiers) ? ratio : undefined;\n}\n\nfunction rotateInverse(\n  point: Readonly<{ x: number; y: number }>,\n  radians: number,\n): Readonly<{ x: number; y: number }> {\n  const cosine = Math.cos(radians);\n  const sine = Math.sin(radians);\n  return {\n    x: point.x * cosine + point.y * sine,\n    y: -point.x * sine + point.y * cosine,\n  };\n}\n\nfunction resizeFromDimensionsRotated(\n  initial: PibblManipulationBox,\n  handle: PibblResizePosition,\n  width: number,\n  height: number,\n  radians: number,\n): PibblManipulationBox {\n  const oldCenter = {\n    x: initial.left + initial.width / 2,\n    y: initial.top + initial.height / 2,\n  };\n  const opposite = {\n    x: handle.includes(\"left\")\n      ? initial.width / 2\n      : handle.includes(\"right\")\n        ? -initial.width / 2\n        : 0,\n    y: handle.includes(\"top\")\n      ? initial.height / 2\n      : handle.includes(\"bottom\")\n        ? -initial.height / 2\n        : 0,\n  };\n  const cosine = Math.cos(radians);\n  const sine = Math.sin(radians);\n  const anchor = {\n    x: oldCenter.x + opposite.x * cosine - opposite.y * sine,\n    y: oldCenter.y + opposite.x * sine + opposite.y * cosine,\n  };\n  const nextOpposite = {\n    x: handle.includes(\"left\")\n      ? width / 2\n      : handle.includes(\"right\")\n        ? -width / 2\n        : 0,\n    y: handle.includes(\"top\")\n      ? height / 2\n      : handle.includes(\"bottom\")\n        ? -height / 2\n        : 0,\n  };\n  const center = {\n    x: anchor.x - (nextOpposite.x * cosine - nextOpposite.y * sine),\n    y: anchor.y - (nextOpposite.x * sine + nextOpposite.y * cosine),\n  };\n  return freezeBox({\n    left: center.x - width / 2,\n    top: center.y - height / 2,\n    width,\n    height,\n  });\n}\n\nfunction constrainDimensions(\n  initial: PibblManipulationBox,\n  handle: PibblResizePosition,\n  proposed: SizePoint,\n  rotation: number,\n  bounds: PibblManipulationBox | undefined,\n  ratio: number | undefined,\n  constraints: ReturnType<typeof resolvedResizeConstraints>,\n): SizePoint {\n  if (!Number.isFinite(proposed.width) || !Number.isFinite(proposed.height))\n    throw new Error(\"Resize geometry exceeds finite coordinates.\");\n  if (bounds) {\n    assertFiniteBox(bounds, \"resize.bounds\");\n    if (!containsRotated(bounds, initial, rotation))\n      throw new Error(\"Resize bounds must contain the initial box.\");\n  }\n  if (ratio !== undefined) {\n    let minimum = Math.max(constraints.minWidth, constraints.minHeight * ratio);\n    let maximum = Math.min(constraints.maxWidth, constraints.maxHeight * ratio);\n    for (const plane of bounds\n      ? boundsPlanes(initial, handle, rotation, bounds)\n      : []) {\n      const slope = plane.a + plane.b / ratio;\n      if (Math.abs(slope) < 1e-12) {\n        if (plane.c < -1e-9)\n          throw new Error(\"Resize bounds have no feasible ratio.\");\n      } else if (slope > 0) maximum = Math.min(maximum, plane.c / slope);\n      else minimum = Math.max(minimum, plane.c / slope);\n    }\n    if (minimum > maximum)\n      throw new Error(\n        \"Resize constraints cannot satisfy the aspect ratio and bounds.\",\n      );\n    const width = clamp(proposed.width, minimum, maximum);\n    return { width, height: width / ratio };\n  }\n  if (bounds)\n    return projectSizeToBounds(\n      initial,\n      handle,\n      proposed,\n      rotation,\n      bounds,\n      constraints,\n    );\n  return {\n    width: clamp(proposed.width, constraints.minWidth, constraints.maxWidth),\n    height: clamp(\n      proposed.height,\n      constraints.minHeight,\n      constraints.maxHeight,\n    ),\n  };\n}\n\ntype SizePoint = Readonly<{ width: number; height: number }>;\ntype HalfPlane = Readonly<{ a: number; b: number; c: number }>;\n\nfunction projectSizeToBounds(\n  initial: PibblManipulationBox,\n  handle: PibblResizePosition,\n  proposed: SizePoint,\n  rotation: number,\n  bounds: PibblManipulationBox,\n  constraints: ReturnType<typeof resolvedResizeConstraints>,\n): SizePoint {\n  const maximumWidth = Number.isFinite(constraints.maxWidth)\n    ? constraints.maxWidth\n    : Math.max(initial.width, bounds.width + bounds.height);\n  const maximumHeight = Number.isFinite(constraints.maxHeight)\n    ? constraints.maxHeight\n    : Math.max(initial.height, bounds.width + bounds.height);\n  let polygon: SizePoint[] = [\n    { width: constraints.minWidth, height: constraints.minHeight },\n    { width: maximumWidth, height: constraints.minHeight },\n    { width: maximumWidth, height: maximumHeight },\n    { width: constraints.minWidth, height: maximumHeight },\n  ];\n  const planes = boundsPlanes(initial, handle, rotation, bounds);\n  for (const plane of planes) polygon = clipPolygon(polygon, plane);\n  if (polygon.length === 0)\n    throw new Error(\"Resize bounds have no feasible size region.\");\n  return closestPointInPolygon(\n    { width: proposed.width, height: proposed.height },\n    polygon,\n  );\n}\n\nfunction boundsPlanes(\n  initial: PibblManipulationBox,\n  handle: PibblResizePosition,\n  rotation: number,\n  bounds: PibblManipulationBox,\n): readonly HalfPlane[] {\n  const zero = resizeFromDimensionsRotated(initial, handle, 0, 0, rotation);\n  const unitWidth = resizeFromDimensionsRotated(\n    initial,\n    handle,\n    1,\n    0,\n    rotation,\n  );\n  const unitHeight = resizeFromDimensionsRotated(\n    initial,\n    handle,\n    0,\n    1,\n    rotation,\n  );\n  const planes: HalfPlane[] = [];\n  const zeroCorners = rotatedCorners(zero, rotation);\n  const widthCorners = rotatedCorners(unitWidth, rotation);\n  const heightCorners = rotatedCorners(unitHeight, rotation);\n  for (let index = 0; index < 4; index++) {\n    for (const [coordinate, lower, upper] of [\n      [\"x\", bounds.left, bounds.left + bounds.width],\n      [\"y\", bounds.top, bounds.top + bounds.height],\n    ] as const) {\n      const constant = zeroCorners[index][coordinate];\n      const a = widthCorners[index][coordinate] - constant;\n      const b = heightCorners[index][coordinate] - constant;\n      planes.push(\n        { a, b, c: upper - constant },\n        { a: -a, b: -b, c: constant - lower },\n      );\n    }\n  }\n  return planes;\n}\n\nfunction clipPolygon(\n  points: readonly SizePoint[],\n  plane: HalfPlane,\n): SizePoint[] {\n  const output: SizePoint[] = [];\n  for (let index = 0; index < points.length; index++) {\n    const from = points[index];\n    const to = points[(index + 1) % points.length];\n    const fromValue = plane.a * from.width + plane.b * from.height - plane.c;\n    const toValue = plane.a * to.width + plane.b * to.height - plane.c;\n    if (fromValue <= 0) output.push(from);\n    if (fromValue <= 0 !== toValue <= 0) {\n      const t = fromValue / (fromValue - toValue);\n      output.push({\n        width: from.width + (to.width - from.width) * t,\n        height: from.height + (to.height - from.height) * t,\n      });\n    }\n  }\n  return output;\n}\n\nfunction closestPointInPolygon(\n  point: SizePoint,\n  polygon: readonly SizePoint[],\n): SizePoint {\n  const area = polygon.reduce((sum, candidate, index) => {\n    const next = polygon[(index + 1) % polygon.length];\n    return sum + candidate.width * next.height - next.width * candidate.height;\n  }, 0);\n  if (\n    Math.abs(area) > 1e-12 &&\n    polygon.every((candidate, index) => {\n      const next = polygon[(index + 1) % polygon.length];\n      return (\n        (next.width - candidate.width) * (point.height - candidate.height) -\n          (next.height - candidate.height) * (point.width - candidate.width) >=\n        -1e-9\n      );\n    })\n  )\n    return point;\n  let best = polygon[0];\n  let distance = Number.POSITIVE_INFINITY;\n  for (let index = 0; index < polygon.length; index++) {\n    const from = polygon[index];\n    const to = polygon[(index + 1) % polygon.length];\n    const dx = to.width - from.width;\n    const dy = to.height - from.height;\n    const scale =\n      dx === 0 && dy === 0\n        ? 0\n        : clamp(\n            ((point.width - from.width) * dx +\n              (point.height - from.height) * dy) /\n              (dx * dx + dy * dy),\n            0,\n            1,\n          );\n    const candidate = {\n      width: from.width + dx * scale,\n      height: from.height + dy * scale,\n    };\n    const nextDistance =\n      (candidate.width - point.width) ** 2 +\n      (candidate.height - point.height) ** 2;\n    if (\n      nextDistance < distance ||\n      (nextDistance === distance &&\n        (candidate.width > best.width ||\n          (candidate.width === best.width && candidate.height > best.height)))\n    ) {\n      best = candidate;\n      distance = nextDistance;\n    }\n  }\n  return best;\n}\n\nfunction containsRotated(\n  bounds: PibblManipulationBox,\n  box: PibblManipulationBox,\n  radians: number,\n): boolean {\n  return rotatedCorners(box, radians).every(\n    (point) =>\n      point.x >= bounds.left &&\n      point.x <= bounds.left + bounds.width &&\n      point.y >= bounds.top &&\n      point.y <= bounds.top + bounds.height,\n  );\n}\n\nfunction rotatedCorners(\n  box: PibblManipulationBox,\n  radians: number,\n): readonly Readonly<{ x: number; y: number }>[] {\n  const center = { x: box.left + box.width / 2, y: box.top + box.height / 2 };\n  const cosine = Math.cos(radians);\n  const sine = Math.sin(radians);\n  return [\n    [-box.width / 2, -box.height / 2],\n    [box.width / 2, -box.height / 2],\n    [box.width / 2, box.height / 2],\n    [-box.width / 2, box.height / 2],\n  ].map(([x, y]) => ({\n    x: center.x + x * cosine - y * sine,\n    y: center.y + x * sine + y * cosine,\n  }));\n}\n\nfunction validateConfiguredSnaps(input: ManipulationSolveInput): void {\n  const check = (\n    step: number | Readonly<Record<string, number>>,\n    origin: Readonly<Record<string, number | undefined>> | undefined,\n    label: string,\n  ) => {\n    for (const [name, value] of Object.entries(\n      typeof step === \"number\" ? { value: step } : step,\n    ))\n      assertPositiveFiniteStep(value, `${label}.${name}`);\n    for (const [name, value] of Object.entries(origin ?? {}))\n      if (value !== undefined)\n        assertFiniteOrigin(value, `${label}.origin.${name}`);\n  };\n  if (input.move?.snap)\n    check(input.move.snap.step, input.move.snap.origin, \"move.snap.step\");\n  if (input.resize?.snap)\n    check(\n      input.resize.snap.step,\n      input.resize.snap.target === \"grid\"\n        ? input.resize.snap.origin\n        : undefined,\n      \"resize.snap.step\",\n    );\n  if (input.rotate?.snap)\n    check(\n      input.rotate.snap.step,\n      { value: input.rotate.snap.origin },\n      \"rotate.snap.step\",\n    );\n}\n\nfunction boxesEqual(\n  left: PibblManipulationBox,\n  right: PibblManipulationBox,\n): boolean {\n  return (\n    left.left === right.left &&\n    left.top === right.top &&\n    left.width === right.width &&\n    left.height === right.height\n  );\n}\n\nfunction result(\n  proposed: PibblManipulationBox,\n  applied: PibblManipulationBox,\n  snapActive: boolean,\n  snapSatisfied: boolean,\n  initialRotation = 0,\n  proposedRotation = initialRotation,\n  appliedRotation = proposedRotation,\n): ManipulationSolveResult {\n  assertFiniteBox(applied, \"applied\");\n  if (!Number.isFinite(proposedRotation) || !Number.isFinite(appliedRotation))\n    throw new Error(\"Rotation exceeds finite coordinates.\");\n  return Object.freeze({\n    proposed,\n    applied,\n    snapActive,\n    snapSatisfied,\n    proposedRotation,\n    appliedRotation,\n  });\n}\n"],
+  "mappings": "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",
+  "names": []
+}