@pixerate/editor 0.160.0 → 0.162.0

package/dist/{chunk-UM3RPYC5.js → chunk-EVPZ5IKN.js}

@@ -14,7 +14,7 @@ import {
   CHART_STACKINGS,
   CHART_TRENDLINE_TYPES,
   CHART_TYPES
-} from "./chunk-H5XX4KHB.js";
+} from "./chunk-HLOKB7WW.js";
 
 // src/chart/schemas.ts
 var VALUE = { type: ["number", "string", "null"], description: 'A number, numeric text ("1,200", "12%", "$40", "(3)") or null for a gap.' };

package/dist/{chunk-XNQ5EFB4.cjs → chunk-EY22AY6R.cjs}

@@ -5,14 +5,14 @@
 
 
 
-var _chunkAKDWAWSYcjs = require('./chunk-AKDWAWSY.cjs');
+var _chunk3IHNXRUVcjs = require('./chunk-3IHNXRUV.cjs');
 
 
-var _chunk4YWAEV4Wcjs = require('./chunk-4YWAEV4W.cjs');
+var _chunkHDGBM7EAcjs = require('./chunk-HDGBM7EA.cjs');
 
 
 
-var _chunkWPPJH6X4cjs = require('./chunk-WPPJH6X4.cjs');
+var _chunkLL3H5XUHcjs = require('./chunk-LL3H5XUH.cjs');
 
 
 var _chunkG43MNQ4Ccjs = require('./chunk-G43MNQ4C.cjs');
