@pptx-studio/cli 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,123 @@
 # @pptx-studio/cli
 
+## 0.2.0
+
+### Minor Changes
+
+- 725ad6d: `renderDeck` takes only what it draws.
+
+  Its options were the `render` verb's own, so a caller that wanted SVG strings passed
+  `out`, `json` and `quiet` — three fields the function ignores — and five more it had no
+  opinion about. `RenderDeckOptions` is the shape now: `slide`, `width`, `fontDirs`,
+  `systemFonts` and `text`, all optional. `renderDeck(bytes)` is a whole call, and
+  `renderDeck(bytes, { slide: 1, width: 640 })` is a thumbnail.
+
+  `RenderOptions` is the verb's: it extends `RenderDeckOptions` with `out`, `json` and
+  `quiet`, and `runRender` is what takes it. `RENDER_DEFAULTS` is gone, because the
+  defaults are in `renderDeck` and `DEFAULT_WIDTH` is still exported. A width that is not
+  a positive whole number now throws `CLI_WIDTH` instead of drawing an empty picture.
+
+  Breaking: a call written against 0.1.0 passes three properties this shape does not have.
+  Delete them, and delete any field you were only passing to satisfy the type.
+
+- c1d7d7d: The face box is read from the table this machine's rasteriser reads.
+
+  `pptx-studio render` took a face's ascent and descent from `OS/2.usWinAscent`/`usWinDescent`
+  everywhere, or `sTypo` where `fsSelection` bit 7 is set. That is what Chromium answers through
+  DirectWrite and it is not what Chromium answers through FreeType, which reads
+  `hhea.ascender`/`descender`. Neither reading fits both: the first scores 12/12 against Windows and
+  76/79 against Linux, the second 79/79 against Linux and 7/12 against Windows, and the misses are
+  75.8 px and 100 px on a 1000 px em rather than roundings.
+
+  On a Linux server — which is where this verb runs — the old reading put the IPA Gothic descent at
+  195.8 px where the browser puts it at 120, 7.6% of the em on every line of Japanese text, moving
+  every line break and every autofit decision.
+
+  `indexFonts` now resolves a `FontBackend` from its platform, and `metricsOf` reads `hhea` under
+  FreeType and `usWin` under DirectWrite, with bit 7 moving both onto `sTypo`. `FaceMetrics.source`
+  gains `hhea`, which is also what a face carrying no `OS/2` now reports rather than claiming `usWin`
+  while returning `hhea`'s numbers. macOS takes the DirectWrite reading and is unmeasured.
+
+  **Breaking:** `facesIn` and `faceOf` take the backend as a third argument. There is no defensible
+  default — a silent one would be a guess about the host — and `backendFor(platform)` is exported for
+  callers that want the local answer.
+
+  The rule is measured, not assumed: 79 real faces on a Linux runner against the 12 probe fonts T13
+  built to disagree with themselves, both scored in
+  `docs/adr/phase-3-text/0045-the-face-box-belongs-to-the-rasteriser.md`.
+
+### Patch Changes
+
+- 725ad6d: The ideographic baseline comes out of the font's `BASE` table.
+
+  `pptx-studio render` placed every upright East Asian glyph on the face's box descent,
+  which is right only for a face carrying no `BASE` table. Yu Gothic reports a box descent
+  of 0.302 em and an ideographic baseline of 0.1201 em, so a vertical `eaVert` frame was
+  drawn 0.18 em out of place on it — and the browser renderer, which asks Chromium, was
+  never wrong about the same face.
+
+  `sfnt.ts` now reads the `BASE` horizontal axis' `ideo` coordinate under the `DFLT`
+  script, and `FaceMetrics` carries it as `ideographic`. Where there is none the box
+  descent stands, and a coordinate outside the em answers zero, which is what
+  `@pptx-studio/text`'s own probe does with an unusable one.
+
+  The rule is measured, not assumed: four probe fonts whose `DFLT`, `latn` and `hani`
+  coordinates all disagree settle it at 30 of 30 in `corpus/ground-truth/font-metrics.json`.
+  Chromium reads `DFLT` and no other script — a `BASE` table naming only `latn`, `hani`
+  and `kana` is ignored whole — and it reads the same coordinate for a Latin run as for a
+  Han one, so the answer is a property of the face rather than of the text.
+
+  A coordinate outside the em is handed over as written rather than clamped — Chromium
+  reported 1.2 em for a font that says so — so both engines see the same unusable number
+  and both answer zero.
+
+- cec9ef2: Kerning is read through a type 9 GPOS Extension lookup.
+
+  `pptx-studio render` measured every face whose `kern` feature sits behind an
+  `ExtensionPosFormat1` subtable as having no kerning at all — no error, no diagnostic, just
+  lines about a twelfth too wide, which moves every break and misfires autofit. Lato is such
+  a face, in all eighteen of the styles a Linux runner carries, and so is most of what a
+  modern font compiler emits: an extension is how a lookup reaches a subtable past the 64 KB
+  a 16-bit offset can address, and compilers wrap unconditionally rather than only when they
+  must.
+
+  `sfnt.ts` read `if (u16(r, lookup) !== 2) continue`, so lookup type 9 was skipped along
+  with mark attachment and cursive positioning, which genuinely do not move an advance. It
+  now follows a type 9 lookup one level, to the type its `ExtensionPosFormat1` names at the
+  32-bit offset from its own start, and reads the `PairPos` there. Exactly one level: the
+  specification forbids an extension targeting another, so nothing recurses, and a subtable
+  naming any other type is skipped as before.
+
+  The rule is measured, not assumed. A twelfth probe font wraps the same `PairPos` the
+  eleventh carries plainly, and Chromium drew the two identically at all six sizes and on
+  all six strings — so the browser honours the wrapper and the reader was wrong rather than
+  strict. Following one extension fits 72 of 72 in
+  `corpus/ground-truth/font-metrics.json`, alone at the top; the reading that skipped it
+  fits 66, exactly the six rows of the wrapped probe.
+
+- cec9ef2: `renderDeck` substitutes a typeface nothing stands in for rather than refusing to draw.
+
+  A deck naming `Calibri Light` on a Linux server holding 53 perfectly good faces threw
+  `CLI_NO_FACE` and rendered nothing. The chain ran exact family, the substitution table,
+  Calibri, Carlito — and then gave up, which is the one place the font guard's design was
+  not applied: `FaceUse` carries `asked`, `drawn` and `substituted` so the answer can be
+  "Calibri Light was drawn in DejaVu Sans" rather than an exception.
+
+  Two steps now follow the measured chain. The shorter forms of the asked-for name, so
+  `Calibri Light` draws in Calibri and `Segoe UI Semilight` in Segoe UI where the machine
+  has them — DrawingML has no weight axis, so a style word is part of the typeface name.
+  Then, past every named candidate, the first family by name draws the run. Both are
+  reported as substitutions under the name the deck asked for, and neither displaces the
+  measured chain: ADR 0033 scored PowerPoint's own last resort at 22 of 22 and a guess must
+  not override a measurement.
+
+  The choice is by family name, not by the order `readdir` returned, and the font walk now
+  sorts its entries — so two machines holding the same faces draw the same picture, where
+  before the answer was the filesystem's own.
+
+  `CLI_NO_FACE` still throws, and now means exactly one thing: no font was found at all,
+  which is nothing to draw with rather than an unusual typeface.
+
 ## 0.1.0
 
 ### Minor Changes

