@aseity/idocs-preview 0.0.0-stage → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,50 @@
+# @aseity/idocs-preview
+
+## 0.2.0
+
+### Minor Changes
+
+- Use browser-local fonts for text measurement and Canvas drawing without downloading font files. Remove the font-file mode and the `readFont` / `readFamily` callbacks from the web API, and exclude the native shaping engine from the WASM bundle to reduce its download size. Mathematical symbols retain their embedded fonts. Different installed fonts can change line breaks and pagination.
+- Floating objects (`floats` on a paragraph) now show in the preview: pictures, shapes, text boxes
+  and groups, over or behind the text, turned and flipped about their centres. The display list
+  gains two item kinds, `shape` (SVG path data, filled and/or stroked, with dashes) and `transform`
+  (an SVG matrix around rotated or flipped objects), and the `textbox` story for a text box's glyph
+  runs, whose lines are not in the hit-testing table.
+
+### Patch Changes
+
+- Lines between bordered paragraphs (Word's "between" paragraph border, `w:pBdr/w:between`)
+  now show in the preview: a line between each two adjacent paragraphs that share it, with
+  its spacing above and below, and none above the first or below the last.
+- Numbered and bulleted lists in table cells now show in the preview as lists: their labels
+  count on with the lists outside the table in document order (row by row, cell by cell),
+  and their indents are measured from the cell's text area, as Word does. Converted Word
+  documents keep the numbering of list paragraphs in table cells instead of dropping it.
+- Emphasis marks (Word's `w:em`: dot, comma, circle, under dot) now show in the preview, one
+  per character except spaces. Path items in the display list may carry the role
+  `emphasisMark`.
+- Text set to a fixed width in Word (Fit Text, `w:fitText`) now keeps that width in the
+  preview: wider spacing when the text is shorter, glyphs compressed horizontally when it
+  is longer. Glyph runs in the display list carry `scaleX` when compressed.
+- Tables in table cells now show in the preview as tables: each sits in its cell's text area
+  the way a table sits in the page's text area, the outer row grows to hold it, and a row
+  that runs onto the next page splits the table in it between its rows, as Word does.
+  Converted Word documents keep a table in a cell as a table instead of flattening it into
+  the cell's paragraphs.
+- Character scale and baseline shift (Word's `w:w` and `w:position`) now show in the preview:
+  `scaleX` on a glyph run also carries the character scale, and `baseline` the shift.
+
+## 0.1.0
+
+### Minor Changes
+
+- First public release of the read-only browser preview for DOCX and iDocs source
+  documents.
+
+  - `@aseity/idocs-preview/core`: a headless session that converts and lays out documents
+    with Word-calibrated metrics in a Web Worker and returns each page's display list,
+    diagnostics and conversion losses.
+  - `@aseity/idocs-preview/view`: a Canvas page view with virtualized pages, text
+    selection and copying, a find bar, zoom with fit-width support, Ctrl+wheel and
+    pinch zoom around the pointer, and page navigation with optional smooth
+    scrolling.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 iDocs contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,207 @@
-# Temporary Holding Version
+# iDocs preview
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Read-only browser preview for Word documents (`.docx`) and iDocs source documents
+(`.idoc`). A Web Worker measures browser-local fonts with Canvas and lays out
+the document in WASM. Canvas draws text using the same font settings. No text
+font downloads or Local Font Access permissions are required. Different installed
+fonts can change line breaks and page counts.
+
+The package ships ES modules, TypeScript declarations, the worker and the WASM
+binary. It has no framework dependency and runs only in browsers.
+
+```sh
+npm install @aseity/idocs-preview
+```
+
+## Local development
+
+```sh
+npm ci
+npm run dev
+```
+
+The build prepends `$CARGO_HOME/bin` (default `~/.cargo/bin`) to its own PATH
+so rustup selects `rust/rust-toolchain.toml`, even when Homebrew Rust comes
+first in your shell. The toolchain file includes the WASM target. No global
+PATH changes or `.env` file are needed. Install rustup and wasm-bindgen CLI
+0.2.128 before building.
+
+## Quick start
+
+```ts
+const { createPreview } = await import("@aseity/idocs-preview/view");
+
+const preview = createPreview(container, {
+  onPageChange: (index, doc) => console.log(`page ${index + 1} of ${doc.pageCount}`),
+  onZoomChange: (zoom) => console.log(`zoomed to ${Math.round(zoom * 100)}%`),
+});
+const doc = await preview.open(bytes, { name: "report.docx" });
+preview.setZoom(preview.view?.fitWidthZoom ?? 1);
+preview.goToPage(2, { behavior: "smooth" });
+preview.destroy();
+```
+
+`container` must have a height; the view fills it and scrolls inside it. Load the
+package lazily on the client (a dynamic `import()` or a client-only component), not
+during server rendering.
+
+## Subpaths
+
+- `@aseity/idocs-preview/core`: the headless session. `createSession()` starts the
+  worker; `session.open(bytes, options)` resolves to a `PreviewDocument` with the
+  pages' display lists, diagnostics and conversion losses.
+- `@aseity/idocs-preview/view`: the reference view. `createPreview(container)`
+  owns a session and a view; `mountPreview(container, doc)` shows a document you
+  opened yourself. Both re-export the core types.
+
+## Opening documents
+
+`open(bytes, { name?, kind?, readResource? })` takes a `Uint8Array` or
+`ArrayBuffer`. The package copies the bytes before transferring them to the worker,
+so the caller can keep using them, for example to download the original.
+
+- `kind` defaults to `docx` for ZIP or OLE bytes or a Word file name, and to `idoc`
+  otherwise.
+- `readResource(path)` resolves images referenced by an `.idoc` file, relative to
+  that file. DOCX images are read from the file itself.
+- A failed open rejects with `PreviewError`, whose `code` is one of
+  `invalid-source`, `layout-failed`, `unsupported-format`, `wasm-unavailable`,
+  `worker-unavailable`, `internal-error`, or a DOCX conversion code
+  (`docx-not-zip`, `docx-encrypted`, `docx-legacy-doc`, `docx-invalid-package`,
+  `docx-strict-ooxml`).
+
+DOCX conversion is lossy: supported floating images, shapes, text boxes and groups
+are preserved as floating objects. Tracked changes, comments and object properties
+outside the model are downgraded or omitted and listed in `conversionLosses`.
+
+### Preview transport
+
+Every open transfers glyph coordinates and text indices in binary buffers.
+Coordinates retain double precision. The painter and hit testing read those
+buffers directly. Page, line, and drawing metadata still use JSON.
+
+Opened previews expose read-only glyph arrays. Indexed glyph objects are
+snapshots; changing one does not change the drawing buffer. Array traversal,
+selection, copying, and JSON serialization remain available.
+
+By default, the view displays the document after every page is ready.
+`createPreview(container, { progressive: true })` shows a provisional first-page
+canvas while later display pages are generated. Full pagination completes before
+any page is sent. Selection and find become available when `open` resolves.
+A failure removes the provisional page.
+
+Headless sessions can receive provisional pages through `open(bytes, { onPage })`.
+Each packet contains a page, the total page count, and cumulative image and glyph
+outline resources. Resource arrays grow as later pages arrive. Resource retries
+can restart delivery from page one. The final promise resolves to the complete
+document. A callback exception rejects its open.
+
+The development page enables progressive delivery with `?progressive=1`.
+There is no `compact` option or legacy JSON-only transport.
+
+## View
+
+- Zoom 1 is 100% (one point is 4/3 CSS pixels), clamped to 0.1–10. `setZoom` keeps
+  the spot at the top of the viewport in place. `view.fitWidthZoom` is the zoom at
+  which the widest page fills the viewport width; the view does not refit by
+  itself.
+- Ctrl+wheel and trackpad pinch zoom around the pointer and report the new zoom
+  through `onZoomChange`. `setZoom` does not call it.
+- `goToPage(index, { behavior })` scrolls a page (0-based) to the top. Pass
+  `"smooth"` to animate, and `"instant"` when the reader prefers reduced motion.
+- Pages are virtualized: only the visible pages and one on either side keep a
+  canvas.
+- Text can be selected and copied. Ctrl+F (Cmd+F on macOS) opens the built-in
+  find bar while the preview has focus. Escape that closes the find bar is marked
+  with `preventDefault()`, so hosts that close their panel on Escape should skip
+  events whose `defaultPrevented` is set.
+
+## Bundlers and hosting
+
+The session creates its worker with `new Worker(new URL("./worker.js",
+import.meta.url), { type: "module" })`, and the WASM glue loads
+`new URL("idocs_wasm_bg.wasm", import.meta.url)`. Vite, webpack and Turbopack
+(Next.js 16) recognize both forms and emit the worker chunk and the WASM asset
+without configuration.
+
+Without a bundler, host the package files at their relative positions and pass the
+addresses: `createPreview(el, { session: { workerUrl, wasmUrl } })`, where
+`workerUrl` points to `dist/core/worker.js` and `wasmUrl` to
+`wasm/idocs_wasm_bg.wasm`.
+
+Use the same package version for the session and its worker. The successful worker
+response carries metadata JSON, a binary glyph buffer, and separate image buffers. Progressive opens send resource deltas and page packets
+before the final response. Custom workers must implement the corresponding
+message variants in `src/core/protocol.ts`.
+
+The worker is a same-origin module worker. Serve the WASM file as
+`application/wasm`. A Content Security Policy needs `script-src
+'wasm-unsafe-eval'` and `worker-src 'self'`.
+
+## Fonts
+
+The web preview uses installed browser fonts. The Worker uses
+OffscreenCanvas `measureText()` for widths and font extents; the view uses the same
+CSS family chain, weight, style and kerning policy with `fillText()`. Missing families
+fall back through the browser's installed fonts. Source text and UTF-16 offsets
+remain available for selection, copying and search. Math continues to use embedded
+KaTeX resources and does not download fonts.
+
+Native snapshots use actual font files. Their line breaks and page counts may
+therefore differ from a browser with different installed fonts.
+
+The WASM build excludes the native font-file feature and HarfRust. There is no
+font-file mode, `readFont` or `readFamily` API. Font file registrations in a document
+do not become network requests. Native builds retain the complete font-file
+resolver, shaping and outline engine. The browser retains the embedded KaTeX
+resources and the parser needed for mathematical outlines.
+
+## Profile core document opening
+
+Build separate timing and allocation modules from the repository root. Run Cargo
+inside `rust/` so rustup selects the pinned toolchain. Use wasm-bindgen CLI
+0.2.128 for both modules.
+
+```sh
+(cd rust && cargo build --profile wasm -j 4 -p idocs-wasm --target wasm32-unknown-unknown --features perf-profile)
+wasm-bindgen rust/target/wasm32-unknown-unknown/wasm/idocs_wasm.wasm --target web --out-dir .audit/core-profile/timing --out-name idocs_wasm
+(cd rust && cargo build --profile wasm -j 4 -p idocs-wasm --target wasm32-unknown-unknown --features perf-alloc)
+wasm-bindgen rust/target/wasm32-unknown-unknown/wasm/idocs_wasm.wasm --target web --out-dir .audit/core-profile/alloc --out-name idocs_wasm
+```
+
+Start Vite in another terminal with `cd web && npx vite --host 127.0.0.1 --port
+5174 --strictPort`. Install Playwright and its Chromium browser in your tooling
+environment. If this script cannot resolve `playwright`, set `PLAYWRIGHT_MODULE`
+to its entry module path.
+
+```sh
+node web/scripts/profile-core.mjs path/to/sample.docx path/to/source.idoc
+```
+
+The script uses a blank page without Vite HMR and a fresh, isolated Worker for
+each run. Each Worker uses the real browser Canvas measurements and enables
+`configureProfile`. Runs are sequential and alternate mode order across at least
+five rounds. Stop other builds and benchmarks before measuring.
+
+Input paths and `OUT` resolve relative to the repository root. Configure
+`BASE_URL`, `ROUNDS`, `TIMEOUT_MS`, and `OUT` through environment variables.
+`PROFILE_DIRS` is a JSON object mapping mode names to module directories, such as
+`{"before":".audit/before","after":".audit/after"}`. Vite must allow access to
+these files and inputs through `/@fs`. The default output is
+`.audit/core-profile/results.json`. Each row includes the complete profile,
+elapsed milliseconds, a combined SHA-256 of metadata, glyph buffers, and images,
+page and conversion loss counts,
+diagnostic counts, output bytes, and WASM memory capacity.
+
+The elapsed timer covers `openDocument`, including Rust output serialization.
+It excludes module initialization, input fetch, profile retrieval, JavaScript
+JSON parsing, and hashing. Allocation instrumentation adds overhead. Compare
+timings with `perf-profile` builds and allocation counts with `perf-alloc` builds.
+Live allocation bytes measure requested bytes. WASM memory capacity measures
+linear memory reserved by the instance. Neither measures physical memory.
+The allocation counters require a single-threaded, isolated Worker. Normal
+builds leave both profiling features off.
+
+## License
+
+MIT

package/dist/core/display.d.ts

@@ -0,0 +1,180 @@
+/** `textbox`: a floating text box's text (#552), whose lines are not in the hit-testing table. */
+export type Story = 'body' | 'header' | 'footer' | 'footnotes' | 'textbox' | 'lineNumber';
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface GlyphOutline {
+    faceId: string;
+    family: string;
+    glyphId: number;
+    d: string;
+}
+export interface GlyphShape {
+    outline: number;
+    advance: number;
+    xOffset: number;
+    yOffset: number;
+    cluster: number;
+}
+export interface Glyph {
+    shapes?: GlyphShape[];
+    /** Display-only discretionary mark; does not consume source text. */
+    generated?: 'automatic' | 'manual';
+    /** Left edge from the metric profile. */
+    x: number;
+    /** Width occupied in the line, including added spacing. */
+    width: number;
+    text: string;
+    /** UTF-16 offset of the source character within its run's text. */
+    offset: number;
+    /**
+     * No metric profile, stand-in font or local font measured this character:
+     * its width is an estimate, and the painter draws a placeholder box.
+     */
+    unmeasured?: true;
+}
+export interface GlyphRun {
+    kind: 'glyphs';
+    /** `leader` for tab leader characters, which are not part of the line text. */
+    runKind: 'text' | 'leader';
+    story: Story;
+    path: string;
+    role: string;
+    family: string;
+    declaredFamily: string;
+    size: number;
+    bold: boolean;
+    italic: boolean;
+    /** Horizontal scale of each glyph about its left edge: the character scale times a compressing fit-width group's; absent when 1. */
+    scaleX?: number;
+    color: string;
+    baseline: number;
+    lineTop: number;
+    lineHeight: number;
+    /** Read-only in opened previews; indexed glyph objects are snapshots. */
+    glyphs: readonly Glyph[];
+    syntheticSlant?: number;
+}
+export type RectRole = 'areaFill' | 'border' | 'shading' | 'characterBorder' | 'underline' | 'strike' | 'footnoteSeparator' | 'mathRule' | 'pageBorder';
+export interface RectItem extends Rect {
+    kind: 'rect';
+    role: RectRole;
+    color: string;
+}
+export interface LineItem {
+    kind: 'line';
+    role: 'diagonal';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    width: number;
+    color: string;
+}
+export interface ImageItem extends Rect {
+    kind: 'image';
+    /** Index into PreviewDocument.images. */
+    image: number;
+    path: string;
+}
+export interface PathItem {
+    kind: 'path';
+    /** emphasisMark: an emphasis mark, `d` in em about its centre. */
+    role: 'mathGlyph' | 'mathPath' | 'emphasisMark';
+    d: string;
+    transform: [number, number, number, number, number, number];
+    color: string;
+    clip?: Rect;
+    glyph?: {
+        file: string;
+        char: string;
+        size: number;
+        text?: {
+            browser?: {
+                family: string;
+                declaredFamily: string;
+                bold: boolean;
+                italic: boolean;
+            };
+            standIn: {
+                strokeEm?: number;
+            };
+            width: number;
+            height: number;
+            depth: number;
+        };
+    };
+}
+export interface ClipItem {
+    kind: 'clip';
+    rect: Rect;
+    items: DisplayItem[];
+}
+export interface TurnItem {
+    kind: 'turn';
+    x: number;
+    y: number;
+    items: DisplayItem[];
+}
+/** A floating object's geometry (#552): SVG path data in page coordinates, filled, stroked or both. */
+export interface ShapeItem {
+    kind: 'shape';
+    path: string;
+    d: string;
+    fill?: string | {
+        width: number;
+        height: number;
+        foreground: string;
+        background: string;
+        rects: [number, number, number, number][];
+    };
+    /** Centred on the path; `dash` lengths in points, absent for a solid line. */
+    stroke?: {
+        width: number;
+        color: string;
+        dash?: number[];
+    };
+}
+/** Items mapped by `matrix` [a, b, c, d, e, f] (SVG `matrix`): a floating object's rotation and flips (#552). */
+export interface TransformItem {
+    kind: 'transform';
+    matrix: [number, number, number, number, number, number];
+    items: DisplayItem[];
+}
+export type DisplayItem = GlyphRun | RectItem | LineItem | ImageItem | PathItem | ShapeItem | ClipItem | TurnItem | TransformItem;
+export interface LineGlyph {
+    x: number;
+    /** UTF-16 offset within the line's text. */
+    offset: number;
+}
+/** One laid-out line's glyph table, for hit testing. */
+export interface TextLine {
+    story: Story;
+    path: string;
+    index: number;
+    x: number;
+    width: number;
+    top: number;
+    height: number;
+    baseline: number;
+    /** Extent of the text above and below `baseline` (the line box less its leading). */
+    ascent: number;
+    descent: number;
+    /** UTF-16 offset of the line start in its story's text. */
+    offset: number;
+    text: string;
+    /** Read-only in opened previews; indexed glyph objects are snapshots. */
+    glyphs: readonly LineGlyph[];
+    turn?: [number, number];
+}
+export interface DisplayPage {
+    number: number;
+    label?: string;
+    width: number;
+    height: number;
+    items: DisplayItem[];
+    lines: TextLine[];
+}

package/dist/core/display.js

@@ -0,0 +1,4 @@
+// Display list types (#442). The Rust definitions in
+// rust/idocs-core/src/display/mod.rs are authoritative; coordinates are points,
+// origin at the page's top-left corner, y down. Item order is drawing order.
+export {};

package/dist/core/engine.d.ts

@@ -0,0 +1,9 @@
+import { type Measure } from './fonts.js';
+import type { Endpoint } from './protocol.js';
+export interface ServeOptions {
+    /** The wasm module bytes or address; defaults to the file next to the glue. */
+    wasm?: BufferSource | URL | string;
+    /** Browser font metrics; defaults to OffscreenCanvas. null disables measurement and causes open to fail. */
+    measure?: Measure | null;
+}
+export declare function serve(endpoint: Endpoint, options?: ServeOptions): void;

package/dist/core/engine.js

@@ -0,0 +1,81 @@
+// The Worker side: owns the wasm instance and answers the protocol in
+// protocol.ts. `serve` takes any message endpoint, so Node tests run the same
+// code behind a MessageChannel. Layout is synchronous inside one wasm call;
+// resources the host has not answered yet come back as `needs`, and the open
+// is retried once they arrive.
+import init, { openDocument } from '../../wasm/idocs_wasm.js';
+import { canvasMeasure } from './fonts.js';
+export function serve(endpoint, options = {}) {
+    let ready;
+    const start = (wasm = options.wasm) => (ready ??= init(wasm === undefined ? undefined : { module_or_path: wasm }));
+    const measure = options.measure === undefined ? canvasMeasure() : (options.measure ?? undefined);
+    const pending = new Map();
+    const post = (message, transfer = []) => endpoint.postMessage(message, transfer);
+    const attempt = (id) => {
+        const job = pending.get(id);
+        if (!job)
+            return;
+        let outcome;
+        try {
+            if (!measure)
+                throw new Error('Browser font measurement requires OffscreenCanvas 2D');
+            if (job.progressive)
+                post({ type: 'pageReset', id });
+            const onPage = job.progressive ? (packet) => {
+                post({ type: 'page', id, ...packet }, [packet.data.buffer, ...packet.images.map(bytes => bytes.buffer)]);
+            } : undefined;
+            outcome = openDocument(job.kind, job.bytes, job.name, job.assets, measure, onPage);
+        }
+        catch (error) {
+            pending.delete(id);
+            post({ type: 'failed', id, error: { code: 'internal-error', message: String(error), diagnostics: [] } });
+            return;
+        }
+        if (outcome.status === 'needs') {
+            post({ type: 'needs', id, needs: JSON.parse(outcome.json) });
+            return;
+        }
+        pending.delete(id);
+        if (outcome.status === 'failed') {
+            post({ type: 'failed', id, error: JSON.parse(outcome.json) });
+            return;
+        }
+        post({ type: 'opened', id, json: outcome.json, images: outcome.images, data: outcome.data }, [outcome.data.buffer, ...outcome.images.map((bytes) => bytes.buffer)]);
+    };
+    endpoint.addEventListener('message', async (event) => {
+        const message = event.data;
+        if (message.type === 'init') {
+            // Start fetching early; a failure is reported to the first open.
+            start(message.wasmUrl).catch(() => { });
+            return;
+        }
+        try {
+            await start();
+        }
+        catch (error) {
+            const id = 'id' in message ? message.id : -1;
+            pending.delete(id);
+            post({ type: 'failed', id, error: { code: 'wasm-unavailable', message: String(error), diagnostics: [] } });
+            return;
+        }
+        if (message.type === 'open') {
+            pending.set(message.id, {
+                kind: message.kind,
+                progressive: message.progressive ?? false,
+                name: message.name,
+                bytes: message.bytes,
+                assets: new Map(),
+            });
+        }
+        else if (message.type === 'resources') {
+            const job = pending.get(message.id);
+            if (!job)
+                return;
+            for (const { need, bytes } of message.answers) {
+                job.assets.set(need.name, bytes);
+            }
+        }
+        attempt(message.id);
+    });
+    endpoint.start?.();
+}

package/dist/core/fonts.d.ts

@@ -0,0 +1,27 @@
+import type { GlyphRun } from './display.js';
+export declare const CANVAS_TEXT_LANGUAGE = "und";
+export type FontChainInput = Pick<GlyphRun, 'family' | 'declaredFamily' | 'role'>;
+/**
+ * The CSS font families to draw `run` with, most preferred first; the last is
+ * always a generic family. When layout measured the declared family itself,
+ * it leads, then the look-alikes of the Word family it names. When the
+ * selected family differs from the declared family, layout measured a fallback face:
+ * that face and its look-alikes lead, so glyphs are drawn as wide as they
+ * were placed, and the declared family only covers characters they lack.
+ */
+export declare function fontChain(run: FontChainInput): string[];
+export type CanvasFontInput = FontChainInput & Pick<GlyphRun, 'size' | 'bold' | 'italic'>;
+/**
+ * The `CanvasRenderingContext2D.font` for `run`, in a context whose unit is
+ * one point: the run's size in points, its weight and slant, then the chain.
+ */
+export declare function canvasFont(run: CanvasFontInput): string;
+/** Measurements use the same CSS chain and kerning policy as the Canvas painter. */
+export interface FontMeasurement {
+    width: number;
+    ascent: number;
+    descent: number;
+}
+export type Measure = (family: string, declaredFamily: string, bold: boolean, italic: boolean, text: string, kern?: boolean) => number | FontMeasurement;
+/** Browser-local fonts only: this neither fetches files nor requests Local Font Access. */
+export declare function canvasMeasure(): Measure | undefined;