@openpresentation/opf-render 0.11.3 → 0.11.5

package/README.md

@@ -1,8 +1,8 @@
 # OPF Render
 
-**Aptos previews with Intos.** The Office pack includes Intos, Intos Display, Intos Narrow and Intos Serif (16 faces, about 12 MB, vendored under `fonts/intos/`, SIL OFL 1.1, pinned to upstream commit fef9315c14da9e4b23b4c3cac8e718998d4e4736 and per-file SHA-256, unmodified from the upstream files). They are the metric-compatible previews for Aptos, Aptos Display, Aptos Narrow and Aptos Serif, the default `aptos` font scheme: 0.000% mean and maximum width difference against Aptos 2.01 in all four styles, with equal vertical metrics. The letter shapes are Intos's own, not Aptos's. The exported PPTX still names Aptos; no Aptos file is bundled or embedded. A registry built without these faces (the base pack) has no Aptos substitute: visual policy falls back to Roboto or Carlito. Like the open families, Intos is `embed: "used"`: it is not in `registry.embeddedFonts` (the 33 eager npm faces), `prepareNodeFonts().options.embeddedFonts` supplies it, and an SVG embeds only the Intos faces its text draws. `registry.lazyFonts` lists the 51 vendored faces (35 open, 16 Intos) with package-relative file and sha256, and `loadBrowserFontRegistry(faces, {lazyFontsBaseUrl})` loads them on demand: `await registry.ensureLazyFonts(presentation)` fetches and verifies only the files the document's font families resolve to (the default Aptos scheme: Intos and Intos Display, 8 files, 5.9 MB), then adds them to the document and the registry together so measurement and painting never disagree. Hosts copy the vendored directories next to the page.
+**Aptos previews with Intos.** The Office pack includes Intos, Intos Display, Intos Narrow and Intos Serif (16 faces, about 12 MB, vendored under `fonts/intos/`, SIL OFL 1.1, pinned to upstream commit fef9315c14da9e4b23b4c3cac8e718998d4e4736 and per-file SHA-256, unmodified from the upstream files). They are the metric-compatible previews for Aptos, Aptos Display, Aptos Narrow and Aptos Serif, the default `aptos` font scheme: 0.000% mean and maximum width difference against Aptos 2.01 in all four styles, with equal vertical metrics. The letter shapes are Intos's own, not Aptos's. The exported PPTX still names Aptos; no Aptos file is bundled or embedded. A registry built without these faces (the base pack) has no Aptos substitute: visual policy falls back to Roboto or Carlito. Like the open families, Intos is `embed: "used"`: it is not in `registry.embeddedFonts` (the 33 eager npm faces), `prepareNodeFonts().options.embeddedFonts` supplies it, and an SVG embeds only the Intos faces its text draws. `registry.lazyFonts` lists the 51 vendored faces (35 open, 16 Intos) with package-relative file and sha256, and `loadBrowserFontRegistry(faces, {lazyFontsBaseUrl})` loads them on demand: `await registry.ensureLazyFonts(presentation)` fetches and verifies only the faces the document draws, by family, weight and style (a plain Aptos deck: Intos Display Bold and Intos Regular, 2 files, 1.5 MB; an italic run adds Intos Italic, a bold run Intos Bold; the code face only when a slide has code), then adds them to the document and the registry together so measurement and painting never disagree. `registry.pendingLazyFonts(presentation)` is the synchronous check hosts gate rendering on, and after an edit it reports just the newly needed faces. The faces are those the renderer itself measures and draws (`presentationFaces(presentation, options, registry)`, one layout-and-paint run with a recording measurement), resolved by the registry's own face selection over the faces it holds plus the vendored ones, so the browser loads exactly what Node draws with every vendored face loaded. A document resolves with the `renderSvg` options the host renders with: pass them as `loadBrowserFontRegistry(entries, { renderOptions: { catalogs } })`, or per call (`pendingLazyFonts(presentation, { catalogs })`, `ensureLazyFonts(presentation, { signal, catalogs })`), so a layout or font scheme id that only the host's catalogs know resolves here too; a document that does not resolve throws (rejects) what `renderSvg` throws for it instead of reporting nothing. Node's `prepareNodeFonts` and `loadOfficeFontRegistry` keep loading the whole open pack and Intos eagerly, so nothing there is face level; with `scripts: 'auto'` they accept `renderOptions: { catalogs }` too. Hosts copy the vendored directories next to the page.
 
-Version 0.11.3 previews the classic chart types natively, draws deprecated chart ids as their replacement and scales value axes like Office (no API change; the preview of chart slides changes). Version 0.11.2 makes `scripts: 'auto'` load the script faces a font scheme names and adds `details.loadedFaceHasGlyph` to `missing-glyph` (no export change). Version 0.11.1 adds the open replacement font families the policy routes to and complete Red Hat styles (no API change). Version 0.11.0 requires `@openpresentation/opf` ^0.11.2 (cover centering, Intos Aptos previews, lazy font loading, automatic script fonts and glyph fallback); use it with PPTX 0.11.0 and editor 0.10.0 so preview and export resolve the same core. Version 0.10.0 required `@openpresentation/opf` ^0.11.1 (font policy table, script fonts and right-to-left paragraphs, socials, slide-image treatments, formatted slide-number and date furniture with the host `date` option, per-item alignment). See the changelog for the intentional preview-output changes.
+Version 0.11.5 loads vendored preview fonts by face, not by family, and lets the font loaders resolve documents with the host's render options (`presentationFaces`, `lazyFacesNeeded`; `pendingLazyFonts`, `ensureLazyFonts`, `pendingScripts` and `ensureScripts` take `catalogs` and throw or reject with the `renderSvg` error for a document that does not resolve; `registry.lazyFonts` still lists 94 faces). Version 0.11.4 previews the seven chartex chart types natively (the world map as a non-geographic tile grid), keeps the Latin Noto Sans replacement for script schemes under `scripts: 'auto'` in Node, shapes Noto Sans Mongolian again and bundles Raleway and Playfair Display (`registry.lazyFonts` lists 94 faces; no API change). Version 0.11.3 previews the classic chart types natively, draws deprecated chart ids as their replacement and scales value axes like Office (no API change; the preview of chart slides changes). Version 0.11.2 makes `scripts: 'auto'` load the script faces a font scheme names and adds `details.loadedFaceHasGlyph` to `missing-glyph` (no export change). Version 0.11.1 adds the open replacement font families the policy routes to and complete Red Hat styles (no API change). Version 0.11.0 requires `@openpresentation/opf` ^0.11.2 (cover centering, Intos Aptos previews, lazy font loading, automatic script fonts and glyph fallback); use it with PPTX 0.11.0 and editor 0.10.0 so preview and export resolve the same core. Version 0.10.0 required `@openpresentation/opf` ^0.11.1 (font policy table, script fonts and right-to-left paragraphs, socials, slide-image treatments, formatted slide-number and date furniture with the host `date` option, per-item alignment). See the changelog for the intentional preview-output changes.
 
 Version 0.9.0 required `@openpresentation/opf` ^0.11.0 and resolved content ColorRef / `variables` through core `resolveColorRef()`. Authored `#RRGGBB` paint stays authored. It retains the existing rendering APIs.
 