package/README.md

@@ -200,14 +200,12 @@ cannot drift apart.
 
 ## Not built yet
 
-The plan gives this package three more verbs. Asking for one says which sub-phase
-brings it rather than "unknown command":
+The plan gives this package one more verb. Asking for it says which sub-phase brings
+it rather than "unknown command":
 
-| verb       | what it will do                               | sub-phase |
-| ---------- | --------------------------------------------- | --------- |
-| `fidelity` | score a render against a reference            | 3.9       |
-| `render`   | render slides to SVG or PNG without a browser | 3.10      |
-| `resolve`  | show where a resolved property came from      | 7.x       |
+| verb      | what it will do                          | sub-phase |
+| --------- | ---------------------------------------- | --------- |
+| `resolve` | show where a resolved property came from | 7.x       |
 
 ## `render`
 
@@ -226,12 +224,24 @@ the same document, and there is no external reference of any kind to resolve.
 face's own `cmap`, `hmtx`, `GPOS` and `OS/2` tables instead. That is a second
 measurement engine, and the risk of a second engine is that it quietly disagrees
 with the first. Experiment T13 settled the arithmetic rather than assuming it:
-seven fonts built so their tables disagree on purpose, 252 widths measured in
-Chromium, and the reader reproduces **all 252 exactly**. The rules it found are
+twelve fonts built so their tables disagree on purpose, 432 widths measured in
+Chromium, and the reader reproduces **all 432 exactly**. It also settled where
+an upright East Asian glyph sits: on the `BASE` table's `ideo` coordinate for
+the `DFLT` script, and on the face box descent only where there is none. The
+rules it found are
 in [`corpus/ground-truth/font-metrics.json`](../../corpus/ground-truth/font-metrics.json)
 and the reasoning is in
 [ADR 0042](../../docs/adr/phase-3-text/0042-rendering-without-a-browser.md).
 
