@motionscript/grids 0.1.0-alpha.5 → 0.1.0-alpha.7

package/dist/browser/chunks/chunk-XDUDKWM7.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/kit/slots/path.ts", "../../../src/kit/slots/slot.ts", "../../../src/kit/slots/radial.ts", "../../../src/kit/slots/rectangular.ts", "../../../src/kit/slots/sphere.ts", "../../../src/kit/slots/path-templates.ts", "../../../src/kit/slots/index.ts", "../../../src/kit/random.ts", "../../../src/kit/stagger.ts", "../../../src/kit/item-effects.ts", "../../../src/kit/order.ts", "../../../src/kit/item-grid.ts"],
-  "sourcesContent": ["import { pathOps, type PathData, type PathSampler } from \"@motionscript/sdk\"\r\n\r\nimport { slot, type Slot, type SlotInput } from \"./slot\"\r\n\r\n/** `distribute` spreads the items over the path; `fixed` sets them a distance apart. */\r\nexport const PATH_SPACINGS = [\"distribute\", \"fixed\"] as const\r\nexport type PathSpacing = (typeof PATH_SPACINGS)[number]\r\n\r\n/** How path coordinates land in the grid's frame: `origin` of the path goes to `(x, y)`, turned and scaled. */\r\nexport interface PathPlacement {\r\n  originX: number\r\n  originY: number\r\n  /** The path is y-down, as SVG and the editor write one. */\r\n  flipY?: boolean\r\n  x: number\r\n  y: number\r\n  /** Degrees clockwise. */\r\n  rotation: number\r\n  scale: number\r\n}\r\n\r\nexport interface PathArrangement {\r\n  kind: \"path\"\r\n  /** y-up, like every path in the library, unless its placement says otherwise. */\r\n  path: PathData\r\n  placement: PathPlacement\r\n  spacing: PathSpacing\r\n  /** Pixels between items when `spacing` is `fixed`. */\r\n  spacingDistance: number\r\n  /** Share of the path the items are moved along; wraps on a closed path. */\r\n  offset: number\r\n  /** Share of the path per second the items travel on their own. */\r\n  flowSpeed: number\r\n  trimStart: number\r\n  trimEnd: number\r\n  /** Turn each item to follow the path's direction. */\r\n  alignToPath: boolean\r\n}\r\n\r\nconst SAMPLERS = new Map<PathData, { sampler: PathSampler; closed: boolean }>()\r\nconst SAMPLER_CACHE = 32\r\n\r\n/** A sampler for `path`, kept while the same value keeps arriving — a path is re-read every frame. */\r\nfunction measured(path: PathData): { sampler: PathSampler; closed: boolean } {\r\n  const hit = SAMPLERS.get(path)\r\n  if (hit) return hit\r\n  const contours = pathOps.contours(path)\r\n  const entry = {\r\n    sampler: pathOps.sampler(path),\r\n    closed: contours.length === 1 && contours[0].closed,\r\n  }\r\n  if (SAMPLERS.size >= SAMPLER_CACHE) SAMPLERS.delete(SAMPLERS.keys().next().value!)\r\n  SAMPLERS.set(path, entry)\r\n  return entry\r\n}\r\n\r\n/**\r\n * Items at even arc-length steps — by distance along the curve rather than the\r\n * path's own parameter, which bunches them up wherever a curve is tight.\r\n *\r\n * On a closed path used whole, `n` items take `n` equal steps and `offset`\r\n * wraps round, so an animated offset is a loop. Anywhere else the ends are\r\n * ends: `n` items take `n - 1` steps so both get one, and an item moved past\r\n * either is hidden rather than piled on it.\r\n */\r\nexport function pathSlots(arrangement: PathArrangement, input: SlotInput): Slot[] {\r\n  const { count } = input\r\n  if (count === 0) return []\r\n  const { sampler, closed } = measured(arrangement.path)\r\n  const length = sampler.length\r\n  const a = clamp01(Math.min(arrangement.trimStart, arrangement.trimEnd))\r\n  const b = clamp01(Math.max(arrangement.trimStart, arrangement.trimEnd))\r\n  const start = a * length\r\n  const span = (b - a) * length\r\n  const loops = closed && a === 0 && b === 1\r\n  const offset = arrangement.offset + arrangement.flowSpeed * input.time\r\n  const place = arrangement.placement\r\n  const rad = (place.rotation * Math.PI) / 180\r\n  const cos = Math.cos(rad)\r\n  const sin = Math.sin(rad)\r\n\r\n  const slots: Slot[] = []\r\n  for (let k = 0; k < count; k++) {\r\n    let u: number\r\n    if (arrangement.spacing === \"fixed\" && span > 0) {\r\n      u = offset + (k * arrangement.spacingDistance) / span\r\n    } else if (loops) {\r\n      u = offset + k / count\r\n    } else {\r\n      u = offset + (count === 1 ? 0.5 : k / (count - 1))\r\n    }\r\n    let visible = true\r\n    if (loops) u = u - Math.floor(u)\r\n    else if (u < -1e-9 || u > 1 + 1e-9) visible = false\r\n    const at = sampler.frameAt(start + clamp01(u) * span)\r\n    if (!at) {\r\n      const s = slot(0, 0, { kind: \"path\", t: clamp01(u) })\r\n      s.opacity = 0\r\n      slots.push(s)\r\n      continue\r\n    }\r\n    // Into the grid's frame: about the path's origin, turned clockwise (y-up).\r\n    const flip = place.flipY ? -1 : 1\r\n    const px = (at.x - place.originX) * place.scale\r\n    const py = (at.y - place.originY) * place.scale * flip\r\n    const s = slot(\r\n      place.x + px * cos + py * sin,\r\n      place.y - px * sin + py * cos,\r\n      { kind: \"path\", t: clamp01(u) },\r\n    )\r\n    if (arrangement.alignToPath) s.rotation = (-Math.atan2(at.ty * flip, at.tx) * 180) / Math.PI + place.rotation\r\n    if (!visible) s.opacity = 0\r\n    slots.push(s)\r\n  }\r\n  return slots\r\n}\r\n\r\nfunction clamp01(v: number): number {\r\n  return v < 0 ? 0 : v > 1 ? 1 : v\r\n}\r\n", "import type { Size2D } from \"@motionscript/sdk\"\r\n\r\n/**\r\n * One place in an arrangement, in the grid's own frame: centred on it, y-up,\r\n * `depth` toward the viewer.\r\n *\r\n * Pure data, and the whole of what an arrangement produces — which is what lets\r\n * a morph blend any two of them item by item, whatever shapes they came from.\r\n */\r\nexport interface Slot {\r\n  x: number\r\n  y: number\r\n  depth: number\r\n  /** Degrees clockwise. */\r\n  rotation: number\r\n  /** Tilt, degrees, as a node's own `rotationX`/`rotationY`. */\r\n  rotationX: number\r\n  rotationY: number\r\n  scale: number\r\n  opacity: number\r\n  meta: SlotMeta\r\n}\r\n\r\n/** What kind of place a slot is — the orderings a stagger can follow. */\r\nexport type SlotMeta =\r\n  | { kind: \"rectangular\"; row: number; column: number }\r\n  /** Degrees clockwise from the arrangement's first slot. */\r\n  | { kind: \"radial\"; angle: number }\r\n  /** `0..1` along the part of the path in use. */\r\n  | { kind: \"path\"; t: number }\r\n  /** `depth` is `-1` at the back of the sphere and `1` at the front. */\r\n  | { kind: \"sphere\"; lat: number; lon: number; depth: number }\r\n\r\n/** What an arrangement is laid out for. */\r\nexport interface SlotInput {\r\n  count: number\r\n  /** Each item's measured size, in item order. */\r\n  sizes: readonly Size2D[]\r\n  /** The grid's content box. */\r\n  box: Size2D\r\n  /** Clip seconds, for arrangements that move on their own. */\r\n  time: number\r\n}\r\n\r\nexport function slot(x: number, y: number, meta: SlotMeta): Slot {\r\n  return { x, y, depth: 0, rotation: 0, rotationX: 0, rotationY: 0, scale: 1, opacity: 1, meta }\r\n}\r\n\r\n/** `a` toward `b`. The meta switches halfway, since an ordering cannot be half one thing. */\r\nexport function blendSlot(a: Slot, b: Slot, t: number): Slot {\r\n  if (t <= 0) return a\r\n  if (t >= 1) return b\r\n  const mix = (p: number, q: number) => p + (q - p) * t\r\n  return {\r\n    x: mix(a.x, b.x),\r\n    y: mix(a.y, b.y),\r\n    depth: mix(a.depth, b.depth),\r\n    rotation: mix(a.rotation, b.rotation),\r\n    rotationX: mix(a.rotationX, b.rotationX),\r\n    rotationY: mix(a.rotationY, b.rotationY),\r\n    scale: mix(a.scale, b.scale),\r\n    opacity: mix(a.opacity, b.opacity),\r\n    meta: t < 0.5 ? a.meta : b.meta,\r\n  }\r\n}\r\n\r\n/** Push `s` away from (or pull it toward) the grid's centre. */\r\nexport function spreadSlot(s: Slot, spread: number): Slot {\r\n  if (spread === 1) return s\r\n  return { ...s, x: s.x * spread, y: s.y * spread, depth: s.depth * spread }\r\n}\r\n\r\n/** Largest width and height among `sizes`. */\r\nexport function largest(sizes: readonly Size2D[]): Size2D {\r\n  let width = 0\r\n  let height = 0\r\n  for (const size of sizes) {\r\n    if (size.width > width) width = size.width\r\n    if (size.height > height) height = size.height\r\n  }\r\n  return { width, height }\r\n}\r\n", "import { slot, type Slot, type SlotInput } from \"./slot\"\r\n\r\nexport const RADIAL_DIRECTIONS = [\"clockwise\", \"counterclockwise\"] as const\r\nexport type RadialDirection = (typeof RADIAL_DIRECTIONS)[number]\r\n\r\nexport interface RadialArrangement {\r\n  kind: \"radial\"\r\n  radius: number\r\n  /** Where the first item sits, degrees clockwise from twelve o'clock. */\r\n  startAngle: number\r\n  /** How much of the circle the items span, degrees. */\r\n  sweep: number\r\n  direction: RadialDirection\r\n  /** Turn each item so its top faces away from the centre. */\r\n  rotateItems: boolean\r\n  /** Degrees per second the ring turns on its own. */\r\n  spinSpeed: number\r\n}\r\n\r\n/**\r\n * The angle of each of `count` slots, clockwise from twelve o'clock. A full\r\n * circle divides by the count, so the last item does not land on the first; an\r\n * arc divides by one less, so both ends get an item. In between the divisor\r\n * slides from one to the other as the arc closes — steeply, so an arc is an arc\r\n * until it is nearly whole, and a sweep animated to 360 lands without a jump.\r\n */\r\nexport function radialAngles(arrangement: RadialArrangement, count: number, time: number): number[] {\r\n  const sweep = arrangement.sweep\r\n  const closing = Math.min(1, Math.abs(sweep) / 360) ** 8\r\n  const step = count <= 1 ? 0 : sweep / (count - 1 + closing)\r\n  const sign = arrangement.direction === \"counterclockwise\" ? -1 : 1\r\n  const start = arrangement.startAngle + arrangement.spinSpeed * time\r\n  const angles: number[] = []\r\n  for (let k = 0; k < count; k++) angles.push(start + sign * k * step)\r\n  return angles\r\n}\r\n\r\nexport function radialSlots(arrangement: RadialArrangement, input: SlotInput): Slot[] {\r\n  const angles = radialAngles(arrangement, input.count, input.time)\r\n  const start = angles[0] ?? 0\r\n  return angles.map((angle) => {\r\n    const rad = (angle * Math.PI) / 180\r\n    const s = slot(arrangement.radius * Math.sin(rad), arrangement.radius * Math.cos(rad), {\r\n      kind: \"radial\",\r\n      angle: Math.abs(angle - start),\r\n    })\r\n    if (arrangement.rotateItems) s.rotation = angle\r\n    return s\r\n  })\r\n}\r\n\r\n/** The change to `startAngle` that brings slot `index` to twelve o'clock by the shorter way round. */\r\nexport function radialTurnToTop(arrangement: RadialArrangement, count: number, index: number): number {\r\n  const angle = radialAngles({ ...arrangement, spinSpeed: 0 }, count, 0)[index] ?? arrangement.startAngle\r\n  return -wrapDegrees(angle)\r\n}\r\n\r\n/** `degrees` folded into `(-180, 180]`. */\r\nexport function wrapDegrees(degrees: number): number {\r\n  const wrapped = ((degrees % 360) + 360) % 360\r\n  return wrapped > 180 ? wrapped - 360 : wrapped\r\n}\r\n", "import type { Size2D } from \"@motionscript/sdk\"\r\n\r\nimport { largest, slot, type Slot, type SlotInput } from \"./slot\"\r\n\r\nexport const FILL_DIRECTIONS = [\"row\", \"column\"] as const\r\nexport type FillDirection = (typeof FILL_DIRECTIONS)[number]\r\n\r\n/**\r\n * How big a cell is: the largest child (`fit`), a size of its own (`fixed`), or\r\n * an equal share of the grid's box (`fill`), which is also the room a child set\r\n * to `fill` grows into.\r\n */\r\nexport const CELL_MODES = [\"fit\", \"fixed\", \"fill\"] as const\r\nexport type CellMode = (typeof CELL_MODES)[number]\r\n\r\n/** Where a short last row (or column, filling by column) sits. */\r\nexport const LINE_ALIGNS = [\"start\", \"center\", \"end\"] as const\r\nexport type LineAlign = (typeof LINE_ALIGNS)[number]\r\n\r\nexport interface RectangularArrangement {\r\n  kind: \"rectangular\"\r\n  columns: number\r\n  fillDirection: FillDirection\r\n  cellMode: CellMode\r\n  cellWidth: number\r\n  cellHeight: number\r\n  columnGap: number\r\n  rowGap: number\r\n  lastLineAlign: LineAlign\r\n  /** Share of a column's pitch every other row shifts right — `0.5` is a brick bond. */\r\n  rowOffset: number\r\n  /** Share of a row's pitch every other column shifts down. */\r\n  columnOffset: number\r\n}\r\n\r\n/** Rows and columns `count` items make, `columns` wide. */\r\nexport function rectangularShape(arrangement: RectangularArrangement, count: number): { rows: number; columns: number } {\r\n  const columns = Math.max(1, Math.round(arrangement.columns))\r\n  const rows = Math.max(1, Math.ceil(count / columns))\r\n  // Filling by column, the rows are set by the count, and a column the items\r\n  // never reach would pull the block off centre.\r\n  if (arrangement.fillDirection === \"column\") return { rows, columns: Math.max(1, Math.ceil(count / rows)) }\r\n  return { rows, columns }\r\n}\r\n\r\n/** The cell every item is laid out in — what a `fill` child is measured against. */\r\nexport function rectangularCell(\r\n  arrangement: RectangularArrangement,\r\n  count: number,\r\n  sizes: readonly Size2D[],\r\n  box: Size2D,\r\n): Size2D {\r\n  const { rows, columns } = rectangularShape(arrangement, count)\r\n  switch (arrangement.cellMode) {\r\n    case \"fixed\":\r\n      return { width: Math.max(0, arrangement.cellWidth), height: Math.max(0, arrangement.cellHeight) }\r\n    case \"fill\":\r\n      return {\r\n        width: Math.max(0, (box.width - arrangement.columnGap * (columns - 1)) / columns),\r\n        height: Math.max(0, (box.height - arrangement.rowGap * (rows - 1)) / rows),\r\n      }\r\n    default:\r\n      return largest(sizes)\r\n  }\r\n}\r\n\r\n/**\r\n * Items fill rows left to right, top to bottom (or columns top to bottom, left to\r\n * right), and the whole block is centred on the grid.\r\n */\r\nexport function rectangularSlots(arrangement: RectangularArrangement, input: SlotInput): Slot[] {\r\n  const { count } = input\r\n  if (count === 0) return []\r\n  const { rows, columns } = rectangularShape(arrangement, count)\r\n  const byColumn = arrangement.fillDirection === \"column\"\r\n  // Filling by column keeps the column count and lets the rows follow from it.\r\n  const lines = byColumn ? columns : rows\r\n  const perLine = byColumn ? rows : columns\r\n  const cell = rectangularCell(arrangement, count, input.sizes, input.box)\r\n  const pitchX = cell.width + arrangement.columnGap\r\n  const pitchY = cell.height + arrangement.rowGap\r\n  const lastLine = lines - 1\r\n  const lastCount = count - lastLine * perLine\r\n  const shortBy = perLine - lastCount\r\n  const lead = arrangement.lastLineAlign === \"center\" ? shortBy / 2 : arrangement.lastLineAlign === \"end\" ? shortBy : 0\r\n  // Shifting every other row by a share of a pitch moves the block's centre by\r\n  // half that share; taking it back keeps the block centred on the grid.\r\n  const shiftX = arrangement.rowOffset * pitchX\r\n  const shiftY = arrangement.columnOffset * pitchY\r\n\r\n  const slots: Slot[] = []\r\n  for (let i = 0; i < count; i++) {\r\n    const line = Math.floor(i / perLine)\r\n    let along = i % perLine\r\n    if (line === lastLine) along += lead\r\n    const row = byColumn ? along : line\r\n    const column = byColumn ? line : along\r\n    // A centred short line sits between whole cells; its parity is the cell it covers most.\r\n    const rowIndex = Math.round(row)\r\n    const columnIndex = Math.round(column)\r\n    const x = (column - (columns - 1) / 2) * pitchX\r\n      + (rowIndex % 2 === 1 ? shiftX : 0) - (rows > 1 ? shiftX / 2 : 0)\r\n    const y = ((rows - 1) / 2 - row) * pitchY\r\n      - (columnIndex % 2 === 1 ? shiftY : 0) + (columns > 1 ? shiftY / 2 : 0)\r\n    slots.push(slot(x, y, { kind: \"rectangular\", row: rowIndex, column: columnIndex }))\r\n  }\r\n  return slots\r\n}\r\n", "import { slot, type Slot, type SlotInput } from \"./slot\"\r\n\r\n/** `outward` lays each item on the sphere's surface; `billboard` keeps every item facing the viewer. */\r\nexport const SPHERE_FACINGS = [\"outward\", \"billboard\"] as const\r\nexport type SphereFacing = (typeof SPHERE_FACINGS)[number]\r\n\r\nexport const SPHERE_AXES = [\"x\", \"y\", \"z\"] as const\r\nexport type SphereAxis = (typeof SPHERE_AXES)[number]\r\n\r\nexport interface SphereArrangement {\r\n  kind: \"sphere\"\r\n  radius: number\r\n  /** Turn about the vertical axis, degrees — positive carries the front to the right. */\r\n  yaw: number\r\n  /** Turn about the horizontal axis, degrees — positive brings the top toward the viewer. */\r\n  pitch: number\r\n  /** Turn about the view axis, degrees clockwise. */\r\n  roll: number\r\n  facing: SphereFacing\r\n  /** The camera's distance from the sphere's centre plane, px — smaller is more dramatic. */\r\n  focalLength: number\r\n  /** How much the back half fades, `0..1`. */\r\n  depthFade: number\r\n  /** Hide the items whose faces point away from the viewer. */\r\n  cullBackfaces: boolean\r\n  /** Degrees per second of yaw the sphere turns on its own. */\r\n  spinSpeed: number\r\n}\r\n\r\nconst GOLDEN_ANGLE = Math.PI * (3 - Math.sqrt(5))\r\nconst DEG = 180 / Math.PI\r\n\r\n/** Point `k` of `count` on the unit sphere — a Fibonacci lattice, as even as `count` points get. */\r\nexport function fibonacciPoint(k: number, count: number): [number, number, number] {\r\n  if (count <= 1) return [0, 0, 1]\r\n  const y = 1 - (2 * (k + 0.5)) / count\r\n  const r = Math.sqrt(Math.max(0, 1 - y * y))\r\n  const theta = k * GOLDEN_ANGLE\r\n  return [Math.cos(theta) * r, y, Math.sin(theta) * r]\r\n}\r\n\r\n/** `p` turned by yaw, then pitch, then roll — y-up, z toward the viewer. */\r\nexport function orient(p: readonly [number, number, number], yaw: number, pitch: number, roll: number): [number, number, number] {\r\n  const [x0, y0, z0] = p\r\n  const ya = yaw / DEG, pa = pitch / DEG, ra = roll / DEG\r\n  const x1 = x0 * Math.cos(ya) + z0 * Math.sin(ya)\r\n  const z1 = -x0 * Math.sin(ya) + z0 * Math.cos(ya)\r\n  const y2 = y0 * Math.cos(pa) - z1 * Math.sin(pa)\r\n  const z2 = y0 * Math.sin(pa) + z1 * Math.cos(pa)\r\n  return [x1 * Math.cos(ra) + y2 * Math.sin(ra), -x1 * Math.sin(ra) + y2 * Math.cos(ra), z2]\r\n}\r\n\r\nexport function sphereSlots(arrangement: SphereArrangement, input: SlotInput): Slot[] {\r\n  const { count } = input\r\n  const radius = arrangement.radius\r\n  const yaw = arrangement.yaw + arrangement.spinSpeed * input.time\r\n  const outward = arrangement.facing === \"outward\"\r\n  const slots: Slot[] = []\r\n  for (let k = 0; k < count; k++) {\r\n    const q = fibonacciPoint(k, count)\r\n    const [nx, ny, nz] = orient(q, yaw, arrangement.pitch, arrangement.roll)\r\n    const s = slot(nx * radius, ny * radius, {\r\n      kind: \"sphere\",\r\n      lat: Math.asin(Math.max(-1, Math.min(1, q[1]))) * DEG,\r\n      lon: Math.atan2(q[2], q[0]) * DEG,\r\n      depth: nz,\r\n    })\r\n    s.depth = nz * radius\r\n    if (outward) {\r\n      // The tilt whose `Rx · Ry` turns a face's normal onto the surface normal.\r\n      s.rotationY = Math.asin(Math.max(-1, Math.min(1, nx))) * DEG\r\n      s.rotationX = Math.atan2(ny, nz) * DEG\r\n    }\r\n    s.opacity = 1 - arrangement.depthFade * (1 - (nz + 1) / 2)\r\n    if (outward && arrangement.cullBackfaces && facesAway(s, [nx, ny, nz], arrangement.focalLength)) s.opacity = 0\r\n    slots.push(s)\r\n  }\r\n  return slots\r\n}\r\n\r\n/** Whether an outward face at `s` shows its back to a viewer `focal` px in front of the centre. */\r\nfunction facesAway(s: Slot, normal: readonly [number, number, number], focal: number): boolean {\r\n  if (focal <= 0) return normal[2] < 0\r\n  return normal[0] * -s.x + normal[1] * -s.y + normal[2] * (focal - s.depth) < 0\r\n}\r\n\r\n/** The yaw and pitch that bring point `index` of `count` round to face the viewer. */\r\nexport function sphereFaceForward(count: number, index: number): { yaw: number; pitch: number } {\r\n  const [x, y, z] = fibonacciPoint(index, count)\r\n  return {\r\n    yaw: -Math.atan2(x, z) * DEG,\r\n    pitch: Math.atan2(y, Math.hypot(x, z)) * DEG,\r\n  }\r\n}\r\n", "import type { PathCommand, Size2D } from \"@motionscript/sdk\"\r\n\r\n/**\r\n * The shapes a path grid can follow without a path of its own, each drawn to\r\n * fill the grid's box. Centred and y-up, like every path in the library; the\r\n * closed ones run clockwise, so an item flowing along any of them travels the\r\n * same way round.\r\n */\r\nexport const PATH_TEMPLATES = [\r\n  \"circle\",\r\n  \"square\",\r\n  \"star\",\r\n  \"heart\",\r\n  \"infinity\",\r\n  \"wave\",\r\n  \"spiral\",\r\n  \"arc\",\r\n  \"line\",\r\n] as const\r\nexport type PathTemplate = (typeof PATH_TEMPLATES)[number]\r\n\r\n/** What a template is drawn at when the grid has no box to fill. */\r\nconst FALLBACK = 400\r\n\r\nconst DRAWN = new Map<string, PathCommand[]>()\r\nconst DRAWN_CACHE = 64\r\n\r\n/**\r\n * `template` drawn to fill `box`. The same template at the same size is the\r\n * same array, which is what lets the path's measurement be kept between frames.\r\n */\r\nexport function templatePath(template: PathTemplate, box: Size2D): PathCommand[] {\r\n  const key = `${template}:${Math.round(box.width * 100)}:${Math.round(box.height * 100)}`\r\n  const hit = DRAWN.get(key)\r\n  if (hit) return hit\r\n  const path = drawTemplate(template, box)\r\n  if (DRAWN.size >= DRAWN_CACHE) DRAWN.delete(DRAWN.keys().next().value!)\r\n  DRAWN.set(key, path)\r\n  return path\r\n}\r\n\r\nfunction drawTemplate(template: PathTemplate, box: Size2D): PathCommand[] {\r\n  const w = box.width > 0 ? box.width : FALLBACK\r\n  const h = box.height > 0 ? box.height : FALLBACK\r\n  const rx = w / 2\r\n  const ry = h / 2\r\n  switch (template) {\r\n    case \"square\":\r\n      return closed([\r\n        [-rx, ry], [rx, ry], [rx, -ry], [-rx, -ry],\r\n      ])\r\n    case \"star\": {\r\n      const points: [number, number][] = []\r\n      for (let i = 0; i < 10; i++) {\r\n        const angle = (i * Math.PI) / 5\r\n        const r = i % 2 === 0 ? 1 : 0.45\r\n        points.push([Math.sin(angle) * rx * r, Math.cos(angle) * ry * r])\r\n      }\r\n      return closed(points)\r\n    }\r\n    case \"heart\":\r\n      return closed(sample(96, (t) => {\r\n        // The classic heart curve, from its top notch, clockwise.\r\n        const a = t * 2 * Math.PI\r\n        const x = 16 * Math.sin(a) ** 3\r\n        const y = 13 * Math.cos(a) - 5 * Math.cos(2 * a) - 2 * Math.cos(3 * a) - Math.cos(4 * a)\r\n        return [(x / 17) * rx, ((y + 2.5) / 15.5) * ry]\r\n      }).slice(0, -1))\r\n    case \"infinity\":\r\n      return closed(sample(96, (t) => {\r\n        const a = t * 2 * Math.PI\r\n        const d = 1 + Math.sin(a) ** 2\r\n        return [(Math.cos(a) / d) * rx, ((Math.sin(a) * Math.cos(a)) / d) * ry * 2]\r\n      }).slice(0, -1))\r\n    case \"wave\":\r\n      return open(sample(96, (t) => [(-1 + 2 * t) * rx, Math.sin(t * 4 * Math.PI) * ry * 0.6]))\r\n    case \"spiral\":\r\n      return open(sample(160, (t) => {\r\n        const a = t * 3 * 2 * Math.PI\r\n        const r = 0.08 + 0.92 * t\r\n        return [Math.sin(a) * rx * r, Math.cos(a) * ry * r]\r\n      }))\r\n    case \"arc\":\r\n      return open(sample(64, (t) => {\r\n        const a = -Math.PI / 2 + t * Math.PI\r\n        return [Math.sin(a) * rx, -ry + Math.cos(a) * h]\r\n      }))\r\n    case \"line\":\r\n      return [{ type: \"M\", x: -rx, y: 0 }, { type: \"L\", x: rx, y: 0 }]\r\n    default:\r\n      return ellipse(rx, ry)\r\n  }\r\n}\r\n\r\n/** Four quarter-arcs from the top, clockwise. */\r\nfunction ellipse(rx: number, ry: number): PathCommand[] {\r\n  const k = 0.5522847498\r\n  return [\r\n    { type: \"M\", x: 0, y: ry },\r\n    { type: \"C\", x1: k * rx, y1: ry, x2: rx, y2: k * ry, x: rx, y: 0 },\r\n    { type: \"C\", x1: rx, y1: -k * ry, x2: k * rx, y2: -ry, x: 0, y: -ry },\r\n    { type: \"C\", x1: -k * rx, y1: -ry, x2: -rx, y2: -k * ry, x: -rx, y: 0 },\r\n    { type: \"C\", x1: -rx, y1: k * ry, x2: -k * rx, y2: ry, x: 0, y: ry },\r\n    { type: \"Z\" },\r\n  ]\r\n}\r\n\r\nfunction sample(steps: number, at: (t: number) => [number, number]): [number, number][] {\r\n  const points: [number, number][] = []\r\n  for (let i = 0; i <= steps; i++) points.push(at(i / steps))\r\n  return points\r\n}\r\n\r\nfunction open(points: [number, number][]): PathCommand[] {\r\n  return points.map(([x, y], i) => (i === 0 ? { type: \"M\", x, y } : { type: \"L\", x, y }))\r\n}\r\n\r\nfunction closed(points: [number, number][]): PathCommand[] {\r\n  return [...open(points), { type: \"Z\" }]\r\n}\r\n", "import { pathSlots, type PathArrangement } from \"./path\"\r\nimport { radialSlots, type RadialArrangement } from \"./radial\"\r\nimport { rectangularSlots, type RectangularArrangement } from \"./rectangular\"\r\nimport type { Slot, SlotInput } from \"./slot\"\r\nimport { sphereSlots, type SphereArrangement } from \"./sphere\"\r\n\r\nexport * from \"./slot\"\r\nexport * from \"./rectangular\"\r\nexport * from \"./radial\"\r\nexport * from \"./path\"\r\nexport * from \"./path-templates\"\r\nexport * from \"./sphere\"\r\n\r\n/**\r\n * Everything an arrangement needs to place items, as plain data — so a\r\n * transition can keep the one it is leaving, and a grid can borrow another's.\r\n */\r\nexport type Arrangement = RectangularArrangement | RadialArrangement | PathArrangement | SphereArrangement\r\n\r\nexport type ArrangementKind = Arrangement[\"kind\"]\r\n\r\n/** Where each of `input.count` items sits under `arrangement`, in slot order. */\r\nexport function slotsOf(arrangement: Arrangement, input: SlotInput): Slot[] {\r\n  switch (arrangement.kind) {\r\n    case \"rectangular\":\r\n      return rectangularSlots(arrangement, input)\r\n    case \"radial\":\r\n      return radialSlots(arrangement, input)\r\n    case \"path\":\r\n      return pathSlots(arrangement, input)\r\n    case \"sphere\":\r\n      return sphereSlots(arrangement, input)\r\n  }\r\n}\r\n\r\n/** The camera distance an arrangement is seen through, or `0` when it is flat. */\r\nexport function focalLengthOf(arrangement: Arrangement): number {\r\n  return arrangement.kind === \"sphere\" ? Math.max(1, arrangement.focalLength) : 0\r\n}\r\n", "/** A seeded generator in `[0, 1)` — mulberry32, so a shuffle is the same on every frame and every machine. */\r\nexport function seededRandom(seed: number): () => number {\r\n  let a = Math.floor(seed) >>> 0\r\n  return () => {\r\n    a = (a + 0x6d2b79f5) >>> 0\r\n    let t = a\r\n    t = Math.imul(t ^ (t >>> 15), t | 1)\r\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61)\r\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296\r\n  }\r\n}\r\n\r\n/** `values` in a seeded random order. */\r\nexport function shuffled<T>(values: readonly T[], seed: number): T[] {\r\n  const out = [...values]\r\n  const random = seededRandom(seed)\r\n  for (let i = out.length - 1; i > 0; i--) {\r\n    const j = Math.floor(random() * (i + 1))\r\n    ;[out[i], out[j]] = [out[j], out[i]]\r\n  }\r\n  return out\r\n}\r\n\r\n/** A stable number for a string — a node's id, so its \"random\" stagger never changes between builds. */\r\nexport function hashSeed(text: string): number {\r\n  let h = 2166136261\r\n  for (let i = 0; i < text.length; i++) h = Math.imul(h ^ text.charCodeAt(i), 16777619)\r\n  return h >>> 0\r\n}\r\n", "import { shuffled } from \"./random\"\r\nimport type { Slot } from \"./slots\"\r\n\r\n/**\r\n * The order a per-item effect sweeps through a grid's items. The first five\r\n * work on any grid; the rest follow one arrangement's own geometry — rows and\r\n * columns of a rectangular grid (or top-to-bottom and left-to-right of any\r\n * other), the way round a ring, the way along a path, front to back of a sphere\r\n * — and fall back to item order where the grid has no such thing.\r\n */\r\nexport const STAGGER_ORDERS = [\r\n  \"index\",\r\n  \"reverse\",\r\n  \"random\",\r\n  \"centerOut\",\r\n  \"edgesIn\",\r\n  \"row\",\r\n  \"column\",\r\n  \"angle\",\r\n  \"path\",\r\n  \"depth\",\r\n] as const\r\nexport type StaggerOrder = (typeof STAGGER_ORDERS)[number]\r\n\r\n/** The most of a command's length the offsets may take; the rest is each item's own motion. */\r\nconst MAX_STAGGER = 0.95\r\n\r\n/**\r\n * Each item's start, `0..1`, as a share of the stagger: `0` goes first, `1`\r\n * last, and items that tie go together — a ring revealed `centerOut` from its\r\n * centre appears all at once, which is what that means.\r\n */\r\nexport function staggerRanks(order: StaggerOrder, slots: readonly Slot[], seed: number): number[] {\r\n  const n = slots.length\r\n  const keys = keysOf(order, slots, seed)\r\n  let min = Infinity\r\n  let max = -Infinity\r\n  for (const key of keys) {\r\n    if (key < min) min = key\r\n    if (key > max) max = key\r\n  }\r\n  const range = max - min\r\n  if (!(range > 1e-9)) return new Array<number>(n).fill(0)\r\n  return keys.map((key) => (key - min) / range)\r\n}\r\n\r\n/**\r\n * Item progress at command time `t`: each item runs over the same length of\r\n * time, starting `rank · stagger` in. The stagger lives inside the command's\r\n * duration, so a one-second reveal takes one second for four items or four\r\n * hundred.\r\n */\r\nexport function staggerProgress(rank: number, t: number, stagger: number): number {\r\n  const s = Math.max(0, Math.min(MAX_STAGGER, stagger))\r\n  const p = s === 0 ? t : (t - rank * s) / (1 - s)\r\n  return p < 0 ? 0 : p > 1 ? 1 : p\r\n}\r\n\r\nfunction keysOf(order: StaggerOrder, slots: readonly Slot[], seed: number): number[] {\r\n  switch (order) {\r\n    case \"reverse\":\r\n      return slots.map((_, i) => -i)\r\n    case \"random\": {\r\n      const sequence = shuffled(slots.map((_, i) => i), seed)\r\n      const keys = new Array<number>(slots.length)\r\n      sequence.forEach((item, rank) => {\r\n        keys[item] = rank\r\n      })\r\n      return keys\r\n    }\r\n    case \"centerOut\":\r\n      return slots.map((s) => Math.round(Math.hypot(s.x, s.y, s.depth) * 1000) / 1000)\r\n    case \"edgesIn\":\r\n      return slots.map((s) => -Math.round(Math.hypot(s.x, s.y, s.depth) * 1000) / 1000)\r\n    case \"row\":\r\n      return slots.map((s) => (s.meta.kind === \"rectangular\" ? s.meta.row : -Math.round(s.y)))\r\n    case \"column\":\r\n      return slots.map((s) => (s.meta.kind === \"rectangular\" ? s.meta.column : Math.round(s.x)))\r\n    case \"angle\":\r\n      return slots.map((s, i) =>\r\n        s.meta.kind === \"radial\" ? s.meta.angle : s.meta.kind === \"rectangular\" || s.meta.kind === \"sphere\" ? clockAngle(s) : i\r\n      )\r\n    case \"path\":\r\n      return slots.map((s, i) => (s.meta.kind === \"path\" ? s.meta.t : i))\r\n    case \"depth\":\r\n      return slots.map((s, i) => (s.meta.kind === \"sphere\" ? -s.meta.depth : i))\r\n    default:\r\n      return slots.map((_, i) => i)\r\n  }\r\n}\r\n\r\n/** Degrees clockwise from twelve o'clock to where `s` sits. */\r\nfunction clockAngle(s: Slot): number {\r\n  const angle = (Math.atan2(s.x, s.y) * 180) / Math.PI\r\n  return angle < 0 ? angle + 360 : angle\r\n}\r\n", "import type { Size2D } from \"@motionscript/sdk\"\r\n\r\nimport type { Slot } from \"./slots\"\r\n\r\n/**\r\n * What an item does on its way in (or out): grow from nothing, fade, fly out of\r\n * the grid's centre, rise into place, flip up, or spin in.\r\n */\r\nexport const REVEAL_STYLES = [\"scale\", \"fade\", \"center\", \"rise\", \"flip\", \"spin\"] as const\r\nexport type RevealStyle = (typeof REVEAL_STYLES)[number]\r\n\r\n/** What a wave does to each item as it passes. */\r\nexport const WAVE_STYLES = [\"scale\", \"lift\", \"fade\", \"spin\"] as const\r\nexport type WaveStyle = (typeof WAVE_STYLES)[number]\r\n\r\n/**\r\n * How far into view each item is, `1` shown and `0` gone — past `1` on the\r\n * way to it under an overshooting ease. Absent means every item is shown.\r\n */\r\nexport interface RevealState {\r\n  style: RevealStyle\r\n  values: readonly number[]\r\n}\r\n\r\n/** Each item's share of the wave passing through it, `0` at rest and `1` at the crest. */\r\nexport interface WaveState {\r\n  style: WaveStyle\r\n  /** How big the crest is — a share of the item's size, opacity or a turn, by style. */\r\n  amount: number\r\n  values: readonly number[]\r\n}\r\n\r\n/** Each item's emphasis: `1` the focus, `-1` pushed back, `0` untouched. */\r\nexport interface FocusState {\r\n  /** How far the others fade, `0..1`. */\r\n  dim: number\r\n  /** How much the focus grows, as a share of its size; the others shrink by half that. */\r\n  grow: number\r\n  values: readonly number[]\r\n}\r\n\r\n/** Layer item `i`'s reveal, wave and focus onto its slot, in place. */\r\nexport function applyItemEffects(\r\n  s: Slot,\r\n  i: number,\r\n  size: Size2D,\r\n  reveal: RevealState | null | undefined,\r\n  wave: WaveState | null | undefined,\r\n  focus: FocusState | null | undefined,\r\n): void {\r\n  if (reveal) applyReveal(s, reveal.style, reveal.values[i] ?? 1, size)\r\n  if (wave) applyWave(s, wave, wave.values[i] ?? 0, size)\r\n  if (focus) applyFocus(s, focus, focus.values[i] ?? 0)\r\n}\r\n\r\nfunction applyReveal(s: Slot, style: RevealStyle, v: number, size: Size2D): void {\r\n  if (v === 1) return\r\n  const shown = clamp01(v)\r\n  switch (style) {\r\n    case \"fade\":\r\n      s.opacity *= shown\r\n      break\r\n    case \"center\":\r\n      s.x *= v\r\n      s.y *= v\r\n      s.depth *= v\r\n      s.opacity *= clamp01(v * 4)\r\n      break\r\n    case \"rise\":\r\n      s.y -= (1 - v) * Math.max(40, size.height)\r\n      s.opacity *= shown\r\n      break\r\n    case \"flip\":\r\n      s.rotationX += (1 - v) * 90\r\n      break\r\n    case \"spin\":\r\n      s.rotation -= (1 - v) * 180\r\n      s.scale *= Math.max(0, v)\r\n      break\r\n    default:\r\n      s.scale *= Math.max(0, v)\r\n  }\r\n}\r\n\r\nfunction applyWave(s: Slot, wave: WaveState, w: number, size: Size2D): void {\r\n  if (w === 0) return\r\n  switch (wave.style) {\r\n    case \"lift\":\r\n      s.y += wave.amount * w * Math.max(40, size.height)\r\n      break\r\n    case \"fade\":\r\n      s.opacity *= clamp01(1 - wave.amount * w)\r\n      break\r\n    case \"spin\":\r\n      s.rotation += wave.amount * w * 360\r\n      break\r\n    default:\r\n      s.scale *= 1 + wave.amount * w\r\n  }\r\n}\r\n\r\nfunction applyFocus(s: Slot, focus: FocusState, f: number): void {\r\n  if (f === 0) return\r\n  if (f > 0) {\r\n    s.scale *= 1 + focus.grow * f\r\n    return\r\n  }\r\n  s.opacity *= clamp01(1 - focus.dim * -f)\r\n  s.scale *= Math.max(0, 1 + focus.grow * 0.5 * f)\r\n}\r\n\r\nfunction clamp01(v: number): number {\r\n  return v < 0 ? 0 : v > 1 ? 1 : v\r\n}\r\n", "/**\r\n * A grid's `order` lists items in slot order: slot `k` holds item `order[k]`.\r\n * These keep it a permutation whatever it was written as — a stale entry past\r\n * the count, a repeat, or nothing at all — so a child added or removed never\r\n * leaves a slot empty or two items in one.\r\n */\r\n\r\n/** `order` repaired into a permutation of `0..count-1`: its valid entries first, then the rest in item order. */\r\nexport function normalizeOrder(order: readonly number[] | undefined, count: number): number[] {\r\n  const out: number[] = []\r\n  const taken = new Array<boolean>(count).fill(false)\r\n  for (const entry of order ?? []) {\r\n    const item = Math.round(entry)\r\n    if (item >= 0 && item < count && !taken[item]) {\r\n      taken[item] = true\r\n      out.push(item)\r\n    }\r\n  }\r\n  for (let item = 0; item < count; item++) if (!taken[item]) out.push(item)\r\n  return out\r\n}\r\n\r\n/** For each item, the slot it sits in. */\r\nexport function slotOfItem(order: readonly number[]): number[] {\r\n  const slots = new Array<number>(order.length)\r\n  order.forEach((item, slot) => {\r\n    slots[item] = slot\r\n  })\r\n  return slots\r\n}\r\n\r\n/** An order written as `\"2, 0, 1\"` or as numbers. */\r\nexport function parseOrder(value: unknown): number[] {\r\n  if (Array.isArray(value)) return value.map(Number).filter(Number.isFinite)\r\n  if (typeof value !== \"string\") return []\r\n  return value\r\n    .split(/[\\s,]+/)\r\n    .filter((part) => part !== \"\")\r\n    .map(Number)\r\n    .filter(Number.isFinite)\r\n}\r\n", "import {\r\n  command,\r\n  easeIn,\r\n  easeInOut,\r\n  easeOut,\r\n  findNode2D,\r\n  flowOps,\r\n  frameIn,\r\n  insetsOps,\r\n  Node2D,\r\n  property,\r\n  sizeInputOps,\r\n  type BoxBounds,\r\n  type ChildPlacement,\r\n  type Command,\r\n  type CommandArgs,\r\n  type MeasureContext2D,\r\n  type EasingFunction,\r\n  type Node2DProps,\r\n  type Size2D,\r\n  type SizeConstraints,\r\n  type SpaceCamera,\r\n} from \"@motionscript/sdk\"\r\n\r\n// Once this kit's own; kept on its barrel for the grids that import them from it.\r\nexport { findNode2D, frameIn } from \"@motionscript/sdk\"\r\n\r\nimport {\r\n  applyItemEffects,\r\n  REVEAL_STYLES,\r\n  WAVE_STYLES,\r\n  type FocusState,\r\n  type RevealState,\r\n  type RevealStyle,\r\n  type WaveState,\r\n  type WaveStyle,\r\n} from \"./item-effects\"\r\nimport { normalizeOrder, parseOrder, slotOfItem } from \"./order\"\r\nimport { hashSeed, shuffled } from \"./random\"\r\nimport { blendSlot, focalLengthOf, slotsOf, spreadSlot, type Arrangement, type Slot } from \"./slots\"\r\nimport { STAGGER_ORDERS, staggerProgress, staggerRanks, type StaggerOrder } from \"./stagger\"\r\n\r\n/** An arrangement a grid is leaving, kept as data so its slots can be worked out afresh every frame. */\r\nexport interface GridSnapshot {\r\n  arrangement: Arrangement\r\n  /** The grid the arrangement was borrowed from, or `\"\"` for the grid's own. */\r\n  source: string\r\n  order: readonly number[]\r\n  spread: number\r\n}\r\n\r\n/** A change of arrangement under way: where the items are coming from, and how far each has come. */\r\nexport interface GridTransition {\r\n  from: GridSnapshot\r\n  /** Each item's eased, staggered progress, `0..1`. */\r\n  mix: readonly number[]\r\n}\r\n\r\nexport interface ItemGridProps extends Node2DProps {\r\n  /** Items in slot order: slot `k` holds child `order[k]`. Empty is the children's own order. */\r\n  order: number[]\r\n  /** `0` gathers every item at the centre, `1` is the arrangement, past `1` pushes them apart. */\r\n  spread: number\r\n  /** Another grid whose arrangement this one takes on — what {@link ItemGrid.morphInto} animates. */\r\n  arrangeLike: string\r\n  // What the per-item commands write. State rather than settings: a command\r\n  // owns each while it runs, and a document has no reason to name them.\r\n  revealState: RevealState | null\r\n  waveState: WaveState | null\r\n  focusState: FocusState | null\r\n  transition: GridTransition | null\r\n}\r\n\r\n/** What a command that moves the items to new slots is built from. */\r\nexport interface TransitionArgs {\r\n  data?: StaggerArgs\r\n  duration: number\r\n  easing?: EasingFunction\r\n}\r\n\r\n/** The stagger options every per-item command takes. */\r\nexport interface StaggerArgs {\r\n  staggerOrder?: StaggerOrder\r\n  /** `0..0.95`: how much of the command's length the items' offsets take up. */\r\n  stagger?: number\r\n}\r\n\r\n/** `@command` descriptors for {@link StaggerArgs}, `stagger` defaulting to `fallback`. */\r\nexport function staggerArgs(fallback: number) {\r\n  return [\r\n    { key: \"staggerOrder\", kind: \"enum\", options: STAGGER_ORDERS, default: \"index\" },\r\n    { key: \"stagger\", min: 0, max: 0.95, step: 0.05, default: fallback },\r\n  ] as const\r\n}\r\n\r\n/**\r\n * Every grid's document key — what a reference to \"another grid\" may name. A\r\n * `nodeRef` descriptor carries it as `nodeTypes`, for a host's picker to offer\r\n * only those.\r\n */\r\nexport const ITEM_GRID_TYPES = [\"rectangularGrid\", \"radialGrid\", \"pathGrid\", \"sphereGrid\"] as const\r\n\r\n/** The stagger a move to new slots takes when its command states none. */\r\nexport const TRANSITION_STAGGER = 0.3\r\n\r\nconst NO_CONTENT: Size2D = { width: 0, height: 0 }\r\nconst CENTRE = { x: 0, y: 0 }\r\n\r\n/**\r\n * The base of every grid: a container that places each of its children in a\r\n * slot of an arrangement — a rectangular grid, a ring, a path, a sphere.\r\n *\r\n * ## Children only\r\n *\r\n * The items are the children, in layer order. A child's slot is a parent\r\n * transform on it, so its own `x`/`y`/`rotation`/`scale` — and any command on\r\n * them — still work, relative to the slot. A group is one item; a grid of\r\n * grids is a grid of items that happen to be grids.\r\n *\r\n * ## One pass\r\n *\r\n * Every frame: measure the children, ask the arrangement for its slots (a pure\r\n * function of the props, the sizes and the clock), blend them from where a\r\n * transition is leaving, and layer on the per-item effects — reveal, wave,\r\n * focus. What is left is each child's box and {@link ChildPlacement}, which the\r\n * renderer, picking and `global` all read, so a selection outline lands on\r\n * the pixels even on a sphere.\r\n *\r\n * ## Commands\r\n *\r\n * Every command is a pure function of time, like the rest of the library. The\r\n * per-item ones stagger *inside* their duration — a one-second reveal takes one\r\n * second for four children or four hundred — and write their per-item state\r\n * into props ({@link revealState} and its siblings), which is what keeps them\r\n * seekable. The ones that change the arrangement itself (a reorder, a morph, a\r\n * column count) keep the arrangement they are leaving as data and blend each\r\n * item from its old slot to its new one.\r\n */\r\nexport abstract class ItemGrid<P extends ItemGridProps = ItemGridProps> extends Node2D<P> {\r\n  @property({ default: [], kind: \"order\", animatable: false }) declare order: number[]\r\n  @property({ default: 1, min: 0, max: 3, step: 0.05 }) declare spread: number\r\n  @property({ default: \"\", kind: \"nodeRef\", nodeTypes: ITEM_GRID_TYPES, animatable: false }) declare arrangeLike: string\r\n  // Unset until a command writes one, so a fresh node's row does not state them.\r\n  @property({ default: undefined, kind: \"state\", animatable: false }) declare revealState: RevealState | null | undefined\r\n  @property({ default: undefined, kind: \"state\", animatable: false }) declare waveState: WaveState | null | undefined\r\n  @property({ default: undefined, kind: \"state\", animatable: false }) declare focusState: FocusState | null | undefined\r\n  @property({ default: undefined, kind: \"state\", animatable: false }) declare transition: GridTransition | null | undefined\r\n\r\n  /**\r\n   * Bring the items in, one after another. Every item starts hidden, so place\r\n   * it where the grid enters — or after a {@link conceal}.\r\n   */\r\n  @command({ args: [{ key: \"style\", kind: \"enum\", options: REVEAL_STYLES, default: \"scale\" }, ...staggerArgs(0.5)] })\r\n  reveal(args: CommandArgs<{ style?: RevealStyle } & StaggerArgs> & { duration: number }): Command<ItemGridProps> {\r\n    const style = args.data?.style ?? \"scale\"\r\n    const ease = args.easing ?? (style === \"scale\" || style === \"flip\" ? easeOut(\"back\") : easeOut(\"cubic\"))\r\n    const ranks = this._ranks(args.data?.staggerOrder)\r\n    const stagger = args.data?.stagger ?? 0.5\r\n    return this.command<ItemGridProps>((t) => {\r\n      if (t >= 1) return { revealState: null }\r\n      return { revealState: { style, values: ranks.map((rank) => ease(staggerProgress(rank, t, stagger))) } }\r\n    }, args.duration)\r\n  }\r\n\r\n  /** Take the items out, one after another — {@link reveal} in reverse. They stay hidden after. */\r\n  @command({ args: [{ key: \"style\", kind: \"enum\", options: REVEAL_STYLES, default: \"scale\" }, ...staggerArgs(0.5)] })\r\n  conceal(args: CommandArgs<{ style?: RevealStyle } & StaggerArgs> & { duration: number }): Command<ItemGridProps> {\r\n    const style = args.data?.style ?? \"scale\"\r\n    const ease = args.easing ?? (style === \"scale\" || style === \"flip\" ? easeIn(\"back\") : easeInOut(\"cubic\"))\r\n    const ranks = this._ranks(args.data?.staggerOrder)\r\n    const stagger = args.data?.stagger ?? 0.5\r\n    const from = this.revealState?.values\r\n    return this.command<ItemGridProps>((t) => ({\r\n      revealState: {\r\n        style,\r\n        values: ranks.map((rank, i) => (from?.[i] ?? 1) * (1 - ease(staggerProgress(rank, t, stagger)))),\r\n      },\r\n    }), args.duration)\r\n  }\r\n\r\n  /** Send a ripple through the items that swells each in turn and settles back. */\r\n  @command({\r\n    args: [\r\n      { key: \"style\", kind: \"enum\", options: WAVE_STYLES, default: \"scale\" },\r\n      { key: \"amount\", min: 0, max: 2, step: 0.05, default: 0.3 },\r\n      ...staggerArgs(0.7),\r\n    ],\r\n  })\r\n  wave(args: CommandArgs<{ style?: WaveStyle; amount?: number } & StaggerArgs> & { duration: number }): Command<ItemGridProps> {\r\n    const style = args.data?.style ?? \"scale\"\r\n    const amount = args.data?.amount ?? 0.3\r\n    const ease = args.easing ?? easeInOut(\"sine\")\r\n    const ranks = this._ranks(args.data?.staggerOrder)\r\n    const stagger = args.data?.stagger ?? 0.7\r\n    return this.command<ItemGridProps>((t) => {\r\n      if (t >= 1) return { waveState: null }\r\n      return {\r\n        waveState: {\r\n          style,\r\n          amount,\r\n          values: ranks.map((rank) => Math.sin(Math.PI * ease(staggerProgress(rank, t, stagger)))),\r\n        },\r\n      }\r\n    }, args.duration)\r\n  }\r\n\r\n  /** Bring one item (by its place in the layers, from 0) forward and push the rest back. */\r\n  @command({\r\n    args: [\r\n      { key: \"item\", min: 0, step: 1, default: 0 },\r\n      { key: \"dim\", min: 0, max: 1, step: 0.05, default: 0.7 },\r\n      { key: \"grow\", min: 0, max: 1, step: 0.05, default: 0.15 },\r\n    ],\r\n  })\r\n  focus(args: CommandArgs<{ item?: number; dim?: number; grow?: number }> & { duration: number }): Command<ItemGridProps> {\r\n    const n = this._itemCount()\r\n    const item = Math.round(args.data?.item ?? 0)\r\n    return this._focusOn((i) => i === item, n, args)\r\n  }\r\n\r\n  /** Bring every item back to even. */\r\n  @command()\r\n  unfocus(args: CommandArgs<Record<string, never>> & { duration: number }): Command<ItemGridProps> {\r\n    const from = this.focusState\r\n    const ease = args.easing ?? easeInOut(\"cubic\")\r\n    return this.command<ItemGridProps>((t) => {\r\n      if (t >= 1 || !from) return { focusState: null }\r\n      const k = 1 - ease(t)\r\n      return { focusState: { ...from, values: from.values.map((v) => v * k) } }\r\n    }, args.duration)\r\n  }\r\n\r\n  /** Gather the items toward the centre (`0`), back to the arrangement (`1`), or push them apart. */\r\n  @command({ args: [{ key: \"spread\", min: 0, max: 3, step: 0.05, default: 1 }] })\r\n  spreadTo(args: CommandArgs<{ spread: number }> & { duration: number }): Command<P> {\r\n    return this.to({ data: { spread: args.data?.spread ?? 1 } as Partial<P>, duration: args.duration, easing: args.easing })\r\n  }\r\n\r\n  /** Send every item to a random slot. The same `seed` always deals the same way. */\r\n  @command({ args: [{ key: \"seed\", min: 0, step: 1, default: 1 }, ...staggerArgs(TRANSITION_STAGGER)] })\r\n  shuffle(args: CommandArgs<{ seed?: number } & StaggerArgs> & { duration: number }): Command<P> {\r\n    const current = normalizeOrder(this.order, this._itemCount())\r\n    let next = shuffled(current, args.data?.seed ?? 1)\r\n    // A shuffle that deals everything back where it was would look like nothing happened.\r\n    if (next.length > 1 && next.every((item, k) => item === current[k])) next = [...next.slice(1), next[0]]\r\n    return this._transitionTo({ order: next } as Partial<P>, args)\r\n  }\r\n\r\n  /** Two items trade places, by their place in the layers. */\r\n  @command({\r\n    args: [\r\n      { key: \"first\", min: 0, step: 1, default: 0 },\r\n      { key: \"second\", min: 0, step: 1, default: 1 },\r\n      ...staggerArgs(0),\r\n    ],\r\n  })\r\n  swap(args: CommandArgs<{ first?: number; second?: number } & StaggerArgs> & { duration: number }): Command<P> {\r\n    const order = normalizeOrder(this.order, this._itemCount())\r\n    const a = order.indexOf(Math.round(args.data?.first ?? 0))\r\n    const b = order.indexOf(Math.round(args.data?.second ?? 1))\r\n    if (a >= 0 && b >= 0) [order[a], order[b]] = [order[b], order[a]]\r\n    return this._transitionTo({ order } as Partial<P>, args, 0)\r\n  }\r\n\r\n  /** Move the items into a new order — a list of layer indices, first slot first, like `\"2, 0, 1\"`. */\r\n  @command({ args: [{ key: \"order\", kind: \"text\", default: \"\" }, ...staggerArgs(TRANSITION_STAGGER)] })\r\n  reorder(args: CommandArgs<{ order?: string | number[] } & StaggerArgs> & { duration: number }): Command<P> {\r\n    const order = normalizeOrder(parseOrder(args.data?.order), this._itemCount())\r\n    return this._transitionTo({ order } as Partial<P>, args)\r\n  }\r\n\r\n  /**\r\n   * Move every item into another grid's arrangement — a grid into a ring, a ring\r\n   * onto a sphere — and keep following it. An empty `target` morphs back to\r\n   * this grid's own.\r\n   */\r\n  @command({ args: [{ key: \"target\", kind: \"nodeRef\", nodeTypes: ITEM_GRID_TYPES }, ...staggerArgs(TRANSITION_STAGGER)] })\r\n  morphInto(args: CommandArgs<{ target?: string } & StaggerArgs> & { duration: number }): Command<P> {\r\n    return this._transitionTo({ arrangeLike: args.data?.target ?? \"\" } as Partial<P>, args)\r\n  }\r\n\r\n  /** This grid's own arrangement, for a content box of `box`. */\r\n  protected abstract arrangementFor(box: Size2D): Arrangement\r\n\r\n  // A grid's size is what its items come to. The base's rule — hug only when\r\n  // built with children — would have a grid from a document, whose children\r\n  // arrive after it, fill its parent instead.\r\n  protected override applyDefaultSize(props?: { readonly width?: unknown; readonly height?: unknown }): void {\r\n    if (!props || props.width === undefined) this.applyProp(\"width\", \"hug\", { tween: sizeInputOps.lerp })\r\n    if (!props || props.height === undefined) this.applyProp(\"height\", \"hug\", { tween: sizeInputOps.lerp })\r\n  }\r\n\r\n  /** The room each item is measured in — the whole content box, unless an arrangement has cells. */\r\n  protected itemSpace(_count: number, space: Size2D, _sizes?: readonly Size2D[]): Size2D {\r\n    return space\r\n  }\r\n\r\n  override measure(constraints: SizeConstraints, scope: MeasureContext2D): Partial<Size2D> {\r\n    this.lastMeasure = { constraints, measurer: scope }\r\n    const padding = this.effectivePadding()\r\n    const items = this.flowChildren()\r\n    if (items.length === 0) {\r\n      this._measured = null\r\n      return flowOps.size(this, constraints, padding, NO_CONTENT)\r\n    }\r\n    const space = flowOps.contentBox(this, constraints, padding)\r\n    const sizes = this._measureItems(items, space, scope)\r\n    this._measured = { space, sizes }\r\n    return flowOps.size(this, constraints, padding, extentOf(this._targetSlots(items.length, sizes, space).slots, sizes, this._focal))\r\n  }\r\n\r\n  protected override layoutChildren(rect: BoxBounds, scope: MeasureContext2D): void {\r\n    this._placements.clear()\r\n    const items = this.flowChildren()\r\n    if (items.length === 0) {\r\n      this._slots = []\r\n      this._sizes = []\r\n      this._focal = 0\r\n      return\r\n    }\r\n    const inner = insetsOps.insetBounds(rect.width, rect.height, this.effectivePadding())\r\n    const measured = this._measured\r\n    this._measured = null\r\n    const sizes = measured && measured.sizes.length === items.length && sameSize(measured.space, inner)\r\n      ? measured.sizes\r\n      : this._measureItems(items, inner, scope)\r\n    const slots = this._resolve(sizes, inner)\r\n    this._slots = slots\r\n    this._sizes = sizes\r\n    for (let i = 0; i < items.length; i++) {\r\n      const s = slots[i]\r\n      items[i].layout({ x: inner.x + s.x, y: inner.y - s.y, width: sizes[i].width, height: sizes[i].height }, scope)\r\n      if (s.rotation !== 0 || s.scale !== 1 || s.rotationX !== 0 || s.rotationY !== 0 || s.depth !== 0 || s.opacity !== 1) {\r\n        this._placements.set(items[i], {\r\n          rotation: s.rotation,\r\n          scale: s.scale,\r\n          rotationX: s.rotationX,\r\n          rotationY: s.rotationY,\r\n          depth: s.depth,\r\n          opacity: s.opacity,\r\n        })\r\n      }\r\n    }\r\n  }\r\n\r\n  override _placementOf(child: Node2D): ChildPlacement | null {\r\n    return this._placements.get(child) ?? null\r\n  }\r\n\r\n  /**\r\n   * A grid whose arrangement has depth is seen through a camera of its own,\r\n   * which paints its items far to near — unless it already sits in a space (an\r\n   * orbit camera, a 3D stage), where its items join that one and its camera.\r\n   */\r\n  override _spaceCamera(): SpaceCamera | null {\r\n    const focal = this._focal\r\n    if (focal <= 0 || this._inSpace()) return null\r\n    return {\r\n      perspective: focal,\r\n      orbit: 0,\r\n      elevation: 0,\r\n      dolly: 0,\r\n      lookAt: CENTRE,\r\n      zoom: 1,\r\n      heading: 0,\r\n      viewportX: 0,\r\n      viewportY: 0,\r\n    }\r\n  }\r\n\r\n  private readonly _placements = new Map<Node2D, ChildPlacement>()\r\n  /** What {@link measure} found, for {@link layoutChildren} to reuse in the same pass. */\r\n  private _measured: { space: Size2D; sizes: Size2D[] } | null = null\r\n  /** Each item's slot from the last layout — what a command ranks its stagger by. */\r\n  private _slots: Slot[] = []\r\n  /** Each item's size from the last layout. */\r\n  private _sizes: readonly Size2D[] = []\r\n  /** The last layout's camera distance, `0` while flat. */\r\n  private _focal = 0\r\n  private _borrowCache: { id: string; grid: ItemGrid } | null = null\r\n\r\n  /** How many items a command built now will act on. */\r\n  protected _itemCount(): number {\r\n    return this.flowChildren().length\r\n  }\r\n\r\n  /** Each item's slot as it stands, for a command being built — the last layout's where it still fits. */\r\n  protected _itemSlots(): Slot[] {\r\n    const n = this._itemCount()\r\n    if (this._slots.length === n) return this._slots\r\n    const sizes = new Array<Size2D>(n).fill({ width: 100, height: 100 })\r\n    return this._targetSlots(n, sizes, contentBoxOf(this)).slots\r\n  }\r\n\r\n  /** The item sizes the last layout found. */\r\n  protected _itemSizes(): readonly Size2D[] {\r\n    return this._sizes.length === this._itemCount() ? this._sizes : []\r\n  }\r\n\r\n  /** Each item's start in a stagger. A random order is seeded by the node's id, so it never changes between builds. */\r\n  protected _ranks(order: StaggerOrder | undefined): number[] {\r\n    return staggerRanks(order ?? \"index\", this._itemSlots(), hashSeed(this.id))\r\n  }\r\n\r\n  /**\r\n   * Write `changes` to the arrangement and move each item from its slot in the\r\n   * one being left to its slot in the new one, staggered.\r\n   */\r\n  protected _transitionTo(changes: Partial<P>, args: TransitionArgs, stagger = TRANSITION_STAGGER): Command<P> {\r\n    const from = this._snapshot()\r\n    const ease = args.easing ?? easeInOut(\"cubic\")\r\n    const ranks = this._ranks(args.data?.staggerOrder)\r\n    const spread = args.data?.stagger ?? stagger\r\n    return this.command<P>((t) => {\r\n      if (t >= 1) return { ...changes, transition: null } as Partial<P>\r\n      const mix = ranks.map((rank) => ease(staggerProgress(rank, t, spread)))\r\n      return { ...changes, transition: { from, mix } } as Partial<P>\r\n    }, args.duration)\r\n  }\r\n\r\n  /** Emphasise the items `isFocus` picks and push the rest back. */\r\n  protected _focusOn(\r\n    isFocus: (item: number) => boolean,\r\n    count: number,\r\n    args: CommandArgs<{ dim?: number; grow?: number }> & { duration: number },\r\n  ): Command<ItemGridProps> {\r\n    const from = this.focusState\r\n    const dim = args.data?.dim ?? 0.7\r\n    const grow = args.data?.grow ?? 0.15\r\n    const target = Array.from({ length: count }, (_, i) => (isFocus(i) ? 1 : -1))\r\n    const ease = args.easing ?? easeInOut(\"cubic\")\r\n    return this.command<ItemGridProps>((t) => {\r\n      const e = ease(t)\r\n      return {\r\n        focusState: {\r\n          dim: lerp(from?.dim ?? dim, dim, e),\r\n          grow: lerp(from?.grow ?? grow, grow, e),\r\n          values: target.map((v, i) => lerp(from?.values[i] ?? 0, v, e)),\r\n        },\r\n      }\r\n    }, args.duration)\r\n  }\r\n\r\n  private _snapshot(): GridSnapshot {\r\n    const source = this._borrowed()\r\n    return {\r\n      arrangement: source ? source.arrangementFor(contentBoxOf(source)) : this.arrangementFor(contentBoxOf(this)),\r\n      source: source?.id ?? \"\",\r\n      order: normalizeOrder(this.order, this._itemCount()),\r\n      spread: this.spread,\r\n    }\r\n  }\r\n\r\n  private _measureItems(items: readonly Node2D[], space: Size2D, scope: MeasureContext2D): Size2D[] {\r\n    const measured = flowOps.measure({}, items, space, scope).sizes\r\n    const cell = this.itemSpace(items.length, space, measured)\r\n    if (cell === space) return [...measured]\r\n    return [...flowOps.measure({}, items, cell, scope).sizes]\r\n  }\r\n\r\n  /** Where each item sits in the arrangement it is heading for, before any transition or effect. */\r\n  private _targetSlots(count: number, sizes: readonly Size2D[], box: Size2D): { slots: Slot[]; arrangement: Arrangement } {\r\n    const source = this._borrowed()\r\n    const arrangement = source ? source.arrangementFor(contentBoxOf(source)) : this.arrangementFor(box)\r\n    let slots = slotsOf(arrangement, { count, sizes, box: source ? contentBoxOf(source) : box, time: this.time.total })\r\n    if (source) slots = this._fromGrid(source, slots)\r\n    const slotOf = slotOfItem(normalizeOrder(this.order, count))\r\n    return { slots: slotOf.map((k) => spreadSlot(slots[k], this.spread)), arrangement }\r\n  }\r\n\r\n  /** Each item's final slot this frame: the target, blended from any transition, with its effects on. */\r\n  private _resolve(sizes: readonly Size2D[], box: Size2D): Slot[] {\r\n    const count = sizes.length\r\n    const target = this._targetSlots(count, sizes, box)\r\n    const slots = target.slots\r\n    let focal = focalLengthOf(target.arrangement)\r\n    const transition = this.transition\r\n    if (transition) {\r\n      const { from } = transition\r\n      const source = from.source ? this._gridById(from.source) : null\r\n      const fromBox = source ? contentBoxOf(source) : box\r\n      let leaving = slotsOf(from.arrangement, { count, sizes, box: fromBox, time: this.time.total })\r\n      if (source && source !== this) leaving = this._fromGrid(source, leaving)\r\n      const slotOf = slotOfItem(normalizeOrder(from.order, count))\r\n      for (let i = 0; i < count; i++) {\r\n        slots[i] = blendSlot(spreadSlot(leaving[slotOf[i]], from.spread), slots[i], transition.mix[i] ?? 1)\r\n      }\r\n      // A morph into or out of depth keeps the camera for its whole length.\r\n      focal = focal || focalLengthOf(from.arrangement)\r\n    }\r\n    this._focal = focal\r\n    const reveal = this.revealState\r\n    const wave = this.waveState\r\n    const focus = this.focusState\r\n    if (reveal || wave || focus) {\r\n      for (let i = 0; i < count; i++) applyItemEffects(slots[i], i, sizes[i], reveal, wave, focus)\r\n    }\r\n    return slots\r\n  }\r\n\r\n  /** Whether an ancestor places this grid in a space, as `spaceFrameOf` walks it. */\r\n  private _inSpace(): boolean {\r\n    for (let n = this.parent; n; n = n.parent) {\r\n      if (n._spaceCamera()) return true\r\n      if (!n._rendersChildrenInSpace()) return false\r\n    }\r\n    return false\r\n  }\r\n\r\n  /** The grid {@link arrangeLike} names, when it names another grid in this tree. */\r\n  private _borrowed(): ItemGrid | null {\r\n    const id = this.arrangeLike\r\n    if (!id || id === this.id) return null\r\n    return this._gridById(id)\r\n  }\r\n\r\n  private _gridById(id: string): ItemGrid | null {\r\n    if (id === this.id) return this\r\n    const cached = this._borrowCache\r\n    if (cached && cached.id === id && cached.grid.mounted) return cached.grid\r\n    const found = findNode2D(this, id)\r\n    const grid = found instanceof ItemGrid ? found : null\r\n    this._borrowCache = grid ? { id, grid } : null\r\n    return grid\r\n  }\r\n\r\n  /** `slots`, laid out in `source`'s frame, moved into this grid's. */\r\n  private _fromGrid(source: ItemGrid, slots: Slot[]): Slot[] {\r\n    const frame = frameIn(this, source)\r\n    return slots.map((s) => {\r\n      const p = rotateClockwise(s.x * frame.scale, s.y * frame.scale, frame.rotation)\r\n      return {\r\n        ...s,\r\n        x: frame.x + p.x,\r\n        y: frame.y + p.y,\r\n        depth: s.depth * frame.scale,\r\n        rotation: s.rotation + frame.rotation,\r\n        scale: s.scale * frame.scale,\r\n      }\r\n    })\r\n  }\r\n}\r\n\r\n/** A node's content box: its laid-out size inside its padding. */\r\nexport function contentBoxOf(grid: Node2D): Size2D {\r\n  const b = grid.layoutBounds\r\n  const inner = insetsOps.insetBounds(b.width, b.height, grid.effectivePadding())\r\n  return { width: inner.width, height: inner.height }\r\n}\r\n\r\n/** The box, centred on the grid, that holds every item where its slot puts it. */\r\nfunction extentOf(slots: readonly Slot[], sizes: readonly Size2D[], focal: number): Size2D {\r\n  let halfWidth = 0\r\n  let halfHeight = 0\r\n  for (let i = 0; i < slots.length; i++) {\r\n    const s = slots[i]\r\n    const size = sizes[i]\r\n    const rad = (s.rotation * Math.PI) / 180\r\n    const cos = Math.abs(Math.cos(rad))\r\n    const sin = Math.abs(Math.sin(rad))\r\n    // What the camera does to a slot at depth, so a sphere hugs its front.\r\n    const lens = focal > 0 && focal - s.depth > 1 ? focal / (focal - s.depth) : 1\r\n    const w = ((size.width * cos + size.height * sin) / 2) * s.scale * lens\r\n    const h = ((size.width * sin + size.height * cos) / 2) * s.scale * lens\r\n    halfWidth = Math.max(halfWidth, Math.abs(s.x) * lens + w)\r\n    halfHeight = Math.max(halfHeight, Math.abs(s.y) * lens + h)\r\n  }\r\n  return { width: halfWidth * 2, height: halfHeight * 2 }\r\n}\r\n\r\nfunction rotateClockwise(x: number, y: number, degrees: number): { x: number; y: number } {\r\n  if (degrees === 0) return { x, y }\r\n  const rad = (degrees * Math.PI) / 180\r\n  const cos = Math.cos(rad)\r\n  const sin = Math.sin(rad)\r\n  return { x: x * cos + y * sin, y: -x * sin + y * cos }\r\n}\r\n\r\nfunction sameSize(a: Size2D, b: Size2D): boolean {\r\n  return Math.abs(a.width - b.width) < 1e-6 && Math.abs(a.height - b.height) < 1e-6\r\n}\r\n\r\nfunction lerp(a: number, b: number, t: number): number {\r\n  return a + (b - a) * t\r\n}\r\n"],
-  "mappings": "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",
-  "names": ["pathOps", "slot", "x", "y", "meta", "blendSlot", "a", "b", "t", "mix", "p", "q", "spreadSlot", "s", "spread", "largest", "sizes", "width", "height", "size", "PATH_SPACINGS", "SAMPLERS", "SAMPLER_CACHE", "measured", "path", "hit", "contours", "pathOps", "entry", "pathSlots", "arrangement", "input", "count", "sampler", "closed", "length", "clamp01", "b", "start", "span", "loops", "offset", "place", "rad", "cos", "sin", "slots", "u", "visible", "at", "s", "slot", "flip", "px", "py", "v", "RADIAL_DIRECTIONS", "radialAngles", "arrangement", "count", "time", "sweep", "closing", "step", "sign", "start", "angles", "k", "radialSlots", "input", "angle", "rad", "s", "slot", "radialTurnToTop", "index", "wrapDegrees", "degrees", "wrapped", "FILL_DIRECTIONS", "CELL_MODES", "LINE_ALIGNS", "rectangularShape", "arrangement", "count", "columns", "rows", "rectangularCell", "sizes", "box", "largest", "rectangularSlots", "input", "byColumn", "lines", "perLine", "cell", "pitchX", "pitchY", "lastLine", "lastCount", "shortBy", "lead", "shiftX", "shiftY", "slots", "i", "line", "along", "row", "column", "rowIndex", "columnIndex", "x", "y", "slot", "SPHERE_FACINGS", "SPHERE_AXES", "GOLDEN_ANGLE", "DEG", "fibonacciPoint", "k", "count", "y", "r", "theta", "orient", "p", "yaw", "pitch", "roll", "x0", "y0", "z0", "ya", "pa", "ra", "x1", "z1", "y2", "z2", "sphereSlots", "arrangement", "input", "radius", "outward", "slots", "q", "nx", "ny", "nz", "s", "slot", "facesAway", "normal", "focal", "sphereFaceForward", "index", "x", "z", "PATH_TEMPLATES", "DRAWN", "DRAWN_CACHE", "templatePath", "template", "box", "key", "hit", "path", "drawTemplate", "w", "h", "rx", "ry", "closed", "points", "angle", "r", "sample", "t", "a", "x", "y", "d", "open", "ellipse", "k", "steps", "at", "i", "slotsOf", "arrangement", "input", "rectangularSlots", "radialSlots", "pathSlots", "sphereSlots", "focalLengthOf", "seededRandom", "seed", "a", "t", "shuffled", "values", "out", "random", "i", "j", "hashSeed", "text", "h", "STAGGER_ORDERS", "MAX_STAGGER", "staggerRanks", "order", "slots", "seed", "n", "keys", "keysOf", "min", "max", "key", "range", "staggerProgress", "rank", "stagger", "s", "p", "_", "i", "sequence", "shuffled", "item", "clockAngle", "angle", "REVEAL_STYLES", "WAVE_STYLES", "applyItemEffects", "s", "i", "size", "reveal", "wave", "focus", "applyReveal", "applyWave", "applyFocus", "style", "v", "shown", "clamp01", "w", "f", "normalizeOrder", "order", "count", "out", "taken", "entry", "item", "slotOfItem", "slots", "slot", "parseOrder", "value", "part", "command", "easeIn", "easeInOut", "easeOut", "findNode2D", "flowOps", "frameIn", "insetsOps", "Node2D", "property", "sizeInputOps", "staggerArgs", "fallback", "STAGGER_ORDERS", "ITEM_GRID_TYPES", "TRANSITION_STAGGER", "NO_CONTENT", "CENTRE", "ItemGrid", "_ItemGrid", "Node2D", "args", "style", "ease", "easeOut", "ranks", "stagger", "t", "rank", "staggerProgress", "easeIn", "easeInOut", "from", "i", "amount", "n", "item", "k", "v", "current", "normalizeOrder", "next", "shuffled", "order", "a", "b", "parseOrder", "props", "sizeInputOps", "_count", "space", "_sizes", "constraints", "scope", "padding", "items", "flowOps", "sizes", "extentOf", "rect", "inner", "insetsOps", "measured", "sameSize", "slots", "s", "child", "focal", "contentBoxOf", "staggerRanks", "hashSeed", "changes", "spread", "mix", "isFocus", "count", "dim", "grow", "target", "_", "e", "lerp", "source", "cell", "box", "arrangement", "slotsOf", "slotOfItem", "spreadSlot", "focalLengthOf", "transition", "fromBox", "leaving", "slotOf", "blendSlot", "reveal", "wave", "focus", "applyItemEffects", "id", "cached", "found", "findNode2D", "grid", "frame", "frameIn", "p", "rotateClockwise", "__decorate", "property", "command", "REVEAL_STYLES", "WAVE_STYLES", "halfWidth", "halfHeight", "size", "rad", "cos", "sin", "lens", "w", "h", "x", "y", "degrees"]
-}