@pixerate/editor 0.163.0 → 0.165.0

package/dist/{chunk-M4MIZPQI.cjs → chunk-SJ2CPTQC.cjs}

@@ -3,6 +3,42 @@
 
 var _chunk2BSBFBOAcjs = require('./chunk-2BSBFBOA.cjs');
 
+// 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, (_nullishCoalesce(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 = (_nullishCoalesce(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 = _optionalChain([globalThis, 'access', _ => _.navigator, 'optionalAccess', _2 => _2.locks]);
+  } catch (e) {
+    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) => `${_nullishCoalesce(options.prefix, () => ( "pixerate.assets:"))}${ref.slice(EDITOR_ASSET_PREFIX.length)}`;
+var assetPrefix = (options) => _nullishCoalesce(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 = _nullishCoalesce(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 = _nullishCoalesce(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,11 +168,134 @@ 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(_nullishCoalesce(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 (e2) {
+    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 (e3) {
+    return null;
+  }
+  return tryCollectEditorAssetGarbage(storage, { ...extra, keep: [current, ..._nullishCoalesce(extra.keep, () => ( []))] });
 }
 
 // src/persistence/migrate.ts
@@ -148,7 +319,7 @@ function toObject(json) {
   if (typeof json === "string") {
     try {
       value = JSON.parse(json);
-    } catch (e) {
+    } catch (e4) {
       return void 0;
     }
   }
@@ -185,7 +356,7 @@ function migrateDocument(json, options) {
   }
   let doc = deepClone(original);
   for (let step = from; step < target; step++) {
-    const fn = _optionalChain([options, 'access', _ => _.steps, 'optionalAccess', _2 => _2[step]]);
+    const fn = _optionalChain([options, 'access', _3 => _3.steps, 'optionalAccess', _4 => _4[step]]);
     if (!fn) {
       report.readOnly = {
         kind: "migrationFailed",
@@ -242,7 +413,7 @@ function loadSections(doc, sections, options = {}) {
 function loadDocument(json, sections, options) {
   const { doc, report } = migrateDocument(json, options);
   const ignore = _nullishCoalesce(options.ignore, () => ( [_nullishCoalesce(options.versionKey, () => ( "version"))]));
-  const result = loadSections(_optionalChain([report, 'access', _3 => _3.readOnly, 'optionalAccess', _4 => _4.kind]) === "invalid" ? {} : doc, sections, {
+  const result = loadSections(_optionalChain([report, 'access', _5 => _5.readOnly, 'optionalAccess', _6 => _6.kind]) === "invalid" ? {} : doc, sections, {
     ignore
   });
   report.problems = result.problems;
@@ -340,7 +511,7 @@ function defineEditorDocument(spec) {
       if (document === void 0 || document === null) throw new EditorDocumentLoadError(`No ${spec.kind} document was given.`);
       try {
         const result = spec.load(spec.assets ? internalizeAssets(document, spec.assets) : document, { history: _nullishCoalesce(options.history, () => ( "reset")) });
-        if (_optionalChain([result, 'optionalAccess', _5 => _5.problems, 'optionalAccess', _6 => _6.length])) report.problems.push(...result.problems);
+        if (_optionalChain([result, 'optionalAccess', _7 => _7.problems, 'optionalAccess', _8 => _8.length])) report.problems.push(...result.problems);
       } catch (error) {
         if (error instanceof EditorDocumentLoadError) throw error;
         throw new EditorDocumentLoadError(error instanceof Error ? error.message : String(error));
@@ -360,9 +531,9 @@ function defineEditorDocument(spec) {
     },
     history: spec.history,
     ...spec.assets ? { assets: spec.assets } : {},
-    readOnly: () => _nullishCoalesce(_optionalChain([spec, 'access', _7 => _7.readOnly, 'optionalCall', _8 => _8()]), () => ( false)),
+    readOnly: () => _nullishCoalesce(_optionalChain([spec, 'access', _9 => _9.readOnly, 'optionalCall', _10 => _10()]), () => ( false)),
     destroy() {
-      _optionalChain([unsubscribe, 'optionalCall', _9 => _9()]);
+      _optionalChain([unsubscribe, 'optionalCall', _11 => _11()]);
       unsubscribe = null;
     }
   };
@@ -390,4 +561,7 @@ function defineEditorDocument(spec) {
 
 
 
-exports.EDITOR_ASSET_PREFIX = EDITOR_ASSET_PREFIX; exports.isInlineAsset = isInlineAsset; exports.createEditorAssetRegistry = createEditorAssetRegistry; exports.externalizeAssets = externalizeAssets; exports.collectAssetRefs = collectAssetRefs; exports.internalizeAssets = internalizeAssets; exports.persistEditorAssets = persistEditorAssets; exports.preloadEditorAssets = preloadEditorAssets; exports.withEditorAssets = withEditorAssets; exports.hasLoadProblems = hasLoadProblems; exports.createLoadReport = createLoadReport; exports.migrateDocument = migrateDocument; exports.loadSections = loadSections; exports.loadDocument = loadDocument; exports.EditorDocumentLoadError = EditorDocumentLoadError; exports.EDITOR_DOCUMENT_FORMAT = EDITOR_DOCUMENT_FORMAT; exports.isEditorDocumentFile = isEditorDocumentFile; exports.toEditorDocumentFile = toEditorDocumentFile; exports.serializeEditorDocument = serializeEditorDocument; exports.parseEditorDocument = parseEditorDocument; exports.defineEditorDocument = defineEditorDocument;
+
+
+
+exports.EDITOR_ASSET_PREFIX = EDITOR_ASSET_PREFIX; exports.isInlineAsset = isInlineAsset; exports.createEditorAssetRegistry = createEditorAssetRegistry; exports.externalizeAssets = externalizeAssets; exports.collectAssetRefs = collectAssetRefs; exports.internalizeAssets = internalizeAssets; exports.persistEditorAssets = persistEditorAssets; exports.preloadEditorAssets = preloadEditorAssets; exports.withEditorAssets = withEditorAssets; exports.collectEditorAssetGarbage = collectEditorAssetGarbage; exports.tryCollectEditorAssetGarbage = tryCollectEditorAssetGarbage; exports.collectRetiredEditorAssets = collectRetiredEditorAssets; exports.hasLoadProblems = hasLoadProblems; exports.createLoadReport = createLoadReport; exports.migrateDocument = migrateDocument; exports.loadSections = loadSections; exports.loadDocument = loadDocument; exports.EditorDocumentLoadError = EditorDocumentLoadError; exports.EDITOR_DOCUMENT_FORMAT = EDITOR_DOCUMENT_FORMAT; exports.isEditorDocumentFile = isEditorDocumentFile; exports.toEditorDocumentFile = toEditorDocumentFile; exports.serializeEditorDocument = serializeEditorDocument; exports.parseEditorDocument = parseEditorDocument; exports.defineEditorDocument = defineEditorDocument;

package/dist/chunk-TFF2GTGN.cjs

@@ -0,0 +1,153 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+
+
+
+
+
+
+
+
+
+var _chunk5UEFBM2Mcjs = require('./chunk-5UEFBM2M.cjs');
+
+// src/color/gamut.ts
+var clamp01 = (v) => Math.min(1, Math.max(0, v));
+function inSrgbGamut(c, epsilon = 1e-5) {
+  return c.r >= -epsilon && c.r <= 1 + epsilon && c.g >= -epsilon && c.g <= 1 + epsilon && c.b >= -epsilon && c.b <= 1 + epsilon;
+}
+function deltaEOK(a, b) {
+  const la = _chunk5UEFBM2Mcjs.rgbToOklab.call(void 0, a);
+  const lb = _chunk5UEFBM2Mcjs.rgbToOklab.call(void 0, b);
+  return Math.hypot(la.l - lb.l, la.a - lb.a, la.b - lb.b);
+}
+function toSrgbGamut(c) {
+  const lch = _chunk5UEFBM2Mcjs.oklabToOklch.call(void 0, _chunk5UEFBM2Mcjs.rgbToOklab.call(void 0, c));
+  if (lch.l >= 1) return { r: 1, g: 1, b: 1, a: c.a };
+  if (lch.l <= 0) return { r: 0, g: 0, b: 0, a: c.a };
+  if (inSrgbGamut(c)) {
+    return { r: clamp01(c.r), g: clamp01(c.g), b: clamp01(c.b), a: c.a };
+  }
+  let low = 0;
+  let high = lch.c;
+  let clippedCandidate = { r: clamp01(c.r), g: clamp01(c.g), b: clamp01(c.b), a: c.a };
+  const JND = 0.02;
+  const EPS = 1e-4;
+  for (let i = 0; i < 30; i++) {
+    const mid = (low + high) / 2;
+    const candidate = _chunk5UEFBM2Mcjs.oklabToRgb.call(void 0, _chunk5UEFBM2Mcjs.oklchToOklab.call(void 0, { l: lch.l, c: mid, h: lch.h, alpha: c.a }));
+    const clipped = {
+      r: clamp01(candidate.r),
+      g: clamp01(candidate.g),
+      b: clamp01(candidate.b),
+      a: c.a
+    };
+    clippedCandidate = clipped;
+    const dE = deltaEOK(candidate, clipped);
+    if (dE < JND) {
+      if (JND - dE < EPS) {
+        return clipped;
+      }
+      low = mid;
+    } else {
+      high = mid;
+    }
+    if (high - low < 1e-4) {
+      break;
+    }
+  }
+  return clippedCandidate;
+}
+
+// src/color/format.ts
+var clamp012 = (v) => Math.min(1, Math.max(0, v));
+var byte = (v) => Math.round(clamp012(v) * 255);
+var hex2 = (n) => n.toString(16).padStart(2, "0");
+var round2 = (n) => (Math.round(n * 100) / 100).toString();
+function formatHex(c) {
+  const mapped = toSrgbGamut(c);
+  const head = `#${hex2(byte(mapped.r))}${hex2(byte(mapped.g))}${hex2(byte(mapped.b))}`;
+  const alpha = byte(mapped.a);
+  return alpha === 255 ? head : head + hex2(alpha);
+}
+function formatColor(c, format) {
+  switch (format) {
+    case "hex":
+      return formatHex(c);
+    case "rgb": {
+      const inGamut = toSrgbGamut(c);
+      const r = byte(inGamut.r);
+      const g = byte(inGamut.g);
+      const b = byte(inGamut.b);
+      return c.a < 1 ? `rgb(${r} ${g} ${b} / ${round2(c.a)})` : `rgb(${r} ${g} ${b})`;
+    }
+    case "hsl": {
+      const hsl = _chunk5UEFBM2Mcjs.rgbToHsl.call(void 0, toSrgbGamut(c));
+      const h = (Math.round(hsl.h * 100) / 100).toString();
+      const s = (Math.round(hsl.s * 1e4) / 100).toString();
+      const l = (Math.round(hsl.l * 1e4) / 100).toString();
+      return c.a < 1 ? `hsl(${h} ${s}% ${l}% / ${round2(c.a)})` : `hsl(${h} ${s}% ${l}%)`;
+    }
+    case "oklch": {
+      const lch = _chunk5UEFBM2Mcjs.oklabToOklch.call(void 0, _chunk5UEFBM2Mcjs.rgbToOklab.call(void 0, c));
+      const l = (lch.l * 100).toFixed(2);
+      const ch = lch.c.toFixed(4);
+      const h = lch.h.toFixed(2);
+      return c.a < 1 ? `oklch(${l}% ${ch} ${h} / ${round2(c.a)})` : `oklch(${l}% ${ch} ${h})`;
+    }
+    case "oklab": {
+      const lab = _chunk5UEFBM2Mcjs.rgbToOklab.call(void 0, c);
+      const l = (lab.l * 100).toFixed(2);
+      const a = lab.a.toFixed(4);
+      const b = lab.b.toFixed(4);
+      return c.a < 1 ? `oklab(${l}% ${a} ${b} / ${round2(c.a)})` : `oklab(${l}% ${a} ${b})`;
+    }
+    case "p3": {
+      const linSrgb = {
+        r: _chunk5UEFBM2Mcjs.srgbToLinear.call(void 0, c.r),
+        g: _chunk5UEFBM2Mcjs.srgbToLinear.call(void 0, c.g),
+        b: _chunk5UEFBM2Mcjs.srgbToLinear.call(void 0, c.b),
+        a: c.a
+      };
+      const linP3 = _chunk5UEFBM2Mcjs.linearSrgbToDisplayP3.call(void 0, linSrgb);
+      const r = _chunk5UEFBM2Mcjs.linearToSrgb.call(void 0, linP3.r).toFixed(4);
+      const g = _chunk5UEFBM2Mcjs.linearToSrgb.call(void 0, linP3.g).toFixed(4);
+      const b = _chunk5UEFBM2Mcjs.linearToSrgb.call(void 0, linP3.b).toFixed(4);
+      return c.a < 1 ? `color(display-p3 ${r} ${g} ${b} / ${round2(c.a)})` : `color(display-p3 ${r} ${g} ${b})`;
+    }
+  }
+}
+function normalizeColor(input) {
+  const parsed = _chunk5UEFBM2Mcjs.parseColor.call(void 0, input);
+  return parsed ? formatHex(parsed) : null;
+}
+
+// src/color/suggest.ts
+function suggestAccessibleForeground(foreground, background, options = {}) {
+  const large = _nullishCoalesce(options.large, () => ( false));
+  const lch = _chunk5UEFBM2Mcjs.oklabToOklch.call(void 0, _chunk5UEFBM2Mcjs.rgbToOklab.call(void 0, foreground));
+  const asHex = (l) => _chunk5UEFBM2Mcjs.parseColor.call(void 0, formatHex(toSrgbGamut(_chunk5UEFBM2Mcjs.oklabToRgb.call(void 0, _chunk5UEFBM2Mcjs.oklchToOklab.call(void 0, { ...lch, l })))));
+  for (let d = 0.01; d <= 1; d += 0.01) {
+    const downCand = asHex(Math.max(0, lch.l - d));
+    const upCand = asHex(Math.min(1, lch.l + d));
+    const downRatio = _chunk5UEFBM2Mcjs.contrastRatio.call(void 0, downCand, background);
+    const upRatio = _chunk5UEFBM2Mcjs.contrastRatio.call(void 0, upCand, background);
+    const downPass = _chunk5UEFBM2Mcjs.contrastLevel.call(void 0, downRatio, { large }) !== "fail";
+    const upPass = _chunk5UEFBM2Mcjs.contrastLevel.call(void 0, upRatio, { large }) !== "fail";
+    if (downPass && upPass) return formatHex(downRatio >= upRatio ? downCand : upCand);
+    if (downPass) return formatHex(downCand);
+    if (upPass) return formatHex(upCand);
+  }
+  return void 0;
+}
+
+
+
+
+
+
+
+
+
+exports.inSrgbGamut = inSrgbGamut; exports.deltaEOK = deltaEOK; exports.toSrgbGamut = toSrgbGamut; exports.formatHex = formatHex; exports.formatColor = formatColor; exports.normalizeColor = normalizeColor; exports.suggestAccessibleForeground = suggestAccessibleForeground;

package/dist/chunk-TTCJPX4U.cjs

@@ -0,0 +1,204 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkVU6WQSMBcjs = require('./chunk-VU6WQSMB.cjs');
+
+// src/diagram/sankey/index.ts
+function parseSankey(source) {
+  const split = _chunkVU6WQSMBcjs.splitSource.call(void 0, source);
+  if (!/^\s*sankey(?:-beta)?\b/i.test(split.header)) {
+    return { error: "Not a sankey diagram: the first line should be `sankey-beta`." };
+  }
+  const firstLine = split.headerIndex + 2;
+  const kept = [];
+  split.bodyLines.forEach((text, i) => {
+    if (/^\s*%%/.test(text)) return;
+    kept.push({ text: text.trim(), line: firstLine + i });
+  });
+  const records = readRecords(kept);
+  if ("error" in records) return records;
+  const nodes = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (name) => {
+    if (!seen.has(name)) {
+      seen.add(name);
+      nodes.push(name);
+    }
+  };
+  const links = [];
+  for (const { fields, line } of records) {
+    if (fields.length !== 3) {
+      return {
+        error: `Expected three fields (source,target,value), found ${fields.length}.`,
+        line
+      };
+    }
+    const [source2, target, raw] = fields;
+    const value = Number.parseFloat(raw);
+    if (!Number.isFinite(value)) {
+      return { error: `"${raw}" is not a number.`, line };
+    }
+    add(source2);
+    add(target);
+    links.push({ source: source2, target, value });
+  }
+  if (!links.length) return { error: "No links: add lines like `A,B,10`." };
+  return { data: { nodes, links } };
+}
+function readRecords(lines) {
+  const records = [];
+  let i = 0;
+  while (i < lines.length) {
+    const start = lines[i];
+    if (start.text === "") {
+      i++;
+      continue;
+    }
+    const fields = [];
+    let text = start.text;
+    let pos = 0;
+    let field = "";
+    let quoted = false;
+    for (; ; ) {
+      if (quoted) {
+        const close = text.indexOf('"', pos);
+        if (close < 0) {
+          field += text.slice(pos);
+          i++;
+          if (i >= lines.length)
+            return { error: "A quoted field is never closed.", line: start.line };
+          field += "\n";
+          text = lines[i].text;
+          pos = 0;
+          continue;
+        }
+        field += text.slice(pos, close);
+        if (text[close + 1] === '"') {
+          field += '"';
+          pos = close + 2;
+          continue;
+        }
+        quoted = false;
+        pos = close + 1;
+        const rest = /^[ \t]*/.exec(text.slice(pos))[0].length;
+        pos += rest;
+        if (pos < text.length && text[pos] !== ",") {
+          return { error: "Unexpected text after a quoted field.", line: lines[i].line };
+        }
+        continue;
+      }
+      if (pos >= text.length) {
+        fields.push(field.trim());
+        break;
+      }
+      const ch = text[pos];
+      if (ch === ",") {
+        fields.push(field.trim());
+        field = "";
+        pos++;
+      } else if (ch === '"' && field.trim() === "") {
+        quoted = true;
+        field = "";
+        pos++;
+      } else if (ch === '"') {
+        return { error: "A quote inside an unquoted field.", line: lines[i].line };
+      } else {
+        field += ch;
+        pos++;
+      }
+    }
+    records.push({ fields, line: start.line });
+    i++;
+  }
+  return records;
+}
+
+// src/diagram/treemap/index.ts
+var NAME = String.raw`(?:"([^"]*)"|'([^']*)')`;
+var CLASS = String.raw`(?:\s*:::\s*([A-Za-z_]\w*))?`;
+var SECTION_RE = new RegExp(String.raw`^${NAME}${CLASS}$`);
+var LEAF_RE = new RegExp(String.raw`^${NAME}\s*[:,]\s*([0-9_.,]+)${CLASS}$`);
+function parseTreemap(source) {
+  const split = _chunkVU6WQSMBcjs.splitSource.call(void 0, source);
+  if (!/^\s*treemap(?:-beta)?\b/i.test(split.header)) {
+    return { error: "Not a treemap: the first line should be `treemap-beta`." };
+  }
+  const data = { items: [] };
+  const stack = [];
+  const firstLine = split.headerIndex + 2;
+  const lines = split.bodyLines;
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const line = firstLine + i;
+    const indent = /^[ \t]*/.exec(raw)[0].length;
+    const text = stripComment(raw).trim();
+    if (!text) continue;
+    const accBlock = /^accDescr\s*\{(.*)$/.exec(text);
+    if (accBlock) {
+      let body = accBlock[1];
+      while (!body.includes("}") && i + 1 < lines.length) body += `
+${lines[++i]}`;
+      if (!body.includes("}")) return { error: "`accDescr {` is never closed.", line };
+      data.accDescr = body.slice(0, body.indexOf("}")).trim();
+      continue;
+    }
+    const acc = /^(accTitle|accDescr)\s*:(.*)$/.exec(text);
+    if (acc) {
+      data[acc[1]] = acc[2].trim();
+      continue;
+    }
+    const title = /^title(?:[ \t]+(.*))?$/.exec(text);
+    if (title) {
+      data.title = (_nullishCoalesce(title[1], () => ( ""))).trim() || void 0;
+      continue;
+    }
+    if (/^classDef\s/.test(text)) continue;
+    let item;
+    const leaf = LEAF_RE.exec(text);
+    const section = leaf ? null : SECTION_RE.exec(text);
+    if (leaf) {
+      const value = Number.parseFloat(leaf[3].replace(/,/g, ""));
+      if (!Number.isFinite(value)) return { error: `"${leaf[3]}" is not a number.`, line };
+      item = { name: _nullishCoalesce(leaf[1], () => ( leaf[2])), value };
+      if (leaf[4]) item.className = leaf[4];
+    } else if (section) {
+      item = { name: _nullishCoalesce(section[1], () => ( section[2])), children: [] };
+      if (section[3]) item.className = section[3];
+    } else {
+      return {
+        error: /^["']/.test(text) ? 'Expected `"Name"` for a section or `"Name": value` for a leaf.' : 'Names must be in quotes, e.g. `"Sales": 120`.',
+        line
+      };
+    }
+    while (stack.length && stack[stack.length - 1].indent >= indent) stack.pop();
+    const parent = _optionalChain([stack, 'access', _ => _[stack.length - 1], 'optionalAccess', _2 => _2.item]);
+    if (parent) parent.children.push(item);
+    else data.items.push(item);
+    if (item.children) stack.push({ item, indent });
+  }
+  if (!data.items.length) return { error: 'No items: add lines like `"Sales": 120`.' };
+  return { data };
+}
+function stripComment(line) {
+  let quote = null;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (quote) {
+      if (ch === quote) quote = null;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+    } else if (ch === "%" && line[i + 1] === "%") {
+      return line.slice(0, i);
+    }
+  }
+  return line;
+}
+function treemapValue(item) {
+  if (!item.children) return _nullishCoalesce(item.value, () => ( 0));
+  return item.children.reduce((sum, child) => sum + treemapValue(child), 0);
+}
+
+
+
+
+
+exports.parseSankey = parseSankey; exports.parseTreemap = parseTreemap; exports.treemapValue = treemapValue;