+**The face box depends on the rasteriser**, so the reader takes the answer
+belonging to the platform it runs on. Chromium reports a face's ascent and
+descent from `OS/2.usWinAscent`/`usWinDescent` through DirectWrite and from
+`hhea.ascender`/`descender` through FreeType, with `fsSelection` bit 7 moving
+both onto `sTypo`. Neither reading fits both: T13's probes score 12/12 and 7/12
+on Windows where 79 real faces score 76/79 and 79/79 on Linux, missing by up to
+100 px on a 1000 px em. See
+[ADR 0045](../../docs/adr/phase-3-text/0045-the-face-box-belongs-to-the-rasteriser.md).
+
 Fonts are found in this platform's own directories, plus any `--font-dir` you
 name, which are searched first so you can override a face without installing
 one. `--no-system-fonts` limits it to what you named; `--no-text` draws geometry
@@ -239,8 +249,21 @@ only and asks no font questions at all.
 
 A typeface the machine does not have is substituted through the same table
 `@pptx-studio/text` uses in the browser, so the two renderers cannot fall back
-differently, and the substitution is reported rather than hidden. A code point
-no indexed face can draw is reported too.
+differently, and the substitution is reported rather than hidden. The chain is
+that table's entry for the name, then Calibri and Carlito — what PowerPoint
+itself falls back to, measured 22 of 22 in
+[ADR 0033](../../docs/adr/phase-3-text/0033-font-substitution-and-the-guard.md) —
+then the family the asked-for name is a variation of, so `Calibri Light` draws
+in Calibri where the machine has it.
+
+Past all of those the first family by name draws the run. The browser's stack
+ends in a generic and this has none, so something has to be chosen, and it is
+chosen by name rather than by the order the files were read in: two machines
+holding the same faces answer identically. It is still reported as a
+substitution, under the name the deck asked for. **`CLI_NO_FACE` is thrown only
+when no font was found at all** — an empty library is nothing to draw with,
+which is a different thing from an unusual typeface. A code point no indexed
+face can draw is reported too.
 
 | flag                |                                                                     |
 | ------------------- | ------------------------------------------------------------------- |
@@ -251,6 +274,37 @@ no indexed face can draw is reported too.
 | `--no-system-fonts` | do not look in this platform's own font directories                 |
 | `--no-text`         | geometry only                                                       |
 | `--json`            | what was drawn, and which face drew each typeface                   |
