@pixerate/editor 0.160.0 → 0.162.0

package/dist/{chunk-DBIVICAO.js → chunk-7CKPUUN4.js}

@@ -6,7 +6,7 @@ import {
   isCartesianChart,
   normalizeChartSpec,
   parseChartColor
-} from "./chunk-H5XX4KHB.js";
+} from "./chunk-HLOKB7WW.js";
 
 // src/chart/ooxml.ts
 var CHART_OOXML_NS = "http://schemas.openxmlformats.org/drawingml/2006/chart";

package/dist/{chunk-57JLBGJ5.cjs → chunk-7YBDRJXT.cjs}

@@ -11,10 +11,10 @@ var _chunkYN6JKAUEcjs = require('./chunk-YN6JKAUE.cjs');
 
 
 
-var _chunk4T44CJ5Kcjs = require('./chunk-4T44CJ5K.cjs');
+var _chunkNA4UVVJ4cjs = require('./chunk-NA4UVVJ4.cjs');
 
 
-var _chunkWPPJH6X4cjs = require('./chunk-WPPJH6X4.cjs');
+var _chunkLL3H5XUHcjs = require('./chunk-LL3H5XUH.cjs');
 
 // src/export/images.ts
 var DOCX_IMAGE_TYPES = {
@@ -1028,12 +1028,12 @@ var DocxBuilder = (_class2 = class {
       this.drop("node", "chart", "chart has no spec");
       return;
     }
-    const spec = _chunkWPPJH6X4cjs.normalizeChartSpec.call(void 0, raw).spec;
-    const written = _chunk4T44CJ5Kcjs.chartToOoxml.call(void 0, spec);
+    const spec = _chunkLL3H5XUHcjs.normalizeChartSpec.call(void 0, raw).spec;
+    const written = _chunkNA4UVVJ4cjs.chartToOoxml.call(void 0, spec);
     for (const issue of written.issues) this.drop("node", "chart", issue);
     const name = `chart${this.charts.length + 1}.xml`;
     this.charts.push(written.xml);
-    const relId = this.rels.add(_chunk4T44CJ5Kcjs.CHART_OOXML_RELATIONSHIP, `charts/${name}`);
+    const relId = this.rels.add(_chunkNA4UVVJ4cjs.CHART_OOXML_RELATIONSHIP, `charts/${name}`);
     let width = _nullishCoalesce(pixelAttr(_optionalChain([node, 'access', _91 => _91.attrs, 'optionalAccess', _92 => _92.width])), () => ( MAX_IMAGE_WIDTH_PX));
     let height = _nullishCoalesce(pixelAttr(_optionalChain([node, 'access', _93 => _93.attrs, 'optionalAccess', _94 => _94.height])), () => ( 320));
     if (width > MAX_IMAGE_WIDTH_PX) {
@@ -1050,8 +1050,8 @@ var DocxBuilder = (_class2 = class {
     drawing.empty("wp:extent", { cx, cy }).empty("wp:effectExtent", { l: 0, t: 0, r: 0, b: 0 });
     drawing.empty("wp:docPr", { id, name: `Chart ${id}`, descr: title || void 0, title: title || void 0 });
     drawing.empty("wp:cNvGraphicFramePr");
-    drawing.open("a:graphic").open("a:graphicData", { uri: _chunk4T44CJ5Kcjs.CHART_OOXML_NS });
-    drawing.empty("c:chart", { "xmlns:c": _chunk4T44CJ5Kcjs.CHART_OOXML_NS, "r:id": relId });
+    drawing.open("a:graphic").open("a:graphicData", { uri: _chunkNA4UVVJ4cjs.CHART_OOXML_NS });
+    drawing.empty("c:chart", { "xmlns:c": _chunkNA4UVVJ4cjs.CHART_OOXML_NS, "r:id": relId });
     drawing.close("a:graphicData").close("a:graphic").close("wp:inline").close("w:drawing").close("w:r");
     this.report.written.paragraphs++;
     w.open("w:p");
@@ -1384,7 +1384,7 @@ var DocxBuilder = (_class2 = class {
     if (people) add("word/people.xml", people, `${CT_WML}people+xml`);
     parts.push({ name: "word/_rels/document.xml.rels", data: this.rels.xml() });
     for (const file of this.media) parts.push({ name: `word/media/${file.name}`, data: file.bytes });
-    this.charts.forEach((xml, i) => add(`word/charts/chart${i + 1}.xml`, xml, _chunk4T44CJ5Kcjs.CHART_OOXML_CONTENT_TYPE));
+    this.charts.forEach((xml, i) => add(`word/charts/chart${i + 1}.xml`, xml, _chunkNA4UVVJ4cjs.CHART_OOXML_CONTENT_TYPE));
     add("docProps/core.xml", this.coreXml(now), "application/vnd.openxmlformats-package.core-properties+xml");
     const app = new XmlWriter();
     app.open("Properties", { xmlns: "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties" });

package/dist/{chunk-KY3FYKP3.js → chunk-BQWGN5WH.js}

@@ -6,7 +6,7 @@ import {
 import {
   oklabToRgb,
   rgbToOklab
-} from "./chunk-AA34BA7G.js";
+} from "./chunk-4VU4CP7R.js";
 
 // src/animation/color.ts
 function rgbToOklab2(r, g, b, alpha = 1) {

package/dist/{chunk-LEUZ4FRC.cjs → chunk-CIPIESX4.cjs}

@@ -6,15 +6,15 @@ var _chunkA6QWKBJPcjs = require('./chunk-A6QWKBJP.cjs');
 
 
 
-var _chunkUKCJ43YLcjs = require('./chunk-UKCJ43YL.cjs');
+var _chunkS6X2QRVUcjs = require('./chunk-S6X2QRVU.cjs');
 
 // src/animation/color.ts
 function rgbToOklab2(r, g, b, alpha = 1) {
-  const lab = _chunkUKCJ43YLcjs.rgbToOklab.call(void 0, { r, g, b, a: alpha });
+  const lab = _chunkS6X2QRVUcjs.rgbToOklab.call(void 0, { r, g, b, a: alpha });
   return { l: lab.l, a: lab.a, b: lab.b, alpha: lab.alpha };
 }
 function oklabToRgb2(color) {
-  const c = _chunkUKCJ43YLcjs.oklabToRgb.call(void 0, { l: color.l, a: color.a, b: color.b, alpha: color.alpha });
+  const c = _chunkS6X2QRVUcjs.oklabToRgb.call(void 0, { l: color.l, a: color.a, b: color.b, alpha: color.alpha });
   const clamp01 = (v) => Math.min(1, Math.max(0, v));
   return {
     r: clamp01(c.r),

package/dist/chunk-CJE5MOIS.js

@@ -0,0 +1,347 @@
+// src/typography/weight.ts
+function normalizeFontWeight(weight) {
+  if (weight === void 0 || weight === "normal") return 400;
+  if (weight === "bold") return 700;
+  if (typeof weight !== "number" || !Number.isFinite(weight)) return 400;
+  return Math.min(9, Math.max(1, Math.round(weight / 100))) * 100;
+}
+function isFontWeight(value) {
+  return value === "normal" || value === "bold" || typeof value === "number" && value >= 100 && value <= 900 && value % 100 === 0;
+}
+function nearestFontWeight(wanted, available) {
+  const target = normalizeFontWeight(wanted);
+  const weights = [...new Set(available.map((w) => normalizeFontWeight(w)))].sort((a, b) => a - b);
+  if (!weights.length) return target;
+  if (weights.includes(target)) return target;
+  const lighter = weights.filter((w) => w < target).reverse();
+  const heavier = weights.filter((w) => w > target);
+  if (target === 400 && weights.includes(500)) return 500;
+  if (target === 500 && weights.includes(400)) return 400;
+  if (target <= 500) return lighter[0] ?? heavier[0];
+  return heavier[0] ?? lighter[0];
+}
+
+// src/typography/registry.ts
+function fontHasWeight(font, weight) {
+  const w = normalizeFontWeight(weight);
+  const ws = font.weights.map((x) => normalizeFontWeight(x));
+  if (font.isVariable && ws.length) return w >= Math.min(...ws) && w <= Math.max(...ws);
+  return ws.includes(w);
+}
+function filterFonts(fonts, filter = {}) {
+  const q = filter.query?.trim().toLowerCase() ?? "";
+  const kept = fonts.filter(
+    (f) => (!filter.category || f.category === filter.category) && (!filter.source || f.source === filter.source) && (filter.weight === void 0 || fontHasWeight(f, filter.weight)) && (!filter.style || f.styles.includes(filter.style)) && (filter.isVariable === void 0 || !!f.isVariable === filter.isVariable) && (!q || f.family.toLowerCase().includes(q))
+  );
+  if (!q) return kept;
+  const starts = kept.filter((f) => f.family.toLowerCase().startsWith(q));
+  return [...starts, ...kept.filter((f) => !f.family.toLowerCase().startsWith(q))];
+}
+function findFont(fonts, family) {
+  const lower = family.trim().toLowerCase();
+  return fonts.find((f) => f.family.toLowerCase() === lower);
+}
+function combineFontProviders(providers, options = {}) {
+  const owner = async (family) => {
+    for (const p of providers) if (await p.hasFont(family)) return p;
+    for (const p of providers) if (findFont(await p.listFonts(), family)) return p;
+    return void 0;
+  };
+  return {
+    id: options.id ?? "fonts",
+    async listFonts() {
+      const seen = /* @__PURE__ */ new Set();
+      const out = [];
+      for (const p of providers) {
+        for (const f of await p.listFonts()) {
+          const key = f.family.toLowerCase();
+          if (seen.has(key)) continue;
+          seen.add(key);
+          out.push(f);
+        }
+      }
+      return out;
+    },
+    async hasFont(family) {
+      for (const p of providers) if (await p.hasFont(family)) return true;
+      return false;
+    },
+    async loadFont(family, weight, style) {
+      for (const p of providers) {
+        if (!p.loadFont) continue;
+        if (findFont(await p.listFonts(), family)) return p.loadFont(family, weight, style);
+      }
+      return !!await owner(family);
+    }
+  };
+}
+async function ensureFontsLoaded(provider, specs) {
+  const result = { loaded: [], failed: [] };
+  const seen = /* @__PURE__ */ new Set();
+  await Promise.all(
+    specs.map(async (s) => {
+      const key = `${s.family.toLowerCase()}|${normalizeFontWeight(s.weight)}|${s.style ?? "normal"}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      const ok = provider.loadFont ? await provider.loadFont(s.family, s.weight, s.style).catch(() => false) : await provider.hasFont(s.family);
+      (ok ? result.loaded : result.failed).push(s.family);
+    })
+  );
+  return result;
+}
+
+// src/typography/catalog.ts
+var ALL = ["macos", "windows", "ios", "android", "linux"];
+var R = [400, 700];
+var NI = ["normal", "italic"];
+var N = ["normal"];
+var sys = (family, category, platforms, weights = R, styles = NI, isVariable) => ({
+  family,
+  category,
+  weights,
+  styles,
+  source: "system",
+  platforms,
+  ...isVariable ? { isVariable } : {}
+});
+var SYSTEM_FONT_CATALOG = [
+  // Sans-serif
+  sys("Arial", "sans-serif", ["macos", "windows", "ios"]),
+  sys("Helvetica", "sans-serif", ["macos", "ios"], [300, 400, 700]),
+  sys("Helvetica Neue", "sans-serif", ["macos", "ios"], [100, 200, 300, 400, 500, 700]),
+  sys("Segoe UI", "sans-serif", ["windows"], [300, 400, 600, 700, 900]),
+  sys("Roboto", "sans-serif", ["android"], [100, 300, 400, 500, 700, 900]),
+  sys("Verdana", "sans-serif", ["macos", "windows"]),
+  sys("Tahoma", "sans-serif", ["macos", "windows"], R, N),
+  sys("Trebuchet MS", "sans-serif", ["macos", "windows"]),
+  sys("Calibri", "sans-serif", ["windows"], [300, 400, 700]),
+  sys("Candara", "sans-serif", ["windows"], [300, 400, 700]),
+  sys("Optima", "sans-serif", ["macos"], [400, 700, 800]),
+  sys("Gill Sans", "sans-serif", ["macos"], [300, 400, 600]),
+  sys("Avenir", "sans-serif", ["macos", "ios"], [300, 400, 500, 800, 900]),
+  sys("Avenir Next", "sans-serif", ["macos", "ios"], [200, 400, 500, 600, 700, 800]),
+  sys("Futura", "sans-serif", ["macos", "ios"], [400, 500, 700]),
+  sys("Century Gothic", "sans-serif", ["windows"]),
+  sys("Noto Sans", "sans-serif", ["android", "linux"], [100, 200, 300, 400, 500, 600, 700, 800, 900], NI, true),
+  sys("DejaVu Sans", "sans-serif", ["linux"], [200, 400, 700]),
+  sys("Liberation Sans", "sans-serif", ["linux"]),
+  sys("Ubuntu", "sans-serif", ["linux"], [300, 400, 500, 700]),
+  sys("Cantarell", "sans-serif", ["linux"], [100, 200, 300, 400, 500, 600, 700, 800], N, true),
+  // Serif
+  sys("Georgia", "serif", ["macos", "windows", "ios"]),
+  sys("Times New Roman", "serif", ["macos", "windows", "ios"]),
+  sys("Times", "serif", ["macos", "ios"]),
+  sys("Cambria", "serif", ["windows"]),
+  sys("Constantia", "serif", ["windows"]),
+  sys("Sitka Text", "serif", ["windows"], [400, 600, 700], NI, true),
+  sys("Charter", "serif", ["macos", "ios"], [400, 700, 900]),
+  sys("Iowan Old Style", "serif", ["macos", "ios"], [400, 700, 900]),
+  sys("Palatino", "serif", ["macos"]),
+  sys("Palatino Linotype", "serif", ["windows"]),
+  sys("Baskerville", "serif", ["macos", "ios"], [400, 600, 700]),
+  sys("Hoefler Text", "serif", ["macos"], [400, 900]),
+  sys("Garamond", "serif", ["windows"]),
+  sys("Book Antiqua", "serif", ["windows"]),
+  sys("Noto Serif", "serif", ["android", "linux"], [100, 200, 300, 400, 500, 600, 700, 800, 900], NI, true),
+  sys("DejaVu Serif", "serif", ["linux"]),
+  sys("Liberation Serif", "serif", ["linux"]),
+  // Monospace
+  sys("Menlo", "monospace", ["macos"]),
+  sys("Monaco", "monospace", ["macos"], [400], N),
+  sys("SF Mono", "monospace", ["macos"], [300, 400, 500, 600, 700, 800]),
+  sys("Consolas", "monospace", ["windows"]),
+  sys("Cascadia Code", "monospace", ["windows"], [200, 300, 400, 500, 600, 700], NI, true),
+  sys("Cascadia Mono", "monospace", ["windows"], [200, 300, 400, 500, 600, 700], NI, true),
+  sys("Courier New", "monospace", ["macos", "windows", "ios"]),
+  sys("Lucida Console", "monospace", ["windows"], [400], N),
+  sys("DejaVu Sans Mono", "monospace", ["linux"]),
+  sys("Liberation Mono", "monospace", ["linux"]),
+  sys("Ubuntu Mono", "monospace", ["linux"]),
+  sys("Droid Sans Mono", "monospace", ["android"], [400], N),
+  // Display
+  sys("Impact", "display", ["macos", "windows"], [400], N),
+  sys("Copperplate", "display", ["macos"], [300, 400, 700], N),
+  sys("Rockwell", "display", ["macos", "windows"]),
+  sys("Didot", "display", ["macos", "ios"], [400, 700]),
+  sys("Bodoni 72", "display", ["macos", "ios"], [400, 700]),
+  sys("Arial Black", "display", ["macos", "windows"], [900], N),
+  // Handwriting
+  sys("Comic Sans MS", "handwriting", ["macos", "windows"]),
+  sys("Segoe Print", "handwriting", ["windows"], R, N),
+  sys("Segoe Script", "handwriting", ["windows"], R, N),
+  sys("Bradley Hand", "handwriting", ["macos", "ios"], [700], N),
+  sys("Brush Script MT", "handwriting", ["macos", "windows"], [400], ["italic"]),
+  sys("Snell Roundhand", "handwriting", ["macos", "ios"], [400, 700, 900], N),
+  sys("Noteworthy", "handwriting", ["macos", "ios"], [300, 700], N)
+];
+var FONT_PLATFORMS = ALL;
+function guessFontCategory(family) {
+  const known = findFont(SYSTEM_FONT_CATALOG, family);
+  if (known) return known.category;
+  const lower = family.toLowerCase();
+  if (lower === "monospace" || lower === "ui-monospace" || /\bmono|code|courier|consol/.test(lower)) return "monospace";
+  if (lower === "cursive" || /script|hand|brush|marker/.test(lower)) return "handwriting";
+  if (lower === "fantasy" || /display|poster/.test(lower)) return "display";
+  if (/sans/.test(lower)) return "sans-serif";
+  if (lower === "serif" || lower === "ui-serif" || /serif|times|garamond|georgia|baskerville|caslon|bodoni|didot/.test(lower)) return "serif";
+  return "sans-serif";
+}
+function createCatalogFontProvider(fonts, options = {}) {
+  const list = [...fonts];
+  return {
+    id: options.id ?? "catalog",
+    listFonts: async () => list.map((f) => ({ ...f })),
+    hasFont: (family) => !!findFont(list, family),
+    loadFont: async (family) => !!findFont(list, family)
+  };
+}
+function weightFromStyleName(style = "") {
+  const s = style.toLowerCase();
+  if (/thin|hairline/.test(s)) return 100;
+  if (/extra ?light|ultra ?light/.test(s)) return 200;
+  if (/light/.test(s)) return 300;
+  if (/medium/.test(s)) return 500;
+  if (/semi ?bold|demi ?bold/.test(s)) return 600;
+  if (/extra ?bold|ultra ?bold/.test(s)) return 800;
+  if (/black|heavy/.test(s)) return 900;
+  if (/bold/.test(s)) return 700;
+  return 400;
+}
+function createSystemFontProvider(options = {}) {
+  const catalog = (options.catalog ?? SYSTEM_FONT_CATALOG).filter((f) => !options.platform || !f.platforms || f.platforms.includes(options.platform));
+  let local = null;
+  const localFonts = () => {
+    if (!options.queryLocalFonts) return Promise.resolve(null);
+    local ??= options.queryLocalFonts().then((entries) => {
+      const byFamily = /* @__PURE__ */ new Map();
+      for (const e of entries) {
+        const key = e.family.toLowerCase();
+        const known = findFont(SYSTEM_FONT_CATALOG, e.family);
+        const entry = byFamily.get(key) ?? { family: known?.family ?? e.family, category: known?.category ?? guessFontCategory(e.family), weights: [], styles: [], source: "system" };
+        const w = weightFromStyleName(e.style);
+        if (!entry.weights.includes(w)) entry.weights.push(w);
+        const st = /italic/i.test(e.style ?? "") ? "italic" : /oblique/i.test(e.style ?? "") ? "oblique" : "normal";
+        if (!entry.styles.includes(st)) entry.styles.push(st);
+        byFamily.set(key, entry);
+      }
+      for (const f of byFamily.values()) f.weights.sort((a, b) => normalizeFontWeight(a) - normalizeFontWeight(b));
+      return [...byFamily.values()];
+    }).catch(() => null);
+    return local;
+  };
+  return {
+    id: options.id ?? "system",
+    async listFonts() {
+      return (await localFonts() ?? catalog).map((f) => ({ ...f }));
+    },
+    async hasFont(family) {
+      return !!findFont(await localFonts() ?? catalog, family);
+    },
+    async loadFont(family) {
+      return !!findFont(await localFonts() ?? catalog, family);
+    }
+  };
+}
+var weightRange = (w) => Array.isArray(w) ? [w[0], w[1]] : [normalizeFontWeight(w), normalizeFontWeight(w)];
+var cssWeight = (w) => {
+  const [lo, hi] = weightRange(w);
+  return lo === hi ? String(lo) : `${lo} ${hi}`;
+};
+function fontFaceCss(def) {
+  return def.sources.map(
+    (s) => [
+      "@font-face {",
+      `  font-family: "${def.family.replace(/"/g, '\\"')}";`,
+      `  src: url("${s.url.replace(/"/g, "%22")}")${s.format ? ` format("${s.format}")` : ""};`,
+      `  font-weight: ${cssWeight(s.weight)};`,
+      `  font-style: ${s.style ?? "normal"};`,
+      `  font-display: ${def.display ?? "swap"};`,
+      ...s.unicodeRange ? [`  unicode-range: ${s.unicodeRange};`] : [],
+      "}"
+    ].join("\n")
+  ).join("\n");
+}
+function webFontSummary(def) {
+  const weights = /* @__PURE__ */ new Set();
+  let isVariable = false;
+  for (const s of def.sources) {
+    const [lo, hi] = weightRange(s.weight);
+    if (lo !== hi) isVariable = true;
+    weights.add(lo);
+    weights.add(hi);
+  }
+  const styles = [...new Set(def.sources.map((s) => s.style ?? "normal"))];
+  return { family: def.family, category: def.category, weights: [...weights].sort((a, b) => a - b), styles, source: "web", ...isVariable ? { isVariable } : {} };
+}
+function createWebFontProvider(options) {
+  const defs = [...options.fonts];
+  const cache = /* @__PURE__ */ new Map();
+  const done = /* @__PURE__ */ new Set();
+  const g = globalThis;
+  const createFace = options.createFontFace ?? (g.FontFace ? (family, source, descriptors) => new g.FontFace(family, source, descriptors) : void 0);
+  const set = () => options.fontFaceSet ?? g.document?.fonts;
+  const def = (family) => defs.find((d) => d.family.toLowerCase() === family.trim().toLowerCase());
+  const key = (family, weight, style) => `${family.toLowerCase()}|${normalizeFontWeight(weight)}|${style ?? "normal"}`;
+  function pickSource(d, weight, style) {
+    const wanted = normalizeFontWeight(weight);
+    const st = style ?? "normal";
+    const sameStyle = d.sources.filter((s) => (s.style ?? "normal") === st);
+    const pool = sameStyle.length ? sameStyle : d.sources;
+    const inRange = pool.find((s) => {
+      const [lo, hi] = weightRange(s.weight);
+      return wanted >= lo && wanted <= hi;
+    });
+    if (inRange) return inRange;
+    const best = nearestFontWeight(wanted, pool.map((s) => weightRange(s.weight)[0]));
+    return pool.find((s) => weightRange(s.weight)[0] === best);
+  }
+  return {
+    id: options.id ?? "web",
+    listFonts: async () => defs.map(webFontSummary),
+    hasFont: (family) => !!def(family),
+    loaded: (family, weight, style) => done.has(key(family, weight, style)),
+    loadFont(family, weight, style) {
+      const k = key(family, weight, style);
+      const cached = cache.get(k);
+      if (cached) return cached;
+      const d = def(family);
+      const source = d && pickSource(d, weight, style);
+      if (!d || !source || !createFace) return Promise.resolve(false);
+      const face = createFace(d.family, `url("${source.url.replace(/"/g, "%22")}")${source.format ? ` format("${source.format}")` : ""}`, {
+        weight: cssWeight(source.weight),
+        style: source.style ?? "normal",
+        display: d.display ?? "swap",
+        ...source.unicodeRange ? { unicodeRange: source.unicodeRange } : {}
+      });
+      const promise = face.load().then(() => {
+        set()?.add(face);
+        done.add(k);
+        return true;
+      }).catch(() => {
+        cache.delete(k);
+        return false;
+      });
+      cache.set(k, promise);
+      return promise;
+    }
+  };
+}
+
+export {
+  normalizeFontWeight,
+  isFontWeight,
+  nearestFontWeight,
+  fontHasWeight,
+  filterFonts,
+  findFont,
+  combineFontProviders,
+  ensureFontsLoaded,
+  SYSTEM_FONT_CATALOG,
+  FONT_PLATFORMS,
+  guessFontCategory,
+  createCatalogFontProvider,
+  createSystemFontProvider,
+  fontFaceCss,
+  webFontSummary,
+  createWebFontProvider
+};

package/dist/{chunk-5QBRAIVK.js → chunk-CX6JLDFC.js}

@@ -5,14 +5,14 @@ import {
   chartToMermaid,
   describeChart,
   layoutSparkline
-} from "./chunk-SSCL7QQ4.js";
+} from "./chunk-XDCFJEU7.js";
 import {
   layoutChart
-} from "./chunk-R3QY7PPL.js";
+} from "./chunk-DTSTNRPH.js";
 import {
   DEFAULT_CHART_THEME,
   normalizeChartSpec
-} from "./chunk-H5XX4KHB.js";
+} from "./chunk-HLOKB7WW.js";
 import {
   plainTextToSlice
 } from "./chunk-2INPJDNY.js";

package/dist/{chunk-R3QY7PPL.js → chunk-DTSTNRPH.js}

@@ -7,7 +7,7 @@ import {
   chartSeriesColor,
   chartSeriesType,
   chartSliceColor
-} from "./chunk-H5XX4KHB.js";
+} from "./chunk-HLOKB7WW.js";
 import {
   NumberFormat
 } from "./chunk-II2WIF5Z.js";