@pixerate/editor 0.164.0 → 0.166.0

package/dist/{chunk-TALQONZ5.js → chunk-VB2CY6EG.js}

@@ -7,7 +7,7 @@ import {
 import {
   CHART_OOXML_NS,
   chartFromOoxml
-} from "./chunk-POR54B55.js";
+} from "./chunk-XNU45TYA.js";
 import {
   compareDocuments
 } from "./chunk-V5OOP74P.js";
@@ -34,10 +34,10 @@ import {
   searchDocument,
   sliceContainsTable,
   syncInitialContent
-} from "./chunk-OXERWBKE.js";
+} from "./chunk-DFCAR7AW.js";
 import {
   chartDataToTable
-} from "./chunk-3NEZJCBY.js";
+} from "./chunk-FR432ROA.js";
 import {
   PIXERATE_DOCUMENT_MIME,
   getClipboardData,

package/dist/{chunk-QY4KUDMY.js → chunk-VRXXAXUT.js}

@@ -18,7 +18,7 @@ import {
   unionBounds,
   vectorGradientPoints,
   widthProfileAt
-} from "./chunk-SET6KJOP.js";
+} from "./chunk-LPIKXPBM.js";
 import {
   segmentLength,
   segmentParamAtLength,
@@ -29,7 +29,7 @@ import {
 } from "./chunk-5UJHB3BW.js";
 import {
   mixColorsOklab
-} from "./chunk-BQWGN5WH.js";
+} from "./chunk-M2TPMYJE.js";
 
 // src/vector/blend.ts
 var lerpN = (a, b, t) => a + (b - a) * t;

package/dist/chunk-VU6WQSMB.cjs

@@ -0,0 +1,164 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/diagram/source/lines.ts
+var HEADER_PATTERNS = [
+  [/^\s*(flowchart|graph)(?:-elk)?\b/i, "flowchart"],
+  [/^\s*stateDiagram(?:-v2)?\b/i, "state"],
+  [/^\s*classDiagram(?:-v2)?\b/i, "class"],
+  [/^\s*erDiagram\b/i, "er"],
+  [/^\s*requirementDiagram\b/i, "requirement"],
+  [/^\s*mindmap\b/i, "mindmap"],
+  [/^\s*sequenceDiagram\b/i, "sequence"],
+  [/^\s*gantt\b/i, "gantt"],
+  [/^\s*pie\b/i, "pie"],
+  [/^\s*journey\b/i, "journey"],
+  [/^\s*timeline\b/i, "timeline"],
+  [/^\s*gitGraph\b/i, "gitGraph"],
+  [/^\s*C4(Context|Container|Component|Dynamic|Deployment)\b/, "c4"],
+  [/^\s*quadrantChart\b/i, "quadrant"],
+  [/^\s*sankey(?:-beta)?\b/i, "sankey"],
+  [/^\s*xychart(?:-beta)?\b/i, "xychart"],
+  [/^\s*block(?:-beta)?\b/i, "block"],
+  [/^\s*architecture(?:-beta)?\b/i, "architecture"],
+  [/^\s*packet(?:-beta)?\b/i, "packet"],
+  [/^\s*kanban\b/i, "kanban"],
+  [/^\s*radar(?:-beta)?\b/i, "radar"],
+  [/^\s*treemap(?:-beta)?\b/i, "treemap"],
+  [/^\s*info\b/i, "info"]
+];
+function detectFamilyFromHeader(header) {
+  for (const [re, family] of HEADER_PATTERNS) {
+    if (re.test(header)) return family;
+  }
+  return "unknown";
+}
+function isCommentLine(line) {
+  const t = line.trim();
+  return t.startsWith("%%") && !t.startsWith("%%{");
+}
+function isDirectiveLine(line) {
+  return /^\s*%%\{.*\}%%\s*$/.test(line);
+}
+function splitSource(source) {
+  const eol = source.includes("\r\n") ? "\r\n" : "\n";
+  const rawLines = source.split(/\r\n|\n/);
+  let end = rawLines.length;
+  while (end > 0 && rawLines[end - 1].trim() === "") end--;
+  const trailingLines = rawLines.slice(end);
+  const trailing = trailingLines.length ? eol + trailingLines.join(eol) : "";
+  const lines = rawLines.slice(0, end);
+  const preambleLines = [];
+  let i = 0;
+  let frontmatter;
+  if (lines[0] !== void 0 && /^---\s*$/.test(lines[0])) {
+    preambleLines.push(lines[0]);
+    i = 1;
+    const fm = [];
+    while (i < lines.length && !/^---\s*$/.test(lines[i])) {
+      fm.push(lines[i]);
+      preambleLines.push(lines[i]);
+      i++;
+    }
+    if (i < lines.length) {
+      preambleLines.push(lines[i]);
+      i++;
+    }
+    frontmatter = parseSimpleYaml(fm);
+  }
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim() === "" || isDirectiveLine(line) || isCommentLine(line)) {
+      preambleLines.push(line);
+      i++;
+      continue;
+    }
+    break;
+  }
+  const headerIndex = i;
+  const header = _nullishCoalesce(lines[i], () => ( ""));
+  const bodyLines = lines.slice(i + 1);
+  return {
+    eol,
+    preamble: { lines: preambleLines, frontmatter },
+    header,
+    headerIndex,
+    bodyLines,
+    trailing
+  };
+}
+function parseSimpleYaml(lines) {
+  const out = {};
+  let currentKey = null;
+  let nested = null;
+  for (const raw of lines) {
+    if (raw.trim() === "" || raw.trim().startsWith("#")) continue;
+    const indent = raw.length - raw.trimStart().length;
+    const m = /^([A-Za-z_][\w-]*)\s*:\s*(.*)$/.exec(raw.trim());
+    if (!m) continue;
+    const [, key, valueRaw] = m;
+    const value = parseYamlScalar(valueRaw);
+    if (indent === 0) {
+      currentKey = key;
+      if (valueRaw.trim() === "") {
+        nested = {};
+        out[key] = nested;
+      } else {
+        nested = null;
+        out[key] = value;
+      }
+    } else if (nested && currentKey) {
+      nested[key] = value;
+    }
+  }
+  return out;
+}
+function parseYamlScalar(v) {
+  const t = v.trim();
+  if (t === "") return "";
+  if (t.startsWith("{") || t.startsWith("[")) {
+    try {
+      return JSON.parse(t);
+    } catch (e) {
+      return t;
+    }
+  }
+  if (/^(true|false)$/i.test(t)) return t.toLowerCase() === "true";
+  if (/^-?\d+(\.\d+)?$/.test(t)) return Number(t);
+  if (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'")) {
+    return t.slice(1, -1);
+  }
+  return t;
+}
+function splitStatements(line) {
+  const parts = [];
+  let depth = 0;
+  let quote = null;
+  let cur = "";
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (quote) {
+      cur += ch;
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "`") {
+      quote = ch;
+      cur += ch;
+      continue;
+    }
+    if (ch === "[" || ch === "(" || ch === "{") depth++;
+    else if (ch === "]" || ch === ")" || ch === "}") depth = Math.max(0, depth - 1);
+    if (ch === ";" && depth === 0) {
+      parts.push(cur);
+      cur = "";
+      continue;
+    }
+    cur += ch;
+  }
+  parts.push(cur);
+  return parts;
+}
+
+
+
+
+
+exports.detectFamilyFromHeader = detectFamilyFromHeader; exports.splitSource = splitSource; exports.splitStatements = splitStatements;