+| `--quiet`           | no summary after writing                                            |
+
+### From a program
+
+`renderDeck` is what the verb runs, without the file handling: it takes bytes and
+returns the markup. Every option has a default, so the smallest call is the deck and
+nothing else.
+
+```ts
+import { renderDeck } from '@pptx-studio/cli';
+
+const deck = renderDeck(bytes); // every slide, 1920 wide
+const thumb = renderDeck(bytes, { slide: 1, width: 640 }).slides[0]?.svg;
+const shape = renderDeck(bytes, { text: false }); // geometry only, no fonts read
+```
+
+| option        | default     |                                                             |
+| ------------- | ----------- | ----------------------------------------------------------- |
+| `slide`       | every slide | 1-based; `null` and omitted both mean every slide           |
+| `width`       | `1920`      | the `width` attribute; the height follows the deck's aspect |
+| `fontDirs`    | none        | searched before the platform's own                          |
+| `systemFonts` | `true`      | also look in this platform's font directories               |
+| `text`        | `true`      | `false` draws geometry only and asks no font questions      |
+
+`--out`, `--json` and `--quiet` are the command's, not the library's: they say where
+the markup goes and what is printed about it. `runRender` takes those, reads the deck
+off the disk and writes the files. `renderDeck` does neither, and a width that is not
+a positive whole number throws `CLI_WIDTH` rather than drawing an empty picture.
+
+Fonts are indexed per call, so a server rendering many decks pays for the scan every
+time.
 
 ### What it does not do
 

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as main } from "./main-DLx2onii.js";
+import { t as main } from "./main-CQsGTsfq.js";
 //#region src/cli.ts
 /**
 * The bin.

package/dist/index.d.ts

@@ -60,6 +60,30 @@ declare function runInspect(path: string, options: InspectOptions, write: (text:
  * against Chromium in experiment T13 rather than taken from the specification.
  * ADR 0042.
  */