@@ -146,9 +146,9 @@ Font schemes select openly licensed Latin families that no Office substitute cov
 | Libre Caslon Text | `@expo-google-fonts/libre-caslon-text@0.4.0` (same) | 400, 400 italic, 700 (Baskerville Old Face, Bookman Old Style) |
 | Bitter | `@expo-google-fonts/bitter@0.4.2` (instanced statics named "Bitter"; the OFL reserves "Bitter Pro") | 400, 700, italics (Rockwell) |
 
-All are SIL OFL 1.1, and each manifest entry records the SPDX id read from the shipped notice, its Reserved Font Names, the upstream project and copyright line. An OFL Reserved Font Name stops a modified version from using the reserved name, so the families that have one (PT Serif, Lora, Merriweather Sans, Source Sans 3) are the copyright holder's byte-identical files: every face records `upstreamFile { url, sha256 }` with a commit-pinned URL and a sha256 equal to the face's own, and `test/font-licenses.mjs` enforces it. The other families have none, except Bitter (Reserved Font Name "Bitter Pro"); their files are either google/fonts statics (Barlow and Anton: byte-identical, also pinned by `upstreamFile`) or the instanced statics of the `@expo-google-fonts` packages, whose notice and version `PROVENANCE.json` records.
+All are SIL OFL 1.1, and each manifest entry records the SPDX id read from the shipped notice, its Reserved Font Names, the upstream project and copyright line. An OFL Reserved Font Name stops a modified version from using the reserved name, so the families that have one (PT Serif, Lora, Merriweather Sans, Source Sans 3, Raleway, Playfair Display) are the copyright holder's byte-identical files: every face records `upstreamFile { url, sha256 }` with a commit-pinned URL and a sha256 equal to the face's own, and `test/font-licenses.mjs` enforces it. The other families have none, except Bitter (Reserved Font Name "Bitter Pro"); their files are either google/fonts statics (Barlow and Anton: byte-identical, also pinned by `upstreamFile`) or the instanced statics of the `@expo-google-fonts` packages, whose notice and version `PROVENANCE.json` records.
 
