@popcraft/kit 0.31.0 → 0.32.1

package/dist/chunks/chunk-74UIMI6P.js

@@ -1,930 +0,0 @@
-import { createRequire as __popcraftRequire } from 'node:module';
-import { fileURLToPath as __popcraftPath } from 'node:url';
-import { dirname as __popcraftDirname } from 'node:path';
-const require = __popcraftRequire(import.meta.url);
-const __filename = __popcraftPath(import.meta.url);
-const __dirname = __popcraftDirname(__filename);
-import {
-  animate,
-  ease,
-  shiftPositionKeys
-} from "./chunk-YYQUCS6P.js";
-import {
-  UNIT_DEFAULTS,
-  animatorPath,
-  isTextNode,
-  withAnimator
-} from "./chunk-QZWEMMEL.js";
-import {
-  frameMotionEnd,
-  frameTimeline
-} from "./chunk-XDMQ6YHY.js";
-import {
-  addMarker,
-  updateMarker
-} from "./chunk-6YRHCDDT.js";
-import {
-  hostFrameOf
-} from "./chunk-PXXO7PQR.js";
-import {
-  asPath,
-  init_properties,
-  readPath
-} from "./chunk-4VICNBUI.js";
-import {
-  init_time,
-  staggerRanks,
-  timeShift
-} from "./chunk-RW67KLLE.js";
-import {
-  init_scene3d,
-  is3DContext
-} from "./chunk-NMFXCSU4.js";
-import {
-  init_transform3d,
-  zoomPx
-} from "./chunk-CK43FENV.js";
-import {
-  init_define_POPCRAFT_COMPONENT_IDS
-} from "./chunk-FFS4SO7R.js";
-
-// lib/motion/presets.ts
-init_define_POPCRAFT_COMPONENT_IDS();
-init_properties();
-init_time();
-init_scene3d();
-init_transform3d();
-var PRESET_IDS = [
-  "fade-in",
-  "rise-in",
-  "drop-in",
-  "pop-in",
-  "scale-in",
-  "slide-in",
-  "wipe-in",
-  "blur-in",
-  "fade-out",
-  "rise-out",
-  "drop-out",
-  "pop-out",
-  "scale-out",
-  "slide-out",
-  "wipe-out",
-  "blur-out",
-  "pulse",
-  "shake",
-  "bounce",
-  "wobble",
-  "flash",
-  "impact-frame",
-  "push-in",
-  "pull-out",
-  "dolly",
-  "drift",
-  "zoom-through",
-  "truck",
-  "crane",
-  "pan",
-  "orbit",
-  "camera-shake",
-  "whip-pan",
-  "typewriter",
-  "letters-in",
-  "words-in",
-  "lines-in",
-  "letters-out",
-  "words-out",
-  "lines-out"
-];
-var num = (n, path, fallback) => {
-  const v = readPath(n, asPath(path));
-  return typeof v === "number" ? v : fallback;
-};
-var restOpacity = (n) => num(n, "opacity", 1);
-var overshoots = (i) => i.kind === "spring" || i.kind === "ease" && /^(back|elastic)-/.test(i.name);
-var fadeCurve = (i, dir) => overshoots(i) ? ease.named("cubic", dir) : i;
-var span = (path, a, b, p, curve = p.ease) => ({ path, keys: [{ t: 0, v: a, ease: curve }, { t: p.duration, v: b }] });
-var enter = (n, path, from, p, curve) => span(path, from, num(n, path, 0), p, curve);
-var leave = (n, path, to, p, curve) => span(path, num(n, path, 0), to, p, curve);
-var fadeIn = (n, p) => span("opacity", 0, restOpacity(n), p, fadeCurve(p.ease, "out"));
-var fadeOut = (n, p) => span("opacity", restOpacity(n), 0, p, fadeCurve(p.ease, "in"));
-var along = (dir, d) => dir === "left" ? { path: "translateX", by: -d } : dir === "right" ? { path: "translateX", by: d } : dir === "up" ? { path: "translateY", by: -d } : { path: "translateY", by: d };
-var scaleSpan = (n, a, b, p, curve) => {
-  const sx = num(n, "scaleX", 1), sy = num(n, "scaleY", 1);
-  return [span("scaleX", sx * a, sx * b, p, curve), span("scaleY", sy * a, sy * b, p, curve)];
-};
-var wave = (n, path, points, p, curve, rest = num(n, path, 0)) => ({ path, keys: points.map(([f, dv], i) => ({ t: f * p.duration, v: rest + dv, ...i < points.length - 1 ? { ease: curve } : {} })) });
-var BLUR_ID = "motion-blur";
-function withBlur(n) {
-  const effects = n.effects ?? [];
-  if (effects.some((e) => e.type === "LAYER_BLUR" && e.id)) return n;
-  return { ...n, effects: [...effects, { type: "LAYER_BLUR", radius: 0, visible: true, id: BLUR_ID }] };
-}
-function blurPath(n) {
-  const e = (n.effects ?? []).find((x) => x.type === "LAYER_BLUR" && x.id);
-  return `effects[@${e.id}].radius`;
-}
-var SMEAR_ID = "motion-smear";
-function withSmear(n, angle) {
-  const effects = n.effects ?? [];
-  const at = effects.findIndex((e) => e.type === "MOTION_BLUR" && e.id);
-  if (at >= 0) return { ...n, effects: effects.map((e, i) => i === at ? { ...e, angle } : e) };
-  return { ...n, effects: [...effects, { type: "MOTION_BLUR", radius: 0, angle, visible: true, id: SMEAR_ID }] };
-}
-function smearPath(n) {
-  const e = (n.effects ?? []).find((x) => x.type === "MOTION_BLUR" && x.id);
-  return `effects[@${e.id}].radius`;
-}
-var SHAKE_STEPS = 12;
-var SHAKE = (() => {
-  let seed = 23118;
-  const rnd = () => {
-    seed = Math.imul(seed, 1103515245) + 12345 >>> 0;
-    return seed / 2 ** 32 * 2 - 1;
-  };
-  const out = [[0, 0, 0, 0]];
-  for (let i = 1; i < SHAKE_STEPS; i++) {
-    const k = 1 - i / SHAKE_STEPS;
-    const sx = i % 2 ? 1 : -1;
-    out.push([i / SHAKE_STEPS, sx * k * (0.55 + 0.45 * Math.abs(rnd())), k * rnd(), k * rnd()]);
-  }
-  out.push([1, 0, 0, 0]);
-  return out;
-})();
-var clips = (n) => "clipsContent" in n || n.type === "FRAME";
-var clipping = (n) => !clips(n) || n.clipsContent ? n : { ...n, clipsContent: true };
-var WIPE_MIN = 0.01;
-function wipe(n, p, open) {
-  const w = num(n, "width", 0), tx = num(n, "translateX", 0);
-  const [a, b] = open ? [WIPE_MIN, w] : [w, WIPE_MIN];
-  const out = [span("width", a, b, p)];
-  if (p.direction === "left") out.push(open ? span("translateX", tx + w - WIPE_MIN, tx, p) : span("translateX", tx, tx + w - WIPE_MIN, p));
-  return out;
-}
-function maskWipe(m, p, open) {
-  const horizontal = p.direction === "left" || p.direction === "right";
-  const size = horizontal ? "width" : "height", shift = horizontal ? "translateX" : "translateY";
-  const full = num(m, size, 0), t0 = num(m, shift, 0);
-  const [a, b] = open ? [WIPE_MIN, full] : [full, WIPE_MIN];
-  const out = [span(size, a, b, p)];
-  if (p.direction === "left" || p.direction === "up") out.push(open ? span(shift, t0 + full - WIPE_MIN, t0, p) : span(shift, t0, t0 + full - WIPE_MIN, p));
-  return out;
-}
-var wipeGroupId = (layerId) => `${layerId}-wipe`;
-var wipeMaskId = (layerId) => `${layerId}-wipe-mask`;
-function ensureWipeMask(nodes, id, hostFrameId) {
-  const n = nodes[id];
-  const maskId = wipeMaskId(id);
-  if (nodes[maskId]) return { nodes, maskId };
-  const mask = (parentId, w, h) => ({
-    id: maskId,
-    type: "RECTANGLE",
-    name: "Wipe mask",
-    x: 0,
-    y: 0,
-    width: w,
-    height: h,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId,
-    childIds: [],
-    isMask: true,
-    maskType: "ALPHA",
-    fills: [{ type: "SOLID", color: { r: 1, g: 1, b: 1, a: 1 }, opacity: 1, visible: true }],
-    strokes: [],
-    cornerRadius: 0,
-    blendMode: "NORMAL",
-    layoutPositioning: "ABSOLUTE"
-  });
-  if (id === hostFrameId) {
-    return { nodes: { ...nodes, [maskId]: mask(id, n.width, n.height), [id]: { ...n, childIds: [maskId, ...n.childIds] } }, maskId };
-  }
-  const parent = n.parentId ? nodes[n.parentId] : void 0;
-  if (!parent) return { nodes, maskId };
-  const gid = wipeGroupId(id);
-  const group = {
-    id: gid,
-    type: "GROUP",
-    name: `${n.name || "Layer"} wipe`,
-    x: n.x,
-    y: n.y,
-    width: n.width,
-    height: n.height,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: parent.id,
-    childIds: [maskId, id],
-    blendMode: "NORMAL",
-    isMaskGroup: true,
-    ...n.layoutPositioning ? { layoutPositioning: n.layoutPositioning } : {}
-  };
-  const moved = { ...n, parentId: gid, x: 0, y: 0, motion: shiftPositionKeys(n.motion, -n.x, -n.y) };
-  if (!moved.motion) delete moved.motion;
-  return {
-    nodes: {
-      ...nodes,
-      [gid]: group,
-      [maskId]: mask(gid, n.width, n.height),
-      [id]: moved,
-      [parent.id]: { ...parent, childIds: parent.childIds.map((c) => c === id ? gid : c) }
-    },
-    maskId
-  };
-}
-var any = () => true;
-var CONTAINERS = /* @__PURE__ */ new Set(["FRAME", "GROUP", "COMPONENT", "INSTANCE", "SECTION"]);
-var isContainer = (n) => CONTAINERS.has(n.type) && n.childIds.length > 0;
-var autoRise = (n) => Math.max(24, Math.min(n.width, n.height) * 0.5);
-var CAM = "scene3d.camera.";
-var zoomOf = (n) => zoomPx(num(n, `${CAM}focalLength`, 50), n.width);
-var camTravel = (n, axis, by, p) => {
-  const r = num(n, CAM + axis, 0);
-  return span(CAM + axis, r, r + by, p);
-};
-var camArrive = (n, axis, by, p) => {
-  const r = num(n, CAM + axis, 0);
-  return span(CAM + axis, r + by, r, p);
-};
-var dollyAxis = (dir, d) => dir === "left" ? { axis: "x", by: -d } : dir === "right" ? { axis: "x", by: d } : dir === "up" ? { axis: "z", by: -d } : { axis: "z", by: d };
-function crane(n, p) {
-  const dy = p.direction === "down" ? p.distance : -p.distance;
-  const tilt = Math.atan2(-dy, zoomOf(n)) * 180 / Math.PI;
-  const r = num(n, `${CAM}rotateX`, 0);
-  return [camTravel(n, "y", dy, p), span(`${CAM}rotateX`, r, r + tilt, p)];
-}
-var cameraOrGroup = (n) => is3DContext(n) || isContainer(n);
-var isPlainText = (n) => isTextNode(n) && !n.threadPrevId;
-var TEXT_NEEDS = "a text layer";
-var unitRise = (n, unit) => Math.round((n.fontSize || 16) * UNIT_DEFAULTS[unit].rise);
-var cascade = (id, unit, sign) => (n, p) => isTextNode(n) ? withAnimator(n, { id, unit, range: { start: 0, end: 1, offset: 0 }, amount: 0, order: "forward", stagger: p.amount, props: { opacity: 0, translateY: sign * p.distance } }) : n;
-var cascadeKeys = (id, dir) => (_n, p) => [span(animatorPath(id, "amount"), dir === "in" ? 1 : 0, dir === "in" ? 0 : 1, p)];
-var cascadeAmount = (unit) => ({ label: "Stagger", default: UNIT_DEFAULTS[unit].stagger, min: 0, max: 2e3, step: 5, unit: "ms" });
-function textCascade(unit, dir) {
-  const id = `${unit}s-${dir}`;
-  const name = { letter: "Letters", word: "Words", line: "Lines" }[unit];
-  return {
-    id,
-    category: "text",
-    label: `${name} ${dir}`,
-    duration: dir === "in" ? 600 : 450,
-    description: dir === "in" ? `Each ${unit} rises into place and fades in, one after another` : `Each ${unit} rises away and fades, one after another`,
-    ease: dir === "in" ? ease.out("expo") : ease.named("expo", "in"),
-    distance: "auto",
-    autoDistance: (n) => unitRise(n, unit),
-    amount: cascadeAmount(unit),
-    appliesTo: isPlainText,
-    needs: TEXT_NEEDS,
-    prepare: cascade(id, unit, dir === "in" ? 1 : -1),
-    tracks: cascadeKeys(id, dir)
-  };
-}
-var slideDistance = (n, dir) => dir === "left" || dir === "right" ? n.width : n.height;
-var LIBRARY = [
-  // Entrances: they end at rest.
-  {
-    id: "fade-in",
-    category: "entrance",
-    label: "Fade in",
-    description: "Opacity from 0",
-    duration: 400,
-    ease: ease.out("cubic"),
-    appliesTo: any,
-    tracks: (n, p) => [span("opacity", 0, restOpacity(n), p)]
-  },
-  {
-    id: "rise-in",
-    category: "entrance",
-    label: "Rise",
-    description: "Moves up into place and fades in",
-    duration: 600,
-    ease: ease.out("expo"),
-    distance: "auto",
-    appliesTo: any,
-    tracks: (n, p) => [fadeIn(n, p), enter(n, "translateY", num(n, "translateY", 0) + p.distance, p)]
-  },
-  {
-    id: "drop-in",
-    category: "entrance",
-    label: "Drop",
-    description: "Moves down into place and fades in",
-    duration: 600,
-    ease: ease.out("expo"),
-    distance: "auto",
-    appliesTo: any,
-    tracks: (n, p) => [fadeIn(n, p), enter(n, "translateY", num(n, "translateY", 0) - p.distance, p)]
-  },
-  {
-    id: "pop-in",
-    category: "entrance",
-    label: "Pop",
-    description: "Grows from smaller with an overshoot",
-    duration: 500,
-    ease: ease.back(1.7),
-    amount: { label: "From scale", default: 0.6, min: 0, max: 1, step: 0.05 },
-    appliesTo: any,
-    tracks: (n, p) => [fadeIn(n, p), ...scaleSpan(n, p.amount, 1, p)]
-  },
-  {
-    id: "scale-in",
-    category: "entrance",
-    label: "Scale in",
-    description: "Grows from nothing about its anchor",
-    duration: 600,
-    ease: ease.out("expo"),
-    amount: { label: "From scale", default: 0, min: 0, max: 1, step: 0.05 },
-    appliesTo: any,
-    tracks: (n, p) => [fadeIn(n, p), ...scaleSpan(n, p.amount, 1, p)]
-  },
-  {
-    id: "slide-in",
-    category: "entrance",
-    label: "Slide in",
-    description: "Slides in from a side by its own size",
-    duration: 600,
-    ease: ease.out("expo"),
-    direction: "left",
-    distance: "auto",
-    appliesTo: any,
-    tracks: (n, p) => {
-      const a = along(p.direction, p.distance);
-      return [fadeIn(n, p), enter(n, a.path, num(n, a.path, 0) + a.by, p)];
-    }
-  },
-  {
-    id: "wipe-in",
-    category: "entrance",
-    label: "Wipe",
-    description: "Revealed across by an opening mask",
-    duration: 600,
-    ease: ease.out("expo"),
-    direction: "right",
-    appliesTo: any,
-    prepare: clipping,
-    tracks: (n, p) => wipe(n, p, true),
-    mask: (m, p) => maskWipe(m, p, true)
-  },
-  {
-    id: "blur-in",
-    category: "entrance",
-    label: "Blur in",
-    description: "Comes into focus as it fades in",
-    duration: 600,
-    ease: ease.out("cubic"),
-    amount: { label: "Blur", default: 24, min: 0, max: 200, step: 1, unit: "px" },
-    appliesTo: any,
-    prepare: withBlur,
-    tracks: (n, p) => [fadeIn(n, p), span(blurPath(n), p.amount, 0, p)]
-  },
-  // Exits: they start at rest and end hidden (and stay so).
-  {
-    id: "fade-out",
-    category: "exit",
-    label: "Fade out",
-    description: "Opacity to 0",
-    duration: 400,
-    ease: ease.named("cubic", "in"),
-    appliesTo: any,
-    tracks: (n, p) => [span("opacity", restOpacity(n), 0, p)]
-  },
-  {
-    id: "rise-out",
-    category: "exit",
-    label: "Rise out",
-    description: "Moves up and fades away",
-    duration: 500,
-    ease: ease.named("expo", "in"),
-    distance: "auto",
-    appliesTo: any,
-    tracks: (n, p) => [fadeOut(n, p), leave(n, "translateY", num(n, "translateY", 0) - p.distance, p)]
-  },
-  {
-    id: "drop-out",
-    category: "exit",
-    label: "Drop out",
-    description: "Moves down and fades away",
-    duration: 500,
-    ease: ease.named("expo", "in"),
-    distance: "auto",
-    appliesTo: any,
-    tracks: (n, p) => [fadeOut(n, p), leave(n, "translateY", num(n, "translateY", 0) + p.distance, p)]
-  },
-  {
-    id: "pop-out",
-    category: "exit",
-    label: "Pop out",
-    description: "Winds up and shrinks away",
-    duration: 400,
-    ease: ease.back(1.7, "in"),
-    amount: { label: "To scale", default: 0.6, min: 0, max: 1, step: 0.05 },
-    appliesTo: any,
-    tracks: (n, p) => [fadeOut(n, p), ...scaleSpan(n, 1, p.amount, p)]
-  },
-  {
-    id: "scale-out",
-    category: "exit",
-    label: "Scale out",
-    description: "Shrinks to nothing about its anchor",
-    duration: 500,
-    ease: ease.named("expo", "in"),
-    amount: { label: "To scale", default: 0, min: 0, max: 1, step: 0.05 },
-    appliesTo: any,
-    tracks: (n, p) => [fadeOut(n, p), ...scaleSpan(n, 1, p.amount, p)]
-  },
-  {
-    id: "slide-out",
-    category: "exit",
-    label: "Slide out",
-    description: "Slides off toward a side by its own size",
-    duration: 500,
-    ease: ease.named("expo", "in"),
-    direction: "right",
-    distance: "auto",
-    appliesTo: any,
-    tracks: (n, p) => {
-      const a = along(p.direction, p.distance);
-      return [fadeOut(n, p), leave(n, a.path, num(n, a.path, 0) + a.by, p)];
-    }
-  },
-  {
-    id: "wipe-out",
-    category: "exit",
-    label: "Wipe out",
-    description: "Hidden across by a closing mask",
-    duration: 500,
-    ease: ease.named("expo", "in"),
-    direction: "right",
-    appliesTo: any,
-    prepare: clipping,
-    tracks: (n, p) => wipe(n, p, false),
-    mask: (m, p) => maskWipe(m, p, false)
-  },
-  {
-    id: "blur-out",
-    category: "exit",
-    label: "Blur out",
-    description: "Goes out of focus as it fades",
-    duration: 500,
-    ease: ease.named("cubic", "in"),
-    amount: { label: "Blur", default: 24, min: 0, max: 200, step: 1, unit: "px" },
-    appliesTo: any,
-    prepare: withBlur,
-    tracks: (n, p) => [fadeOut(n, p), span(blurPath(n), 0, p.amount, p)]
-  },
-  // Emphasis: from rest, back to rest.
-  {
-    id: "pulse",
-    category: "emphasis",
-    label: "Pulse",
-    description: "Swells and settles, twice",
-    duration: 800,
-    ease: ease.inOut("sine"),
-    amount: { label: "Swell", default: 0.08, min: 0, max: 1, step: 0.01 },
-    appliesTo: any,
-    tracks: (n, p) => ["scaleX", "scaleY"].map((path) => {
-      const r = num(n, path, 1);
-      return wave(n, path, [[0, 0], [0.25, r * p.amount], [0.5, 0], [0.75, r * p.amount], [1, 0]], p, p.ease);
-    })
-  },
-  {
-    id: "shake",
-    category: "emphasis",
-    label: "Shake",
-    description: "Side to side, dying away",
-    duration: 600,
-    ease: ease.inOut("sine"),
-    distance: 12,
-    appliesTo: any,
-    tracks: (n, p) => [wave(n, "translateX", [[0, 0], ...[1, 2, 3, 4, 5, 6, 7].map((i) => [i / 8, (i % 2 ? 1 : -1) * p.distance * (1 - i / 8)]), [1, 0]], p, p.ease)]
-  },
-  {
-    id: "bounce",
-    category: "emphasis",
-    label: "Bounce",
-    description: "Hops up and bounces back down",
-    duration: 900,
-    ease: ease.out("bounce"),
-    distance: 40,
-    appliesTo: any,
-    tracks: (n, p) => {
-      const r = num(n, "translateY", 0);
-      return [{ path: "translateY", keys: [{ t: 0, v: r, ease: ease.out("cubic") }, { t: 0.3 * p.duration, v: r - p.distance, ease: p.ease }, { t: p.duration, v: r }] }];
-    }
-  },
-  {
-    id: "wobble",
-    category: "emphasis",
-    label: "Wobble",
-    description: "Rocks about its anchor, dying away",
-    duration: 800,
-    ease: ease.inOut("sine"),
-    amount: { label: "Angle", default: 10, min: 0, max: 90, step: 1, unit: "\xB0" },
-    appliesTo: any,
-    tracks: (n, p) => [wave(n, "rotation", [[0, 0], ...[1, 2, 3, 4, 5].map((i) => [i / 6, (i % 2 ? 1 : -1) * p.amount * (1 - i / 6)]), [1, 0]], p, p.ease)]
-  },
-  {
-    id: "flash",
-    category: "emphasis",
-    label: "Flash",
-    description: "Blinks off and on, twice",
-    duration: 800,
-    ease: ease.inOut("sine"),
-    appliesTo: any,
-    tracks: (n, p) => {
-      const r = restOpacity(n);
-      return [wave(n, "opacity", [[0, 0], [0.25, -r], [0.5, 0], [0.75, -r], [1, 0]], p, p.ease, r)];
-    }
-  },
-  {
-    id: "impact-frame",
-    category: "emphasis",
-    label: "Impact frame",
-    description: "Held full on for a few frames at the hit, blinks off, on, and back to rest: a flash or inverted frame (rest it hidden)",
-    duration: 160,
-    ease: ease.hold,
-    appliesTo: any,
-    // Absolute: a flash is all or nothing. A flash layer rests hidden (opacity 0), so it is out of the way until the hit.
-    tracks: (n, p) => {
-      const r = restOpacity(n);
-      return [{ path: "opacity", keys: [{ t: 0, v: r, ease: ease.hold }, { t: 1, v: 1, ease: ease.hold }, { t: Math.round(0.45 * p.duration), v: 0, ease: ease.hold }, { t: Math.round(0.65 * p.duration), v: 1, ease: ease.hold }, { t: p.duration, v: r }] }];
-    }
-  },
-  // Camera: on a 3D context, moves its camera; on a group or frame, moves the group, carrying everything in it.
-  {
-    id: "push-in",
-    category: "camera",
-    label: "Push in",
-    description: "A slow move in: toward the scene in 3D, or the group grows about its anchor",
-    duration: 3e3,
-    ease: ease.inOut("cubic"),
-    amount: { label: "Zoom", default: 0.15, min: 0, max: 4, step: 0.01 },
-    appliesTo: cameraOrGroup,
-    needs: "a group or frame with layers in it, or a 3D scene",
-    tracks: (n, p) => is3DContext(n) ? [camTravel(n, "z", -zoomOf(n) * Math.min(0.95, p.amount), p)] : scaleSpan(n, 1, 1 + p.amount, p)
-  },
-  {
-    id: "pull-out",
-    category: "camera",
-    label: "Pull out",
-    description: "Starts close and eases back to the full view",
-    duration: 3e3,
-    ease: ease.inOut("cubic"),
-    amount: { label: "Zoom", default: 0.15, min: 0, max: 4, step: 0.01 },
-    appliesTo: cameraOrGroup,
-    needs: "a group or frame with layers in it, or a 3D scene",
-    tracks: (n, p) => is3DContext(n) ? [camArrive(n, "z", -zoomOf(n) * Math.min(0.95, p.amount), p)] : scaleSpan(n, 1 + p.amount, 1, p)
-  },
-  {
-    id: "dolly",
-    category: "camera",
-    label: "Dolly",
-    description: "Travels along a track: sideways, or in (up) and out (down) in 3D",
-    duration: 3e3,
-    ease: ease.inOut("expo"),
-    direction: "left",
-    distance: 160,
-    appliesTo: cameraOrGroup,
-    needs: "a group or frame with layers in it, or a 3D scene",
-    tracks: (n, p) => {
-      if (is3DContext(n)) {
-        const a2 = dollyAxis(p.direction, p.distance);
-        return [camTravel(n, a2.axis, a2.by, p)];
-      }
-      const a = along(p.direction, p.distance);
-      const r = num(n, a.path, 0);
-      return [span(a.path, r, r + a.by, p)];
-    }
-  },
-  {
-    id: "drift",
-    category: "camera",
-    label: "Drift",
-    description: "A slow float with a slight push",
-    duration: 4e3,
-    ease: ease.inOut("sine"),
-    direction: "right",
-    distance: 24,
-    amount: { label: "Zoom", default: 0.03, min: 0, max: 1, step: 0.01 },
-    appliesTo: isContainer,
-    needs: "a group or frame with layers in it",
-    tracks: (n, p) => {
-      const a = along(p.direction, p.distance);
-      const r = num(n, a.path, 0);
-      return [span(a.path, r, r + a.by, p), ...scaleSpan(n, 1, 1 + p.amount, p)];
-    }
-  },
-  {
-    id: "zoom-through",
-    category: "camera",
-    label: "Zoom through",
-    description: "Rushes toward the view and fades: a cut to the next scene",
-    duration: 800,
-    ease: ease.named("expo", "in"),
-    amount: { label: "Zoom", default: 2, min: 0, max: 20, step: 0.1 },
-    appliesTo: isContainer,
-    needs: "a group or frame with layers in it",
-    tracks: (n, p) => {
-      const r = restOpacity(n);
-      return [...scaleSpan(n, 1, 1 + p.amount, p), { path: "opacity", keys: [{ t: 0, v: r, ease: ease.hold }, { t: 0.6 * p.duration, v: r, ease: ease.named("cubic", "in") }, { t: p.duration, v: 0 }] }];
-    }
-  },
-  {
-    id: "truck",
-    category: "camera",
-    label: "Truck",
-    description: "The camera slides sideways past the scene",
-    duration: 3e3,
-    ease: ease.inOut("cubic"),
-    direction: "right",
-    distance: 240,
-    appliesTo: is3DContext,
-    needs: "a 3D scene (turn a group or frame 3D first)",
-    tracks: (n, p) => [camTravel(n, "x", p.direction === "left" ? -p.distance : p.distance, p)]
-  },
-  {
-    id: "crane",
-    category: "camera",
-    label: "Crane",
-    description: "The camera rises (or sinks), tilting to keep the scene in view",
-    duration: 3e3,
-    ease: ease.inOut("cubic"),
-    direction: "up",
-    distance: 240,
-    appliesTo: is3DContext,
-    needs: "a 3D scene (turn a group or frame 3D first)",
-    tracks: crane
-  },
-  {
-    id: "pan",
-    category: "camera",
-    label: "Pan",
-    description: "The camera turns in place to look across the scene",
-    duration: 3e3,
-    ease: ease.inOut("sine"),
-    direction: "right",
-    amount: { label: "Angle", default: 12, min: 0, max: 90, step: 1, unit: "\xB0" },
-    appliesTo: is3DContext,
-    needs: "a 3D scene (turn a group or frame 3D first)",
-    tracks: (n, p) => {
-      const r = num(n, `${CAM}rotateY`, 0);
-      return [span(`${CAM}rotateY`, r, r + (p.direction === "left" ? p.amount : -p.amount), p)];
-    }
-  },
-  {
-    id: "orbit",
-    category: "camera",
-    label: "Orbit",
-    description: "The camera circles the point of interest",
-    duration: 4e3,
-    ease: ease.inOut("cubic"),
-    direction: "right",
-    amount: { label: "Angle", default: 30, min: 0, max: 360, step: 1, unit: "\xB0" },
-    appliesTo: is3DContext,
-    needs: "a 3D scene (turn a group or frame 3D first)",
-    tracks: (n, p) => {
-      const r = num(n, `${CAM}orbit`, 0);
-      return [span(`${CAM}orbit`, r, r + (p.direction === "left" ? -p.amount : p.amount), p)];
-    }
-  },
-  {
-    id: "camera-shake",
-    category: "camera",
-    label: "Camera shake",
-    description: "A jolt that jitters and dies away: an impact, an explosion, a landing",
-    duration: 500,
-    ease: ease.inOut("sine"),
-    distance: 24,
-    amount: { label: "Turn", default: 1.5, min: 0, max: 20, step: 0.1, unit: "\xB0" },
-    appliesTo: isContainer,
-    needs: "a group or frame with layers in it",
-    tracks: (n, p) => [
-      wave(n, "translateX", SHAKE.map(([f, x]) => [f, x * p.distance]), p, p.ease),
-      wave(n, "translateY", SHAKE.map(([f, , y]) => [f, y * p.distance * 0.7]), p, p.ease),
-      wave(n, "rotation", SHAKE.map(([f, , , r]) => [f, r * p.amount]), p, p.ease)
-    ]
-  },
-  {
-    id: "whip-pan",
-    category: "camera",
-    label: "Whip pan",
-    description: "Swings fast along a direction, streaked with motion blur at its quickest",
-    duration: 360,
-    ease: ease.inOut("expo"),
-    direction: "left",
-    distance: "auto",
-    autoDistance: (n) => n.width,
-    amount: { label: "Streak", default: 120, min: 0, max: 1e3, step: 1, unit: "px" },
-    appliesTo: isContainer,
-    needs: "a group or frame with layers in it",
-    prepare: (n, p) => withSmear(n, p.direction === "up" || p.direction === "down" ? 90 : 0),
-    tracks: (n, p) => {
-      const a = along(p.direction, -p.distance);
-      const r = num(n, a.path, 0);
-      const blur = smearPath(n), b0 = num(n, blur, 0);
-      return [span(a.path, r, r + a.by, p), { path: blur, keys: [{ t: 0, v: b0, ease: ease.inOut("sine") }, { t: p.duration / 2, v: b0 + p.amount, ease: ease.inOut("sine") }, { t: p.duration, v: b0 }] }];
-    }
-  },
-  // Text: per letter, word or line (lib/motion/text-animators.ts).
-  {
-    id: "typewriter",
-    category: "text",
-    label: "Typewriter",
-    description: "Types the text out letter by letter",
-    duration: 1500,
-    ease: ease.linear,
-    appliesTo: isPlainText,
-    needs: TEXT_NEEDS,
-    // Every letter hidden while the range covers it; the range's start sweeps across, and each letter it passes is typed.
-    prepare: (n) => isTextNode(n) ? withAnimator(n, { id: "typewriter", unit: "letter", range: { start: 1, end: 1, offset: 0 }, order: "forward", props: { opacity: 0 }, ease: ease.hold }) : n,
-    tracks: (_n, p) => [{ path: animatorPath("typewriter", "range.start"), keys: [{ t: 0, v: 0, ease: p.ease }, { t: p.duration, v: 1 }] }]
-  },
-  textCascade("letter", "in"),
-  textCascade("word", "in"),
-  textCascade("line", "in"),
-  textCascade("letter", "out"),
-  textCascade("word", "out"),
-  textCascade("line", "out")
-];
-var BY_ID = new Map(LIBRARY.map((p) => [p.id, p]));
-if (BY_ID.size !== PRESET_IDS.length || PRESET_IDS.some((id) => !BY_ID.has(id))) throw new Error("motion presets: the id list and the library disagree");
-var MOTION_PRESETS = LIBRARY;
-var PRESET_CATEGORIES = [
-  { id: "entrance", label: "Entrance" },
-  { id: "exit", label: "Exit" },
-  { id: "emphasis", label: "Emphasis" },
-  { id: "camera", label: "Camera" },
-  { id: "text", label: "Text" }
-];
-var presetById = (id) => BY_ID.get(id);
-var isPresetId = (id) => BY_ID.has(id);
-function resolvePresetParams(preset, node, params = {}) {
-  const direction = params.direction ?? preset.direction ?? "left";
-  const distance = params.distance ?? (preset.distance === "auto" ? preset.autoDistance ? preset.autoDistance(node) : preset.id === "slide-in" || preset.id === "slide-out" ? slideDistance(node, direction) : autoRise(node) : preset.distance ?? 0);
-  return {
-    duration: Math.max(1, Math.round(params.duration ?? preset.duration)),
-    ease: params.ease ?? preset.ease,
-    distance,
-    direction,
-    amount: params.amount ?? preset.amount?.default ?? 0
-  };
-}
-function presetTracks(preset, node, params = {}) {
-  const p = resolvePresetParams(preset, node, params);
-  return preset.tracks(preset.prepare ? preset.prepare(node, p) : node, p);
-}
-function applyPreset(node, presetId, params = {}, at = 0) {
-  const preset = BY_ID.get(presetId);
-  if (!preset) throw new Error(`applyPreset: no preset "${presetId}"`);
-  const p = resolvePresetParams(preset, node, params);
-  let n = preset.prepare ? preset.prepare(node, p) : node;
-  const start = Math.max(0, at + (params.delay ?? 0));
-  for (const tr of preset.tracks(n, p)) n = animate(n, tr.path, tr.keys.map((k) => ({ ...k, t: start + k.t })));
-  return n;
-}
-function treeOrder(nodes, ids) {
-  const pathOf = (id) => {
-    const out = [];
-    for (let n = nodes[id]; n?.parentId; n = nodes[n.parentId]) {
-      const parent = nodes[n.parentId];
-      if (!parent) break;
-      out.unshift(parent.childIds.indexOf(n.id));
-    }
-    return out;
-  };
-  const paths = new Map(ids.map((id) => [id, pathOf(id)]));
-  return [...ids].sort((a, b) => {
-    const pa = paths.get(a), pb = paths.get(b);
-    for (let i = 0; i < Math.min(pa.length, pb.length); i++) if (pa[i] !== pb[i]) return pa[i] - pb[i];
-    return pa.length - pb.length;
-  });
-}
-function staggerPlaces(nodes, ids, order = "index", seed = 0) {
-  return order === "selection" ? staggerRanks(ids, "index") : staggerRanks(treeOrder(nodes, ids), order, seed);
-}
-function applyPresetToDocument(doc, ids, presetId, opts = {}) {
-  const preset = BY_ID.get(presetId);
-  if (!preset) throw new Error(`applyPresetToDocument: no preset "${presetId}"`);
-  let nodes = doc.nodes;
-  const skipped = [];
-  const hosts = /* @__PURE__ */ new Map();
-  for (const id of ids) {
-    const n = nodes[id];
-    const host = n ? hostFrameOf(nodes, id) : null;
-    if (!n || !host) {
-      skipped.push({ id, reason: "not inside a frame" });
-      continue;
-    }
-    if (!preset.appliesTo(n)) {
-      skipped.push({ id, reason: `${preset.label} needs ${preset.needs ?? "another kind of layer"}` });
-      continue;
-    }
-    hosts.set(id, host);
-  }
-  const targets = [...hosts.keys()];
-  const frames = [...new Set(hosts.values())];
-  const startOf = new Map(frames.map((f) => [f, opts.at ?? (opts.onClick ? frameMotionEnd(nodes, f) : 0)]));
-  const liveParent = opts.stagger && !preset.mask ? liveStaggerParent(nodes, targets) : null;
-  const places = opts.stagger && !liveParent ? staggerPlaces(nodes, targets, opts.stagger.order, opts.stagger.seed) : null;
-  let out = { ...nodes };
-  if (liveParent && opts.stagger) {
-    const { delay, order = "index", seed } = opts.stagger;
-    const parent = out[liveParent];
-    out[liveParent] = { ...parent, motion: { tracks: {}, ...parent.motion, stagger: { delay, order: order === "selection" ? { ids: [...targets] } : order, ...order === "random" && seed !== void 0 ? { seed } : {} } } };
-  }
-  for (const id of targets) {
-    const frameId = hosts.get(id);
-    const frameAt = startOf.get(frameId) + (places ? (places.get(id) ?? 0) * opts.stagger.delay : 0);
-    if (preset.mask) {
-      const wrapped = ensureWipeMask(out, id, frameId);
-      out = { ...wrapped.nodes };
-      const m = out[wrapped.maskId];
-      if (!m) {
-        skipped.push({ id, reason: `${preset.label} needs a layer inside a frame` });
-        continue;
-      }
-      const p = resolvePresetParams(preset, m, opts);
-      const start = Math.max(0, frameAt - timeShift(out, m.id, frameId) + (opts.delay ?? 0));
-      let keyed = m;
-      for (const tr of preset.mask(m, p, preset.category === "entrance")) keyed = animate(keyed, tr.path, tr.keys.map((k) => ({ ...k, t: start + k.t })));
-      out[m.id] = keyed;
-      continue;
-    }
-    const local = frameAt - (id === frameId ? 0 : timeShift(nodes, id, frameId));
-    out[id] = applyPreset(nodes[id], presetId, opts, local);
-  }
-  nodes = out;
-  const timelines = {};
-  for (const frameId of frames) {
-    const end = frameMotionEnd(nodes, frameId);
-    const stored = nodes[frameId].timeline;
-    let tl = stored;
-    if (opts.onClick) {
-      const added = addMarker(frameTimeline(nodes, frameId), startOf.get(frameId));
-      tl = updateMarker(added.timeline, added.id, { kind: "pause" });
-    }
-    tl = lengthenedTo(tl, end);
-    if (tl !== stored) timelines[frameId] = { ...nodes[frameId], timeline: tl };
-  }
-  if (Object.keys(timelines).length) nodes = { ...nodes, ...timelines };
-  return { document: { ...doc, nodes }, ids: targets, frameIds: frames, skipped };
-}
-function liveStaggerParent(nodes, ids) {
-  if (ids.length < 2) return null;
-  const parentId = nodes[ids[0]]?.parentId;
-  const parent = parentId ? nodes[parentId] : void 0;
-  if (!parent || parent.type === "PAGE" || parent.motion?.stagger) return null;
-  const set = new Set(ids);
-  if (set.size !== parent.childIds.length || !parent.childIds.every((c) => set.has(c))) return null;
-  const still = (id) => {
-    const n = nodes[id];
-    if (!n) return true;
-    const m = n.motion;
-    if (m && (Object.keys(m.tracks).length || m.timeOffset || m.span || m.stagger)) return false;
-    return (n.childIds ?? []).every(still);
-  };
-  return ids.every(still) ? parent.id : null;
-}
-var lengthenedTo = (tl, end) => tl && tl.duration < end ? { ...tl, duration: Math.ceil(end) } : tl;
-function staggerDocument(doc, ids, opts) {
-  const present = ids.filter((id) => doc.nodes[id]);
-  if (!present.length) return doc;
-  const places = staggerPlaces(doc.nodes, present, opts.order, opts.seed);
-  const nodes = { ...doc.nodes };
-  for (const id of present) {
-    const n = nodes[id];
-    const offset = Math.round((opts.start ?? 0) + (places.get(id) ?? 0) * opts.delay);
-    const { timeOffset: _was, ...rest } = n.motion ?? { tracks: {} };
-    void _was;
-    const motion = offset ? { ...rest, timeOffset: offset } : rest;
-    const empty = !Object.keys(motion.tracks).length && motion.timeOffset === void 0 && !motion.span && !motion.stagger;
-    if (empty) {
-      const { motion: _m, ...bare } = n;
-      void _m;
-      nodes[id] = bare;
-    } else nodes[id] = { ...n, motion };
-  }
-  return { ...doc, nodes };
-}
-
-export {
-  PRESET_IDS,
-  wipeGroupId,
-  wipeMaskId,
-  ensureWipeMask,
-  MOTION_PRESETS,
-  PRESET_CATEGORIES,
-  presetById,
-  isPresetId,
-  resolvePresetParams,
-  presetTracks,
-  applyPreset,
-  treeOrder,
-  staggerPlaces,
-  applyPresetToDocument,
-  liveStaggerParent,
-  lengthenedTo,
-  staggerDocument
-};