+/**
+ * The rasteriser a Chromium reads a face's vertical metrics through.
+ *
+ * T13 scored `usWin` 24/24 against DirectWrite on fonts built to disagree, and
+ * T14 scored `hhea` 79/79 against FreeType on real faces where `usWin` reaches
+ * 76/79. One reader cannot answer both. ADR 0045.
+ */
+type FontBackend = 'directwrite' | 'freetype';
+/** FreeType on Linux, DirectWrite elsewhere. macOS is unmeasured. ADR 0045. */
+declare function backendFor(platform: string): FontBackend;
+/** One ascent and descent in font units, the descent positive below the baseline. */
+interface MetricPair {
+  readonly ascent: number;
+  readonly descent: number;
+}
+/** Every pair a browser could report a face box from, each as its table wrote it. */
+interface MetricCandidates {
+  readonly hhea: MetricPair;
+  /** `undefined` on a face with no `OS/2` table long enough to hold version 0. */
+  readonly usWin: MetricPair | undefined;
+  readonly sTypo: MetricPair | undefined;
+  /** `OS/2.fsSelection` bit 7, USE_TYPO_METRICS. */
+  readonly useTypoMetrics: boolean;
+}
 interface FaceMetrics {
   /** `head.unitsPerEm`, the denominator of every number here. */
   readonly unitsPerEm: number;
@@ -68,7 +92,11 @@ interface FaceMetrics {
   /** Below the baseline, in font units, positive. */
   readonly descent: number;
   /** Which table `ascent` and `descent` came out of, for the diagnostics. */
-  readonly source: 'usWin' | 'sTypo';
+  readonly source: 'hhea' | 'usWin' | 'sTypo';
+  /** The `BASE` `ideo` coordinate under `DFLT`, in font units below the baseline. */
+  readonly ideographic: number | undefined;
+  /** The pairs `ascent` and `descent` were chosen from, so a rival reading is scorable. */
+  readonly candidates: MetricCandidates;
 }
 interface Face {
   /** `name` ID 1, which is what PowerPoint matches a typeface on. */
@@ -86,7 +114,7 @@ interface Face {
   kernBetween(left: number, right: number): number;
 }
 /** Every face in a file, which is one unless the file is a collection. */
-declare function facesIn(bytes: Uint8Array, subject: string): readonly Face[];
+declare function facesIn(bytes: Uint8Array, subject: string, backend: FontBackend): readonly Face[];
 //#endregion
 //#region src/render/faces.d.ts
 /** Where fonts live on this platform, whether or not the directories exist. */
@@ -154,23 +182,26 @@ declare function createFontMeasurer(library: FontLibrary): FontMeasurer;
 //#region src/render/render.d.ts
 /** What a slide is drawn at when the caller says nothing. PowerPoint's own. */
 declare const DEFAULT_WIDTH = 1920;
-interface RenderOptions {
-  /** 1-based, or `null` for every slide. */
-  readonly slide: number | null;
-  readonly width: number;
+/** What to draw. Every field has a default, so `renderDeck(bytes)` is a whole call. */
+interface RenderDeckOptions {
+  /** 1-based. Omitted, or `null`, is every slide. */
+  readonly slide?: number | null;
+  /** The `width` attribute in CSS pixels; the height follows the deck's aspect. */
+  readonly width?: number;
+  /** Searched before the platform's own, so a face can be overridden without installing it. */
+  readonly fontDirs?: readonly string[];
+  /** Also look in this platform's font directories. Default true. */
+  readonly systemFonts?: boolean;
+  /** Draw text. `false` draws geometry only and asks no font questions. Default true. */
+  readonly text?: boolean;
+}
+/** What the verb adds: where the markup goes, and what is said about it. */
+interface RenderOptions extends RenderDeckOptions {
   /** A directory for many slides, a file for one, or `null` for stdout. */
   readonly out: string | null;
-  readonly fontDirs: readonly string[];
-  readonly systemFonts: boolean;
-  readonly text: boolean;
   readonly json: boolean;
   readonly quiet: boolean;
 }
-declare const RENDER_DEFAULTS: {
-  readonly width: 1920;
-  readonly systemFonts: true;
-  readonly text: true;
-};
 interface RenderedSlide {
   /** 1-based, as the flag and the file name spell it. */
   readonly number: number;
@@ -190,10 +221,10 @@ interface RenderResult {
 /**
  * Render a deck that is already in memory.
  *
- * Separate from `runRender` so that the whole pipeline is exercised by the test
- * suite without a file system, a process or a captured stdout.
+ * The library entry point: no file system, no process, no stdout. `runRender` is
+ * the verb wrapped around it, and the three fields it adds are its own.
  */
-declare function renderDeck(bytes: Uint8Array, options: RenderOptions): RenderResult;
+declare function renderDeck(bytes: Uint8Array, options?: RenderDeckOptions): RenderResult;
 /** Read, render, write, and return an exit code. Never calls `process.exit`. */
 declare function runRender(file: string, options: RenderOptions, out: (text: string) => void): number;
 //#endregion
@@ -216,6 +247,8 @@ type RenderErrorCode =
 'CLI_FONT_SIZE' |
 /** A slide index outside the deck. */
 'CLI_NO_SLIDE' |
+/** A width that is not a positive whole number of pixels. */
+'CLI_WIDTH' |
 /** An output path that names no directory, or a directory that is a file. */
 'CLI_OUTPUT_PATH';
 declare const RENDER_ERROR_CODES: readonly RenderErrorCode[];
@@ -228,5 +261,5 @@ declare class RenderError extends Error {
 }
 declare function isRenderError(error: unknown): error is RenderError;
 //#endregion
-export { DEFAULT_WIDTH, type Face, type FaceUse, type FontLibrary, type FontMeasurer, INSPECT_DEFAULTS, type InspectOptions, type InspectResult, RENDER_DEFAULTS, RENDER_ERROR_CODES, RenderError, type RenderErrorCode, type RenderOptions, type RenderResult, type RenderedSlide, type Streams, createFontMeasurer, facesIn, indexFonts, inspectFile, isRenderError, main, renderDeck, runInspect, runRender, systemFontDirectories };
+export { DEFAULT_WIDTH, type Face, type FaceUse, type FontBackend, type FontLibrary, type FontMeasurer, INSPECT_DEFAULTS, type InspectOptions, type InspectResult, RENDER_ERROR_CODES, type RenderDeckOptions, RenderError, type RenderErrorCode, type RenderOptions, type RenderResult, type RenderedSlide, type Streams, backendFor, createFontMeasurer, facesIn, indexFonts, inspectFile, isRenderError, main, renderDeck, runInspect, runRender, systemFontDirectories };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/main.ts","../src/inspect.ts","../src/render/sfnt.ts","../src/render/faces.ts","../src/render/measure.ts","../src/render/render.ts","../src/render/errors.ts"],"mappings":";;;UA0HiB;WACN,MAAM;WACN,MAAM;;;iBASD,KAAK,yBAAyB,UAAS;;;;;;;;;;;;;;;UCrHtC;WACN;WACA;WACA;WACA;;WAEA;;cAGE,kBAAkB;UAQd;WACN,QAAQ;WACR;;;;;;;;;;WAUA;;;iBAIK,YACd,cACA,UAAS,iBACR;;iBAiBa,WACd,cACA,SAAS,gBACT,QAAQ;;;;;;;;;;;;;UCpDO;;WAEN;;WAEA;;WAEA;;WAEA;;UAGM;;WAEN;;WAEA;;WAEA;WACA,SAAS;WACT;WACA;;EAET,UAAU;;EAEV,YAAY,cAAc;;;iBAqdZ,QAAQ,OAAO,YAAY,2BAA2B;;;;iBCnetD,sBAAsB;UAuCrB;WACN,MAAM;WACN;;;UAIM;WACN,MAAM;;WAEN;;WAEA;WACA;WACA;;UAGM;;WAEN,kBAAkB;;WAElB;EACT,QAAQ,gBAAgB,eAAe,kBAAkB;;UAG1C;;WAEN;;WAEA;WACA;;;;;;;;;iBAoBK,WAAW,UAAS,eAAoB;;;UCxEvC;WACN;WACA;WACA;WACA;;UAGM;WACN,UAAU;WACV,SAAS;;EAElB,iBAAiB;;EAEjB;;;;;;;;iBASc,mBAAmB,SAAS,cAAc;;;;cC9C7C;UAEI;;WAEN;WACA;;WAEA;WACA;WACA;WACA;WACA;WACA;;cAGE;;;;;UAMI;;WAEN;WACA;;UAGM;WACN,iBAAiB;WACjB;WACA;;WAEA,gBAAgB;;WAEhB;WACA;WACA;;;;;;;;iBAoBK,WAAW,OAAO,YAAY,SAAS,gBAAgB;;iBAuIvD,UACd,cACA,SAAS,eACT,MAAM;;;;;;;;;;KCjNI;;;;;;;;;;;;;cAcC,6BAA6B;cAS7B,oBAAoB;WACb;WACT,MAAM;;WAEN;EAEG,YAAA,MAAM,iBAAiB,iBAAiB;;iBAOtC,cAAc,iBAAiB,SAAS"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/main.ts","../src/inspect.ts","../src/render/sfnt.ts","../src/render/faces.ts","../src/render/measure.ts","../src/render/render.ts","../src/render/errors.ts"],"mappings":";;;UAgIiB;WACN,MAAM;WACN,MAAM;;;iBASD,KAAK,yBAAyB,UAAS;;;;;;;;;;;;;;;UC3HtC;WACN;WACA;WACA;WACA;;WAEA;;cAGE,kBAAkB;UAQd;WACN,QAAQ;WACR;;;;;;;;;;WAUA;;;iBAIK,YACd,cACA,UAAS,iBACR;;iBAiBa,WACd,cACA,SAAS,gBACT,QAAQ;;;;;;;;;;;;;;;;;;;;KC7CE;;iBAGI,WAAW,mBAAmB;;UAK7B;WACN;WACA;;;UAIM;WACN,MAAM;;WAEN,OAAO;WACP,OAAO;;WAEP;;UAGM;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA,YAAY;;UAGN;;WAEN;;WAEA;;WAEA;WACA,SAAS;WACT;WACA;;EAET,UAAU;;EAEV,YAAY,cAAc;;;iBAgjBZ,QAAQ,OAAO,YAAY,iBAAiB,SAAS,uBAAuB;;;;iBC1lB5E,sBAAsB;UAyCrB;WACN,MAAM;WACN;;;UAIM;WACN,MAAM;;WAEN;;WAEA;WACA;WACA;;UAGM;;WAEN,kBAAkB;;WAElB;EACT,QAAQ,gBAAgB,eAAe,kBAAkB;;UAG1C;;WAEN;;WAEA;WACA;;;;;;;;;iBAuDK,WAAW,UAAS,eAAoB;;;UCtHvC;WACN;WACA;WACA;WACA;;UAGM;WACN,UAAU;WACV,SAAS;;EAElB,iBAAiB;;EAEjB;;;;;;;;iBASc,mBAAmB,SAAS,cAAc;;;;cC3C7C;;UAGI;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA;;;UAIM,sBAAsB;;WAE5B;WACA;WACA;;UAQM;;WAEN;WACA;;UAGM;WACN,iBAAiB;WACjB;WACA;;WAEA,gBAAgB;;WAEhB;WACA;WACA;;;;;;;;iBAoBK,WAAW,OAAO,YAAY,UAAS,oBAAyB;;iBAoJhE,UACd,cACA,SAAS,eACT,MAAM;;;;;;;;;;KCtOI;;;;;;;;;;;;;;;cAgBC,6BAA6B;cAU7B,oBAAoB;WACb;WACT,MAAM;;WAEN;EAEG,YAAA,MAAM,iBAAiB,iBAAiB;;iBAOtC,cAAc,iBAAiB,SAAS"}

package/dist/index.js

@@ -1,2 +1,2 @@
-import { a as runRender, c as systemFontDirectories, d as RenderError, f as isRenderError, h as runInspect, i as renderDeck, l as facesIn, m as inspectFile, n as DEFAULT_WIDTH, o as createFontMeasurer, p as INSPECT_DEFAULTS, r as RENDER_DEFAULTS, s as indexFonts, t as main, u as RENDER_ERROR_CODES } from "./main-DLx2onii.js";
-export { DEFAULT_WIDTH, INSPECT_DEFAULTS, RENDER_DEFAULTS, RENDER_ERROR_CODES, RenderError, createFontMeasurer, facesIn, indexFonts, inspectFile, isRenderError, main, renderDeck, runInspect, runRender, systemFontDirectories };
+import { a as createFontMeasurer, c as backendFor, d as RenderError, f as isRenderError, h as runInspect, i as runRender, l as facesIn, m as inspectFile, n as DEFAULT_WIDTH, o as indexFonts, p as INSPECT_DEFAULTS, r as renderDeck, s as systemFontDirectories, t as main, u as RENDER_ERROR_CODES } from "./main-CQsGTsfq.js";
+export { DEFAULT_WIDTH, INSPECT_DEFAULTS, RENDER_ERROR_CODES, RenderError, backendFor, createFontMeasurer, facesIn, indexFonts, inspectFile, isRenderError, main, renderDeck, runInspect, runRender, systemFontDirectories };