-Not bundled: **Raleway** and **Playfair Display**. Their upstream releases ship only variable fonts, and the Node raster engine (resvg 2.6.2) ignores the weight axis: weights 400 and 700 rendered byte-identically, and Raleway's default instance is Thin. Bundling the instanced statics would modify them under their Reserved Font Names. They keep failing with "no face" until the raster engine supports variable weights or upstream publishes statics. **Bitter** (the Rockwell replacement) reserves the name "Bitter Pro". OFL only stops a modified font from carrying its Reserved Font Name in its family or file name, so the instanced statics, named "Bitter", are allowed; `test/font-licenses.mjs` implements exactly that name-contains rule for instanced faces (an instanced face named Carlito, Raleway, Lora or Playfair Display still fails, and a family that must keep its reserved name ships the unmodified upstream file). **Libre Caslon Text** has no bold italic (its static releases and the Google Fonts instances stop at Regular, Italic and Bold): a bold italic request draws the real italic and reports `visual`; bold is never synthesized.
+**Raleway** and **Playfair Display** reserve their own names, and Google Fonts serves them only as variable fonts, which the Node raster engine (resvg 2.6.2) draws at one weight (400 and 700 rendered byte-identically, and Raleway's default instance is Thin). Instancing them would be a modified version under the reserved name, so they are bundled as the copyright holders' unmodified static files instead: googlefonts/Raleway at commit `7e0be84` and clauseggers/Playfair at `6e115d7` (tag 1.202), `fonts/TTF`, four styles each, byte-identical with `upstreamFile` pins. **Bitter** (the Rockwell replacement) reserves the name "Bitter Pro". OFL only stops a modified font from carrying its Reserved Font Name in its family or file name, so the instanced statics, named "Bitter", are allowed; `test/font-licenses.mjs` implements exactly that name-contains rule for instanced faces (an instanced face named Carlito, Raleway, Lora or Playfair Display still fails, and a family that must keep its reserved name ships the unmodified upstream file). **Libre Caslon Text** has no bold italic (its static releases and the Google Fonts instances stop at Regular, Italic and Bold): a bold italic request draws the real italic and reports `visual`; bold is never synthesized.
 
 Source Sans Pro was renamed Source Sans 3. A request for the old name draws the Source Sans 3 faces through a built-in alias (`renamedFrom` in the manifest) and is reported `visual`, in any substitution policy, because the releases differ (bold advances by about 0.7%). Source Sans 3 itself resolves exact and is also the declared replacement for Candara, Corbel, Gill Sans MT and Seaford. Red Hat Display and Text are the declared replacements for Segoe UI and Tahoma. The RedHatFont repository's own static files cannot be used: the Regular, Light and SemiBold italics (and Red Hat Text Italic) do not set the OS/2 italic bit (only the Bold Italic files do), Red Hat Display SemiBold declares weight 707 and Bold 799 (Red Hat Text Bold declares 700), so in resvg a 600 request paints as Bold and the regular and bold italics paint as one face (probed). The vendored Red Hat faces are therefore the correctly labelled instanced statics of `@expo-google-fonts` (Red Hat has no Reserved Font Name): Segoe UI Semibold draws a real 600 (and 600 italic), and Segoe UI, Segoe UI Light and Tahoma draw real italics, none synthesized. Trade-off: the shipped Red Hat Display Bold (Google Fonts weight 700 instance) is about 2.5% narrower than the RedHatFont Bold it replaces, so the Segoe UI Bold preview moves from +0.6% to -1.8% mean width against Segoe UI Bold 5.71 (mean absolute 0.95% to 1.86%, max 6.0% to 5.5%); the regular widths are identical. A style a family lacks is not synthesized: Bebas Neue and Anton bold draw the regular face and report `visual`, and an italic request throws `font-style-unavailable`, as for Roboto Mono. A test renders every vendored face through resvg and checks that exactly that face paints.
 
@@ -189,6 +189,8 @@ registry.scriptSelection; // { detected, scripts, unavailable, packages, notInst
 const fonts = await loadBrowserFontRegistry(baseEntries, { substitutionPolicy: 'visual', fallbackFamily: 'Roboto', scriptBaseUrl: '/script-fonts/' });
 if (fonts.pendingScripts(presentation).length) await fonts.ensureScripts(presentation); // resolves { detected, scripts, unavailable, loaded }
 // pendingScripts is synchronous: empty means nothing is missing, so render at once.
+// Text decides, so the analysis does not resolve layouts or catalogs. Pass the render options (renderOptions: { catalogs } to
+// loadBrowserFontRegistry, or per call) so a font scheme only the host's catalogs have and that names a script font (Yu Gothic) counts.
 ```
 
 Where the renderer has per-character glyph fallback (`glyphFallbackFamilies`), auto also loads Noto Sans when the text has Greek or Cyrillic (the chosen Latin face may lack it), and the next CJK face of the fallback chain when a drawn Han, kana or Hangul character is missing from the loaded ones (a Simplified-only hanzi in Japanese text, hanja). That is capped at one fallback package beyond the packages the text's own scripts need: a character no CJK face covers never pulls in all four (10 to 20 MiB each); it is listed in `ensureScripts().uncovered` (Node: `script-glyph-uncovered`, `registry.scriptSelection.uncovered`) and the renderer reports `missing-glyph`. Browser loads are all or nothing per package: a failed fetch, hash check or `FontFace.load()` leaves the registry, the document and `loadedScriptPackages` unchanged and the package pending. One failing package does not lose the others: `ensureScripts` loads every package it can, then rejects with an `OPFFontError` whose `details` are `{ loaded, failed: [{package, code, message}] }`, and the next call retries only the failures. `ensureScripts(presentation, { signal })` and `loadScripts(scripts, { signal })` take a per-call `AbortSignal` (the creation signal is not reused), and `dispose()` during a load leaves no face behind and rejects with `font-registry-disposed`. Script faces carry `embed: "used"`, like the open families: the eager `registry.embeddedFonts` leaves them out, and when you pass them explicitly (`registry.selectEmbeddedFonts(face => face.scripts)`) an SVG embeds one only when the slide's text uses its family, so a Latin slide never carries a CJK face.
@@ -244,6 +246,8 @@ Dependency policy:
 
 Browser support boundary: `renderSvg`, `renderSvgDeck`, and `resolvePresentation` are browser-importable pure JavaScript APIs. `svgToPng` and `svgToPdf` are Node APIs in this package version because they depend on the Node build of resvg.
 
+Chartex chart previews (FF-22b) draw the constructs opf-pptx exports as Office 2016 chartex parts: `treemap` (squarified tiles of the first series, one colour per tile, category labels), `histogram` (a lone value column binned like PowerPoint with Scott's rule count and right-closed bins, or one column per category), `pareto` (columns sorted descending with the cumulative-percentage line on a 0-100% axis), `box-and-whisker` (rows grouped by category, one box per series, exclusive quartiles, whiskers within 1.5 IQR, mean markers, outlier points), `waterfall` (floating bars from the running total, increases and decreases in the first two palette colours, connector lines) and `funnel` (centred bars with value labels). `world` is an honest non-geographic preview: one tile per region shaded by value with its name and value. No geography data is shipped; PowerPoint draws the real map from Bing geodata it fetches itself, so the preview and the native map agree on labels, values and the series colour, not on shapes. Each chartex kind also accepts a lone value column (row numbers as categories; histogram and pareto bin the values). Every mark and label keeps a `data-opf-path` (bins and boxes trace to their value column).
+
 Classic chart previews keep finite axis coordinates for subnormal values and values up to `Number.MAX_VALUE`, including mixed positive/negative ranges. At these limits, available numeric precision can merge adjacent axis ticks or prevent extra headroom. Authored values are unchanged. Stacked, percentage or pie/doughnut totals that overflow the finite numeric range are still unsupported: rendering throws a `RangeError` naming the chart path and asking the caller to rescale the values. It does not substitute an empty chart or silently discard the overflowing values.
 
 ## Development

package/dist/charts.js

@@ -105,9 +105,21 @@ const RENDERERS = {
   pie: renderCircularChart,
   doughnut: renderCircularChart,
   scatter: renderScatterChart,
-  radar: renderRadarChart
+  radar: renderRadarChart,
+  // Chartex constructs (opf-pptx writes them as cx:chartSpace parts, FF-22b).
+  treemap: renderTreemapChart,
+  histogram: renderHistogramChart,
+  pareto: renderHistogramChart,
+  box: renderBoxWhiskerChart,
+  waterfall: renderWaterfallChart,
+  funnel: renderFunnelChart,
+  map: renderRegionMapChart
 };
 
+// Chartex constructs also accept a lone value column (the exporter plots it
+// against row numbers, or bins it for histogram and pareto).
+const CHARTEX_KINDS = new Set(["treemap", "histogram", "pareto", "box", "waterfall", "funnel", "map"]);
+
 /**
  * Render a catalog chart. Returns null when the id is outside the catalog, has
  * no preview renderer, or carries no inline category-major data, so the caller
@@ -120,7 +132,7 @@ export function renderCatalogChart(item, box, bound, options, svg) {
   const data = item.value?.data;
   const rows = Array.isArray(data?.rows) ? data.rows.map((row) => Array.isArray(row) ? row : [row]) : [];
   const columns = Array.isArray(data?.columns) ? data.columns : [];
-  if (!render || !rows.length || columns.length < 2) return null;
+  if (!render || !rows.length || columns.length < (CHARTEX_KINDS.has(spec.kind) ? 1 : 2)) return null;
   const c = chartContext(item, box, bound, options, svg, rows, columns);
   c.mark("rect", { x: box.x, y: box.y, width: box.width, height: box.height, fill: c.surface, stroke: bound.design.colors.border, "stroke-width": 1 }, item.path);
   render(c, spec);
@@ -642,3 +654,356 @@ function renderRadarChart(c, spec) {
     c.text(label, { x: cx - width - fontPx * 0.2, y: cy - rAt(tick) - c.lineHeight / 2, width, height: c.lineHeight }, c.path, "right");
   }
 }
+
+// ---------------------------------------------------------------------------
+// Chartex constructs (FF-22b). opf-pptx writes these as native Office 2016
+// chartex parts (cx:series layoutId treemap, clusteredColumn with binning or
+// aggregation, paretoLine, boxWhisker, waterfall, funnel, regionMap); the
+// previews below draw the same data with the same colours and defaults.
+
+/**
+ * The plotted column of a chartex chart: [Category, Value, ...] plots the first
+ * value column against its categories; a lone value column is plotted against
+ * the row numbers (histogram and pareto bin the values instead).
+ */
+export function chartexValues(rows, columns) {
+  const hasCategories = columns.length > 1;
+  const column = hasCategories ? 1 : 0;
+  const values = rows.map((row) => chartNumber(row[column]));
+  const categories = rows.map((row, i) => hasCategories ? (row[0] === null || row[0] === undefined ? "" : String(row[0])) : String(i + 1));
+  return { hasCategories, column, values, categories };
+}
+
+// Office's automatic histogram bins: Scott's normal reference rule gives the bin
+// width 3.49 * sd * n^(-1/3) (sample standard deviation) over [min, max]; the
+// exporter writes the same count as cx:binCount.
+export function scottBinCount(values) {
+  const n = values.length;
+  if (n === 0) return 1;
+  let min = Infinity, max = -Infinity, mean = 0;
+  for (const value of values) { if (value < min) min = value; if (value > max) max = value; mean += value / n; }
+  if (!(max > min) || n < 2) return 1;
+  let variance = 0;
+  for (const value of values) variance += (value - mean) * (value - mean) / (n - 1);
+  const width = 3.49 * Math.sqrt(variance) * Math.cbrt(n) ** -1;
+  if (!(width > 0) || !Number.isFinite(width)) return 1;
+  const count = Math.ceil((max - min) / width - 1e-9);
+  return Number.isFinite(count) && count >= 1 ? count : 1;
+}
+
+/**
+ * Equal-width bins from the minimum, closed on the right like PowerPoint's
+ * ("[min, e1]", then "(e1, e2]"): each value falls in the last bin whose upper
+ * edge it does not exceed. Labels carry six significant digits, and more when
+ * two bins would read alike.
+ */
+export function histogramBins(values) {
+  const finite = values.filter((value) => value !== null && Number.isFinite(value));
+  if (!finite.length) return [];
+  const min = finite.reduce((a, b) => Math.min(a, b)), max = finite.reduce((a, b) => Math.max(a, b));
+  const count = scottBinCount(finite);
+  const edge = (index) => index === 0 ? min : index === count ? max : min / count * (count - index) + max / count * index;
+  const bins = Array.from({ length: count }, (_, index) => ({ low: edge(index), high: edge(index + 1), count: 0 }));
+  for (const value of finite) {
+    let index = 0;
+    while (index + 1 < count && value > bins[index].high) index++;
+    bins[index].count++;
+  }
+  for (let precision = 6; ; precision++) {
+    const format = (value) => String(Number(value.toPrecision(precision)));
+    const labels = bins.map((bin, index) => count === 1 && min === max ? format(min) : `${index === 0 ? "[" : "("}${format(bin.low)}, ${format(bin.high)}]`);
+    if (new Set(labels).size === labels.length || precision === 17) return bins.map((bin, index) => ({ ...bin, label: labels[index] }));
+  }
+}
+
+// Vertical layout shared by the axis-bearing constructs: category labels below,
+// value ticks on the left (and a percentage axis on the right for pareto).
+function chartexPlot(c, { categories, legendWidth = 0, tickLabels = [], percentAxis = false }) {
+  const { box, pad, fontPx } = c;
+  const top = box.y + pad + c.lineHeight / 2;
+  const bottom = box.y + box.height - pad - c.lineHeight;
+  const height = Math.max(1, bottom - top);
+  const tickWidth = Math.max(0, ...tickLabels.map((label) => c.width(label))) + fontPx * 0.5;
+  const x = box.x + pad + tickWidth;
+  const right = box.x + box.width - pad - legendWidth - (percentAxis ? c.width("100%") + fontPx : fontPx / 2);
+  const plot = { x, y: top, width: Math.max(1, right - x), height };
+  const band = plot.width / Math.max(1, categories.length);
+  categories.forEach((entry, i) => c.text(entry.name, { x: plot.x + i * band, y: plot.y + plot.height, width: band, height: c.lineHeight }, entry.path));
+  return { plot, band };
+}
+
+function valueAxis(c, plot, scale) {
+  const at = (value) => plot.y + axisFraction(value, scale, true) * plot.height;
+  for (const tick of scale.ticks) {
+    const y = at(tick);
+    gridline(c, plot.x, y, plot.x + plot.width, y);
+    c.text(formatTick(tick), { x: c.box.x + c.pad, y: y - c.lineHeight / 2, width: plot.x - c.box.x - c.pad - c.fontPx * 0.35, height: c.lineHeight }, c.path, "right");
+  }
+  const crossing = at(Math.min(scale.max, Math.max(scale.min, 0)));
+  axisLine(c, plot.x, plot.y, plot.x, plot.y + plot.height);
+  axisLine(c, plot.x, crossing, plot.x + plot.width, crossing);
+  return { at, crossing };
+}
+
+// Histogram (cx:binning or cx:aggregation) and Pareto (sorted columns with the cumulative-percentage line on a percentage axis).
+function renderHistogramChart(c, spec) {
+  const pareto = spec.kind === "pareto";
+  const { hasCategories, column, values, categories } = chartexValues(c.rows, c.columns);
+  let bars;
+  if (hasCategories) {
+    bars = values.map((value, i) => ({ value, name: categories[i], path: `${c.path}.data.rows.${i}.${column}`, labelPath: `${c.path}.data.rows.${i}.0` })).filter((bar) => bar.value !== null);
+  } else {
+    bars = histogramBins(values).map((bin) => ({ value: bin.count, name: bin.label, path: `${c.path}.data.columns.${column}`, labelPath: c.path }));
+  }
+  if (pareto) bars = bars.slice().sort((a, b) => b.value - a.value);
+  const total = bars.reduce((sum, bar) => sum + Math.max(0, bar.value), 0);
+  if (!Number.isFinite(total)) throw chartAggregateError(c.path, "cumulative total");
+  const dataMax = bars.length ? Math.max(...bars.map((bar) => bar.value)) : 1, dataMin = bars.length ? Math.min(0, ...bars.map((bar) => bar.value)) : 0;
+  const probe = niceScale(dataMin, dataMax, 10);
+  const { plot, band } = chartexPlot(c, { categories: bars.map((bar) => ({ name: bar.name, path: bar.labelPath })), tickLabels: probe.ticks.map((tick) => formatTick(tick)), percentAxis: pareto });
+  const scale = niceScale(dataMin, dataMax, maxIntervalsFor(plot.height, c.lineHeight * 1.2));
+  const { at, crossing } = valueAxis(c, plot, scale);
+  const width = band / 1.06, offset = (band - width) / 2;
+  bars.forEach((bar, i) => {
+    const y = at(bar.value);
+    c.mark("rect", { x: plot.x + i * band + offset, y: Math.min(y, crossing), width, height: Math.abs(crossing - y), fill: c.colors[0] }, bar.path);
+  });
+  if (pareto && bars.length) {
+    // Percentage axis on the right, 0-100%, and the cumulative line through the bar centres.
+    const percent = niceScale(0, 1, maxIntervalsFor(plot.height, c.lineHeight * 1.2), { percent: true });
+    const right = plot.x + plot.width;
+    axisLine(c, right, plot.y, right, plot.y + plot.height);
+    for (const tick of percent.ticks) {
+      const y = plot.y + axisFraction(tick, percent, true) * plot.height;
+      c.text(formatTick(tick, true), { x: right + c.fontPx * 0.35, y: y - c.lineHeight / 2, width: c.box.x + c.box.width - c.pad - right - c.fontPx * 0.35, height: c.lineHeight }, c.path, "left");
+    }
+    let running = 0;
+    const points = bars.map((bar, i) => {
+      running += Math.max(0, bar.value);
+      const fraction = total ? running / total : 0;
+      return `${c.num(plot.x + (i + 0.5) * band)},${c.num(plot.y + axisFraction(fraction, percent, true) * plot.height)}`;
+    });
+    c.mark("polyline", { points: points.join(" "), fill: "none", stroke: c.colors[1 % c.colors.length], "stroke-width": 2 * c.pt, "stroke-linejoin": "round", "stroke-linecap": "round" }, `${c.path}.data.columns.${column}`);
+  }
+}
+
+// Waterfall: floating bars from the running total, increases and decreases in the first two palette colours, connector lines between bars.
+function renderWaterfallChart(c) {
+  const { column, values, categories } = chartexValues(c.rows, c.columns);
+  let running = 0;
+  const bars = values.map((value, i) => {
+    if (value === null) return null;
+    const from = running;
+    running += value;
+    if (!Number.isFinite(running)) throw chartAggregateError(c.path, "running total");
+    return { i, value, from, to: running };
+  }).filter(Boolean);
+  const extents = bars.flatMap((bar) => [bar.from, bar.to]);
+  const dataMin = extents.length ? Math.min(0, ...extents) : 0, dataMax = extents.length ? Math.max(0, ...extents) : 1;
+  const probe = niceScale(dataMin, dataMax, 10);
+  const { plot, band } = chartexPlot(c, { categories: categories.map((name, i) => ({ name, path: `${c.path}.data.rows.${i}.0` })), tickLabels: probe.ticks.map((tick) => formatTick(tick)) });
+  const scale = niceScale(dataMin, dataMax, maxIntervalsFor(plot.height, c.lineHeight * 1.2));
+  const { at } = valueAxis(c, plot, scale);
+  const width = band / 1.5, offset = (band - width) / 2;
+  bars.forEach((bar, k) => {
+    const a = at(bar.from), b = at(bar.to);
+    const x = plot.x + bar.i * band + offset;
+    c.mark("rect", { x, y: Math.min(a, b), width, height: Math.abs(b - a), fill: c.colors[bar.value < 0 ? 1 : 0] }, `${c.path}.data.rows.${bar.i}.${column}`);
+    const next = bars[k + 1];
+    if (next) c.mark("line", { x1: x + width, y1: b, x2: plot.x + next.i * band + offset, y2: b, stroke: c.axisColor, "stroke-width": c.pt });
+  });
+}
+
+// Funnel: centred bars from the top, widths proportional to the value, value labels inside and category labels on the left.
+function renderFunnelChart(c) {
+  const { box, pad, fontPx } = c;
+  const { column, values, categories } = chartexValues(c.rows, c.columns);
+  const count = categories.length;
+  const max = Math.max(0, ...values.filter((value) => value !== null));
+  const labelWidth = Math.min(box.width * 0.3, Math.max(0, ...categories.map(c.width)) + fontPx * 0.5);
+  const plot = { x: box.x + pad + labelWidth + pad / 2, y: box.y + pad, width: Math.max(1, box.width - 2 * pad - labelWidth - pad / 2), height: Math.max(1, box.height - 2 * pad) };
+  const band = plot.height / count, height = band / 1.06, offset = (band - height) / 2;
+  categories.forEach((name, i) => {
+    const y = plot.y + i * band;
+    c.text(name, { x: box.x + pad, y, width: labelWidth, height: band }, `${c.path}.data.rows.${i}.0`, "right");
+    const value = values[i];
+    if (value === null || !(max > 0) || value <= 0) return;
+    const width = plot.width * Math.min(1, value / max);
+    const x = plot.x + (plot.width - width) / 2;
+    c.mark("rect", { x, y: y + offset, width, height, fill: c.colors[0] }, `${c.path}.data.rows.${i}.${column}`);
+    c.text(formatTick(value), { x: plot.x, y: y + offset, width: plot.width, height }, `${c.path}.data.rows.${i}.${column}`);
+  });
+}
+
+/**
+ * Squarified treemap layout (Bruls, Huizing and van Wijk): items are laid out
+ * in rows along the shorter side, each row closed when adding the next item
+ * would worsen its worst aspect ratio. Returns one rectangle per item, in the
+ * item order given (null for items without area).
+ */
+export function squarify(items, x, y, width, height) {
+  const total = items.reduce((sum, item) => sum + item.value, 0);
+  const rects = new Array(items.length).fill(null);
+  if (!(total > 0) || !(width > 0) || !(height > 0)) return rects;
+  const scale = width * height / total;
+  const ordered = items.map((item, index) => ({ area: item.value * scale, index })).filter((item) => item.area > 0).sort((a, b) => b.area - a.area || a.index - b.index);
+  let free = { x, y, width, height };
+  let row = [];
+  const worst = (candidates, side) => {
+    const sum = candidates.reduce((s, item) => s + item.area, 0);
+    const min = Math.min(...candidates.map((item) => item.area)), max = Math.max(...candidates.map((item) => item.area));
+    return Math.max(side * side * max / (sum * sum), sum * sum / (side * side * min));
+  };
+  const layoutRow = () => {
+    const sum = row.reduce((s, item) => s + item.area, 0);
+    const horizontal = free.width >= free.height;
+    const side = horizontal ? free.height : free.width;
+    const thickness = side > 0 ? sum / side : 0;
+    let offset = 0;
+    for (const item of row) {
+      const length = thickness > 0 ? item.area / thickness : 0;
+      rects[item.index] = horizontal
+        ? { x: free.x, y: free.y + offset, width: thickness, height: length }
+        : { x: free.x + offset, y: free.y, width: length, height: thickness };
+      offset += length;
+    }
+    free = horizontal
+      ? { x: free.x + thickness, y: free.y, width: Math.max(0, free.width - thickness), height: free.height }
+      : { x: free.x, y: free.y + thickness, width: free.width, height: Math.max(0, free.height - thickness) };
+    row = [];
+  };
+  for (const item of ordered) {
+    const side = Math.min(free.width, free.height);
+    if (row.length && side > 0 && worst([...row, item], side) > worst(row, side)) layoutRow();
+    row.push(item);
+  }
+  if (row.length) layoutRow();
+  return rects;
+}
+
+// Treemap: one tile per category from the first value column (positive values only), one palette colour per tile, category labels inside.
+function renderTreemapChart(c) {
+  const { box, pad, fontPx } = c;
+  const { column, values, categories } = chartexValues(c.rows, c.columns);
+  const items = values.map((value) => ({ value: value !== null && value > 0 ? value : 0 }));
+  const total = items.reduce((sum, item) => sum + item.value, 0);
+  if (!Number.isFinite(total)) throw chartAggregateError(c.path, "tile total");
+  const area = { x: box.x + pad, y: box.y + pad, width: Math.max(1, box.width - 2 * pad), height: Math.max(1, box.height - 2 * pad) };
+  if (!total) {
+    c.text("No positive chart values", area, c.path);
+    return;
+  }
+  const rects = squarify(items, area.x, area.y, area.width, area.height);
+  rects.forEach((rect, i) => {
+    if (!rect || !(rect.width > 0) || !(rect.height > 0)) return;
+    c.mark("rect", { x: rect.x, y: rect.y, width: rect.width, height: rect.height, fill: c.colors[i % c.colors.length], stroke: "#FFFFFF", "stroke-width": c.pt }, `${c.path}.data.rows.${i}.${column}`);
+    if (rect.width >= fontPx * 2 && rect.height >= c.lineHeight) {
+      c.text(categories[i], { x: rect.x + fontPx * 0.25, y: rect.y, width: rect.width - fontPx * 0.5, height: rect.height }, `${c.path}.data.rows.${i}.0`);
+    }
+  });
+}
+
+/**
+ * Box statistics as PowerPoint computes them with the exclusive quartile
+ * method (Excel QUARTILE.EXC): the rank p(n + 1) interpolates between sorted
+ * values and clamps to the extremes, whiskers reach the furthest values within
+ * 1.5 IQR of the box, and values beyond are outliers.
+ */
+export function boxStatistics(values) {
+  const sorted = values.filter((value) => value !== null && Number.isFinite(value)).sort((a, b) => a - b);
+  const n = sorted.length;
+  if (!n) return null;
+  const quantile = (p) => {
+    const rank = p * (n + 1);
+    if (rank <= 1) return sorted[0];
+    if (rank >= n) return sorted[n - 1];
+    const lower = Math.floor(rank), fraction = rank - lower;
+    return sorted[lower - 1] + fraction * (sorted[lower] - sorted[lower - 1]);
+  };
+  const q1 = quantile(0.25), median = quantile(0.5), q3 = quantile(0.75);
+  const iqr = q3 - q1;
+  const inside = sorted.filter((value) => value >= q1 - 1.5 * iqr && value <= q3 + 1.5 * iqr);
+  const mean = sorted.reduce((sum, value) => sum + value, 0) / n;
+  return { q1, median, q3, mean, low: inside[0] ?? q1, high: inside[inside.length - 1] ?? q3, outliers: sorted.filter((value) => value < q1 - 1.5 * iqr || value > q3 + 1.5 * iqr) };
+}
+
+// Box and whisker: rows with the same category form one box per series; median line, mean marker and outliers, gap width 100%.
+function renderBoxWhiskerChart(c) {
+  // A lone value column has no category column: like the exporter, its values plot against their row numbers (one box per row).
+  const lone = c.columns.length === 1;
+  const series = lone ? [{ name: c.label(c.columns[0]), column: 0, index: 0, values: c.rows.map((row) => chartNumber(row[0])) }] : c.series();
+  const groups = [];
+  c.rows.forEach((row, i) => {
+    const name = lone ? String(i + 1) : c.label(row[0]);
+    let group = groups.find((entry) => entry.name === name);
+    if (!group) groups.push(group = { name, first: i, rows: [] });
+    group.rows.push(i);
+  });
+  const boxes = series.map((s) => groups.map((group) => ({ stats: boxStatistics(group.rows.map((i) => s.values[i])), rows: group.rows })));
+  const all = boxes.flat().flatMap((entry) => entry.stats ? [entry.stats.low, entry.stats.high, ...entry.stats.outliers] : []);
+  const dataMin = all.length ? Math.min(...all) : 0, dataMax = all.length ? Math.max(...all) : 1;
+  const legendWidth = seriesLegend(c, series);
+  const probe = niceScale(dataMin, dataMax, 10);
+  const { plot, band } = chartexPlot(c, { categories: groups.map((group) => ({ name: group.name, path: lone ? c.path : `${c.path}.data.rows.${group.first}.0` })), legendWidth, tickLabels: probe.ticks.map((tick) => formatTick(tick)) });
+  const scale = niceScale(dataMin, dataMax, maxIntervalsFor(plot.height, c.lineHeight * 1.2));
+  const { at } = valueAxis(c, plot, scale);
+  const group = band / 2, width = group / series.length, offset = (band - group) / 2;
+  series.forEach((s, j) => {
+    const color = c.colors[j % c.colors.length], path = `${c.path}.data.columns.${s.column}`;
+    boxes[j].forEach((entry, i) => {
+      const stats = entry.stats;
+      if (!stats) return;
+      const x = plot.x + i * band + offset + j * width, mid = x + width / 2;
+      const top = at(stats.q3), bottom = at(stats.q1);
+      c.mark("line", { x1: mid, y1: at(stats.high), x2: mid, y2: top, stroke: color, "stroke-width": c.pt }, path);
+      c.mark("line", { x1: mid, y1: bottom, x2: mid, y2: at(stats.low), stroke: color, "stroke-width": c.pt }, path);
+      c.mark("line", { x1: x + width * 0.25, y1: at(stats.high), x2: x + width * 0.75, y2: at(stats.high), stroke: color, "stroke-width": c.pt }, path);
+      c.mark("line", { x1: x + width * 0.25, y1: at(stats.low), x2: x + width * 0.75, y2: at(stats.low), stroke: color, "stroke-width": c.pt }, path);
+      c.mark("rect", { x, y: top, width, height: Math.max(c.pt, bottom - top), fill: color }, path);
+      c.mark("line", { x1: x, y1: at(stats.median), x2: x + width, y2: at(stats.median), stroke: c.labelColor, "stroke-width": c.pt }, path);
+      const r = 2.5 * c.pt, my = at(stats.mean);
+      c.mark("path", { d: `M ${c.num(mid - r)} ${c.num(my - r)} L ${c.num(mid + r)} ${c.num(my + r)} M ${c.num(mid - r)} ${c.num(my + r)} L ${c.num(mid + r)} ${c.num(my - r)}`, fill: "none", stroke: c.labelColor, "stroke-width": c.pt }, path);
+      for (const value of stats.outliers) {
+        const row = entry.rows.find((k) => s.values[k] === value);
+        c.mark("circle", { cx: mid, cy: at(value), r: 3 * c.pt, fill: color, stroke: color, "stroke-width": 0.75 * c.pt }, `${c.path}.data.rows.${row}.${s.column}`);
+      }
+    });
+  });
+}
+
+/** Mix two hex colours (#RRGGBB) by `t` in [0, 1], rounded per channel. */
+export function mixHex(from, to, t) {
+  const channel = (hex, i) => parseInt(hex.slice(1 + 2 * i, 3 + 2 * i), 16);
+  const clamp = Math.min(1, Math.max(0, t));
+  return `#${[0, 1, 2].map((i) => Math.round(channel(from, i) + (channel(to, i) - channel(from, i)) * clamp).toString(16).toUpperCase().padStart(2, "0")).join("")}`;
+}
+
+// Region map: an honest non-geographic preview. PowerPoint draws the map from
+// Bing geodata it fetches itself; the preview shows one tile per region, shaded
+// from a light tint to the series colour by value, with the region name and
+// its value, so labels and colours are traceable without shipping geography.
+function renderRegionMapChart(c) {
+  const { box, pad, fontPx } = c;
+  const { column, values, categories } = chartexValues(c.rows, c.columns);
+  const count = categories.length;
+  const area = { x: box.x + pad, y: box.y + pad, width: Math.max(1, box.width - 2 * pad), height: Math.max(1, box.height - 2 * pad) };
+  const columns = Math.max(1, Math.min(count, Math.round(Math.sqrt(count * area.width / Math.max(1, area.height)))));
+  const rowsCount = Math.ceil(count / columns);
+  const tileWidth = area.width / columns, tileHeight = area.height / rowsCount;
+  const finite = values.filter((value) => value !== null);
+  const min = finite.length ? Math.min(...finite) : 0, max = finite.length ? Math.max(...finite) : 0;
+  const light = mixHex(/^#[0-9A-Fa-f]{6}$/.test(c.surface) ? c.surface : "#FFFFFF", c.colors[0], 0.15);
+  categories.forEach((name, i) => {
+    const value = values[i];
+    const t = value === null ? 0 : max > min ? (value - min) / (max - min) : 1;
+    const x = area.x + (i % columns) * tileWidth, y = area.y + Math.floor(i / columns) * tileHeight;
+    c.mark("rect", { x, y, width: tileWidth, height: tileHeight, fill: value === null ? c.surface : mixHex(light, c.colors[0], t), stroke: "#FFFFFF", "stroke-width": c.pt }, `${c.path}.data.rows.${i}.${column}`);
+    const inset = { x: x + fontPx * 0.25, width: Math.max(1, tileWidth - fontPx * 0.5) };
+    if (tileHeight >= c.lineHeight * 2) {
+      c.text(name, { ...inset, y: y + tileHeight / 2 - c.lineHeight, height: c.lineHeight }, `${c.path}.data.rows.${i}.0`);
+      if (value !== null) c.text(formatTick(value), { ...inset, y: y + tileHeight / 2, height: c.lineHeight }, `${c.path}.data.rows.${i}.${column}`);
+    } else if (tileHeight >= c.lineHeight) {
+      c.text(name, { ...inset, y: y + (tileHeight - c.lineHeight) / 2, height: c.lineHeight }, `${c.path}.data.rows.${i}.0`);
+    }
+  });
+}

package/dist/font-manifest.js

@@ -1121,6 +1121,130 @@ export const BUNDLED_FONT_MANIFEST=freeze({
         }
       ]
     },
