@laminapdf/sdk 0.0.0-stage → 0.2.0-alpha.2

package/README.md

@@ -1,3 +1,209 @@
-# Temporary Holding Version
+# `@laminapdf/sdk`
 
-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.
+Create, read, edit and save PDFs from TypeScript. Lamina PDF's Rust core runs as WebAssembly, so after one `await init()` the API is synchronous and the same in browsers, Node, Deno, Bun and Cloudflare Workers.
+
+```ts
+import { Document, init } from "@laminapdf/sdk";
+
+await init();
+const doc = Document.open(bytes);
+console.log(doc.pageCount);
+```
+
+The package is ESM only. It isn't published to npm yet.
+
+## Quick start
+
+```ts
+import { Builder, Document, Font, init } from "@laminapdf/sdk";
+
+await init({ text: true }); // the base module, and the text module for fonts and text
+
+// Generate
+const b = new Builder({ producer: "my app" });
+const page = b.page("A4");
+page.surface().text("Hello, world!", { font: Font.standard("Helvetica"), size: 24, at: [72, 96] });
+page.finish();
+const bytes: Uint8Array = b.finish().save();
+
+// Read and edit
+const doc = Document.open(bytes);
+doc.transact((tx) => tx.setInfo({ title: "Hello" })); // synchronous: collected ops are applied as one transaction
+const edited = doc.save({ mode: "incremental" }); // the original bytes, then one appended revision
+doc.free();
+```
+
+Coordinates are in page space: points from the top-left of the displayed page, with y going down. A text run's `at[1]` is its baseline. Page indexes start at 0.
+
+## Two modules
+
+| Module | gzip | What it can do |
+| --- | ---: | --- |
+| base (`init()`) | ≈ 373 KB | Open (passwords, limits, strict mode), read pages and Info, warnings, edit with ops (transactions, undo/redo), save (auto, incremental, full rewrite; save jobs); build vector and image pages with links, outline, page labels, metadata |
+| extract (`init({ extract: true })` or `loadExtract()`) | ≈ 526 KB | Everything in base, plus text extraction (`page.text()`) |
+| text (`init({ text: true })` or `loadText()`) | ≈ 1,009 KB | Everything in base, plus fonts (`Font.fromBytes`, the standard 14), shaped text runs and text boxes, and text extraction |
+
+A page that never draws text never downloads the text module. A `Builder` is built in the text module when it is loaded at the time the builder is created (or with `new Builder({ text: true })`); drawing text on a base-module builder throws `text-module-not-loaded`.
+
+## Loading per runtime
+
+`package.json` `exports` resolves one entry per runtime, each with its own loader (no environment sniffing):
+
+| Condition | Entry | How the `.wasm` is loaded |
+| --- | --- | --- |
+| `workerd` | `dist/entry/workerd.js` | `import wasm from "@laminapdf/wasm/lamina_pdf_base.wasm"`: a `WebAssembly.Module` bundled with the Worker (both modules) |
+| `deno`, `browser`, `default` | `dist/index.js` | `new URL("lamina_pdf_base.wasm", import.meta.url)` in the package's loader, fetched and compiled streaming; bundlers emit it as an asset |
+| `node` (Node, Bun) | `dist/entry/node.js` | the file of `@laminapdf/wasm`, read as bytes |
+
+The escape hatch is the input of `init`: a URL or string, a `Response` (or a promise of one), bytes (`ArrayBuffer`, `Uint8Array`) or a compiled `WebAssembly.Module`, for the base module (`init(source)` or `init({ module })`) and the text module (`init({ text: source })` or `loadText(source)`). `init` is idempotent and a failed load can be retried; naming a different source after a module is loaded (or loading) throws `already-initialized`.
+
+**Vite:** exclude the package from dependency pre-bundling, so the `.wasm` files stay next to the JavaScript that loads them:
+
+```ts
+// vite.config.ts
+export default { optimizeDeps: { exclude: ["@laminapdf/sdk"] } };
+```
+
+## Passwords, fonts and images
+
+- A password is tried as given, then (after `wrong-password`) in its NFKC form, so older passwords reach the core unchanged and AES-256 ones match SASLprep's normalisation.
+- Equal fonts are one PDF font per builder: standard 14 fonts by name, others by their bytes, however many `Font` objects name them.
+- `Image` copies its input and decodes it in the module of first use; bad data surfaces there (or when `width`/`height` is read).
+
+## Tagged PDF
+
+`new Builder({ tagged: true })` tags a document before anything is drawn; a page that uses `tag` or `artifact` tags it either way. Structure is drawn with callbacks, as paths and transactions are:
+
+```ts
+s.artifact("pagination", (s) => s.text("Page 1", { font, size: 9, at: [520, 810] }));
+s.text("Invoice 42", { font, size: 24, at: [56, 80], tag: "H1" });
+s.tag("Table", (s) => {
+  s.tag("TR", (s) => {
+    s.text("Item", { font, size: 11, at: [56, 160], tag: { type: "TH", scope: "column" } });
+  });
+});
+s.image(logo, [440, 56, 100, 40], "The Acme logo"); // a Figure with /Alt
+s.text("Pay online", { font, size: 11, at: [56, 320], link: { target, contents: "Pay invoice 42 online" }, tag: "P" });
+```
+
+`tag` takes a standard type (`TagName`) or a `TagSpec` (`{ type, role, alt, actualText, lang, expansion, scope }`; a custom `type` needs the standard `role` it maps to); text and text boxes take a `tag` option; a link inside an element becomes a `Link` element holding its annotation. Elements and artifacts the callback leaves open end with it, also when it throws. Elements are per page.
+
+## Errors and warnings
+
+Every error is a `LaminaPdfError`. Its fields are `code` (one of the `ErrorCode` union), `kind`, `message`, `hint`, `didYouMean`, `location`, `data` (the only place document text appears) and `docsUrl`, a link to the code's page in the [error reference](https://docs.laminapdf.com/reference/codes/). `toJSON()` gives the plain object back.
+
+```ts
+try {
+  Document.open(bytes, { password });
+} catch (e) {
+  if (isLaminaPdfError(e, "wrong-password")) askAgain();
+  else throw e;
+}
+```
+
+`isLaminaPdfError(e, code)` narrows: inside the `if`, `e.code` has the type `"wrong-password"`. `LaminaPdfError<C>` is generic over the `ErrorCode` union, so a `switch (e.code)` with a `never` default is checked for exhaustiveness, and stops compiling when a new code arrives until you handle it. `toJSON()` validates against the `laminapdf.error/1` JSON Schema, shipped as `@laminapdf/sdk/schemas/error.schema.json`.
+
+`doc.warnings` lists what the reader repaired, as `LaminaPdfWarning` objects of the same shape (without `didYouMean`), typed by `WarningCode`.
+
+`@laminapdf/sdk/explain` is a separate entry, kept out of the main bundle: `explain(code)` returns the code's page as Markdown (what happened, why, how to fix, an example, the `data` fields), with `KINDS`, `HINTS` and `docsUrl(code)` for every code.
+
+```ts
+import { explain } from "@laminapdf/sdk/explain";
+if (isLaminaPdfError(e)) console.error(e.message, e.hint, explain(e.code));
+```
+
+## Extracting text
+
+`page.text()` returns a page's text in four forms:
+
+- `lines`: the lines in content order, trimmed.
+- `text()`: the lines joined with `\n`.
+- `runs`: font, size, direction, marked-content ID, `ActualText`, visibility and bounds; `glyphs()` gives each glyph's text and quad.
+- `buffers`: every glyph's quad in one `Float32Array` (8 numbers per glyph, in page space) and the glyph text with UTF-16 offsets, ready to transfer from a Web Worker.
+
+Documents open in the richest module loaded: text, then extract, then base. Load the extract or text module before you open or build a document whose text you need; otherwise `page.text()` throws `extract-module-not-loaded`. `doc.canExtractText` tells which module a document is in.
+
+The text module also extracts text. Once it is loaded, Lamina PDF doesn't load the extract module, and documents live in the text module's memory. In a Cloudflare Worker, pass the module yourself: then only a Cloudflare Worker that extracts text bundles it: `import extract from "@laminapdf/wasm/lamina_pdf_extract.wasm"; await loadExtract(extract);`.
+
+```ts
+await init({ extract: true });
+const doc = Document.open(bytes);
+const text = doc.page(0).text({ skipInvisible: true });
+console.log(text.text());
+```
+
+## Remote and large files
+
+`Document.openRange(source, options)` opens a file whose bytes are fetched range by range, so a remote PDF opens without downloading it whole. Only what the open needs is fetched: the end of the file (the xref), the catalog, the page tree. The document stays synchronous; a call that needs bytes not fetched yet throws `data-pending` with `e.ranges`, and `await doc.ensure(() => …)` fetches them and calls again.
+
+```ts
+const doc = await Document.openRange(httpRangeSource("https://example.com/big.pdf"));
+const pages = await doc.ensure(() => doc.pages);
+const bytes = await doc.ensure(() => doc.save({ mode: "fullRewrite" })); // fetches the rest
+```
+
+- **`httpRangeSource(url, { headers, credentials, signal, blockSize })`:** the first request asks for the last 64 KiB with `Range: bytes=-65536`, which also gives the size. Later requests are aligned to 16 KiB blocks and send `If-Range` with the first strong `ETag` (else `Last-Modified`); a different `ETag`, `Last-Modified` or size fails with `source-changed`. A server without either validator can't be checked: serve one. A server that answers `200` (no range support) is read from that one full download. HTTP errors are `fetch-failed` with `data.status`; the URL never appears in an error.
+- **CORS:** a `Range` header makes a cross-origin request preflighted. The server must answer with `Access-Control-Allow-Headers: Range` and expose `Content-Range`, `Content-Length` and `ETag` (`Access-Control-Expose-Headers`). It must not compress the response: `Content-Encoding` breaks byte ranges.
+- **`callbackSource(size, read)`:** any other random-access input (a `Blob`'s `slice`, a file handle, an IPC call).
+- **Options:** `signal` (for the open; aborting rejects and cancels its requests in flight; `ensure(f, { signal })` takes its own), `blockSize`, `readahead`, `budget` (the most bytes the document may hold; more is `source-budget-exceeded`) and `maxRounds`.
+- **Off the main thread:** each `ensure` call can take several round trips. `client.openUrl` in a Web Worker hides the loop behind its async API (see below).
+- **Large local files in Rust:** the `laminapdf-source` crate's `FileSource` (positioned reads) or, for files nothing changes, `MmapSource`; its rustdoc describes both.
+
+## Off the main thread: `@laminapdf/sdk/worker`
+
+The API is synchronous, so a large file opened on the main thread blocks the page. `@laminapdf/sdk/worker` runs the same API in a Web Worker and gives you async twins of `Document` and its pages.
+
+```ts
+import { connect } from "@laminapdf/sdk/worker";
+
+const client = await connect(); // starts the Web Worker, checks its version, calls init() there
+await using doc = await client.open(bytes); // copied; { transfer: true } moves it instead
+console.log(await doc.pageCount());
+const page = await doc.page(0);
+const text = await page.text(); // a PageText, rebuilt from the transferred arrays (after client.loadExtract())
+const updated = await doc.save({ mode: "incremental" }, { signal, onProgress: (p) => bar(p) });
+```
+
+- **Same names, async:** every served member of `Document` and `PageRef` is a method of the same name returning a `Promise`. Getters become methods: `await doc.pageCount()`. A page is a remote handle too.
+- **Not served:**
+  - `transact`: a callback can't cross to the Web Worker. Use `apply(ops)` instead.
+  - `saveJob`: the remote `save` is a stepped job already.
+  - `ensure`: the Web Worker fetches a range document's bytes itself.
+  - `free`: use `close()` or `await using`.
+  - `Builder`: its callbacks (`path`, `tag`) can't cross either. Build on the main thread or in your own Web Worker.
+
+- **Remote files:** `client.openUrl(url, options)` opens a file by range requests in the Web Worker; every call fetches what it needs first. Its options are `httpRangeSource`'s, without a custom `fetch` (a function can't be sent to the Web Worker), and `openRange`'s (`budget`, `readahead`, `maxRounds`). Aborting the call's `signal` also cancels the fetches in flight.
+- **Cancellation:** pass `signal` to any call. An aborted call rejects at once with `LaminaPdfError` `cancelled`, whose `cause` is the signal's reason, and a late answer is dropped.
+  - **Not started yet:** the call never runs.
+  - **`save` / `saveWithReport`:** they run as stepped jobs and stop at the next step. The document stays usable.
+  - **Every other call:** one synchronous call in the Web Worker, so it can't be stopped midway (`open` included). `client.terminate()` is the hard stop.
+- **Transfers:** `save()` bytes and page text arrays come back transferred. Inputs are copied unless you pass `transfer: true`, which detaches your buffer.
+- **Errors:** errors are `LaminaPdfError` on the main thread, with every field. If the Web Worker crashes (an uncaught error, a WebAssembly trap, out of memory), pending calls reject with `worker-crashed` and `client.on("crashed", …)` fires. `client.restart()` starts a new Web Worker. Calls made while it starts wait for it, and the old Web Worker's handles reject with `disposed` (their `close()` does nothing). `terminate()` doesn't fire `crashed`. There's no heartbeat, so a long call is not a crash.
+- **Unsendable parameters:** a parameter the Web Worker can't receive (a function) rejects with `invalid-argument`, as do unknown methods. With `transfer: true`, only a buffer the input covers whole moves; a subarray or a `SharedArrayBuffer` view is copied. An error inside the Web Worker that isn't Lamina PDF's is `worker-failed` (internal: a bug to report).
+- **`init`:** `connect({ init })` takes what can be sent to a Web Worker: a URL (string or `URL`, resolved against the page), bytes or a `WebAssembly.Module`, alone or as `{ module, text, extract }`. A `Response` can't cross.
+- **Version handshake:** on connect, the Web Worker and the client compare their protocol and package versions. A Web Worker from another build rejects `connect()` with `worker-version-mismatch`.
+- **Bundlers:** `connect()` contains the literal `new Worker(new URL("./entry.js", import.meta.url), { type: "module" })`, which Vite and webpack bundle with no config. In Vite, keep the package out of pre-bundling (`optimizeDeps: { exclude: ["@laminapdf/sdk"] }`), as for the main entry.
+- **CSP or your own hosting:** pass `connect({ worker: () => new Worker(url, { type: "module" }) })`. A factory, so that `restart()` can make a new one.
+- **Runtimes:** browsers (Chromium, Firefox, WebKit), and Deno and Bun Web Workers (smoke-tested). Node's `worker_threads` isn't a web `Worker` and isn't supported.
+- **Extending the Web Worker:** `@laminapdf/sdk/worker/server`'s `serve({ methods })` serves the same protocol with more methods in the same Web Worker. `@laminapdf/viewer` adds its render methods this way.
+  - The page calls them with `client.request(method, params, { priority, key, signal })`.
+  - The Web Worker runs the highest `priority` first, and runs calls with the same `key` once. Each caller still gets its own answer: an extension method's `reply(result)` builds one per caller, so each can be given its own transferables.
+  - `emit(name, data)` in the Web Worker reaches `client.on("event", …)`.
+  - `connect({ onDiscard })` sees the answers of calls already rejected. By default it closes the `ImageBitmap`s in them.
+  - `serve({ methods, saveBudget })` sets how many work units each step of a save takes (20,000 by default). A smaller budget answers a cancel sooner and reports progress more often, at some cost in speed.
+  - `workerStats()` in the Web Worker reports the calls started, the handles the page holds and the calls queued. A handle the page never frees keeps its document's WebAssembly memory alive, so a growing count finds the `RemoteDocument` an app forgot to close.
+  - `Emitter`, from `@laminapdf/sdk/worker`, is the typed event emitter the client uses, for a package that wraps it: `on(event, listener)` returns a function that stops listening, and a listener that throws doesn't stop the others.
+
+## Memory
+
+Documents, builders, pages and images live in WebAssembly memory. `doc.free()` (or `using doc = Document.open(…)`) frees a document at once; `page.finish()` and `builder.finish()` free their own side; the garbage collector frees anything you don't release, through a `FinalizationRegistry`. `wasmMemory()` reports each module's memory size.
+
+## Examples
+
+The [examples](https://docs.laminapdf.com/examples/) are `hello`, `invoice`, `multilingual`, `images-and-vectors`, `links-and-outlines` and `generate-then-edit`, plus `report`, 100 pages with two embedded fonts. Each produces the same bytes as its Rust twin.
+
+A Cloudflare Worker example generates a PDF per request: `/?name=Ada` returns a letter in Helvetica, or a 400 with the error as JSON for a name it can't draw, and `/report` returns the report. The [Cloudflare Workers quick start](https://docs.laminapdf.com/quick-start/workers/) shows it and how to run it.
+
+## Working on this package
+
+How the package is built and tested in every runtime is in `CONTRIBUTING.md`, next to this README in the repository.

package/dist/api.d.ts

@@ -0,0 +1,23 @@
+export type { ArtifactKind, BlendMode, BuilderOptions, FillRule, LineCap, LineJoin, PageSizeName, StrokeStyle, TableScope, Tag, TagName, TagSpec, TextBoxOptions, TextOptions, } from "./builder.js";
+export { Builder, PAGE_SIZES, Page, PendingPath, Surface, TAG_NAMES } from "./builder.js";
+export { Document, PageRef, SaveJob } from "./document.js";
+export type { Diagnostic, ErrorKind, LaminaPdfWarning, Location } from "./errors.js";
+export { isLaminaPdfError, LaminaPdfError } from "./errors.js";
+export type { FontInfo, Standard14 } from "./font.js";
+export { Font, Image } from "./font.js";
+export type { ErrorCode, LimitName, WarningCode } from "./generated/codes.js";
+export type { InitOptions, WasmMemory, WasmSource } from "./init.js";
+export { isExtractLoaded, isInitialized, isTextLoaded, wasmMemory } from "./init.js";
+export type { Transform } from "./matrix.js";
+export { Matrix } from "./matrix.js";
+export type { PathBuilder } from "./path.js";
+export type { HttpRangeOptions } from "./source/http.js";
+export { httpRangeSource } from "./source/http.js";
+export type { ByteRange, RangeOptions, RangeSource } from "./source/range.js";
+export { callbackSource } from "./source/range.js";
+export type { GlyphQuad, QuadPoint, TextGlyph, TextOptions as PageTextOptions } from "./text.js";
+export { PageText, TextRun as PageTextRun } from "./text.js";
+export type { InfoPatch, Rotation } from "./transaction.js";
+export { Transaction } from "./transaction.js";
+export type { AfRelationship, Align, AttachmentOptions, BoxRect, BuildOptions, Color, Direction, DocumentInfo, Edited, Fit, Limits, LineBox, LinkTarget, Metadata, Op, OpenOptions, OpLog, OutlineEntry, Overflow, PageInfo, PageLabel, Point, Profile, Progress, Rect, RenderMode, SaveOptions, SaveReport, TextLayout, TextRunInfo, UndoOutcome, ViewerPreferences, } from "./types.js";
+//# sourceMappingURL=api.d.ts.map

package/dist/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"AAEA,YAAY,EACV,YAAY,EACZ,SAAS,EACT,cAAc,EACd,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,YAAY,EACZ,WAAW,EACX,UAAU,EACV,GAAG,EACH,OAAO,EACP,OAAO,EACP,cAAc,EACd,WAAW,GACZ,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC1F,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC3D,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACrF,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC/D,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACtD,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AACxC,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC9E,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACrF,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,YAAY,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,YAAY,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,WAAW,IAAI,eAAe,EAAE,MAAM,WAAW,CAAC;AACjG,OAAO,EAAE,QAAQ,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7D,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,YAAY,EACV,cAAc,EACd,KAAK,EACL,iBAAiB,EACjB,OAAO,EACP,YAAY,EACZ,KAAK,EACL,SAAS,EACT,YAAY,EACZ,MAAM,EACN,GAAG,EACH,MAAM,EACN,OAAO,EACP,UAAU,EACV,QAAQ,EACR,EAAE,EACF,WAAW,EACX,KAAK,EACL,YAAY,EACZ,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,KAAK,EACL,OAAO,EACP,QAAQ,EACR,IAAI,EACJ,UAAU,EACV,WAAW,EACX,UAAU,EACV,UAAU,EACV,WAAW,EACX,WAAW,EACX,iBAAiB,GAClB,MAAM,YAAY,CAAC"}