@@ -1211,7 +1211,7 @@ var ChartNodeView = (_class = class {
     this.dom.contentEditable = "false";
     this.syncAttributes();
     this.key = specKey(this.node.attrs.spec);
-    this.controller = new (0, _chunkAKDWAWSYcjs.ChartController)({ spec: this.node.attrs.spec });
+    this.controller = new (0, _chunk3IHNXRUVcjs.ChartController)({ spec: this.node.attrs.spec });
     this.unsubscribe = this.controller.subscribe((state) => {
       if (!state.gesture) this.writeBack();
     });
@@ -1444,7 +1444,7 @@ function readSpec(value) {
     }
   }
   if (!input || typeof input !== "object" || Array.isArray(input)) return null;
-  return _chunkWPPJH6X4cjs.normalizeChartSpec.call(void 0, input).spec;
+  return _chunkLL3H5XUHcjs.normalizeChartSpec.call(void 0, input).spec;
 }
 var readSize = (value) => {
   const n = value === null ? NaN : Number(value);
@@ -1470,10 +1470,10 @@ function staticChartSvg(node, options) {
   const spec = node.attrs.spec;
   const width = _nullishCoalesce(node.attrs.width, () => ( options.defaultWidth));
   const height = _nullishCoalesce(node.attrs.height, () => ( options.defaultHeight));
-  const scene = _chunk4YWAEV4Wcjs.layoutChart.call(void 0, spec, { width, height, theme: options.theme, selection: null });
-  return _chunkAKDWAWSYcjs.chartSceneToDomSpec.call(void 0, scene, {
+  const scene = _chunkHDGBM7EAcjs.layoutChart.call(void 0, spec, { width, height, theme: options.theme, selection: null });
+  return _chunk3IHNXRUVcjs.chartSceneToDomSpec.call(void 0, scene, {
     ariaLabel: spec.title || "Chart",
-    description: _chunkAKDWAWSYcjs.describeChart.call(void 0, spec),
+    description: _chunk3IHNXRUVcjs.describeChart.call(void 0, spec),
     attrs: { style: "max-width: 100%; height: auto; display: block" }
   });
 }
@@ -1489,7 +1489,7 @@ var Chart = _core.Node.create({
     return {
       HTMLAttributes: {},
       nodeView: null,
-      theme: _chunkWPPJH6X4cjs.DEFAULT_CHART_THEME,
+      theme: _chunkLL3H5XUHcjs.DEFAULT_CHART_THEME,
       defaultWidth: 640,
       defaultHeight: 320,
       generateId: () => generateStructureId("chart")
@@ -1503,7 +1503,7 @@ var Chart = _core.Node.create({
         renderHTML: (attributes) => attributes.id ? { "data-chart-id": attributes.id } : {}
       },
       spec: {
-        default: _chunkWPPJH6X4cjs.normalizeChartSpec.call(void 0, {}).spec,
+        default: _chunkLL3H5XUHcjs.normalizeChartSpec.call(void 0, {}).spec,
         // null (no `data-chart`) keeps what the parse rule found, e.g. a mermaid block's spec.
         parseHTML: (element) => readSpec(element.getAttribute("data-chart")),
         renderHTML: (attributes) => ({
@@ -1541,7 +1541,7 @@ var Chart = _core.Node.create({
           const code = element.querySelector("code");
           const language = _nullishCoalesce(_nullishCoalesce(_optionalChain([code, 'optionalAccess', _34 => _34.getAttribute, 'call', _35 => _35("class")]), () => ( element.getAttribute("data-language"))), () => ( ""));
           if (!/(?:^|\s)language-mermaid(?:\s|$)/.test(language) && language !== "mermaid") return false;
-          const result = _chunkAKDWAWSYcjs.chartFromMermaid.call(void 0, _nullishCoalesce((_nullishCoalesce(code, () => ( element))).textContent, () => ( "")));
+          const result = _chunk3IHNXRUVcjs.chartFromMermaid.call(void 0, _nullishCoalesce((_nullishCoalesce(code, () => ( element))).textContent, () => ( "")));
           return result.family ? { spec: result.spec } : false;
         }
       }
@@ -1565,7 +1565,7 @@ var Chart = _core.Node.create({
     return {
       markdown: {
         serialize(state, node) {
-          const text = _chunkAKDWAWSYcjs.chartToMermaid.call(void 0, node.attrs.spec);
+          const text = _chunk3IHNXRUVcjs.chartToMermaid.call(void 0, node.attrs.spec);
           const fence = "`".repeat(Math.max(3, longestBacktickRun(text) + 1));
           state.write(`${fence}mermaid
 `);
@@ -1587,7 +1587,7 @@ var Chart = _core.Node.create({
         type: this.name,
         attrs: {
           id: _nullishCoalesce(options.id, () => ( this.options.generateId())),
-          spec: _chunkWPPJH6X4cjs.normalizeChartSpec.call(void 0, _nullishCoalesce(options.spec, () => ( {}))).spec,
+          spec: _chunkLL3H5XUHcjs.normalizeChartSpec.call(void 0, _nullishCoalesce(options.spec, () => ( {}))).spec,
           width: _nullishCoalesce(options.width, () => ( null)),
           height: _nullishCoalesce(options.height, () => ( this.options.defaultHeight))
         }
@@ -1598,7 +1598,7 @@ var Chart = _core.Node.create({
         if (dispatch) {
           tr.setNodeMarkup(chart.pos, void 0, {
             ...chart.node.attrs,
-            ...changes.spec !== void 0 ? { spec: _chunkWPPJH6X4cjs.normalizeChartSpec.call(void 0, changes.spec).spec } : {},
+            ...changes.spec !== void 0 ? { spec: _chunkLL3H5XUHcjs.normalizeChartSpec.call(void 0, changes.spec).spec } : {},
             ...changes.width !== void 0 ? { width: changes.width } : {},
             ...changes.height !== void 0 ? { height: changes.height } : {}
           });
@@ -1705,14 +1705,14 @@ var Sparkline = _core.Node.create({
     return [{ tag: 'span[data-type="sparkline"]', priority: 60 }];
   },
   renderHTML({ node, HTMLAttributes }) {
-    const scene = _chunkAKDWAWSYcjs.layoutSparkline.call(void 0, node.attrs.values, {
+    const scene = _chunk3IHNXRUVcjs.layoutSparkline.call(void 0, node.attrs.values, {
       kind: node.attrs.kind,
       width: node.attrs.width,
       height: node.attrs.height,
       color: _nullishCoalesce(node.attrs.color, () => ( this.options.color)),
       negativeColor: this.options.negativeColor
     });
-    const svg = _chunkAKDWAWSYcjs.chartSceneToDomSpec.call(void 0, scene, {
+    const svg = _chunk3IHNXRUVcjs.chartSceneToDomSpec.call(void 0, scene, {
       ariaLabel: sparklineLabel(node),
       attrs: { style: "display: inline-block; vertical-align: middle" }
     });

package/dist/chunk-FKUKJ3XA.cjs

@@ -0,0 +1,347 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await 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; }// 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 _nullishCoalesce(lighter[0], () => ( heavier[0]));
+  return _nullishCoalesce(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 = _nullishCoalesce(_optionalChain([filter, 'access', _ => _.query, 'optionalAccess', _2 => _2.trim, 'call', _3 => _3(), 'access', _4 => _4.toLowerCase, 'call', _5 => _5()]), () => ( ""));
+  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: _nullishCoalesce(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)}|${_nullishCoalesce(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: _nullishCoalesce(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 = (_nullishCoalesce(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 = _nullishCoalesce(byFamily.get(key), () => ( { family: _nullishCoalesce(_optionalChain([known, 'optionalAccess', _6 => _6.family]), () => ( e.family)), category: _nullishCoalesce(_optionalChain([known, 'optionalAccess', _7 => _7.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(_nullishCoalesce(e.style, () => ( ""))) ? "italic" : /oblique/i.test(_nullishCoalesce(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: _nullishCoalesce(options.id, () => ( "system")),
+    async listFonts() {
+      return (await _asyncNullishCoalesce(await localFonts(), async () => ( catalog))).map((f) => ({ ...f }));
+    },
+    async hasFont(family) {
+      return !!findFont(await _asyncNullishCoalesce(await localFonts(), async () => ( catalog)), family);
+    },
+    async loadFont(family) {
+      return !!findFont(await _asyncNullishCoalesce(await localFonts(), async () => ( 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: ${_nullishCoalesce(s.style, () => ( "normal"))};`,
+      `  font-display: ${_nullishCoalesce(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) => _nullishCoalesce(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 = _nullishCoalesce(options.createFontFace, () => ( (g.FontFace ? (family, source, descriptors) => new g.FontFace(family, source, descriptors) : void 0)));
+  const set = () => _nullishCoalesce(options.fontFaceSet, () => ( _optionalChain([g, 'access', _8 => _8.document, 'optionalAccess', _9 => _9.fonts])));
+  const def = (family) => defs.find((d) => d.family.toLowerCase() === family.trim().toLowerCase());
+  const key = (family, weight, style) => `${family.toLowerCase()}|${normalizeFontWeight(weight)}|${_nullishCoalesce(style, () => ( "normal"))}`;
+  function pickSource(d, weight, style) {
+    const wanted = normalizeFontWeight(weight);
+    const st = _nullishCoalesce(style, () => ( "normal"));
+    const sameStyle = d.sources.filter((s) => (_nullishCoalesce(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: _nullishCoalesce(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: _nullishCoalesce(source.style, () => ( "normal")),
+        display: _nullishCoalesce(d.display, () => ( "swap")),
+        ...source.unicodeRange ? { unicodeRange: source.unicodeRange } : {}
+      });
+      const promise = face.load().then(() => {
+        _optionalChain([set, 'call', _10 => _10(), 'optionalAccess', _11 => _11.add, 'call', _12 => _12(face)]);
+        done.add(k);
+        return true;
+      }).catch(() => {
+        cache.delete(k);
+        return false;
+      });
+      cache.set(k, promise);
+      return promise;
+    }
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.normalizeFontWeight = normalizeFontWeight; exports.isFontWeight = isFontWeight; exports.nearestFontWeight = nearestFontWeight; exports.fontHasWeight = fontHasWeight; exports.filterFonts = filterFonts; exports.findFont = findFont; exports.combineFontProviders = combineFontProviders; exports.ensureFontsLoaded = ensureFontsLoaded; exports.SYSTEM_FONT_CATALOG = SYSTEM_FONT_CATALOG; exports.FONT_PLATFORMS = FONT_PLATFORMS; exports.guessFontCategory = guessFontCategory; exports.createCatalogFontProvider = createCatalogFontProvider; exports.createSystemFontProvider = createSystemFontProvider; exports.fontFaceCss = fontFaceCss; exports.webFontSummary = webFontSummary; exports.createWebFontProvider = createWebFontProvider;

package/dist/{chunk-YABNLNY7.js → chunk-GLMP22FT.js}

@@ -7,7 +7,7 @@ import {
 import {
   CHART_OOXML_NS,
   chartFromOoxml
-} from "./chunk-DBIVICAO.js";
+} from "./chunk-7CKPUUN4.js";
 import {
   compareDocuments
 } from "./chunk-V5OOP74P.js";
@@ -34,10 +34,10 @@ import {
   searchDocument,
   sliceContainsTable,
   syncInitialContent
-} from "./chunk-5QBRAIVK.js";
+} from "./chunk-CX6JLDFC.js";
 import {
   chartDataToTable
-} from "./chunk-H5XX4KHB.js";
+} from "./chunk-HLOKB7WW.js";
 import {
   PIXERATE_DOCUMENT_MIME,
   getClipboardData,

package/dist/{chunk-SUF6WRXR.cjs → chunk-GTELFJRE.cjs}

@@ -4,7 +4,7 @@
 var _chunkDWJJI6RTcjs = require('./chunk-DWJJI6RT.cjs');
 
 
-var _chunkLEUZ4FRCcjs = require('./chunk-LEUZ4FRC.cjs');
+var _chunkCIPIESX4cjs = require('./chunk-CIPIESX4.cjs');
 
 // src/animation/keyframes.ts
 var ANIMATION_TIME_EPSILON = 1e-6;
@@ -46,7 +46,7 @@ function interpolateAnimationValue(from, to, t, type = "number") {
   if (t <= 0) return from;
   if (t >= 1) return to;
   if (type === "color" || typeof from === "string" && typeof to === "string") {
-    const mixed = _chunkLEUZ4FRCcjs.mixColorsOklab.call(void 0, from, to, t);
+    const mixed = _chunkCIPIESX4cjs.mixColorsOklab.call(void 0, from, to, t);
     if (mixed !== null) return mixed;
   }
   return from;

package/dist/{chunk-72BGL3I2.js → chunk-GWV4T5NZ.js}

@@ -89,7 +89,7 @@ import {
   textRectPath,
   translateMatrix,
   warpPresetMesh
-} from "./chunk-6UPGM3JB.js";
+} from "./chunk-2TKHLX6H.js";
 import {
   bezierPathBounds,
   outlineStroke,

package/dist/{chunk-AY65VQSU.js → chunk-H3OEM3Q2.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-5UJHB3BW.js";
 import {
   mixColorsOklab
-} from "./chunk-KY3FYKP3.js";
+} from "./chunk-BQWGN5WH.js";
 
 // src/animation/keyframes.ts
 var ANIMATION_TIME_EPSILON = 1e-6;