@pixerate/editor 0.161.0 → 0.162.1

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

@@ -18,7 +18,7 @@
 
 
 
-var _chunkQMI5HZWAcjs = require('./chunk-QMI5HZWA.cjs');
+var _chunkJCXMJUQOcjs = require('./chunk-JCXMJUQO.cjs');
 
 
 
@@ -29,7 +29,7 @@ var _chunkGF2RBSDMcjs = require('./chunk-GF2RBSDM.cjs');
 var _chunkDWJJI6RTcjs = require('./chunk-DWJJI6RT.cjs');
 
 
-var _chunkLEUZ4FRCcjs = require('./chunk-LEUZ4FRC.cjs');
+var _chunkCIPIESX4cjs = require('./chunk-CIPIESX4.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 = _chunkQMI5HZWAcjs.IDENTITY_MATRIX) {
+function subpathToMorphContour(sp, m = _chunkJCXMJUQOcjs.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 = _chunkQMI5HZWAcjs.IDENTITY_MATRIX, closed = c.closed) {
-  const pts = _chunkQMI5HZWAcjs.isIdentityMatrix.call(void 0, m) ? c.pts : c.pts.map((p) => mapP(m, p));
+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));
   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 = _chunkQMI5HZWAcjs.IDENTITY_MATRIX, closed
     anchors[(k + 1) % count].in = { x: p2[0], y: p2[1] };
   }
   for (const a of anchors) {
-    const type = _chunkQMI5HZWAcjs.inferAnchorType.call(void 0, a);
+    const type = _chunkJCXMJUQOcjs.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 = _chunkQMI5HZWAcjs.unionBounds.call(void 0, [boundsOfPoints(c.pts)]);
+  const b = _chunkJCXMJUQOcjs.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(_chunkLEUZ4FRCcjs.mixColorsOklab.call(void 0, a, b, t), () => ( (t < 0.5 ? a : b)));
+  return _nullishCoalesce(_chunkCIPIESX4cjs.mixColorsOklab.call(void 0, a, b, t), () => ( (t < 0.5 ? a : b)));
 }
 function resampleGradientStops(g, offsets) {
   return offsets.map((offset) => {
-    const s = _chunkQMI5HZWAcjs.sampleVectorGradient.call(void 0, g, offset);
+    const s = _chunkJCXMJUQOcjs.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 = _chunkQMI5HZWAcjs.sortedVectorGradientStops.call(void 0, a);
-  let stopsB = _chunkQMI5HZWAcjs.sortedVectorGradientStops.call(void 0, b);
+  let stopsA = _chunkJCXMJUQOcjs.sortedVectorGradientStops.call(void 0, a);
+  let stopsB = _chunkJCXMJUQOcjs.sortedVectorGradientStops.call(void 0, b);
   const resampled = stopsA.length !== stopsB.length || !sameColourModel(a, b);
   if (resampled) {
-    const offs = [..._chunkQMI5HZWAcjs.expandVectorGradientStops.call(void 0, a), ..._chunkQMI5HZWAcjs.expandVectorGradientStops.call(void 0, b), ...stopsA, ...stopsB].map((s) => s.offset).filter(Number.isFinite).sort((x, y) => x - y);
+    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 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 = _chunkQMI5HZWAcjs.hasExplicitGradientGeometry.call(void 0, a);
-  const eb = _chunkQMI5HZWAcjs.hasExplicitGradientGeometry.call(void 0, b);
+  const ea = _chunkJCXMJUQOcjs.hasExplicitGradientGeometry.call(void 0, a);
+  const eb = _chunkJCXMJUQOcjs.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 = _chunkQMI5HZWAcjs.vectorGradientPoints.call(void 0, a);
-  const pb = _chunkQMI5HZWAcjs.vectorGradientPoints.call(void 0, b);
+  const pa = _chunkJCXMJUQOcjs.vectorGradientPoints.call(void 0, a);
+  const pb = _chunkJCXMJUQOcjs.vectorGradientPoints.call(void 0, b);
   if (pa.units !== pb.units) {
-    const src = _chunkQMI5HZWAcjs.explicitVectorGradient.call(void 0, near);
+    const src = _chunkJCXMJUQOcjs.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 = _chunkQMI5HZWAcjs.hasPaint.call(void 0, a);
-  const pb = _chunkQMI5HZWAcjs.hasPaint.call(void 0, b);
+  const pa = _chunkJCXMJUQOcjs.hasPaint.call(void 0, a);
+  const pb = _chunkJCXMJUQOcjs.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 && _chunkQMI5HZWAcjs.isVectorGradient.call(void 0, a) ? a : null;
-  const gb = pb && _chunkQMI5HZWAcjs.isVectorGradient.call(void 0, b) ? b : null;
+  const ga = pa && _chunkJCXMJUQOcjs.isVectorGradient.call(void 0, a) ? a : null;
+  const gb = pb && _chunkJCXMJUQOcjs.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 = _chunkQMI5HZWAcjs.widthProfileAt.call(void 0, a, pos);
-    const y = _chunkQMI5HZWAcjs.widthProfileAt.call(void 0, b, pos);
+    const x = _chunkJCXMJUQOcjs.widthProfileAt.call(void 0, a, pos);
+    const y = _chunkJCXMJUQOcjs.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 = _chunkQMI5HZWAcjs.reverseWidthProfile.call(void 0, s.strokeWidthProfile);
+  if (_optionalChain([s, 'access', _6 => _6.strokeWidthProfile, 'optionalAccess', _7 => _7.length])) out.strokeWidthProfile = _chunkJCXMJUQOcjs.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 _chunkQMI5HZWAcjs.expandVectorCorners.call(void 0, node.subpaths).map((sp) => subpathToMorphContour(sp, m)).filter((c) => !!c);
+  return _chunkJCXMJUQOcjs.expandVectorCorners.call(void 0, node.subpaths).map((sp) => subpathToMorphContour(sp, m)).filter((c) => !!c);
 }
-function preparePathMorph(a, b, options, ma = _chunkQMI5HZWAcjs.nodeMatrix.call(void 0, a), mb = _chunkQMI5HZWAcjs.nodeMatrix.call(void 0, b)) {
+function preparePathMorph(a, b, options, ma = _chunkJCXMJUQOcjs.nodeMatrix.call(void 0, a), mb = _chunkJCXMJUQOcjs.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 = !_chunkQMI5HZWAcjs.isIdentityMatrix.call(void 0, ma) || !_chunkQMI5HZWAcjs.isIdentityMatrix.call(void 0, mb);
+  const rigid = !_chunkJCXMJUQOcjs.isIdentityMatrix.call(void 0, ma) || !_chunkJCXMJUQOcjs.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) : _chunkQMI5HZWAcjs.IDENTITY_MATRIX;
-    const back = rigid ? _chunkQMI5HZWAcjs.invertMatrix.call(void 0, m) : _chunkQMI5HZWAcjs.IDENTITY_MATRIX;
+    const m = rigid ? interpolateRigidMatrix(ma, mb, t) : _chunkJCXMJUQOcjs.IDENTITY_MATRIX;
+    const back = rigid ? _chunkJCXMJUQOcjs.invertMatrix.call(void 0, m) : _chunkJCXMJUQOcjs.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 = _chunkQMI5HZWAcjs.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 && !_chunkQMI5HZWAcjs.isIdentityMatrix.call(void 0, m)) node.transform = m;
+    if (rigid && !_chunkJCXMJUQOcjs.isIdentityMatrix.call(void 0, m)) node.transform = m;
     return node;
   };
 }
-function flattenPaths(node, parent = _chunkQMI5HZWAcjs.IDENTITY_MATRIX) {
-  const m = _chunkQMI5HZWAcjs.multiplyMatrices.call(void 0, _chunkQMI5HZWAcjs.nodeMatrix.call(void 0, node), parent);
+function flattenPaths(node, parent = _chunkJCXMJUQOcjs.IDENTITY_MATRIX) {
+  const m = _chunkJCXMJUQOcjs.multiplyMatrices.call(void 0, _chunkJCXMJUQOcjs.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(_chunkQMI5HZWAcjs.expandVectorAppearance.call(void 0, node), parent);
+  if (node.type === "text" || node.type === "instance") return flattenPaths(_chunkJCXMJUQOcjs.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 = _chunkQMI5HZWAcjs.unionBounds.call(void 0, pa.map((e) => placedBounds(e.path, e.m)));
-  const bb = _chunkQMI5HZWAcjs.unionBounds.call(void 0, pb.map((e) => placedBounds(e.path, e.m)));
+  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 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, _chunkQMI5HZWAcjs.IDENTITY_MATRIX));
+      parts.push(preparePathMorph(x.path, collapsedPath(x.path, x.m, ba, bb), sub, x.m, _chunkJCXMJUQOcjs.IDENTITY_MATRIX));
       opacities.push([x.opacity, x.opacity]);
     } else if (y) {
-      parts.push(preparePathMorph(collapsedPath(y.path, y.m, bb, ba), y.path, sub, _chunkQMI5HZWAcjs.IDENTITY_MATRIX, y.m));
+      parts.push(preparePathMorph(collapsedPath(y.path, y.m, bb, ba), y.path, sub, _chunkJCXMJUQOcjs.IDENTITY_MATRIX, y.m));
       opacities.push([y.opacity, y.opacity]);
     }
   }

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
+};