@phin-tech/dottie 0.8.0 → 0.9.0

package/dist/dottie-player.js

@@ -1,4 +1,4 @@
-/*! dottie.js 0.8.0 | Apache-2.0 | https://github.com/phin-tech/dottie */
+/*! dottie.js 0.9.0 | Apache-2.0 | https://github.com/phin-tech/dottie */
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value2) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value: value2 }) : obj[key] = value2;
 var __export = (target, all) => {
@@ -609,15 +609,15 @@ var Reader = class {
     const keys = (Array.isArray(v.keys) ? v.keys : []).map((k) => this.keyframe(k)).filter((k) => k !== null && k.t >= 0 && k.t <= MAX_DURATION);
     stableSortBy(keys, (k) => k.t);
     const follow = Array.isArray(v.follow) ? v.follow.filter(isObj).flatMap((f) => {
-      const path = uuid(f.path), start = num(f.start), end = num(f.end);
-      if (!path || start === void 0 || end === void 0 || start < 0 || end > MAX_DURATION) return [];
-      return [{ path, start, end, ease: this.ease(f.ease), reverse: bool(f.reverse) ?? null, orient: bool(f.orient) ?? null, laps: num(f.laps) ?? null }];
+      const path = uuid(f.path), start2 = num(f.start), end = num(f.end);
+      if (!path || start2 === void 0 || end === void 0 || start2 < 0 || end > MAX_DURATION) return [];
+      return [{ path, start: start2, end, ease: this.ease(f.ease), reverse: bool(f.reverse) ?? null, orient: bool(f.orient) ?? null, laps: num(f.laps) ?? null }];
     }) : null;
     const repeats = Array.isArray(v.repeats) ? v.repeats.filter(isObj).flatMap((r) => {
-      const start = num(r.start), end = num(r.end);
-      if (start === void 0 || end === void 0) return [];
+      const start2 = num(r.start), end = num(r.end);
+      if (start2 === void 0 || end === void 0) return [];
       const count = num(r.count);
-      const rep = { start, end, count: count === void 0 ? null : Math.trunc(count) };
+      const rep = { start: start2, end, count: count === void 0 ? null : Math.trunc(count) };
       return repeatIsValid(rep) ? [rep] : [];
     }) : null;
     return { element, keys, boil: bool(v.boil) ?? null, follow, repeats, march: clampMarch(num(v.march)) };
@@ -842,6 +842,21 @@ function pieces(para) {
   if (cur || out.length === 0) out.push(cur);
   return out;
 }
+function prefixWidths(chars, fontSize, face, font) {
+  const fam = familyMetrics(font);
+  const f = fam.faces[face] ?? fam.faces.regular;
+  const fallback = f.w["n"];
+  const out = [0];
+  let w = 0;
+  let prev = "";
+  for (const ch of chars) {
+    w += f.w[ch] ?? fallback;
+    if (prev) w += f.k[prev + ch] ?? 0;
+    prev = ch;
+    out.push(w * fontSize / 1e3);
+  }
+  return out;
+}
 function wrap(s, fontSize, maxWidth, face = "regular", font) {
   const width = (t) => measure(t, fontSize, face, font);
   const out = [];
@@ -857,8 +872,9 @@ function wrap(s, fontSize, maxWidth, face = "regular", font) {
       }
       while (width(line2.trimEnd()) > maxWidth && [...line2.trimEnd()].length > 1) {
         const chars = [...line2];
+        const prefix = prefixWidths(chars, fontSize, face, font);
         let n = chars.length - 1;
-        while (n > 1 && width(chars.slice(0, n).join("")) > maxWidth) n--;
+        while (n > 1 && prefix[n] > maxWidth) n--;
         out.push(chars.slice(0, n).join(""));
         line2 = chars.slice(n).join("");
       }
@@ -1013,13 +1029,13 @@ var Path = class _Path {
   contours() {
     const out = [];
     let current = [];
-    let start = { x: 0, y: 0 };
+    let start2 = { x: 0, y: 0 };
     for (const s of this.segments) {
-      const last = current.length ? current[current.length - 1] : start;
+      const last = current.length ? current[current.length - 1] : start2;
       switch (s.op) {
         case "M":
           if (current.length > 1) out.push(current);
-          start = s.p;
+          start2 = s.p;
           current = [s.p];
           break;
         case "L":
@@ -1041,9 +1057,9 @@ var Path = class _Path {
           }
           break;
         case "Z":
-          current.push(start);
+          current.push(start2);
           if (current.length > 1) out.push(current);
-          current = [start];
+          current = [start2];
           break;
       }
     }
@@ -1435,9 +1451,17 @@ function midpoint(e, index) {
   }
   return pts[0];
 }
+var indexes = /* @__PURE__ */ new WeakMap();
+function isIndexOf(page, index) {
+  return indexes.get(page.elements)?.index === index;
+}
 function indexOf(page) {
+  const els = page.elements;
+  const hit = indexes.get(els);
+  if (hit && hit.members.length === els.length && hit.members.every((e, i) => e === els[i])) return hit.index;
   const m = /* @__PURE__ */ new Map();
-  for (const e of page.elements) if (!m.has(e.id)) m.set(e.id, e);
+  for (const e of els) if (!m.has(e.id)) m.set(e.id, e);
+  indexes.set(els, { members: [...els], index: m });
   return m;
 }
 
@@ -1520,43 +1544,112 @@ function packetID(flow, k) {
   return flow.slice(0, 24) + (n < 0 ? n + 2 ** 48 : n).toString(16).toUpperCase().padStart(12, "0");
 }
 var routeCost = (cost) => cost === null || !Number.isFinite(cost) ? 1 : Math.min(Math.max(cost, 0), 1e6);
-function flowTree(from, frame2, offline = /* @__PURE__ */ new Set()) {
-  const shapes2 = new Set(frame2.elements.filter((e) => e.kind !== "connector" && !offline.has(e.id)).map((e) => e.id));
-  if (!shapes2.has(from)) return null;
-  const next = /* @__PURE__ */ new Map();
-  const add2 = (a, edge) => {
-    const list = next.get(a);
-    if (list) list.push(edge);
-    else next.set(a, [edge]);
-  };
-  for (const e of frame2.elements) {
+var graphs = /* @__PURE__ */ new WeakMap();
+var networks = /* @__PURE__ */ new Map();
+function graphOf(frame2) {
+  const els = frame2.elements;
+  const hit = graphs.get(els);
+  if (hit && hit.members.length === els.length && hit.members.every((e, i) => e === els[i])) return hit.graph;
+  const shapes2 = new Set(els.filter((e) => e.kind !== "connector").map((e) => e.id));
+  const lines = [];
+  for (const e of els) {
     const c = e.connector;
-    const a = c?.start.elementID ?? null, b = c?.end.elementID ?? null;
-    if (!c || offline.has(e.id) || a === null || b === null || a === b || !shapes2.has(a) || !shapes2.has(b)) continue;
-    const cost = routeCost(c.cost);
-    add2(a, { to: b, via: e.id, back: false, cost });
-    if (c.startHead !== "none") add2(b, { to: a, via: e.id, back: true, cost });
+    if (c) lines.push([e.id, c.start.elementID, c.end.elementID, String(routeCost(c.cost)), c.startHead !== "none" ? "both" : "one"]);
+  }
+  const key = JSON.stringify([[...shapes2], lines]);
+  let graph = networks.get(key);
+  if (!graph) {
+    const next = /* @__PURE__ */ new Map();
+    const add2 = (a, edge) => {
+      const list = next.get(a);
+      if (list) list.push(edge);
+      else next.set(a, [edge]);
+    };
+    for (const e of els) {
+      const c = e.connector;
+      const a = c?.start.elementID ?? null, b = c?.end.elementID ?? null;
+      if (!c || a === null || b === null || a === b || !shapes2.has(a) || !shapes2.has(b)) continue;
+      const cost = routeCost(c.cost);
+      add2(a, { to: b, via: e.id, back: false, cost });
+      if (c.startHead !== "none") add2(b, { to: a, via: e.id, back: true, cost });
+    }
+    graph = { shapes: shapes2, next, trees: /* @__PURE__ */ new Map() };
+    if (networks.size >= 16) networks.clear();
+    networks.set(key, graph);
+  }
+  graphs.set(els, { members: [...els], graph });
+  return graph;
+}
+var Frontier = class {
+  constructor() {
+    __publicField(this, "heap", []);
+  }
+  get size() {
+    return this.heap.length;
+  }
+  less(i, j) {
+    const a = this.heap[i], b = this.heap[j];
+    return a.dist < b.dist || a.dist === b.dist && a.order < b.order;
+  }
+  swap(i, j) {
+    [this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]];
+  }
+  push(id, dist, order) {
+    this.heap.push({ id, dist, order });
+    for (let i = this.heap.length - 1; i > 0; ) {
+      const up = i - 1 >> 1;
+      if (!this.less(i, up)) break;
+      this.swap(i, up);
+      i = up;
+    }
+  }
+  pop() {
+    const top = this.heap[0], last = this.heap.pop();
+    if (this.heap.length > 0) {
+      this.heap[0] = last;
+      for (let i = 0; ; ) {
+        const l = 2 * i + 1, r = l + 1;
+        let m = i;
+        if (l < this.heap.length && this.less(l, m)) m = l;
+        if (r < this.heap.length && this.less(r, m)) m = r;
+        if (m === i) break;
+        this.swap(i, m);
+        i = m;
+      }
+    }
+    return top;
   }
+};
+function flowTree(from, frame2, offline = /* @__PURE__ */ new Set(), until) {
+  const graph = graphOf(frame2);
+  const key = JSON.stringify([from, until ?? null, [...offline].sort()]);
+  if (graph.trees.has(key)) return graph.trees.get(key);
+  const tree = grow(graph, from, offline, until);
+  if (graph.trees.size >= 4096) graph.trees.clear();
+  graph.trees.set(key, tree);
+  return tree;
+}
+function grow({ shapes: shapes2, next }, from, offline, until) {
+  if (!shapes2.has(from) || offline.has(from)) return null;
   const dist = /* @__PURE__ */ new Map([[from, 0]]), order = /* @__PURE__ */ new Map([[from, 0]]);
   let counter = 1;
   const tree = new FlowTree(from);
-  const open = [from];
-  while (open.length > 0) {
-    let best = 0;
-    for (let i = 1; i < open.length; i++) {
-      const da = dist.get(open[i]), db = dist.get(open[best]);
-      if (da < db || da === db && order.get(open[i]) < order.get(open[best])) best = i;
-    }
-    const n = open.splice(best, 1)[0];
+  const open = new Frontier();
+  open.push(from, 0, 0);
+  while (open.size > 0) {
+    const { id: n, order: o } = open.pop();
+    if (tree.settled.has(n) || order.get(n) !== o) continue;
     tree.settled.add(n);
+    if (n === until && n !== from) break;
     for (const edge of next.get(n) ?? []) {
+      if (offline.has(edge.via) || offline.has(edge.to)) continue;
       if (tree.settled.has(edge.to)) continue;
       const d = dist.get(n) + edge.cost;
       const old = dist.get(edge.to);
       if (old !== void 0 && old <= d) continue;
-      if (old === void 0) open.push(edge.to);
       dist.set(edge.to, d);
-      order.set(edge.to, counter++);
+      order.set(edge.to, counter);
+      open.push(edge.to, d, counter++);
       tree.came.set(edge.to, { from: n, via: edge.via, back: edge.back });
     }
   }
@@ -1636,8 +1729,16 @@ function delayOf(e) {
 var queueKey = (shape, flow) => shape + "|" + flow;
 function flowFrame(flows, frame2, t, values, offline = /* @__PURE__ */ new Set(), sinceChange = null, carried = {}) {
   const since = Math.max(0, Math.min(sinceChange ?? t, 1e6));
-  const byID = /* @__PURE__ */ new Map();
-  for (const e of frame2.elements) if (!byID.has(e.id)) byID.set(e.id, e);
+  const byID = indexOf(frame2);
+  const traced = /* @__PURE__ */ new Map();
+  const traceOf = (c) => {
+    let pts = traced.get(c.id);
+    if (!pts) {
+      pts = tracing(c, frame2, byID).points;
+      traced.set(c.id, pts);
+    }
+    return pts;
+  };
   const metrics2 = emptyMetrics();
   for (const e of frame2.elements) {
     if (e.kind === "connector" && !e.connector) continue;
@@ -1667,7 +1768,7 @@ function flowFrame(flows, frame2, t, values, offline = /* @__PURE__ */ new Set()
     hops.forEach(([id, back], k) => {
       const c = byID.get(id);
       if (!c) return;
-      const line2 = back ? [...tracing(c, frame2).points].reverse() : tracing(c, frame2).points;
+      const line2 = back ? [...traceOf(c)].reverse() : traceOf(c);
       if (line2.length === 0) return;
       const last = points[points.length - 1];
       if (last) {
@@ -1676,9 +1777,9 @@ function flowFrame(flows, frame2, t, values, offline = /* @__PURE__ */ new Set()
         inside.push([length, length + gap, shape ? delayOf(shape) : 0]);
         length += gap;
       }
-      const start = length;
+      const start2 = length;
       for (let q = 1; q < line2.length; q++) length += Math.hypot(line2[q].x - line2[q - 1].x, line2[q].y - line2[q - 1].y);
-      stretches.push([id, start, length]);
+      stretches.push([id, start2, length]);
       points.push(...line2);
     });
     return length > 0 ? { line: new Polyline(points), length, inside, stretches } : null;
@@ -1713,22 +1814,27 @@ function flowFrame(flows, frame2, t, values, offline = /* @__PURE__ */ new Set()
   const packets = [];
   const waitingBy = /* @__PURE__ */ new Map();
   const everyOf = (flow) => Math.min(Math.max(clamp(flow.every, DEFAULT_EVERY, 0.05, 60) * biggest / Math.max(amountIn(flow, values), TINY), 0.05), 60);
+  const bases = /* @__PURE__ */ new Map();
+  const baseTree = (from) => {
+    if (!bases.has(from)) bases.set(from, flowTree(from, frame2, offline));
+    return bases.get(from);
+  };
   for (const [i, flow] of list.entries()) {
     if (flow.when !== null && values !== null && !holds(flow.when, values)) continue;
     const source = byID.get(flow.from);
-    const base2 = source ? flowTree(flow.from, frame2, offline) : null;
+    const base2 = source ? baseTree(flow.from) : null;
     if (!source || !base2) continue;
     const volume = amountIn(flow, values);
     const fm = { volume, placed: 0, backlog: 0, backup: 0, transit: null };
     const placements = [];
-    const waiting = [];
+    const waiting2 = [];
     const goals = base2.goals(flow.to, flow.spread === true);
     const shares = goals.length > 1 ? goals.map((g) => [[g], volume / goals.length]) : [[flow.to, volume]];
     for (const [candidates, share] of shares) {
       if (!(share > TINY)) continue;
       let left = share;
       for (let n = 0; n < 32 && left > TINY; n++) {
-        const tree = flowTree(flow.from, frame2, union2(offline, full()));
+        const tree = flowTree(flow.from, frame2, union2(offline, full()), candidates[0]);
         const goal2 = tree?.goals(candidates, false)[0];
         if (!tree || goal2 === void 0) break;
         const r = route2(tree, goal2);
@@ -1768,18 +1874,18 @@ function flowFrame(flows, frame2, t, values, offline = /* @__PURE__ */ new Set()
           placements.push({ hops, shapes: shapes2, goal: at, amount: left, waits: true });
         }
       }
-      const existing = waiting.find(([s]) => s === at);
+      const existing = waiting2.find(([s]) => s === at);
       if (existing) existing[1] += left;
-      else waiting.push([at, left]);
+      else waiting2.push([at, left]);
     }
-    waitingBy.set(flow.id, waiting);
+    waitingBy.set(flow.id, waiting2);
     for (const p of placements) {
       for (const id of [...p.shapes, ...p.hops.map(([h]) => h)]) bump(id, (m) => {
         m.throughput += p.amount;
       });
       if (!p.waits) fm.placed += p.amount;
     }
-    for (const [at, a] of waiting) {
+    for (const [at, a] of waiting2) {
       bump(at, (m) => {
         m.backlog += a;
       });
@@ -1824,10 +1930,12 @@ function flowFrame(flows, frame2, t, values, offline = /* @__PURE__ */ new Set()
     metrics2.flows.set(flow.id, fm);
   }
   const piles = /* @__PURE__ */ new Map();
+  const carriedKeys = Object.keys(carried).filter((k) => carried[k] > TINY);
   for (const flow of list) {
-    const waiting = waitingBy.get(flow.id) ?? [];
-    const shapes2 = waiting.map(([s]) => s);
-    for (const e of frame2.elements) {
+    const waiting2 = waitingBy.get(flow.id) ?? [];
+    const shapes2 = waiting2.map(([s]) => s);
+    const suffix = "|" + flow.id;
+    if (carriedKeys.some((k) => k.endsWith(suffix))) for (const e of frame2.elements) {
       const c = carried[queueKey(e.id, flow.id)];
       if (c !== void 0 && c > TINY && !shapes2.includes(e.id)) shapes2.push(e.id);
     }
@@ -1841,7 +1949,7 @@ function flowFrame(flows, frame2, t, values, offline = /* @__PURE__ */ new Set()
       const shape = byID.get(at);
       if (!shape) return;
       const layer = byID.get(flow.from)?.layerID ?? shape.layerID;
-      const backlog = waiting.find(([s]) => s === at)?.[1] ?? 0;
+      const backlog = waiting2.find(([s]) => s === at)?.[1] ?? 0;
       const before = Math.max(0, carried[queueKey(at, flow.id)] ?? 0);
       let depth = before + backlog * since;
       if (backlog <= TINY && before > TINY) {
@@ -1850,7 +1958,7 @@ function flowFrame(flows, frame2, t, values, offline = /* @__PURE__ */ new Set()
         let total = 0;
         for (let n2 = 0; n2 < 32; n2++) {
           const blocked = new Set([...trial].filter(([, v]) => v <= TINY).map(([id]) => id));
-          const tree = flowTree(at, frame2, union2(offline, blocked));
+          const tree = flowTree(at, frame2, union2(offline, blocked), flow.to[0]);
           const goal = tree?.goals(flow.to, false)[0];
           if (!tree || goal === void 0) break;
           const r = route2(tree, goal);
@@ -1963,21 +2071,21 @@ function metricLookup(m, frame2) {
     return id === null ? null : metricValue(m, term.metric, id);
   };
 }
-function finishing(elements, metrics2, values, frame2, flows, since = Infinity, carried = {}) {
+function finishPlan(elements, metrics2, values, frame2, since = Infinity, carried = {}) {
   const lookup = metricLookup(metrics2, frame2);
-  const out = [], readings = {};
-  for (let e of elements) {
+  const plan2 = [], readings = {};
+  for (const e of elements) {
+    const applied = [];
     if (values !== null && e.overrides) {
-      for (const o of e.overrides) {
-        const own = e.id;
-        if (mentionsMetric(o.when) && holds(o.when, values, (m) => lookup(m, own))) e = applyOverride(looksOnly(o), e);
-      }
+      e.overrides.forEach((o, k) => {
+        if (mentionsMetric(o.when) && holds(o.when, values, (m) => lookup(m, e.id))) applied.push(k);
+      });
     }
-    if (!e.gauge || values === null) {
-      out.push(e);
+    const g = values === null ? null : e.gauge;
+    if (!g) {
+      plan2.push({ applied, gauge: null });
       continue;
     }
-    const g = e.gauge;
     let shown = metricValue(metrics2, g.metric, g.of);
     const then = carried[gaugeKey(e.id)];
     if (shown !== null && then !== void 0 && g.metric !== "depth" && g.metric !== "inFlight" && since < GAUGE_EASE) {
@@ -1985,8 +2093,19 @@ function finishing(elements, metrics2, values, frame2, flows, since = Infinity,
       shown = then + (shown - then) * smooth;
     }
     if (shown !== null) readings[gaugeKey(e.id)] = shown;
-    out.push(...gauge(e, g, shown, frame2, flows));
+    plan2.push({ applied, gauge: { value: shown } });
   }
+  return { plan: plan2, readings };
+}
+function finishing(elements, metrics2, values, frame2, flows, since = Infinity, carried = {}) {
+  const { plan: plan2, readings } = finishPlan(elements, metrics2, values, frame2, since, carried);
+  const out = [];
+  elements.forEach((e, i) => {
+    for (const k of plan2[i].applied) e = applyOverride(looksOnly(e.overrides[k]), e);
+    const g = plan2[i].gauge;
+    if (g && e.gauge) out.push(...gauge(e, e.gauge, g.value, frame2, flows));
+    else out.push(e);
+  });
   return { elements: out, readings };
 }
 var gaugeKey = (id) => "gauge|" + id;
@@ -2132,7 +2251,7 @@ function line(a, b, rng, roughness, bowing, preserveEnds, into) {
     const bow = offset(rng, length / 60, roughness) * bowing * gain;
     const dx = b.x - a.x, dy = b.y - a.y;
     const nx = -dy / length, ny = dx / length;
-    const start = preserveEnds ? a : (() => {
+    const start2 = preserveEnds ? a : (() => {
       const x = a.x + j();
       return { x, y: a.y + j() };
     })();
@@ -2144,7 +2263,7 @@ function line(a, b, rng, roughness, bowing, preserveEnds, into) {
     const c1y = a.y + dy * mid * 0.66 + ny * bow + j() * 0.5;
     const c2x = a.x + dx * (0.5 + mid * 0.5) + nx * bow + j() * 0.5;
     const c2y = a.y + dy * (0.5 + mid * 0.5) + ny * bow + j() * 0.5;
-    into.moveTo(start);
+    into.moveTo(start2);
     into.curveTo(end, { x: c1x, y: c1y }, { x: c2x, y: c2y });
   }
 }
@@ -2405,10 +2524,10 @@ var Cache = class {
     __publicField(this, "limit");
     this.limit = limit;
   }
-  get(key, make) {
+  get(key, make2) {
     const hit = this.map.get(key);
     if (hit !== void 0) return hit;
-    const v = make();
+    const v = make2();
     if (this.map.size >= this.limit) this.map.clear();
     this.map.set(key, v);
     return v;
@@ -2632,26 +2751,59 @@ function subCubic(p, t0, t1) {
   const left = split(p, t1)[0];
   return t1 > 0 ? split(left, t0 / t1)[1] : [p[0], p[0], p[0], p[0]];
 }
+function boxOf(pts) {
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (const p of pts) {
+    x0 = Math.min(x0, p.x);
+    y0 = Math.min(y0, p.y);
+    x1 = Math.max(x1, p.x);
+    y1 = Math.max(y1, p.y);
+  }
+  return { x0, y0, x1, y1 };
+}
+function touching(a, b) {
+  const eps = 1e-6;
+  return a.x0 <= b.x1 + eps && b.x0 <= a.x1 + eps && a.y0 <= b.y1 + eps && b.y0 <= a.y1 + eps;
+}
+var hopFrames = /* @__PURE__ */ new WeakMap();
+function linesBeneath(e, page, index) {
+  let f = hopFrames.get(index);
+  if (!f || f.layers !== page.layers || !isIndexOf(page, index)) {
+    const visible = new Set(page.layers.filter((l) => l.visible).map((l) => l.id));
+    const first = /* @__PURE__ */ new Map(), under = [];
+    for (const o of orderedElements(page)) {
+      if (!first.has(o.id)) first.set(o.id, under.length);
+      if (o.kind === "connector" && visible.has(o.layerID)) under.push(o);
+    }
+    f = { layers: page.layers, first, under, lines: [] };
+    if (isIndexOf(page, index)) hopFrames.set(index, f);
+  }
+  const count = f.first.get(e.id) ?? f.under.length;
+  while (f.lines.length < count) {
+    const points = routePoints(route(f.under[f.lines.length], index));
+    f.lines.push({ points, box: boxOf(points) });
+  }
+  return { lines: f.lines, count };
+}
 function hopCrossings(e, r, page, index) {
   const segments = hopSamples(r);
   if (segments.length === 0) return [];
-  const visible = new Set(page.layers.filter((l) => l.visible).map((l) => l.id));
-  const beneath = [];
-  for (const o of orderedElements(page)) {
-    if (o.id === e.id) break;
-    if (o.kind !== "connector" || !visible.has(o.layerID)) continue;
-    beneath.push(routePoints(route(o, index)));
-  }
+  const { lines, count } = linesBeneath(e, page, index);
   const rad = hopRadius(e.style.strokeWidth);
   const out = [];
   for (const samples of segments) {
     const along = runningLengths(samples);
     const length = along[along.length - 1];
     const found = [];
+    const near = [];
+    const whole = boxOf(samples);
+    for (let n = 0; n < count; n++) if (touching(whole, lines[n].box)) near.push(lines[n]);
     for (let i = 0; i < samples.length - 1; i++) {
       const p = samples[i], q = samples[i + 1];
       const dx = q.x - p.x, dy = q.y - p.y;
-      for (const line2 of beneath) {
+      const box = boxOf([p, q]);
+      for (const { points: line2, box: lineBox } of near) {
+        if (!touching(box, lineBox)) continue;
         for (let k = 0; k < line2.length - 1; k++) {
           const a = line2[k], b = line2[k + 1];
           const ex = b.x - a.x, ey = b.y - a.y;
@@ -2931,8 +3083,8 @@ function followSpan(track, t) {
   if (track.keys.some((k) => k.t >= span.end && k.t <= t && (k.x !== void 0 || k.y !== void 0))) return null;
   return f;
 }
-function tracing(e, page) {
-  if (e.kind === "connector") return new Polyline(routePoints(route(e, indexOf(page))));
+function tracing(e, page, index = indexOf(page)) {
+  if (e.kind === "connector") return new Polyline(routePoints(route(e, index)));
   const clean = cloneElement(e);
   clean.style.roughness = 0;
   const pts = outline(clean).contours()[0] ?? [];
@@ -2942,9 +3094,10 @@ function following(track, e, t, page) {
   const f = followSpan(track, t);
   if (!f) return e;
   t = localTime(track, t);
-  const pathElement = page.elements.find((x) => x.id === f.path);
+  const index = indexOf(page);
+  const pathElement = index.get(f.path);
   if (!pathElement || pathElement.id === e.id) return e;
-  const line2 = tracing(pathElement, page);
+  const line2 = tracing(pathElement, page, index);
   const span = f.end - f.start;
   let u = Math.min(Math.max(applyEase(f.ease ?? "easeInOut", span > 0 ? Math.min(1, (t - f.start) / span) : 1), 0), 1) * (f.laps ?? 1);
   if (u > 1) u = rem(u, 1) === 0 ? 1 : rem(u, 1);
@@ -3199,17 +3352,30 @@ function symbolPage(s) {
 function hasInstances(page) {
   return page.elements.some((e) => e.kind === "symbol");
 }
-function expandingSymbols(page, t, posing = true, times = /* @__PURE__ */ new Map()) {
+var Expansions = class {
+  constructor(page, t, posing) {
+    __publicField(this, "page");
+    __publicField(this, "t");
+    __publicField(this, "posing");
+    /** For each instance: its time override, the budget it found and left, and what it made. */
+    __publicField(this, "made", /* @__PURE__ */ new Map());
+    this.page = page;
+    this.t = t;
+    this.posing = posing;
+  }
+};
+function expandingSymbols(page, t, posing = true, times = /* @__PURE__ */ new Map(), memo) {
   if (!hasInstances(page)) return page;
   const budget = { left: MAX_ELEMENTS };
-  return { ...page, elements: expand(page.elements, page, t, symbolTable(page), [], posing, budget, times) };
+  const m = memo && memo.page === page && memo.t === t && memo.posing === posing ? memo : void 0;
+  return { ...page, elements: expand(page.elements, page, t, symbolTable(page), [], posing, budget, times, m) };
 }
 function symbolTable(page) {
   const table = /* @__PURE__ */ new Map();
   for (const s of page.symbols ?? []) if (!table.has(s.id)) table.set(s.id, s);
   return table;
 }
-function expand(elements, page, t, table, stack, posing, budget, times = /* @__PURE__ */ new Map()) {
+function expand(elements, page, t, table, stack, posing, budget, times = /* @__PURE__ */ new Map(), memo) {
   const instances = new Set(elements.filter((e) => e.kind === "symbol").map((e) => e.id));
   if (instances.size === 0) {
     budget.left -= elements.length;
@@ -3234,6 +3400,14 @@ function expand(elements, page, t, table, stack, posing, budget, times = /* @__P
       budget.left -= 1;
       continue;
     }
+    const override0 = stack.length === 0 ? times.get(e.id) : void 0;
+    const was = memo?.made.get(e);
+    if (was && was.override === override0 && was.after > 0 && budget.left - (was.before - was.after) > 0) {
+      budget.left -= was.before - was.after;
+      for (const x of was.out) out.push(x);
+      continue;
+    }
+    const before = budget.left, from = out.length;
     budget.left -= 1;
     const id = e.symbol;
     const symbol = id === null ? void 0 : table.get(id);
@@ -3249,6 +3423,7 @@ function expand(elements, page, t, table, stack, posing, budget, times = /* @__P
       layers: [{ id: e.layerID, name: "", visible: true, locked: false }]
     };
     for (const x of expand(drawn.elements, drawn, u, table, [...stack, id], posing, budget)) out.push(placed(x, e, symbol));
+    if (memo && stack.length === 0 && !was) memo.made.set(e, { override: override0, before, after: budget.left, out: out.slice(from) });
   }
   return out;
 }
@@ -3516,13 +3691,13 @@ function blocks(lines) {
   flush();
   return out;
 }
-function parseList(lines, start) {
-  const first = reItem.exec(lines[start]);
+function parseList(lines, start2) {
+  const first = reItem.exec(lines[start2]);
   const indent = first[1].length;
   const bullet = /^\d/.test(first[2]) ? null : first[2];
   const ordered = bullet === null ? parseInt(first[2], 10) : null;
   const items = [];
-  let i = start;
+  let i = start2;
   while (i < lines.length) {
     const m = reItem.exec(lines[i]);
     if (!m || m[1].length !== indent || bullet === null !== /^\d/.test(m[2]) || bullet !== null && m[2] !== bullet) break;
@@ -3851,10 +4026,10 @@ function layoutLines(paras, width, height, fontSize, fam) {
     let k = 0;
     let firstLine = true;
     while (k < chars.length || firstLine && chars.length === 0) {
-      const start = firstLine ? p.firstIndent : p.indent;
+      const start2 = firstLine ? p.firstIndent : p.indent;
       const maxX2 = width;
       const glyphs = [];
-      let x = start, lastSpace = -1, end = k;
+      let x = start2, lastSpace = -1, end = k;
       for (; end < chars.length; end++) {
         const { ch, run } = chars[end];
         const r = runs[run];
@@ -3903,7 +4078,7 @@ function layoutLines(paras, width, height, fontSize, fam) {
       }
       if (glyphs.length === 0 && end === k && k < chars.length) {
         const { ch, run } = chars[k];
-        glyphs.push({ ch, run, x: start, w: charWidth(ch, runs[run], fam) });
+        glyphs.push({ ch, run, x: start2, w: charWidth(ch, runs[run], fam) });
         end = k + 1;
       }
       let asc = 0, desc = 0, lead = 0;
@@ -3929,13 +4104,38 @@ function layoutLines(paras, width, height, fontSize, fam) {
   });
   return lines;
 }
+var Memo = class {
+  constructor(limit) {
+    __publicField(this, "map", /* @__PURE__ */ new Map());
+    __publicField(this, "limit");
+    this.limit = limit;
+  }
+  get(key, make2) {
+    const hit = this.map.get(key);
+    if (hit !== void 0) return hit;
+    const v = make2();
+    if (this.map.size >= this.limit) this.map.clear();
+    this.map.set(key, v);
+    return v;
+  }
+};
+var layouts = new Memo(500);
+var markups = new Memo(500);
 function noteMarkup(source, e) {
+  const st = e.style, ink = st.stroke;
+  const key = JSON.stringify([...[e.x, e.y, e.width, e.height, st.fontSize, ink.r, ink.g, ink.b, ink.a].map(String), st.font ?? "", source]);
+  return markups.get(key, () => computeNoteMarkup(source, e));
+}
+function computeNoteMarkup(source, e) {
   const rect2 = textRect({ x: e.x, y: e.y, width: e.width, height: e.height });
   if (!(rect2.width > 1 && rect2.height > 1)) return "";
   const fam = familyMetrics(e.style.font);
-  const b = new Builder(e.style.fontSize, rect2.width, fam);
-  for (const block of parseBlocks(source)) b.block(block, { indent: 0, marker: null, quote: null, listDepth: 0 });
-  const lines = layoutLines(b.paras, rect2.width, rect2.height, e.style.fontSize, fam);
+  const layoutKey = JSON.stringify([...[rect2.width, rect2.height, e.style.fontSize].map(String), e.style.font ?? "", source]);
+  const lines = layouts.get(layoutKey, () => {
+    const b = new Builder(e.style.fontSize, rect2.width, fam);
+    for (const block of parseBlocks(source)) b.block(block, { indent: 0, marker: null, quote: null, listDepth: 0 });
+    return layoutLines(b.paras, rect2.width, rect2.height, e.style.fontSize, fam);
+  });
   const ink = color(e.style.stroke);
   let s = "";
   const marks = [];
@@ -4024,6 +4224,26 @@ function bounds(page, padding = 24) {
   return inset(r, -padding, -padding);
 }
 function plan(page) {
+  const hit = plans.get(page);
+  if (hit && unchanged(page, hit.fields)) return hit.plan;
+  const made = makePlan(page);
+  plans.set(page, { fields: { ...page }, plan: made });
+  return made;
+}
+var plans = /* @__PURE__ */ new WeakMap();
+function hasPlan(page) {
+  const hit = plans.get(page);
+  return !!hit && unchanged(page, hit.fields);
+}
+function rememberPlan(page, made) {
+  plans.set(page, { fields: { ...page }, plan: made });
+}
+function unchanged(page, fields) {
+  const a = page, b = fields;
+  const keys = Object.keys(a);
+  return keys.length === Object.keys(b).length && keys.every((k) => a[k] === b[k]);
+}
+function makePlan(page) {
   const tl = page.timeline ?? { fps: 12, duration: 0, boil: null, settle: null, poster: null, tracks: [], camera: null, markers: null };
   const times = frameTimes(tl);
   const first = tl.camera?.find((k) => k.width > 1 && k.height > 1);
@@ -4051,8 +4271,8 @@ function svgOpen(b, background, paint) {
   }
   return out;
 }
-function svgParts(page, background, fixed, links = false) {
-  if (hasInstances(page)) return svgParts(expandingSymbols(page, 0), background, fixed, links);
+function svgParts(page, background, fixed, links = false, only) {
+  if (hasInstances(page)) return svgParts(expandingSymbols(page, 0), background, fixed, links, only);
   const theme = themeNamed(page.theme);
   const bg = background ? theme?.background ?? background : null;
   const ink = theme?.ink ?? black;
@@ -4063,11 +4283,11 @@ function svgParts(page, background, fixed, links = false) {
   const index = indexOf(d);
   const ordered = orderedElements(d);
   const floors = ordered.filter((e) => visible.has(e.layerID) && isFloor(e));
-  const rockMarkup = rock(floors).map((r) => `<path d="${r.path.data()}" fill="none" stroke="${color(r.ink)}"${opacity(r.ink, "stroke-opacity")} stroke-width="${fmt(r.width)}" stroke-linecap="round"/>
+  const rockMarkup = only && !only("rock") ? "" : rock(floors).map((r) => `<path d="${r.path.data()}" fill="none" stroke="${color(r.ink)}"${opacity(r.ink, "stroke-opacity")} stroke-width="${fmt(r.width)}" stroke-linecap="round"/>
 `).join("");
   if (rockMarkup) parts.push({ key: "rock", markup: rockMarkup });
   for (const e of ordered) {
-    if (!visible.has(e.layerID)) continue;
+    if (!visible.has(e.layerID) || only && !only(e.id)) continue;
     const alpha = Math.min(Math.max(e.style.opacity ?? 1, 0), 1);
     if (alpha <= 0) continue;
     let body = svgElement(e, index, bg, d);
@@ -4215,6 +4435,110 @@ function textElement(text, f, e, centered) {
   return s + "</text>\n";
 }
 
+// src/planner.ts
+var WORKER_WORK = 3e4;
+function planWork(page) {
+  const tl = page.timeline;
+  if (!tl || tl.camera?.some((k) => k.width > 1 && k.height > 1)) return 0;
+  const elements = page.elements.length + (page.symbols ?? []).reduce((n, s) => n + s.elements.length, 0);
+  return frameTimes(tl).length * elements;
+}
+function workerMaker() {
+  if (typeof Worker === "undefined" || false) return null;
+  if (false) {
+    const source = `(${dottiePlayerScript.toString()})();
+`;
+    return () => {
+      const url = URL.createObjectURL(new Blob([source], { type: "text/javascript" }));
+      try {
+        return new Worker(url);
+      } finally {
+        setTimeout(() => URL.revokeObjectURL(url), 6e4);
+      }
+    };
+  }
+  if (true) {
+    const here = import.meta.url;
+    if (!here) return null;
+    return () => new Worker(new URL("./dottie-player.min.js", here));
+  }
+  return null;
+}
+var make;
+var worker = null;
+var failed = false;
+var nextID = 1;
+var waiting = /* @__PURE__ */ new Map();
+function plansInWorker(page) {
+  if (failed || hasPlan(page) || planWork(page) < WORKER_WORK) return false;
+  if (make === void 0) make = workerMaker();
+  return make !== null;
+}
+function planInWorker(page) {
+  return new Promise((resolve2) => {
+    const done = (p) => {
+      if (p) rememberPlan(page, p);
+      resolve2();
+    };
+    let w;
+    try {
+      w = worker ?? start();
+    } catch {
+      failed = true;
+      done(null);
+      return;
+    }
+    const id = nextID++;
+    waiting.set(id, { page, done });
+    try {
+      w.postMessage({ dottiePlan: id, page });
+    } catch {
+      waiting.delete(id);
+      done(null);
+    }
+  });
+}
+function start() {
+  const w = make();
+  w.onmessage = (ev) => {
+    const { dottiePlan: id, plan: p } = ev.data ?? {};
+    const job = id === void 0 ? void 0 : waiting.get(id);
+    if (!job) return;
+    waiting.delete(id);
+    job.done(p ?? null);
+    if (waiting.size === 0 && worker === w) {
+      w.terminate();
+      worker = null;
+    }
+  };
+  w.onerror = (ev) => {
+    ev.preventDefault?.();
+    failed = true;
+    if (worker === w) worker = null;
+    w.terminate();
+    const jobs = [...waiting.values()];
+    waiting.clear();
+    for (const job of jobs) job.done(null);
+  };
+  worker = w;
+  return w;
+}
+function servePlans() {
+  const g = globalThis;
+  if (typeof g.WorkerGlobalScope === "undefined" || !(g instanceof g.WorkerGlobalScope)) return;
+  g.addEventListener("message", (ev) => {
+    const id = ev.data?.dottiePlan;
+    if (typeof id !== "number") return;
+    let p = null;
+    try {
+      p = plan(ev.data.page);
+    } catch {
+      p = null;
+    }
+    g.postMessage({ dottiePlan: id, plan: p });
+  });
+}
+
 // src/player.ts
 var WHITE = { r: 1, g: 1, b: 1, a: 1 };
 function pageIndex(file, spec) {
@@ -4284,7 +4608,7 @@ var Playback = class {
     __publicField(this, "order", []);
     __publicField(this, "frame", -1);
     __publicField(this, "onFrame", null);
-    this.page = options.clean ? withRoughness(page, 0) : page;
+    this.page = options.clean ? cleanCopy(page) : page;
     addFonts(usedFonts(this.page));
     this.plan = plan(this.page);
     this.clicks = clickTargets(page, options.file);
@@ -4361,7 +4685,7 @@ var Playback = class {
   }
   /** Whether a copy is still playing through after a click. */
   replaying(now = performance.now()) {
-    for (const [id, start] of this.replayStarts) if (now - start < (this.replays.get(id) ?? 0) * 1e3) return true;
+    for (const [id, start2] of this.replayStarts) if (now - start2 < (this.replays.get(id) ?? 0) * 1e3) return true;
     return false;
   }
   /** Draws the last moment drawn again, for copies replaying while the page stands still. */
@@ -4374,17 +4698,24 @@ var Playback = class {
     const r = this.plan.rects[Math.min(i, this.plan.rects.length - 1)];
     const now = typeof performance === "undefined" ? 0 : performance.now();
     const times = /* @__PURE__ */ new Map();
-    for (const [id, start] of this.replayStarts) times.set(id, Math.min((now - start) / 1e3, this.replays.get(id) ?? 0));
+    for (const [id, start2] of this.replayStarts) times.set(id, Math.min((now - start2) / 1e3, this.replays.get(id) ?? 0));
     const tc = clampTime(t);
     const pose = posed(this.page, tc, this.state, this.sinceChange(now), this.carried);
-    const frame2 = expandingSymbols(pose, tc, true, times);
+    const made = new Expansions(pose, tc, true);
+    const frame2 = expandingSymbols(pose, tc, true, times, made);
     const { parts } = svgParts(frame2, this.background, r);
     const owned = (m, parts2) => {
       for (const p of parts2) if (this.owner.has(p.key)) m.set(p.key, p.markup);
       return m;
     };
-    const state = (st) => st.size === 0 ? /* @__PURE__ */ new Map() : owned(/* @__PURE__ */ new Map(), svgParts(expandingSymbols(pose, tc, true, new Map([...times, ...st])), this.background, r).parts.filter((p) => st.has(this.owner.get(p.key) ?? "")));
-    const hover = this.hoverIDs.size === 0 ? /* @__PURE__ */ new Map() : owned(/* @__PURE__ */ new Map(), svgParts(hovered(frame2, this.hoverIDs), this.background, r).parts.filter((p) => this.hoverIDs.has(p.key)));
+    const state = (st) => st.size === 0 ? /* @__PURE__ */ new Map() : owned(/* @__PURE__ */ new Map(), svgParts(
+      expandingSymbols(pose, tc, true, new Map([...times, ...st]), made),
+      this.background,
+      r,
+      false,
+      (key) => st.has(this.owner.get(key) ?? "")
+    ).parts);
+    const hover = this.hoverIDs.size === 0 ? /* @__PURE__ */ new Map() : owned(/* @__PURE__ */ new Map(), svgParts(hovered(frame2, this.hoverIDs), this.background, r, false, (key) => this.hoverIDs.has(key)).parts);
     const over = state(this.overTimes), down = state(this.downTimes), hit = state(this.hitTimes);
     const normal = owned(/* @__PURE__ */ new Map(), parts);
     const merged = [];
@@ -4513,6 +4844,14 @@ ${h}</g>
     return { frame: next, stop: entered >= 0 && !this.sceneLoops[entered] };
   }
 };
+var cleanCopies = /* @__PURE__ */ new WeakMap();
+function cleanCopy(page) {
+  const hit = cleanCopies.get(page);
+  if (hit && unchanged(page, hit.fields)) return hit.page;
+  const clean = withRoughness(page, 0);
+  cleanCopies.set(page, { fields: { ...page }, page: clean });
+  return clean;
+}
 var ElementBase = typeof HTMLElement === "undefined" ? class {
 } : HTMLElement;
 var DottiePlayer = class extends ElementBase {
@@ -4535,6 +4874,10 @@ var DottiePlayer = class extends ElementBase {
     __publicField(this, "raf", 0);
     __publicField(this, "replayRaf", 0);
     __publicField(this, "loadToken", 0);
+    /** Counts mounts, so a plan that comes back from a worker after a newer one is dropped. */
+    __publicField(this, "mountToken", 0);
+    /** The time a still shows; null while the drawing is animated. */
+    __publicField(this, "stillTime", null);
     __publicField(this, "visible", true);
     __publicField(this, "observer", null);
     this.root = this.attachShadow({ mode: "open" });
@@ -4611,9 +4954,19 @@ var DottiePlayer = class extends ElementBase {
         text = inline2.textContent ?? "";
       }
       if (token !== this.loadToken) return;
-      this.setFile(parseDottie(text));
+      this.showFile(parseDottie(text));
     } catch (err) {
       if (token !== this.loadToken) return;
+      this.setPlaying(false);
+      cancelAnimationFrame(this.raf);
+      cancelAnimationFrame(this.replayRaf);
+      this.raf = 0;
+      this.replayRaf = 0;
+      this.playback = null;
+      this.file = null;
+      this.mountToken++;
+      this.stillTime = null;
+      this.bar.hidden = true;
       this.stage.innerHTML = "";
       const box = document.createElement("div");
       box.className = "error";
@@ -4624,15 +4977,35 @@ var DottiePlayer = class extends ElementBase {
   }
   /** Shows an already-parsed file. */
   setFile(file) {
+    this.loadToken++;
+    this.showFile(file);
+  }
+  showFile(file) {
     this.file = file;
     for (const w of file.warnings) console.warn(`dottie-player: ${w}`);
-    this.mount();
-    this.dispatchEvent(new CustomEvent("load", { detail: { file } }));
+    this.mount(() => this.dispatchEvent(new CustomEvent("load", { detail: { file } })));
   }
-  mount() {
+  /** Shows the file's page; then `mounted`. A big animation is planned in a worker first (planner.ts), and what was
+   * showing stays until it is ready; a newer mount, file or failed load in the meantime wins. */
+  mount(mounted) {
     const file = this.file;
     const page = file.pages[pageIndex(file, this.getAttribute("page"))];
-    const p = new Playback(page, this.stage, { clean: this.hasAttribute("clean"), file });
+    const clean = this.hasAttribute("clean");
+    const token = ++this.mountToken;
+    const shown = clean ? cleanCopy(page) : page;
+    if (!plansInWorker(shown)) {
+      this.mountPage(file, page, clean);
+      mounted?.();
+      return;
+    }
+    void planInWorker(shown).then(() => {
+      if (token !== this.mountToken || this.file !== file) return;
+      this.mountPage(file, page, clean);
+      mounted?.();
+    });
+  }
+  mountPage(file, page, clean) {
+    const p = new Playback(page, this.stage, { clean, file });
     p.still = this.hasAttribute("at");
     this.playback = p;
     this.style.setProperty("--dottie-page", color(p.background));
@@ -4655,10 +5028,14 @@ var DottiePlayer = class extends ElementBase {
       this.dispatchEvent(new CustomEvent("frame", { detail: { frame: i, time: p.plan.times[i] } }));
     };
     if (!animated) {
-      p.drawAt(at !== null ? Number(at) || 0 : posterTime(page), at !== null ? nearest(p, Number(at) || 0) : p.posterFrame);
+      const i = at !== null ? nearest(p, Number(at) || 0) : p.posterFrame;
+      this.stillTime = at !== null ? Number(at) || 0 : posterTime(page);
+      p.drawAt(this.stillTime, i);
+      p.frame = i;
       this.setPlaying(false);
       return;
     }
+    this.stillTime = null;
     p.show(0);
     const reduced = typeof matchMedia === "function" && matchMedia("(prefers-reduced-motion: reduce)").matches;
     if (reduced) {
@@ -4672,8 +5049,10 @@ var DottiePlayer = class extends ElementBase {
   get paused() {
     return !this.playing;
   }
+  /** The moment shown: a still's own time (its `at`, or the poster), else the current frame's. */
   get currentTime() {
     const p = this.playback;
+    if (p && this.stillTime !== null) return this.stillTime;
     return p && p.frame >= 0 ? p.plan.times[p.frame] : 0;
   }
   set currentTime(t) {
@@ -4960,9 +5339,10 @@ function render(source, options = {}) {
 function isFile(v) {
   return typeof v === "object" && v !== null && Array.isArray(v.pages) && Array.isArray(v.warnings);
 }
-var VERSION = "0.8.0";
+var VERSION = "0.9.0";
 
 // src/player-entry.ts
+servePlans();
 definePlayer();
 globalThis.Dottie ?? (globalThis.Dottie = index_exports);
 export {