+    {
+      "name": "raleway",
+      "vendored": "fonts/raleway",
+      "version": "7e0be846a3097743b9bf442eb8e65bc1fd96c934",
+      "pack": "open",
+      "source": "https://github.com/googlefonts/Raleway/tree/7e0be846a3097743b9bf442eb8e65bc1fd96c934/fonts/TTF",
+      "license": "OFL-1.1",
+      "licenseFile": "OFL.txt",
+      "licenseSha256": "7e946cf1171784d1015279e7dc35f827957a6b5d1f1f659ae0c98e5f5e37ed9b",
+      "upstreamLicenseUrl": "https://raw.githubusercontent.com/googlefonts/Raleway/7e0be846a3097743b9bf442eb8e65bc1fd96c934/OFL.txt",
+      "reservedFontNames": [
+        "Raleway"
+      ],
+      "upstream": "http://scripts.sil.org/OFL",
+      "copyright": "Copyright 2010 The Raleway Project Authors (impallari@gmail.com), with Reserved Font Name \"Raleway\".",
+      "faces": [
+        {
+          "file": "Raleway-Regular.ttf",
+          "family": "Raleway",
+          "weight": 400,
+          "italic": false,
+          "sha256": "cb70f8815eecd850263d54fa59286377b1d7362bec612e981155a00039d8b513",
+          "upstreamFile": {
+            "url": "https://raw.githubusercontent.com/googlefonts/Raleway/7e0be846a3097743b9bf442eb8e65bc1fd96c934/fonts/TTF/Raleway-Regular.ttf",
+            "sha256": "cb70f8815eecd850263d54fa59286377b1d7362bec612e981155a00039d8b513"
+          }
+        },
+        {
+          "file": "Raleway-Italic.ttf",
+          "family": "Raleway",
+          "weight": 400,
+          "italic": true,
+          "sha256": "63f52b6d8e88afa43d94162147ff55846f28af630d834018de5cb7ccc75a8ee8",
+          "upstreamFile": {
+            "url": "https://raw.githubusercontent.com/googlefonts/Raleway/7e0be846a3097743b9bf442eb8e65bc1fd96c934/fonts/TTF/Raleway-Italic.ttf",
+            "sha256": "63f52b6d8e88afa43d94162147ff55846f28af630d834018de5cb7ccc75a8ee8"
+          }
+        },
+        {
+          "file": "Raleway-Bold.ttf",
+          "family": "Raleway",
+          "weight": 700,
+          "italic": false,
+          "sha256": "6894481ab1c298e9c66f23455ecf05ccb25393d719a6b2d63428358c0409d2d0",
+          "upstreamFile": {
+            "url": "https://raw.githubusercontent.com/googlefonts/Raleway/7e0be846a3097743b9bf442eb8e65bc1fd96c934/fonts/TTF/Raleway-Bold.ttf",
+            "sha256": "6894481ab1c298e9c66f23455ecf05ccb25393d719a6b2d63428358c0409d2d0"
+          }
+        },
+        {
+          "file": "Raleway-BoldItalic.ttf",
+          "family": "Raleway",
+          "weight": 700,
+          "italic": true,
+          "sha256": "57eb1a701136eca30b52a4847edcec93daa53f0b5597dd98dbc0b07f475ce44a",
+          "upstreamFile": {
+            "url": "https://raw.githubusercontent.com/googlefonts/Raleway/7e0be846a3097743b9bf442eb8e65bc1fd96c934/fonts/TTF/Raleway-BoldItalic.ttf",
+            "sha256": "57eb1a701136eca30b52a4847edcec93daa53f0b5597dd98dbc0b07f475ce44a"
+          }
+        }
+      ]
+    },
+    {
+      "name": "playfair-display",
+      "vendored": "fonts/playfair-display",
+      "version": "6e115d70ee7ff6ed887babf3829ccd1de65fd2bd",
+      "pack": "open",
+      "source": "https://github.com/clauseggers/Playfair/tree/6e115d70ee7ff6ed887babf3829ccd1de65fd2bd/fonts/TTF",
+      "license": "OFL-1.1",
+      "licenseFile": "OFL.txt",
+      "licenseSha256": "e414e07f7a4da16ed47ebec80d52dd79f21d3ca42bc92385a755d8078a038814",
+      "upstreamLicenseUrl": "https://raw.githubusercontent.com/clauseggers/Playfair/6e115d70ee7ff6ed887babf3829ccd1de65fd2bd/OFL.txt",
+      "reservedFontNames": [
+        "Playfair Display"
+      ],
+      "upstream": "https://github.com/clauseggers/Playfair-Display",
+      "copyright": "Copyright 2017 The Playfair Display Project Authors (https://github.com/clauseggers/Playfair-Display), with Reserved Font Name \"Playfair Display\".",
+      "faces": [
+        {
+          "file": "PlayfairDisplay-Regular.ttf",
+          "family": "Playfair Display",
+          "weight": 400,
+          "italic": false,
+          "sha256": "70ef3ee8de32dc81c39f2733a4a2a050c7e6ba78a2f1632f9d5c6cfd482c3abb",
+          "upstreamFile": {
+            "url": "https://raw.githubusercontent.com/clauseggers/Playfair/6e115d70ee7ff6ed887babf3829ccd1de65fd2bd/fonts/TTF/PlayfairDisplay-Regular.ttf",
+            "sha256": "70ef3ee8de32dc81c39f2733a4a2a050c7e6ba78a2f1632f9d5c6cfd482c3abb"
+          }
+        },
+        {
+          "file": "PlayfairDisplay-Italic.ttf",
+          "family": "Playfair Display",
+          "weight": 400,
+          "italic": true,
+          "sha256": "30a7eb5a9309754d4b3e205e6435ef07d80e1b86735774b2ace427f6ed61f991",
+          "upstreamFile": {
+            "url": "https://raw.githubusercontent.com/clauseggers/Playfair/6e115d70ee7ff6ed887babf3829ccd1de65fd2bd/fonts/TTF/PlayfairDisplay-Italic.ttf",
+            "sha256": "30a7eb5a9309754d4b3e205e6435ef07d80e1b86735774b2ace427f6ed61f991"
+          }
+        },
+        {
+          "file": "PlayfairDisplay-Bold.ttf",
+          "family": "Playfair Display",
+          "weight": 700,
+          "italic": false,
+          "sha256": "898a01a59214578e72012131ef4c346844c1fd35613f4ee113a37d61a094a2d0",
+          "upstreamFile": {
+            "url": "https://raw.githubusercontent.com/clauseggers/Playfair/6e115d70ee7ff6ed887babf3829ccd1de65fd2bd/fonts/TTF/PlayfairDisplay-Bold.ttf",
+            "sha256": "898a01a59214578e72012131ef4c346844c1fd35613f4ee113a37d61a094a2d0"
+          }
+        },
+        {
+          "file": "PlayfairDisplay-BoldItalic.ttf",
+          "family": "Playfair Display",
+          "weight": 700,
+          "italic": true,
+          "sha256": "bd3b48ca605438de4337d05ece1ecb9e4149a975d3207174f28e02098bbec3ff",
+          "upstreamFile": {
+            "url": "https://raw.githubusercontent.com/clauseggers/Playfair/6e115d70ee7ff6ed887babf3829ccd1de65fd2bd/fonts/TTF/PlayfairDisplay-BoldItalic.ttf",
+            "sha256": "bd3b48ca605438de4337d05ece1ecb9e4149a975d3207174f28e02098bbec3ff"
+          }
+        }
+      ]
+    },
     {
       "name": "barlow",
       "vendored": "fonts/barlow",