package/dist/{chunk-NHLYK3AX.js → chunk-XBQX76CT.js}

@@ -3,6 +3,42 @@ import {
   stripPrototypeKeys
 } from "./chunk-HF5QZS7Z.js";
 
+// src/persistence/assetWrites.ts
+var leases = /* @__PURE__ */ new Map();
+var watchers = /* @__PURE__ */ new Set();
+function leaseAssetRefs(refs) {
+  const held = [...new Set(refs)];
+  for (const ref of held) {
+    leases.set(ref, (leases.get(ref) ?? 0) + 1);
+    for (const touched of watchers) touched.add(ref);
+  }
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    for (const ref of held) {
+      const n = (leases.get(ref) ?? 1) - 1;
+      if (n > 0) leases.set(ref, n);
+      else leases.delete(ref);
+    }
+  };
+}
+function watchAssetLeases() {
+  const touched = new Set(leases.keys());
+  watchers.add(touched);
+  return { touched, stop: () => void watchers.delete(touched) };
+}
+function withAssetLock(prefix, mode, task) {
+  let locks;
+  try {
+    locks = globalThis.navigator?.locks;
+  } catch {
+    locks = void 0;
+  }
+  if (!locks || typeof locks.request !== "function") return task();
+  return locks.request(`pixerate-editor-assets:${prefix}`, { mode }, task);
+}
+
 // src/persistence/assets.ts
 var EDITOR_ASSET_PREFIX = "pixerate-asset:";
 var REF = /pixerate-asset:[0-9a-z]+-[0-9a-z]+(?:~[0-9]+)?/g;
