@pptx-studio/cli 0.1.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,154 @@
 # @pptx-studio/cli
 
+## 0.3.0
+
+### Minor Changes
+
+- 3622457: `render` on macOS lays text out on the box CoreText reads: `hhea` whatever `fsSelection` bit 7 says, rounded half up from the em ratio held as 16.16 fixed point, measured 248/248 on `macos-latest`. `FontBackend` gains `coretext` and `FaceMetrics` says which backend it was read for.
+- 55f3073: `pptx-studio render` writes the face it measured a run in into the markup, and reads the face box
+  the way the browser reports it.
+
+  The SVG said `font-family="Calibri Light"` and nothing else, so a viewer picked its own face while
+  the line breaks and origins had been computed for whatever stood in — the one place the two
+  renderers could still disagree about what was drawn, open since ADR 0044. Every run now carries a
+  list: the face this machine drew it in, then the face the deck asked for, then the substitution
+  table's entry, then Calibri and Carlito, then `sans-serif`. `Calibri Light` drawn in Carlito reads
+  `"Carlito", "Calibri Light", "Calibri", sans-serif`; a face the machine has leads its own list.
+
+  `FontMeasurer` gains `cssFamilyFor`, answered from the resolved-face cache the measurer already
+  filled, so it cannot name a face other than the one that measured. A face whose name cannot be
+  written into a CSS shorthand is no longer claimed by the index, as a blank name already was not.
+
+  The face box is rounded half up to a whole pixel at the size the browser reads it, and the
+  ideographic baseline of a face with no `BASE` table is that rounded descent: T13 on a 2048 and a
+  2000 em, 28 of 28 and 36 of 36, where the exact fraction scores 25 and 34. ADR 0052.
+
+### Patch Changes
+
+- 55f3073: The help text spells `this platform's own font directories` with its apostrophe, and the
+  `render-dom` tarball carries `CHANGELOG.md` like the other eleven.
+- Updated dependencies [55f3073]
+  - @pptx-studio/render-svg@0.2.0
+  - @pptx-studio/text@0.2.0
+
+## 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,39 @@ 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
+fifteen fonts built so their tables disagree on purpose, 540 widths measured in
+Chromium, and the reader reproduces **all 540 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 — and
+that the box itself is reported in whole pixels, each side rounded half up at
+the size it is read, which three probes on a 2048, a 2000 and a 2560 em are the
+only ones able to show. 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`; through CoreText it reports `hhea` whatever bit 7 says. No
+one reading fits two of them: T13's probes score 15/15, 7/15 and 6/15 on
+Windows, where 94 faces score 94/94 on Linux and 248 score 248/248 on macOS,
+the rivals missing by up to 100 px on a 1000 px em. CoreText also holds the em
+ratio as 16.16 fixed point before it rounds, which moves a box that sits exactly
+on the half; DirectWrite and FreeType do not. See
+[ADR 0045](../../docs/adr/phase-3-text/0045-the-face-box-belongs-to-the-rasteriser.md)
+and [ADR 0053](../../docs/adr/phase-3-text/0053-what-linux-and-macos-said.md).
+
+Each reading is measured on its own runner, so a slide is laid out for the
+machine that renders it. Line breaks, line origins and word spacing are
+written into the SVG with that machine's advances, and a viewer flows each
+line's glyphs with its own, so a deck rendered on a Linux server and opened on a
+Windows desktop differs by whatever the two rasterisers disagree by — a rounding
+per glyph on the same face, and the whole difference between two faces where
+the viewer picks another from the list. Opened on the machine that made it, the
+file draws exactly what was measured.
+
 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 +264,36 @@ 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.
+
+**The markup names the face that measured it.** Every run's `font-family` is a
+list, not a name: the face this machine drew the run in, then the face the deck
+asked for, then the substitution table's entry, then Calibri and Carlito, then
+`sans-serif`. `Calibri Light` drawn in Carlito comes out as
+`"Carlito", "Calibri Light", "Calibri", sans-serif`; a face the machine has
+leads its own list, so on a machine holding the deck's fonts the markup reads as
+the deck does. The order is the point. Line breaks and line origins are written
+into the SVG with the first face's advances, so a viewer that has it draws
+exactly what was measured; one that has only the face the deck named draws the
+author's face on positions computed for a stand-in, which is right where the two
+are metric-compatible and approximate where they are not; and one that has
+neither lands where PowerPoint would have rather than on the browser's own
+default. `--json` pairs each `asked` with its `drawn`: the drawn face leads that
+run's list, and the asked one follows it wherever the two differ.
 
 | flag                |                                                                     |
 | ------------------- | ------------------------------------------------------------------- |
@@ -251,6 +304,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-3sNR_Xlp.js";
 //#region src/cli.ts
 /**
 * The bin.

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { PackageCensus } from "@pptx-studio/census";
-import { FaceBoxProbe, TextMeasurer } from "@pptx-studio/text";
+import { FaceBoxProbe, RunFont, TextMeasurer } from "@pptx-studio/text";
 //#region src/main.d.ts
 interface Streams {
   readonly out: (text: string) => void;
@@ -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` 30/30 against DirectWrite on fonts built to disagree; T14
+ * scored `hhea` 94/94 against FreeType and 248/248 against CoreText on real
+ * faces. One reader cannot answer for all three. ADR 0045, ADR 0053.
+ */
+type FontBackend = 'directwrite' | 'freetype' | 'coretext';
+/** FreeType on Linux, CoreText on macOS, DirectWrite elsewhere. ADR 0045, ADR 0053. */
+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,13 @@ 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 rasteriser `source` was chosen for, which also fixes how the box rounds. */
+  readonly backend: FontBackend;
+  /** 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 +116,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. */
@@ -138,6 +168,8 @@ interface FaceUse {
 interface FontMeasurer {
   readonly measurer: TextMeasurer;
   readonly faceBox: FaceBoxProbe;
+  /** The CSS family list a run is drawn in: the face that measured it, then the deck's own stack. */
+  readonly cssFamilyFor: (font: RunFont) => string;
   /** Every typeface asked for, and what it was drawn in. */
   used(): readonly FaceUse[];
   /** Code points no face in the library could draw. */
@@ -154,23 +186,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 +225,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 +251,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 +265,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":";;;UAyHiB;WACN,MAAM;WACN,MAAM;;;iBASD,KAAK,yBAAyB,UAAS;;;;;;;;;;;;;;;UCpHtC;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;;UAO7B;WACN;WACA;;;UAIM;WACN,MAAM;;WAEN,OAAO;WACP,OAAO;;WAEP;;UAGM;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA,SAAS;;WAET;;WAEA,YAAY;;UAGN;;WAEN;;WAEA;;WAEA;WACA,SAAS;WACT;WACA;;EAET,UAAU;;EAEV,YAAY,cAAc;;;iBAyjBZ,QAAQ,OAAO,YAAY,iBAAiB,SAAS,uBAAuB;;;;iBC5lB5E,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;;;UC9GvC;WACN;WACA;WACA;WACA;;UAGM;WACN,UAAU;WACV,SAAS;;WAET,eAAe,MAAM;;EAE9B,iBAAiB;;EAEjB;;;;;;;;iBASc,mBAAmB,SAAS,cAAc;;;;cChE7C;;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;;iBAqJhE,UACd,cACA,SAAS,eACT,MAAM;;;;;;;;;;KCvOI;;;;;;;;;;;;;;;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-3sNR_Xlp.js";
+export { DEFAULT_WIDTH, INSPECT_DEFAULTS, RENDER_ERROR_CODES, RenderError, backendFor, createFontMeasurer, facesIn, indexFonts, inspectFile, isRenderError, main, renderDeck, runInspect, runRender, systemFontDirectories };