package/dist/api.js

@@ -0,0 +1,11 @@
+export { Builder, PAGE_SIZES, Page, PendingPath, Surface, TAG_NAMES } from "./builder.js";
+export { Document, PageRef, SaveJob } from "./document.js";
+export { isLaminaPdfError, LaminaPdfError } from "./errors.js";
+export { Font, Image } from "./font.js";
+export { isExtractLoaded, isInitialized, isTextLoaded, wasmMemory } from "./init.js";
+export { Matrix } from "./matrix.js";
+export { httpRangeSource } from "./source/http.js";
+export { callbackSource } from "./source/range.js";
+export { PageText, TextRun as PageTextRun } from "./text.js";
+export { Transaction } from "./transaction.js";
+//# sourceMappingURL=api.js.map

package/dist/api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.js","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC1F,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE3D,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE/D,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAGxC,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAErF,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAGrC,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EAAE,QAAQ,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7D,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/builder.d.ts

@@ -0,0 +1,319 @@
+import type { WasmPageBuilder as TextPageBuilder, WasmFont } from "@laminapdf/wasm/text";
+import { Document } from "./document.js";
+import type { Font, FontInfo, Image } from "./font.js";
+import { type ArtifactKind, type BlendMode, type FillRule, type LineCap, type LineJoin, type TableScope, type TagName } from "./generated/builder-enums.js";
+import { type BaseGlue, type TextGlue } from "./init.js";
+import type { Transform } from "./matrix.js";
+import { type PathBuilder } from "./path.js";
+import type { Align, AttachmentOptions, BuildOptions, Color, Direction, Fit, LinkTarget, Metadata, OutlineEntry, Overflow, PageLabel, Point, Rect, RenderMode, TextLayout, TextRunInfo, ViewerPreferences } from "./types.js";
+/** Named page sizes (ISO 216 sizes from millimetres, as the Rust `PageSize` computes them). */
+export type PageSizeName = "A0" | "A1" | "A2" | "A3" | "A4" | "A5" | "A6" | "Letter" | "Legal" | "Tabloid";
+/** Each named size in points, width × height. */
+export declare const PAGE_SIZES: Readonly<Record<PageSizeName, readonly [width: number, height: number]>>;
+/** Options for a new {@link Builder}. */
+export interface BuilderOptions extends Omit<BuildOptions, "id"> {
+    /** `/ID[0]`: 16 bytes, as 32 hex digits or a `Uint8Array` (default: derived from the content). */
+    readonly id?: string | Uint8Array;
+    /**
+     * Build in the text module (fonts and text). Default: when it is loaded. `true` without the
+     * text module loaded throws `text-module-not-loaded`.
+     */
+    readonly text?: boolean;
+}
+/** How strokes are drawn. */
+export interface StrokeStyle {
+    /** Line width in points (default 1). */
+    readonly width?: number;
+    /** Line ends (default `butt`). */
+    readonly cap?: LineCap;
+    /** Corners (default `miter`). */
+    readonly join?: LineJoin;
+    /** Miter limit (default 10). */
+    readonly miterLimit?: number;
+    /** Dash pattern in points (default: solid). */
+    readonly dash?: readonly number[];
+    /** Where the dash pattern starts (default 0). */
+    readonly dashPhase?: number;
+}
+export type { ArtifactKind, BlendMode, FillRule, LineCap, LineJoin, TableScope, TagName, } from "./generated/builder-enums.js";
+export { TAG_NAMES } from "./generated/builder-enums.js";
+/** A structure element with attributes; `type` may be a custom name when `role` is given. */
+export interface TagSpec {
+    /** A standard type, or a custom name written with a `RoleMap` entry to `role`. */
+    readonly type: TagName | (string & {});
+    /** The standard type a custom `type` stands for. */
+    readonly role?: TagName;
+    /** `/Alt`: alternate text (a `Figure` needs it). */
+    readonly alt?: string;
+    /** `/ActualText`: the exact text the content stands for. */
+    readonly actualText?: string;
+    /** `/Lang`: the element's language (BCP 47). */
+    readonly lang?: string;
+    /** `/E`: the expansion of an abbreviation. */
+    readonly expansion?: string;
+    /** `/Scope` of a `TH`. */
+    readonly scope?: TableScope;
+}
+/** A structure element: a type, or a type with attributes. */
+export type Tag = TagName | TagSpec;
+/** Options of {@link Surface.text}. */
+export interface TextOptions {
+    /** The font (needs the text module). */
+    readonly font: Font;
+    /** Size in points. */
+    readonly size: number;
+    /** Where the first line starts: `x`, and `y` is the baseline (ADR 0027 §5). */
+    readonly at: Point;
+    /** Fill colour. */
+    readonly fill?: Color;
+    /** Rendering mode (`invisible` for an OCR layer). */
+    readonly renderMode?: RenderMode;
+    /** A link over the run. */
+    readonly link?: {
+        readonly target: LinkTarget;
+        readonly contents?: string;
+    };
+    /** OpenType features (`liga=0`, `smcp`). */
+    readonly features?: readonly string[];
+    /** Language (BCP 47). */
+    readonly language?: string;
+    /** Paragraph direction (default: from the first strong character). */
+    readonly direction?: Direction;
+    /** The structure element the run is (as drawing it inside {@link Surface.tag}). */
+    readonly tag?: Tag;
+}
+/** Options of {@link Surface.textBox}. */
+export interface TextBoxOptions {
+    /** The font (needs the text module). */
+    readonly font: Font;
+    /** Size in points. */
+    readonly size: number;
+    /** The box the lines are broken into. */
+    readonly box: Rect;
+    /** Line alignment (default `start`). */
+    readonly align?: Align;
+    /** Line height as a factor of the size (default 1.2). */
+    readonly lineHeight?: number;
+    /** What happens to text that doesn't fit (default `clip`; `error` throws `text-overflow`). */
+    readonly overflow?: Overflow;
+    /** Paragraph direction. */
+    readonly direction?: Direction;
+    /** Language (BCP 47). */
+    readonly language?: string;
+    /** OpenType features. */
+    readonly features?: readonly string[];
+    /** The structure element the box is (as drawing it inside {@link Surface.tag}). */
+    readonly tag?: Tag;
+}
+/** The raw page of a {@link Page}: freed when the page finishes, `builder-finished` afterwards. */
+declare class LivePage {
+    #private;
+    constructor(raw: TextPageBuilder, onFree: (page: LivePage) => void);
+    get(): TextPageBuilder;
+    free(): void;
+}
+/** A path waiting to be painted: fill it, stroke it, both, or clip to it. */
+export declare class PendingPath {
+    #private;
+    /** @internal */
+    constructor(surface: Surface, page: LivePage, path: Float64Array);
+    /** Fills the path with the fill colour. @returns the surface. */
+    fill(rule?: FillRule): Surface;
+    /** Strokes the path with the stroke colour and `style`. @returns the surface. */
+    stroke(style?: StrokeStyle): Surface;
+    /** Fills, then strokes the path. @returns the surface. */
+    fillStroke(rule?: FillRule, style?: StrokeStyle): Surface;
+    /** Clips what is drawn next to the path, until the next `restore`. @returns the surface. */
+    clip(rule?: FillRule): Surface;
+}
+/**
+ * What a page is drawn with. Methods that set state return the surface, so calls chain; invalid
+ * geometry is reported by {@link Page.finish} (`invalid-geometry`).
+ */
+export declare class Surface {
+    #private;
+    /** @internal */
+    constructor(builder: Builder, page: LivePage);
+    /** Saves the graphics state (`q`). */
+    save(): this;
+    /** Restores the graphics state (`Q`). */
+    restore(): this;
+    /** Applies `matrix` (page space) to what is drawn next. See {@link Matrix}. */
+    transform(matrix: Transform): this;
+    /** The colour fills (and text) use. */
+    fillColor(color: Color): this;
+    /** The colour strokes use. */
+    strokeColor(color: Color): this;
+    /** Fill and stroke opacity, 0 to 1. */
+    opacity(fill: number, stroke: number): this;
+    /** The blend mode. */
+    blendMode(mode: BlendMode): this;
+    /** @internal The stroke style the next stroke uses. */
+    strokeStyle(style: StrokeStyle): void;
+    /**
+     * A path, built by `build`, to paint.
+     *
+     * @example
+     * ```ts
+     * surface.path((p) => p.moveTo(56, 590).lineTo(539, 590)).stroke({ width: 0.5 });
+     * ```
+     */
+    path(build: (p: PathBuilder) => void): PendingPath;
+    /**
+     * Draws `image` scaled into `rect`; with `alt`, as a `Figure` structure element with that
+     * alternate text.
+     */
+    image(image: Image, rect: Rect, alt?: string): this;
+    /**
+     * Draws what `draw` draws inside the structure element `tag`: its text, paths and images
+     * become the element's content, elements opened inside it its children, links its `Link`
+     * children, in reading order. Elements and artifacts `draw` leaves open end with it, also when
+     * it throws. A page using an element makes the document tagged.
+     *
+     * @example
+     * ```ts
+     * s.tag("Sect", (s) => {
+     *   s.text("Results", { font, size: 18, at: [56, 96], tag: "H1" });
+     *   s.tag({ type: "P", lang: "en-GB" }, (s) => s.textBox(summary, { font, size: 11, box }));
+     * });
+     * ```
+     * @throws {@link LaminaPdfError} `invalid-argument` for an unknown type without a `role`.
+     */
+    tag(tag: Tag, draw: (s: this) => void): this;
+    /**
+     * Draws what `draw` draws as an artifact: decoration, running heads and footers, backgrounds;
+     * content outside the structure tree.
+     */
+    artifact(kind: ArtifactKind, draw: (s: this) => void): this;
+    /** A link annotation over `rect`, with `contents` as its alternate text. */
+    link(rect: Rect, target: LinkTarget, contents?: string): this;
+    /**
+     * Draws `text`: shaped, bidi-resolved, one line per line break (needs the text module).
+     *
+     * @returns what the run measures.
+     * @throws {@link LaminaPdfError} `text-module-not-loaded`, `missing-glyph`, `font-not-shapable`, …
+     */
+    text(text: string, options: TextOptions): TextRunInfo;
+    /**
+     * Lays `text` out in `options.box`, breaking lines at Unicode line-break opportunities.
+     *
+     * @returns the lines drawn and where the overflow starts (UTF-16 offsets).
+     * @throws {@link LaminaPdfError} as {@link Surface.text}; `text-overflow` with `overflow: "error"`.
+     */
+    textBox(text: string, options: TextBoxOptions): TextLayout;
+}
+/** A page being drawn: its boxes and rotation, its {@link Surface}, then {@link Page.finish}. */
+export declare class Page {
+    #private;
+    /** @internal */
+    constructor(builder: Builder, page: LivePage);
+    /** What the page is drawn with (the same object on every call). */
+    surface(): Surface;
+    /** `/Rotate`: 0, 90, 180 or 270 degrees. */
+    rotate(degrees: 0 | 90 | 180 | 270): this;
+    /** `/UserUnit`, for pages larger than 14,400 units. */
+    userUnit(unit: number): this;
+    /** `/CropBox` (the visible region), in the media box's page space. */
+    cropBox(rect: Rect): this;
+    /** `/BleedBox`. */
+    bleedBox(rect: Rect): this;
+    /** `/TrimBox`. */
+    trimBox(rect: Rect): this;
+    /** `/ArtBox`. */
+    artBox(rect: Rect): this;
+    /**
+     * Writes the page into its builder and frees the page's WASM side; the page takes no more
+     * drawing afterwards (`builder-finished`).
+     *
+     * @returns the page's ID.
+     * @throws {@link LaminaPdfError} `invalid-geometry`, `builder-finished`.
+     */
+    finish(): string;
+    /** Drops the page without writing it (frees its WASM side). */
+    free(): void;
+}
+/**
+ * Builds a new document: pages, navigation and metadata; {@link Builder.finish} returns a
+ * {@link Document} to save. Created in the text module when it is loaded (or `text: true`),
+ * else in the reading module (text, extract, then base; vector and image pages only).
+ *
+ * @example
+ * ```ts
+ * await init({ text: true });
+ * const b = new Builder({ producer: "my app" });
+ * const page = b.page("A4");
+ * page.surface().text("Hello, world!", { font: Font.standard("Helvetica"), size: 24, at: [72, 96] });
+ * page.finish();
+ * const bytes = b.finish().save();
+ * ```
+ */
+export declare class Builder {
+    #private;
+    /** @internal The module the document is built in. */
+    readonly glue: BaseGlue | TextGlue;
+    /**
+     * @param options - version, file ID, producer, creation date, compression, tagging,
+     *   conformance `profiles`; `text`.
+     * @throws {@link LaminaPdfError} `not-initialized`, `text-module-not-loaded`; `unknown-option`.
+     */
+    constructor(options?: BuilderOptions);
+    /** As `new Builder(options)`. */
+    static create(options?: BuilderOptions): Builder;
+    /** Whether this builder draws in the text module (fonts and text). */
+    get hasText(): boolean;
+    /** A new page of a named size or `[width, height]` in points. */
+    page(size?: PageSizeName | readonly [width: number, height: number]): Page;
+    /**
+     * Registers `font` with this builder (otherwise it is registered at first use).
+     *
+     * @throws {@link LaminaPdfError} `text-module-not-loaded`, `invalid-font`, `font-not-embeddable`.
+     */
+    font(font: Font): FontInfo;
+    /** @internal The font in this builder's instance. */
+    wasmFont(font: Font): WasmFont;
+    /** Defines the named destination `name`: page `index`, shown as `fit` (default: the page). */
+    destination(name: string, index: number, fit?: Fit): this;
+    /** Adds outline (bookmark) items with their children. @returns their IDs, in pre-order. */
+    outline(entries: readonly OutlineEntry[]): string[];
+    /** The page labels (`i, ii, 1, 2…`), ranges by first page; checked at finish. */
+    pageLabels(ranges: readonly PageLabel[]): this;
+    /** The metadata, written as the Info dictionary and an XMP packet. */
+    metadata(metadata: Metadata): this;
+    /** The natural language (`/Lang`), a BCP 47 tag. */
+    lang(tag: string): this;
+    /**
+     * Attaches a file: PDF/A-3b's associated files, such as an e-invoice's XML. The same name
+     * again replaces the file. PDF/A-2b and PDF/A-2u refuse attachments at {@link Builder.finish},
+     * and every PDF/A profile refuses one without a MIME type there.
+     *
+     * @param name - the file name viewers show.
+     * @param bytes - the file's contents.
+     * @param mime - its MIME type, such as `text/xml`.
+     * @param options - how the file relates to the document (`relationship`, default
+     *   `unspecified`), its `description` and `modDate`.
+     * @throws {@link LaminaPdfError} `invalid-argument` for a `modDate` that isn't a PDF date,
+     *   `unknown-option` for an unknown key, `builder-finished` after {@link Builder.finish}.
+     */
+    attach(name: string, bytes: Uint8Array, mime: string, options?: AttachmentOptions): this;
+    /** How viewers present the document when it opens. */
+    viewerPreferences(preferences: ViewerPreferences): this;
+    /**
+     * Writes fonts, links, the page tree, outline and metadata; the builder (and its unfinished
+     * pages) take no more calls afterwards.
+     *
+     * @returns the new document (unsaved; its save is a full rewrite).
+     * @throws {@link LaminaPdfError} `page-index-out-of-range`, `unknown-destination`,
+     *   `invalid-page-labels`, `invalid-geometry`, `subset-failed`, `builder-finished`; under a
+     *   profile (`profiles` in the options), the first rule the document breaks, with that rule's
+     *   code (the error reference lists them, from `profile-version-conflict` on).
+     */
+    finish(): Document;
+    /**
+     * Frees the builder's WASM memory now (`finish` does this itself); the builder takes no more
+     * calls afterwards. Unfinished pages are freed with {@link Page.free}.
+     */
+    free(): void;
+    /** Frees the builder at the end of a `using` block. */
+    [Symbol.dispose](): void;
+}
+//# sourceMappingURL=builder.d.ts.map

package/dist/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../src/builder.ts"],"names":[],"mappings":"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"}