@@ -45,7 +81,8 @@ function createEditorAssetRegistry() {
     },
     get size() {
       return byRef.size;
-    }
+    },
+    refs: () => [...byRef.keys()]
   };
 }
 function externalizeAssets(value, registry) {
@@ -85,11 +122,22 @@ function internalizeAssets(value, registry) {
   return walk(value);
 }
 var persisted = /* @__PURE__ */ new WeakMap();
-var assetKey = (ref, options) => `${options.prefix ?? "pixerate.assets:"}${ref.slice(EDITOR_ASSET_PREFIX.length)}`;
+var assetPrefix = (options) => options.prefix ?? "pixerate.assets:";
+var assetKey = (ref, options) => `${assetPrefix(options)}${ref.slice(EDITOR_ASSET_PREFIX.length)}`;
+var markerKey = (options) => `${assetPrefix(options)}#collected`;
+var ASSET_ID = /^[0-9a-z]+-[0-9a-z]+(?:~[0-9]+)?$/;
 async function persistEditorAssets(storage, registry, document, options = {}) {
-  const written = persisted.get(storage) ?? /* @__PURE__ */ new Set();
-  persisted.set(storage, written);
-  for (const ref of collectAssetRefs(document)) {
+  const refs = collectAssetRefs(document);
+  if (!refs.length) return;
+  const cache = persisted.get(storage) ?? { marker: void 0, keys: /* @__PURE__ */ new Set() };
+  persisted.set(storage, cache);
+  const marker = await storage.get(markerKey(options)).catch(() => void 0);
+  if (marker === void 0 || marker !== cache.marker) {
+    cache.keys.clear();
+    cache.marker = marker;
+  }
+  const written = cache.keys;
+  for (const ref of refs) {
     const key = assetKey(ref, options);
     if (written.has(key)) continue;
     const data = registry.get(ref);
@@ -120,12 +168,135 @@ function withEditorAssets(storage, registry, options = {}) {
       return value;
     },
     async set(key, value) {
-      if (value.includes(EDITOR_ASSET_PREFIX)) await persistEditorAssets(storage, registry, value, options);
-      await storage.set(key, value);
+      if (!value.includes(EDITOR_ASSET_PREFIX)) return storage.set(key, value);
+      await writeWithAssets(storage, registry, value, options, () => storage.set(key, value));
     },
-    remove: (key) => storage.remove(key)
+    remove: (key) => storage.remove(key),
+    ...storage.keys ? { keys: (prefix) => storage.keys(prefix) } : {}
   };
 }
+async function writeWithAssets(storage, registry, document, options, write) {
+  const release = leaseAssetRefs(collectAssetRefs(document));
+  try {
+    await withAssetLock(assetPrefix(options), "shared", async () => {
+      if (registry) await persistEditorAssets(storage, registry, document, options);
+      await write();
+    });
+  } finally {
+    release();
+  }
+}
+var isRegistry = (value) => !!value && typeof value === "object" && ["put", "get", "has", "set"].every((k) => typeof value[k] === "function");
+var refChars = (ref) => parseInt(ref.slice(EDITOR_ASSET_PREFIX.length).split("-")[0], 36) || 0;
+function keptRefs(keep) {
+  const out = /* @__PURE__ */ new Set();
+  const addRegistry = (registry) => {
+    if (typeof registry.refs !== "function") {
+      throw new Error("A registry passed in keep cannot list its references (it has no refs()). Use createEditorAssetRegistry, or pass the documents to keep instead.");
+    }
+    for (const ref of registry.refs()) out.add(ref);
+  };
+  for (const item of keep) {
+    if (isRegistry(item)) addRegistry(item);
+    else if (item && typeof item === "object" && isRegistry(item.assets)) addRegistry(item.assets);
+    else for (const ref of collectAssetRefs(item)) out.add(ref);
+  }
+  return out;
+}
+async function collectEditorAssetGarbage(storage, options = {}) {
+  if (typeof storage.keys !== "function") {
+    throw new Error(
+      `This ${storage.kind} storage cannot list its keys, so unreferenced assets cannot be found. Give the adapter a keys(prefix) method (every built-in adapter has one).`
+    );
+  }
+  const listKeys = storage.keys.bind(storage);
+  const prefix = assetPrefix(options);
+  const keep = keptRefs(options.keep ?? []);
+  const dryRun = options.dryRun === true;
+  return withAssetLock(prefix, "exclusive", async () => {
+    const watch = watchAssetLeases();
+    try {
+      const assetKeys = (await listKeys(prefix)).filter((key) => ASSET_ID.test(key.slice(prefix.length)));
+      const others = (await listKeys("")).filter((key) => !key.startsWith(prefix));
+      const live = /* @__PURE__ */ new Set();
+      for (const key of others) {
+        const value = await storage.get(key);
+        if (value !== null && value.includes(EDITOR_ASSET_PREFIX)) for (const ref of collectAssetRefs(value)) live.add(ref);
+      }
+      const toRef = (key) => `${EDITOR_ASSET_PREFIX}${key.slice(prefix.length)}`;
+      let referenced = 0;
+      let kept = 0;
+      const candidates = [];
+      for (const key of assetKeys) {
+        const ref = toRef(key);
+        if (live.has(ref)) referenced++;
+        else if (keep.has(ref) || watch.touched.has(ref)) kept++;
+        else candidates.push(ref);
+      }
+      let unreferenced = candidates;
+      if (options.only) {
+        const wanted = new Set(options.only);
+        const stale = [...wanted].filter((ref) => !candidates.includes(ref));
+        if (stale.length) {
+          throw new Error(
+            `${stale.length} of the given asset${stale.length === 1 ? " is" : "s are"} not unreferenced in storage now (${stale.slice(0, 3).join(", ")}${stale.length > 3 ? ", \u2026" : ""}): unknown, already deleted, referenced or in use. Nothing was deleted; find the unreferenced assets again.`
+          );
+        }
+        unreferenced = candidates.filter((ref) => wanted.has(ref));
+      }
+      const report = {
+        assets: assetKeys.length,
+        scannedKeys: others.length,
+        referenced,
+        kept,
+        unreferenced,
+        unreferencedChars: unreferenced.reduce((n, ref) => n + refChars(ref), 0),
+        removed: [],
+        freedChars: 0,
+        dryRun
+      };
+      if (dryRun || !unreferenced.length) return report;
+      await storage.set(markerKey(options), `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`);
+      for (const ref of unreferenced) {
+        if (watch.touched.has(ref)) {
+          report.kept++;
+          continue;
+        }
+        try {
+          await storage.remove(assetKey(ref, options));
+        } catch (error) {
+          throw new Error(
+            `Deleted ${report.removed.length} of ${unreferenced.length} unreferenced assets, then storage failed: ${error instanceof Error ? error.message : String(error)}. The rest are still stored and nothing refers to the deleted ones; run the collection again.`
+          );
+        }
+        report.removed.push(ref);
+        report.freedChars += refChars(ref);
+      }
+      return report;
+    } finally {
+      watch.stop();
+    }
+  });
+}
+async function tryCollectEditorAssetGarbage(storage, options = {}) {
+  if (typeof storage.keys !== "function") return null;
+  try {
+    return await collectEditorAssetGarbage(storage, options);
+  } catch {
+    return null;
+  }
+}
+async function collectRetiredEditorAssets(storage, doc, setting = true) {
+  if (!doc.assets || setting === false) return null;
+  const extra = setting === true ? {} : setting;
+  let current;
+  try {
+    current = doc.getDocument();
+  } catch {
+    return null;
+  }
+  return tryCollectEditorAssetGarbage(storage, { ...extra, keep: [current, ...extra.keep ?? []] });
+}
 
 // src/persistence/migrate.ts
 function hasLoadProblems(report) {
@@ -378,6 +549,9 @@ export {
   persistEditorAssets,
   preloadEditorAssets,
   withEditorAssets,
+  collectEditorAssetGarbage,
+  tryCollectEditorAssetGarbage,
+  collectRetiredEditorAssets,
   hasLoadProblems,
   createLoadReport,
   migrateDocument,

package/dist/{chunk-5AARIS3R.cjs → chunk-XCDGM7TD.cjs}

@@ -18,7 +18,7 @@
 
 
 
-var _chunkJCXMJUQOcjs = require('./chunk-JCXMJUQO.cjs');
+var _chunkEGZM52EOcjs = require('./chunk-EGZM52EO.cjs');
 
 
 
@@ -29,7 +29,7 @@ var _chunkGF2RBSDMcjs = require('./chunk-GF2RBSDM.cjs');
 var _chunkDWJJI6RTcjs = require('./chunk-DWJJI6RT.cjs');
 
 
-var _chunkCIPIESX4cjs = require('./chunk-CIPIESX4.cjs');
+var _chunk4ZC5QJE2cjs = require('./chunk-4ZC5QJE2.cjs');
 
 // src/vector/blend.ts
 var lerpN = (a, b, t) => a + (b - a) * t;
@@ -37,7 +37,7 @@ var lerpP = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
 var toP = (v) => [v.x, v.y];
 var mapP = (m, p) => [m[0] * p[0] + m[2] * p[1] + m[4], m[1] * p[0] + m[3] * p[1] + m[5]];
 var curvesOf = (c) => Math.max(0, (c.pts.length - 1) / 3) | 0;
-function subpathToMorphContour(sp, m = _chunkJCXMJUQOcjs.IDENTITY_MATRIX) {
+function subpathToMorphContour(sp, m = _chunkEGZM52EOcjs.IDENTITY_MATRIX) {
   const n = sp.anchors.length;
   if (!n) return null;
   const first = mapP(m, toP(sp.anchors[0]));
@@ -67,8 +67,8 @@ function isStraight(p0, p1, p2, p3) {
   const u2 = along(p2);
   return off(p1) < tol && off(p2) < tol && u1 >= -1e-9 && u1 <= 1 + 1e-9 && u2 >= -1e-9 && u2 <= 1 + 1e-9;
 }
-function morphContourToSubpath(c, m = _chunkJCXMJUQOcjs.IDENTITY_MATRIX, closed = c.closed) {
-  const pts = _chunkJCXMJUQOcjs.isIdentityMatrix.call(void 0, m) ? c.pts : c.pts.map((p) => mapP(m, p));
+function morphContourToSubpath(c, m = _chunkEGZM52EOcjs.IDENTITY_MATRIX, closed = c.closed) {
+  const pts = _chunkEGZM52EOcjs.isIdentityMatrix.call(void 0, m) ? c.pts : c.pts.map((p) => mapP(m, p));
   const curves = curvesOf(c);
   const dropLast = closed && c.closed && curves > 0;
   const count = dropLast ? curves : curves + 1;
@@ -84,7 +84,7 @@ function morphContourToSubpath(c, m = _chunkJCXMJUQOcjs.IDENTITY_MATRIX, closed
     anchors[(k + 1) % count].in = { x: p2[0], y: p2[1] };
   }
   for (const a of anchors) {
-    const type = _chunkJCXMJUQOcjs.inferAnchorType.call(void 0, a);
+    const type = _chunkEGZM52EOcjs.inferAnchorType.call(void 0, a);
     if (type !== "corner") a.type = type;
   }
   const isClosed = closed && curves > 0;
@@ -267,7 +267,7 @@ function bestStart(fixed, free, useShapeContext) {
   return best;
 }
 function placeIn(c, from, to) {
-  const b = _chunkJCXMJUQOcjs.unionBounds.call(void 0, [boundsOfPoints(c.pts)]);
+  const b = _chunkEGZM52EOcjs.unionBounds.call(void 0, [boundsOfPoints(c.pts)]);
   const p = b ? [b.x + b.width / 2, b.y + b.height / 2] : c.pts[0];
   if (!from || !to) return p;
   const fx = from.width > 0 ? (p[0] - from.x) / from.width : 0.5;
@@ -452,11 +452,11 @@ function interpolateRigidMatrix(a, b, t) {
 function interpolateVectorColor(a, b, t) {
   if (t <= 0) return a;
   if (t >= 1) return b;
-  return _nullishCoalesce(_chunkCIPIESX4cjs.mixColorsOklab.call(void 0, a, b, t), () => ( (t < 0.5 ? a : b)));
+  return _nullishCoalesce(_chunk4ZC5QJE2cjs.mixColorsOklab.call(void 0, a, b, t), () => ( (t < 0.5 ? a : b)));
 }
 function resampleGradientStops(g, offsets) {
   return offsets.map((offset) => {
-    const s = _chunkJCXMJUQOcjs.sampleVectorGradient.call(void 0, g, offset);
+    const s = _chunkEGZM52EOcjs.sampleVectorGradient.call(void 0, g, offset);
     return s.opacity < 1 ? { offset, color: s.color, opacity: Math.round(s.opacity * 1e4) / 1e4 } : { offset, color: s.color };
   });
 }
@@ -467,11 +467,11 @@ function lerpAngle(a, b, t) {
 var lerpPoint = (a, b, t) => ({ x: lerpN(a.x, b.x, t), y: lerpN(a.y, b.y, t) });
 var sameColourModel = (a, b) => (_nullishCoalesce(a.interpolation, () => ( "srgb"))) === (_nullishCoalesce(b.interpolation, () => ( "srgb"))) && (_nullishCoalesce(a.smoothness, () => ( 0))) === (_nullishCoalesce(b.smoothness, () => ( 0)));
 function lerpStops(a, b, t) {
-  let stopsA = _chunkJCXMJUQOcjs.sortedVectorGradientStops.call(void 0, a);
-  let stopsB = _chunkJCXMJUQOcjs.sortedVectorGradientStops.call(void 0, b);
+  let stopsA = _chunkEGZM52EOcjs.sortedVectorGradientStops.call(void 0, a);
+  let stopsB = _chunkEGZM52EOcjs.sortedVectorGradientStops.call(void 0, b);
   const resampled = stopsA.length !== stopsB.length || !sameColourModel(a, b);
   if (resampled) {
-    const offs = [..._chunkJCXMJUQOcjs.expandVectorGradientStops.call(void 0, a), ..._chunkJCXMJUQOcjs.expandVectorGradientStops.call(void 0, b), ...stopsA, ...stopsB].map((s) => s.offset).filter(Number.isFinite).sort((x, y) => x - y);
+    const offs = [..._chunkEGZM52EOcjs.expandVectorGradientStops.call(void 0, a), ..._chunkEGZM52EOcjs.expandVectorGradientStops.call(void 0, b), ...stopsA, ...stopsB].map((s) => s.offset).filter(Number.isFinite).sort((x, y) => x - y);
     const common = offs.filter((o, i) => i === 0 || o - offs[i - 1] > 1e-4);
     stopsA = resampleGradientStops(a, common);
     stopsB = resampleGradientStops(b, common);
@@ -498,8 +498,8 @@ function lerpGradient(a, b, t) {
   }
   if (near.spread && near.spread !== "pad") out.spread = near.spread;
   if (near.strokeMode && near.strokeMode !== "within") out.strokeMode = near.strokeMode;
-  const ea = _chunkJCXMJUQOcjs.hasExplicitGradientGeometry.call(void 0, a);
-  const eb = _chunkJCXMJUQOcjs.hasExplicitGradientGeometry.call(void 0, b);
+  const ea = _chunkEGZM52EOcjs.hasExplicitGradientGeometry.call(void 0, a);
+  const eb = _chunkEGZM52EOcjs.hasExplicitGradientGeometry.call(void 0, b);
   if (!ea && !eb) {
     if (a.angle !== void 0 || b.angle !== void 0 || a.type === "linear" || a.type === "reflected") {
       const fallback = a.type === "linear" || a.type === "reflected" ? 180 : 90;
@@ -512,10 +512,10 @@ function lerpGradient(a, b, t) {
     }
     return out;
   }
-  const pa = _chunkJCXMJUQOcjs.vectorGradientPoints.call(void 0, a);
-  const pb = _chunkJCXMJUQOcjs.vectorGradientPoints.call(void 0, b);
+  const pa = _chunkEGZM52EOcjs.vectorGradientPoints.call(void 0, a);
+  const pb = _chunkEGZM52EOcjs.vectorGradientPoints.call(void 0, b);
   if (pa.units !== pb.units) {
-    const src = _chunkJCXMJUQOcjs.explicitVectorGradient.call(void 0, near);
+    const src = _chunkEGZM52EOcjs.explicitVectorGradient.call(void 0, near);
     return { ...src, stops: out.stops, ...out.interpolation ? { interpolation: out.interpolation } : {}, ...out.smoothness ? { smoothness: out.smoothness } : {} };
   }
   out.start = lerpPoint(pa.start, pb.start, t);
@@ -535,14 +535,14 @@ function solidLike(color, like) {
 function interpolateVectorPaint(a, b, t) {
   if (t <= 0) return a;
   if (t >= 1) return b;
-  const pa = _chunkJCXMJUQOcjs.hasPaint.call(void 0, a);
-  const pb = _chunkJCXMJUQOcjs.hasPaint.call(void 0, b);
+  const pa = _chunkEGZM52EOcjs.hasPaint.call(void 0, a);
+  const pb = _chunkEGZM52EOcjs.hasPaint.call(void 0, b);
   if (!pa && !pb) return t < 0.5 ? a : b;
   if (typeof a === "string" && pa && typeof b === "string" && pb) return interpolateVectorColor(a, b, t);
   if (!pa && typeof b === "string") return interpolateVectorColor("transparent", b, t);
   if (!pb && typeof a === "string") return interpolateVectorColor(a, "transparent", t);
-  const ga = pa && _chunkJCXMJUQOcjs.isVectorGradient.call(void 0, a) ? a : null;
-  const gb = pb && _chunkJCXMJUQOcjs.isVectorGradient.call(void 0, b) ? b : null;
+  const ga = pa && _chunkEGZM52EOcjs.isVectorGradient.call(void 0, a) ? a : null;
+  const gb = pb && _chunkEGZM52EOcjs.isVectorGradient.call(void 0, b) ? b : null;
   if (ga && gb) return _nullishCoalesce(lerpGradient(ga, gb, t), () => ( (t < 0.5 ? a : b)));
   if (gb) return _nullishCoalesce(lerpGradient(solidLike(pa ? a : null, gb), gb, t), () => ( b));
   if (ga) return _nullishCoalesce(lerpGradient(ga, solidLike(pb ? b : null, ga), t), () => ( a));
@@ -553,8 +553,8 @@ function interpolateWidthProfiles(a, b, t) {
   const at = [..._nullishCoalesce(a, () => ( [])), ..._nullishCoalesce(b, () => ( [])), { t: 0 }, { t: 1 }].map((p) => p.t).sort((x, y) => x - y);
   const ts = at.filter((v, i) => i === 0 || v - at[i - 1] > 1e-6);
   return ts.map((pos) => {
-    const x = _chunkJCXMJUQOcjs.widthProfileAt.call(void 0, a, pos);
-    const y = _chunkJCXMJUQOcjs.widthProfileAt.call(void 0, b, pos);
+    const x = _chunkEGZM52EOcjs.widthProfileAt.call(void 0, a, pos);
+    const y = _chunkEGZM52EOcjs.widthProfileAt.call(void 0, b, pos);
     return { t: pos, left: lerpN(x.left, y.left, t), right: lerpN(x.right, y.right, t) };
   });
 }
@@ -597,7 +597,7 @@ function reversedStyle(s) {
   out.endArrow = s.startArrow;
   out.startArrowScale = s.endArrowScale;
   out.endArrowScale = s.startArrowScale;
-  if (_optionalChain([s, 'access', _6 => _6.strokeWidthProfile, 'optionalAccess', _7 => _7.length])) out.strokeWidthProfile = _chunkJCXMJUQOcjs.reverseWidthProfile.call(void 0, s.strokeWidthProfile);
+  if (_optionalChain([s, 'access', _6 => _6.strokeWidthProfile, 'optionalAccess', _7 => _7.length])) out.strokeWidthProfile = _chunkEGZM52EOcjs.reverseWidthProfile.call(void 0, s.strokeWidthProfile);
   for (const k of ["startArrow", "endArrow", "startArrowScale", "endArrowScale"]) if (out[k] === void 0) delete out[k];
   return out;
 }
@@ -623,19 +623,19 @@ function styleOf(n) {
   return out;
 }
 function contoursOf(node, m) {
-  return _chunkJCXMJUQOcjs.expandVectorCorners.call(void 0, node.subpaths).map((sp) => subpathToMorphContour(sp, m)).filter((c) => !!c);
+  return _chunkEGZM52EOcjs.expandVectorCorners.call(void 0, node.subpaths).map((sp) => subpathToMorphContour(sp, m)).filter((c) => !!c);
 }
-function preparePathMorph(a, b, options, ma = _chunkJCXMJUQOcjs.nodeMatrix.call(void 0, a), mb = _chunkJCXMJUQOcjs.nodeMatrix.call(void 0, b)) {
+function preparePathMorph(a, b, options, ma = _chunkEGZM52EOcjs.nodeMatrix.call(void 0, a), mb = _chunkEGZM52EOcjs.nodeMatrix.call(void 0, b)) {
   const corr = correspondMorphContours(contoursOf(a, ma), contoursOf(b, mb), options);
   const sim = procrustes(corr.a, corr.b);
   const styleA = styleOf(a);
   const styleB = corr.reversed ? reversedStyle(styleOf(b)) : styleOf(b);
-  const rigid = !_chunkJCXMJUQOcjs.isIdentityMatrix.call(void 0, ma) || !_chunkJCXMJUQOcjs.isIdentityMatrix.call(void 0, mb);
+  const rigid = !_chunkEGZM52EOcjs.isIdentityMatrix.call(void 0, ma) || !_chunkEGZM52EOcjs.isIdentityMatrix.call(void 0, mb);
   const id = _nullishCoalesce(options.id, () => ( a.id));
   return (t) => {
     const contours = interpolateMorphContours(corr.a, corr.b, t, { linear: options.linear, rigidity: options.rigidity, similarity: sim });
-    const m = rigid ? interpolateRigidMatrix(ma, mb, t) : _chunkJCXMJUQOcjs.IDENTITY_MATRIX;
-    const back = rigid ? _chunkJCXMJUQOcjs.invertMatrix.call(void 0, m) : _chunkJCXMJUQOcjs.IDENTITY_MATRIX;
+    const m = rigid ? interpolateRigidMatrix(ma, mb, t) : _chunkEGZM52EOcjs.IDENTITY_MATRIX;
+    const back = rigid ? _chunkEGZM52EOcjs.invertMatrix.call(void 0, m) : _chunkEGZM52EOcjs.IDENTITY_MATRIX;
     const subpaths = contours.map((c, k) => {
       const closed = t <= 0 ? corr.a[k].closed : t >= 1 ? corr.b[k].closed : corr.a[k].closed && corr.b[k].closed;
       return morphContourToSubpath({ closed: corr.a[k].closed && corr.b[k].closed, pts: c.pts }, back, closed);
@@ -643,14 +643,14 @@ function preparePathMorph(a, b, options, ma = _chunkJCXMJUQOcjs.nodeMatrix.call(
     const node = { id, type: "path", subpaths, ...interpolateVectorStyle(styleA, styleB, t) };
     const opacity = lerpN(_nullishCoalesce(a.opacity, () => ( 1)), _nullishCoalesce(b.opacity, () => ( 1)), t);
     if (opacity < 1) node.opacity = opacity;
-    if (rigid && !_chunkJCXMJUQOcjs.isIdentityMatrix.call(void 0, m)) node.transform = m;
+    if (rigid && !_chunkEGZM52EOcjs.isIdentityMatrix.call(void 0, m)) node.transform = m;
     return node;
   };
 }
-function flattenPaths(node, parent = _chunkJCXMJUQOcjs.IDENTITY_MATRIX) {
-  const m = _chunkJCXMJUQOcjs.multiplyMatrices.call(void 0, _chunkJCXMJUQOcjs.nodeMatrix.call(void 0, node), parent);
+function flattenPaths(node, parent = _chunkEGZM52EOcjs.IDENTITY_MATRIX) {
+  const m = _chunkEGZM52EOcjs.multiplyMatrices.call(void 0, _chunkEGZM52EOcjs.nodeMatrix.call(void 0, node), parent);
   if (node.type === "path") return [{ path: node, m, opacity: 1 }];
-  if (node.type === "text" || node.type === "instance") return flattenPaths(_chunkJCXMJUQOcjs.expandVectorAppearance.call(void 0, node), parent);
+  if (node.type === "text" || node.type === "instance") return flattenPaths(_chunkEGZM52EOcjs.expandVectorAppearance.call(void 0, node), parent);
   const o = _nullishCoalesce(node.opacity, () => ( 1));
   return node.children.filter((c) => c.visible !== false).flatMap((c) => flattenPaths(c, m)).map((e) => ({ ...e, opacity: e.opacity * o }));
 }
@@ -672,8 +672,8 @@ function createVectorMorph(a, b, options = {}) {
   }
   const pa = flattenPaths(a);
   const pb = flattenPaths(b);
-  const ba = _chunkJCXMJUQOcjs.unionBounds.call(void 0, pa.map((e) => placedBounds(e.path, e.m)));
-  const bb = _chunkJCXMJUQOcjs.unionBounds.call(void 0, pb.map((e) => placedBounds(e.path, e.m)));
+  const ba = _chunkEGZM52EOcjs.unionBounds.call(void 0, pa.map((e) => placedBounds(e.path, e.m)));
+  const bb = _chunkEGZM52EOcjs.unionBounds.call(void 0, pb.map((e) => placedBounds(e.path, e.m)));
   const id = _nullishCoalesce(options.id, () => ( a.id));
   const parts = [];
   const opacities = [];
@@ -685,10 +685,10 @@ function createVectorMorph(a, b, options = {}) {
       parts.push(preparePathMorph(x.path, y.path, sub, x.m, y.m));
       opacities.push([x.opacity, y.opacity]);
     } else if (x) {
-      parts.push(preparePathMorph(x.path, collapsedPath(x.path, x.m, ba, bb), sub, x.m, _chunkJCXMJUQOcjs.IDENTITY_MATRIX));
+      parts.push(preparePathMorph(x.path, collapsedPath(x.path, x.m, ba, bb), sub, x.m, _chunkEGZM52EOcjs.IDENTITY_MATRIX));
       opacities.push([x.opacity, x.opacity]);
     } else if (y) {
-      parts.push(preparePathMorph(collapsedPath(y.path, y.m, bb, ba), y.path, sub, _chunkJCXMJUQOcjs.IDENTITY_MATRIX, y.m));
+      parts.push(preparePathMorph(collapsedPath(y.path, y.m, bb, ba), y.path, sub, _chunkEGZM52EOcjs.IDENTITY_MATRIX, y.m));
       opacities.push([y.opacity, y.opacity]);
     }
   }

package/dist/{chunk-POR54B55.js → chunk-XNU45TYA.js}

@@ -8,7 +8,7 @@ import {
   isCartesianChart,
   normalizeChartSpec,
   parseChartColor
-} from "./chunk-3NEZJCBY.js";
+} from "./chunk-FR432ROA.js";
 
 // src/chart/ooxml.ts
 var CHART_OOXML_NS = "http://schemas.openxmlformats.org/drawingml/2006/chart";
@@ -475,6 +475,12 @@ function chartToOoxml(spec) {
   } else if (family === "sunburst") {
     issues.push(`Sunburst charts are written as doughnut charts of the ${spec.tree.length ? "top-level group totals" : "values"}: DrawingML has no sunburst type (Office 2016 stores it as chartex).`);
     type = "donut";
+  } else if (family === "barrace") {
+    issues.push("Bar chart races are written as clustered bar charts of every name at every time point: DrawingML has no animation.");
+    type = "bar";
+  } else if (family === "sankey") {
+    issues.push("Sankey diagrams are written as bar charts of how much passes through each node: DrawingML has no flows.");
+    type = "bar";
   } else if (family === "parliament") {
     issues.push("Parliament charts are written as doughnut charts of the seats: DrawingML has no parliament type.");
     type = "donut";