@embedpdf/engine-core 3.0.0-next.14 → 3.0.0-next.15

package/dist/format-Dgg428Kb.js

@@ -0,0 +1,461 @@
+//#region src/errors/EngineErrorCode.ts
+const EngineErrorCode = {
+	Unknown: "Unknown",
+	InvalidArg: "InvalidArg",
+	DocNotOpen: "DocNotOpen",
+	DocOpenFailed: "DocOpenFailed",
+	DocPasswordRequired: "DocPasswordRequired",
+	DocPasswordIncorrect: "DocPasswordIncorrect",
+	/**
+	* A share-token exchange (`open({ kind: 'share' })`) needs the grant's
+	* passphrase: none was supplied, or the supplied one was rejected —
+	* indistinguishable by design, mirroring the server. Prompt and retry
+	* with `sharePassword`. Distinct from `DocPasswordRequired`, which is
+	* about the PDF's own encryption password.
+	*/
+	SharePasswordRequired: "SharePasswordRequired",
+	Aborted: "Aborted",
+	Network: "Network",
+	Unauthenticated: "Unauthenticated",
+	Forbidden: "Forbidden",
+	NotFound: "NotFound",
+	WireFormat: "WireFormat",
+	RuntimeUnavailable: "RuntimeUnavailable",
+	/**
+	* A layer write lost its optimistic-concurrency check: the layer's
+	* durable version advanced (another writer — typically another server
+	* replica — committed) between the operation's prepare and its commit,
+	* and the server exhausted its rebase-and-retry budget. Retryable: the
+	* operation was not applied; re-issue it against the new state.
+	*/
+	LayerVersionConflict: "LayerVersionConflict",
+	/**
+	* The requested operation is typed but not yet wired in this engine
+	* version. The wire shape stays valid; clients can detect this with
+	* `EngineError.is(err, EngineErrorCode.NotImplemented)` and degrade
+	* gracefully.
+	*/
+	NotImplemented: "NotImplemented",
+	/**
+	* The PDF was loadable enough for PDFium to parse, but violates a
+	* structural invariant the engine relies on. Surfaced for the rare
+	* spec-violating PDF that ships a direct (non-indirect) page
+	* dictionary in the /Pages tree — see `EPDFPage_GetObjectNumber`
+	* returning `0`. PDFium creation paths (`FPDFPage_New`,
+	* `EPDFPage_CreateAnnot`) always produce indirect objects, so this
+	* error code is intentionally not used for engine-produced state;
+	* it specifically signals "this input file is broken in a way we
+	* cannot work around without compromising stable identity".
+	*
+	* Distinct from `DocOpenFailed` (PDFium refused to load the bytes
+	* at all) and `NotFound` (a well-formed page/annotation/etc. simply
+	* doesn't exist).
+	*/
+	MalformedPdf: "MalformedPdf",
+	/**
+	* A signing candidate is parked on this session: every mutation is
+	* refused until `signatures.complete` or `signatures.cancel`.
+	*/
+	SigningPending: "SigningPending",
+	/** The candidate's TTL elapsed; prepare again. */
+	SigningExpired: "SigningExpired",
+	/**
+	* `complete` presented a version the candidate was not built on (the
+	* document or the layer moved since `prepare`). The CMS cannot be
+	* reused: it signs a digest of bytes that will never be the head.
+	* Prepare again on the current version.
+	*/
+	SigningVersionMismatch: "SigningVersionMismatch",
+	/**
+	* The engine refused to author the signature: the field is signed,
+	* read-only, or locked by an earlier signature; a certification is
+	* requested after a signature exists; the seed value requires what the
+	* engine does not implement; the request is inconsistent. The message
+	* names the reason.
+	*/
+	SignatureRefused: "SignatureRefused",
+	/**
+	* A signature already in the document forbids this change (a
+	* certification's permission, or a FieldMDP or `/Lock`; the approval
+	* baseline is judged, never refused). The message names the signature and
+	* the restriction. The
+	* engine option `signedDocumentPolicy: 'permit'` disables the guard.
+	*/
+	ProtectedDocument: "ProtectedDocument",
+	/**
+	* The layer is built on a base version that is no longer the
+	* document's head (another signing completed); it can be read and
+	* edited but not signed from.
+	*/
+	StaleBase: "StaleBase",
+	/**
+	* A payload passed one of its limits: an annotation bundle's bytes,
+	* counts or image pixels. Nothing was read past the limit and nothing was
+	* written. `details` has the `limit`, its `max` and the `value` found.
+	*/
+	PayloadTooLarge: "PayloadTooLarge",
+	/**
+	* A create named an object number it can't use. `details.objectNumber`
+	* is the number; `details.reason` is `'not-held'` when the caller's
+	* session doesn't hold it (never reserved, already spent, or lost to
+	* another session) and `'taken'` when an object is already at it. Nothing
+	* was written.
+	*/
+	ObjectNumberUnavailable: "ObjectNumberUnavailable",
+	/**
+	* The document would pass the highest object number a file should have
+	* (`OBJECT_NUMBER_CEILING`): no more numbers are handed out, and a write
+	* that needs more is refused. `details.lastObjectNumber` is the document's
+	* last number. A compacted copy of the document starts afresh.
+	*/
+	LayerFull: "LayerFull",
+	/**
+	* An op's `expect` didn't match what the document holds: the change was
+	* refused whole. `details.opIndex` names the op and `details.fields` the
+	* fields that differ.
+	*/
+	ChangeConflict: "ChangeConflict",
+	/**
+	* `{ undoOf }` named a change that can no longer be undone.
+	* `details.reason` says why: `'final-change'` (a redaction apply, flatten,
+	* signing or form repair came after it), `'base-changed'` (a new version
+	* was published since) or `'expired'` (past retention).
+	*/
+	UndoUnavailable: "UndoUnavailable",
+	/**
+	* An `opId` that already has an answer came again with a different
+	* payload. Nothing ran; a retry must send the same change.
+	*/
+	IdempotencyKeyReused: "IdempotencyKeyReused"
+};
+//#endregion
+//#region \0@oxc-project+runtime@0.140.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.140.0/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.140.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.140.0/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region src/errors/EngineError.ts
+/**
+* Single error class shared across engine implementations. Has a stable
+* machine-readable `code` (see EngineErrorCode) so callers can match without
+* sniffing message strings. Every failure the engine reports is one: the
+* named subclasses (`PermissionDenied`, `InvalidScope`, `MissingIdentity`,
+* `AbortError`) only preset the code and keep their name for stack traces.
+*/
+var EngineError = class EngineError extends Error {
+	constructor(code, message, opts = {}) {
+		super(message ?? code, opts.cause === void 0 ? void 0 : { cause: opts.cause });
+		_defineProperty(this, "name", "EngineError");
+		_defineProperty(this, "code", void 0);
+		_defineProperty(this, "details", void 0);
+		this.code = code;
+		this.details = opts.details;
+	}
+	static is(value, code) {
+		if (!(value instanceof EngineError) && value?.name !== "EngineError") return false;
+		if (code === void 0) return true;
+		return value.code === code;
+	}
+	toJSON() {
+		return {
+			name: "EngineError",
+			code: this.code,
+			message: this.message,
+			details: this.details
+		};
+	}
+};
+function serializeError(err) {
+	if (EngineError.is(err)) return err.toJSON();
+	if (err instanceof Error) return {
+		name: "EngineError",
+		code: err.name === "AbortError" ? EngineErrorCode.Aborted : EngineErrorCode.Unknown,
+		message: err.message
+	};
+	return {
+		name: "EngineError",
+		code: EngineErrorCode.Unknown,
+		message: String(err ?? "unknown error")
+	};
+}
+function deserializeError(payload) {
+	return new EngineError(payload.code, payload.message, { details: payload.details });
+}
+//#endregion
+//#region src/identity/annotationKey.ts
+/**
+* The string key for an annotation address — for maps, sets and React keys.
+* A ref is an object, and JavaScript keys objects by identity, so two refs
+* that name the same annotation need one canonical value form; this is it.
+* The ref stays the thing you pass to the engine; this is only how you index.
+*
+* The page appears exactly where it carries information:
+*
+*   objectNumber  →  `obj:42`              an indirect object number is unique
+*                                           across the whole document
+*   baseIndex     →  `base:<page>:<i>`      a position in one page's /Annots
+*
+* This agrees with the wire: `obj:42` is the route's `:annotKey`
+* (`encodeAnnotKey`), and a `base` key is the route's `:pageKey` +
+* `:annotKey` folded into one string, because a client-side map has no path
+* segment to keep the page in.
+*/
+function annotationKey(ref) {
+	switch (ref.kind) {
+		case "objectNumber": return `obj:${ref.objectNumber}`;
+		case "baseIndex": return `base:${ref.page.objectNumber}:${ref.baseIndex}`;
+	}
+}
+//#endregion
+//#region src/identity/PageObjectNumber.ts
+/**
+* Type guard for the rare malformed-PDF case where a page is a direct
+* object. The engine treats `0` as malformed and throws `EngineError(NotFound)`
+* before any page-level operation.
+*/
+function isValidPageObjectNumber(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+//#endregion
+//#region src/identity/PageRef.ts
+/** Build the address for a page from its object number. */
+function toPageRef(pageObjectNumber) {
+	return {
+		kind: "objectNumber",
+		objectNumber: pageObjectNumber
+	};
+}
+/** Structural equality for two page addresses. */
+function pageRefsEqual(a, b) {
+	return a.kind === b.kind && a.objectNumber === b.objectNumber;
+}
+/**
+* URL-safe encoding of a `PageRef`, used by the cloud HTTP surface as the
+* `:pageKey` route parameter. Mirrors `encodeAnnotKey` (`obj:42` /
+* `base:2`) and `encodeFieldRefKey` (`obj:12` / `fqn:…`), so every identity
+* reads the same on the wire:
+*
+*   `{ kind: 'objectNumber', objectNumber: 3 }` -> `'obj:3'`
+*
+* The caller is responsible for `encodeURIComponent`-ing the result before
+* splicing it into a URL path; the `wirePaths` builders already do that.
+*/
+function encodePageKey(ref) {
+	if (!isValidPageObjectNumber(ref.objectNumber)) throw new RangeError(`encodePageKey: objectNumber must be a positive integer, got ${ref.objectNumber}`);
+	return `obj:${ref.objectNumber}`;
+}
+/**
+* Inverse of `encodePageKey`. Returns `null` for malformed input so the
+* server can answer 400 InvalidArg with a useful message instead of
+* throwing. The input is the already-`decodeURIComponent`-ed segment from
+* the route path.
+*/
+function decodePageKey(key) {
+	if (!key.startsWith("obj:")) return null;
+	const rest = key.slice(4);
+	const n = Number.parseInt(rest, 10);
+	if (!Number.isInteger(n) || n <= 0 || String(n) !== rest) return null;
+	return {
+		kind: "objectNumber",
+		objectNumber: n
+	};
+}
+//#endregion
+//#region src/annotation/primitives.ts
+/**
+* The 14 standard PDF fonts a free-text annotation's `/DA` can name. We use
+* kebab-case so the wire format is stable across language ports; the engine
+* maps these onto PDFium's `FPDF_STANDARD_FONT` integer codes at write time.
+*/
+const STANDARD_FONTS = [
+	"courier",
+	"courier-bold",
+	"courier-bold-oblique",
+	"courier-oblique",
+	"helvetica",
+	"helvetica-bold",
+	"helvetica-bold-oblique",
+	"helvetica-oblique",
+	"times-roman",
+	"times-bold",
+	"times-bold-italic",
+	"times-italic",
+	"symbol",
+	"zapf-dingbats"
+];
+const NO_ANNOTATION_FLAGS = {
+	invisible: false,
+	hidden: false,
+	print: false,
+	noZoom: false,
+	noRotate: false,
+	noView: false,
+	readOnly: false,
+	locked: false,
+	toggleNoView: false,
+	lockedContents: false
+};
+//#endregion
+//#region src/identity/FormFieldRef.ts
+/** A ref to a field by its full name (`'billing.name'`), for a name you already know. */
+function toFieldRef(name) {
+	return {
+		kind: "fqn",
+		name
+	};
+}
+/**
+* URL-safe encoding of a `FormFieldRef`, used by the cloud HTTP surface as
+* the `:fieldKey` route parameter. Decoded by the server back into a
+* `FormFieldRef` via `decodeFieldRefKey`. Mirrors the annotation plane's
+* `encodeAnnotKey` (`obj:42` / `base:2`) so the two member-key syntaxes
+* read the same on the wire:
+*
+*   `{ kind: 'objectNumber', objectNumber: 12 }` -> `'obj:12'`
+*   `{ kind: 'fqn', name: 'billing.name' }`           -> `'fqn:billing.name'`
+*
+* The caller is responsible for `encodeURIComponent`-ing the result before
+* splicing it into a URL path; the `wirePaths.layerFormField*` builders
+* already do that. FQNs are opaque strings and may contain anything; the
+* `fqn:` prefix keeps them unambiguous from numeric ids.
+*/
+function encodeFieldRefKey(ref) {
+	if (ref.kind === "objectNumber") {
+		if (!Number.isInteger(ref.objectNumber) || ref.objectNumber <= 0) throw new RangeError(`encodeFieldRefKey: objectNumber must be a positive integer, got ${ref.objectNumber}`);
+		return `obj:${ref.objectNumber}`;
+	}
+	return `fqn:${ref.name}`;
+}
+/**
+* Inverse of `encodeFieldRefKey`. Returns `null` for malformed input so the
+* server can answer 400 InvalidArg with a useful message instead of
+* throwing. The input is the already-`decodeURIComponent`-ed segment from
+* the route path. Empty FQNs are rejected: `fqn:` with no suffix is not a
+* valid identity.
+*/
+function decodeFieldRefKey(key) {
+	if (key.startsWith("obj:")) {
+		const rest = key.slice(4);
+		const n = Number.parseInt(rest, 10);
+		if (!Number.isInteger(n) || n <= 0 || String(n) !== rest) return null;
+		return {
+			kind: "objectNumber",
+			objectNumber: n
+		};
+	}
+	if (key.startsWith("fqn:")) {
+		const name = key.slice(4);
+		if (name.length === 0) return null;
+		return {
+			kind: "fqn",
+			name
+		};
+	}
+	return null;
+}
+/** The one place a widget record is built: computes `ref` from the raw facts. */
+function formWidget(objectNumber, page) {
+	return {
+		ref: objectNumber > 0 && page ? {
+			kind: "objectNumber",
+			page,
+			objectNumber
+		} : null,
+		objectNumber,
+		page
+	};
+}
+//#endregion
+//#region src/measure/format.ts
+const group = (value, separator) => value.replace(/\B(?=(\d{3})+(?!\d))/g, () => separator);
+const gcd = (a, b) => b ? gcd(b, a % b) : a;
+function validNumberFormat(nf) {
+	const c = Math.fround(nf.conversion ?? NaN);
+	if (!Number.isFinite(c) || c <= 0) return false;
+	const d = nf.precision ?? (nf.fraction === "fraction" ? 16 : 100);
+	if (!Number.isInteger(d) || d < 1 || d > 2147483647) return false;
+	if ((nf.fraction ?? "decimal") === "decimal" && !Number.isInteger(Math.log10(d))) return false;
+	return true;
+}
+function last(value, nf) {
+	const mode = nf.fraction ?? "decimal";
+	const sep = nf.thousands ?? ",";
+	if (mode === "round") return group(String(Math.round(value)), sep);
+	if (mode === "truncate") return group(String(Math.trunc(value)), sep);
+	if (mode === "fraction") {
+		const denominator = nf.precision ?? 16;
+		let whole = Math.floor(value);
+		let numerator = Math.round((value - whole) * denominator);
+		if (numerator === denominator) {
+			whole++;
+			numerator = 0;
+		}
+		if (!numerator) return group(String(whole), sep);
+		const divisor = nf.fixed ? 1 : gcd(numerator, denominator);
+		return `${whole ? `${group(String(whole), sep)} ` : ""}${numerator / divisor}/${denominator / divisor}`;
+	}
+	const digits = Math.log10(nf.precision ?? 100);
+	const [integer, decimal = ""] = value.toFixed(digits).split(".");
+	return group(integer, sep) + (decimal ? (nf.decimal || ".") + decimal : "");
+}
+/** ISO 32000-2 §12.9.2 cascade. PDF float conversions are normalized before use.
+* Unit text and explicit spacing are preserved, including trailing unit spaces. */
+function formatMeasurement(value, formats) {
+	if (!Number.isFinite(value) || !formats.length || !formats.every(validNumberFormat)) throw new EngineError(EngineErrorCode.InvalidArg, "Measurement requires a finite value and valid number formats");
+	let remainder = Math.abs(value);
+	const parts = [];
+	for (const [index, nf] of formats.entries()) {
+		remainder *= Math.fround(nf.conversion);
+		if (!Number.isFinite(remainder)) throw new EngineError(EngineErrorCode.InvalidArg, "Measurement overflow");
+		const whole = Math.floor(remainder);
+		const fraction = remainder - whole;
+		const final = index === formats.length - 1;
+		const terminal = final || fraction === 0;
+		const number = final ? last(remainder, nf) : group(String(whole), nf.thousands ?? ",");
+		const prefix = nf.labelPosition === "prefix";
+		const ps = nf.prefixSpacing ?? (prefix && index === 0 ? "" : " ");
+		const ss = nf.suffixSpacing ?? (!prefix && terminal ? "" : " ");
+		const label = ps + nf.unit + ss;
+		parts.push(prefix ? label + number : number + label);
+		if (terminal) break;
+		remainder = fraction;
+	}
+	return (value < 0 ? "-" : "") + parts.join("");
+}
+//#endregion
+export { serializeError as _, formWidget as a, STANDARD_FONTS as c, pageRefsEqual as d, toPageRef as f, deserializeError as g, EngineError as h, encodeFieldRefKey as i, decodePageKey as l, annotationKey as m, validNumberFormat as n, toFieldRef as o, isValidPageObjectNumber as p, decodeFieldRefKey as r, NO_ANNOTATION_FLAGS as s, formatMeasurement as t, encodePageKey as u, _defineProperty as v, EngineErrorCode as y };
+
+//# sourceMappingURL=format-Dgg428Kb.js.map

package/dist/format-Dgg428Kb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-Dgg428Kb.js","names":[],"sources":["../src/errors/EngineErrorCode.ts","../src/errors/EngineError.ts","../src/identity/annotationKey.ts","../src/identity/PageObjectNumber.ts","../src/identity/PageRef.ts","../src/annotation/primitives.ts","../src/identity/FormFieldRef.ts","../src/measure/format.ts"],"sourcesContent":["export const EngineErrorCode = {\n  Unknown: 'Unknown',\n  InvalidArg: 'InvalidArg',\n  DocNotOpen: 'DocNotOpen',\n  DocOpenFailed: 'DocOpenFailed',\n  DocPasswordRequired: 'DocPasswordRequired',\n  DocPasswordIncorrect: 'DocPasswordIncorrect',\n  /**\n   * A share-token exchange (`open({ kind: 'share' })`) needs the grant's\n   * passphrase: none was supplied, or the supplied one was rejected —\n   * indistinguishable by design, mirroring the server. Prompt and retry\n   * with `sharePassword`. Distinct from `DocPasswordRequired`, which is\n   * about the PDF's own encryption password.\n   */\n  SharePasswordRequired: 'SharePasswordRequired',\n  Aborted: 'Aborted',\n  Network: 'Network',\n  Unauthenticated: 'Unauthenticated',\n  Forbidden: 'Forbidden',\n  NotFound: 'NotFound',\n  WireFormat: 'WireFormat',\n  RuntimeUnavailable: 'RuntimeUnavailable',\n  /**\n   * A layer write lost its optimistic-concurrency check: the layer's\n   * durable version advanced (another writer — typically another server\n   * replica — committed) between the operation's prepare and its commit,\n   * and the server exhausted its rebase-and-retry budget. Retryable: the\n   * operation was not applied; re-issue it against the new state.\n   */\n  LayerVersionConflict: 'LayerVersionConflict',\n  /**\n   * The requested operation is typed but not yet wired in this engine\n   * version. The wire shape stays valid; clients can detect this with\n   * `EngineError.is(err, EngineErrorCode.NotImplemented)` and degrade\n   * gracefully.\n   */\n  NotImplemented: 'NotImplemented',\n  /**\n   * The PDF was loadable enough for PDFium to parse, but violates a\n   * structural invariant the engine relies on. Surfaced for the rare\n   * spec-violating PDF that ships a direct (non-indirect) page\n   * dictionary in the /Pages tree — see `EPDFPage_GetObjectNumber`\n   * returning `0`. PDFium creation paths (`FPDFPage_New`,\n   * `EPDFPage_CreateAnnot`) always produce indirect objects, so this\n   * error code is intentionally not used for engine-produced state;\n   * it specifically signals \"this input file is broken in a way we\n   * cannot work around without compromising stable identity\".\n   *\n   * Distinct from `DocOpenFailed` (PDFium refused to load the bytes\n   * at all) and `NotFound` (a well-formed page/annotation/etc. simply\n   * doesn't exist).\n   */\n  MalformedPdf: 'MalformedPdf',\n  /**\n   * A signing candidate is parked on this session: every mutation is\n   * refused until `signatures.complete` or `signatures.cancel`.\n   */\n  SigningPending: 'SigningPending',\n  /** The candidate's TTL elapsed; prepare again. */\n  SigningExpired: 'SigningExpired',\n  /**\n   * `complete` presented a version the candidate was not built on (the\n   * document or the layer moved since `prepare`). The CMS cannot be\n   * reused: it signs a digest of bytes that will never be the head.\n   * Prepare again on the current version.\n   */\n  SigningVersionMismatch: 'SigningVersionMismatch',\n  /**\n   * The engine refused to author the signature: the field is signed,\n   * read-only, or locked by an earlier signature; a certification is\n   * requested after a signature exists; the seed value requires what the\n   * engine does not implement; the request is inconsistent. The message\n   * names the reason.\n   */\n  SignatureRefused: 'SignatureRefused',\n  /**\n   * A signature already in the document forbids this change (a\n   * certification's permission, or a FieldMDP or `/Lock`; the approval\n   * baseline is judged, never refused). The message names the signature and\n   * the restriction. The\n   * engine option `signedDocumentPolicy: 'permit'` disables the guard.\n   */\n  ProtectedDocument: 'ProtectedDocument',\n  /**\n   * The layer is built on a base version that is no longer the\n   * document's head (another signing completed); it can be read and\n   * edited but not signed from.\n   */\n  StaleBase: 'StaleBase',\n  /**\n   * A payload passed one of its limits: an annotation bundle's bytes,\n   * counts or image pixels. Nothing was read past the limit and nothing was\n   * written. `details` has the `limit`, its `max` and the `value` found.\n   */\n  PayloadTooLarge: 'PayloadTooLarge',\n  /**\n   * A create named an object number it can't use. `details.objectNumber`\n   * is the number; `details.reason` is `'not-held'` when the caller's\n   * session doesn't hold it (never reserved, already spent, or lost to\n   * another session) and `'taken'` when an object is already at it. Nothing\n   * was written.\n   */\n  ObjectNumberUnavailable: 'ObjectNumberUnavailable',\n  /**\n   * The document would pass the highest object number a file should have\n   * (`OBJECT_NUMBER_CEILING`): no more numbers are handed out, and a write\n   * that needs more is refused. `details.lastObjectNumber` is the document's\n   * last number. A compacted copy of the document starts afresh.\n   */\n  LayerFull: 'LayerFull',\n  /**\n   * An op's `expect` didn't match what the document holds: the change was\n   * refused whole. `details.opIndex` names the op and `details.fields` the\n   * fields that differ.\n   */\n  ChangeConflict: 'ChangeConflict',\n  /**\n   * `{ undoOf }` named a change that can no longer be undone.\n   * `details.reason` says why: `'final-change'` (a redaction apply, flatten,\n   * signing or form repair came after it), `'base-changed'` (a new version\n   * was published since) or `'expired'` (past retention).\n   */\n  UndoUnavailable: 'UndoUnavailable',\n  /**\n   * An `opId` that already has an answer came again with a different\n   * payload. Nothing ran; a retry must send the same change.\n   */\n  IdempotencyKeyReused: 'IdempotencyKeyReused',\n} as const;\n\nexport type EngineErrorCode = (typeof EngineErrorCode)[keyof typeof EngineErrorCode];\n","import { EngineErrorCode } from './EngineErrorCode';\n\nexport interface EngineErrorOptions {\n  cause?: unknown;\n  details?: Record<string, unknown>;\n}\n\n/**\n * Single error class shared across engine implementations. Has a stable\n * machine-readable `code` (see EngineErrorCode) so callers can match without\n * sniffing message strings. Every failure the engine reports is one: the\n * named subclasses (`PermissionDenied`, `InvalidScope`, `MissingIdentity`,\n * `AbortError`) only preset the code and keep their name for stack traces.\n */\nexport class EngineError extends Error {\n  override readonly name: string = 'EngineError';\n  readonly code: EngineErrorCode;\n  readonly details?: Record<string, unknown>;\n\n  constructor(code: EngineErrorCode, message?: string, opts: EngineErrorOptions = {}) {\n    super(message ?? code, opts.cause === undefined ? undefined : { cause: opts.cause });\n    this.code = code;\n    this.details = opts.details;\n  }\n\n  static is(value: unknown, code?: EngineErrorCode): value is EngineError {\n    if (\n      !(value instanceof EngineError) &&\n      (value as { name?: string } | null)?.name !== 'EngineError'\n    ) {\n      return false;\n    }\n    if (code === undefined) return true;\n    return (value as EngineError).code === code;\n  }\n\n  toJSON(): {\n    name: 'EngineError';\n    code: EngineErrorCode;\n    message: string;\n    details?: Record<string, unknown>;\n  } {\n    return {\n      name: 'EngineError',\n      code: this.code,\n      message: this.message,\n      details: this.details,\n    };\n  }\n}\n\nexport interface SerializedEngineError {\n  name: 'EngineError';\n  code: EngineErrorCode;\n  message: string;\n  details?: Record<string, unknown>;\n}\n\nexport function serializeError(err: unknown): SerializedEngineError {\n  if (EngineError.is(err)) {\n    return err.toJSON();\n  }\n  if (err instanceof Error) {\n    const code: EngineErrorCode =\n      err.name === 'AbortError' ? EngineErrorCode.Aborted : EngineErrorCode.Unknown;\n    return { name: 'EngineError', code, message: err.message };\n  }\n  return {\n    name: 'EngineError',\n    code: EngineErrorCode.Unknown,\n    message: String(err ?? 'unknown error'),\n  };\n}\n\nexport function deserializeError(payload: SerializedEngineError): EngineError {\n  return new EngineError(payload.code, payload.message, { details: payload.details });\n}\n","import type { AnnotationRef } from './AnnotationRef';\n\n/**\n * The string key for an annotation address — for maps, sets and React keys.\n * A ref is an object, and JavaScript keys objects by identity, so two refs\n * that name the same annotation need one canonical value form; this is it.\n * The ref stays the thing you pass to the engine; this is only how you index.\n *\n * The page appears exactly where it carries information:\n *\n *   objectNumber  →  `obj:42`              an indirect object number is unique\n *                                           across the whole document\n *   baseIndex     →  `base:<page>:<i>`      a position in one page's /Annots\n *\n * This agrees with the wire: `obj:42` is the route's `:annotKey`\n * (`encodeAnnotKey`), and a `base` key is the route's `:pageKey` +\n * `:annotKey` folded into one string, because a client-side map has no path\n * segment to keep the page in.\n */\nexport function annotationKey(ref: AnnotationRef): string {\n  switch (ref.kind) {\n    case 'objectNumber':\n      return `obj:${ref.objectNumber}`;\n    case 'baseIndex':\n      return `base:${ref.page.objectNumber}:${ref.baseIndex}`;\n  }\n}\n","/**\n * PDF indirect object number for a page.\n *\n * Resolved via the PDFium runtime helper `EPDFPage_GetObjectNumber(pagePtr)`.\n * Always > 0 for well-formed PDFs, and the primary addressing key. The\n * page index is kept on `PageHandle` as display\n * metadata only, because it can shift when pages are inserted, deleted, or\n * reordered while a session is open.\n */\nexport type PageObjectNumber = number;\n\n/**\n * Type guard for the rare malformed-PDF case where a page is a direct\n * object. The engine treats `0` as malformed and throws `EngineError(NotFound)`\n * before any page-level operation.\n */\nexport function isValidPageObjectNumber(value: unknown): value is PageObjectNumber {\n  return typeof value === 'number' && Number.isInteger(value) && value > 0;\n}\n","import type { PageObjectNumber } from './PageObjectNumber';\nimport { isValidPageObjectNumber } from './PageObjectNumber';\n\n/**\n * How callers address a page — the page-plane sibling of `AnnotationRef`\n * and `FormFieldRef`.\n *\n * `objectNumber` is the indirect object number of the page dictionary.\n * ISO 32000-1 §7.7.3.3 requires every `/Kids` entry to be an indirect\n * reference, the layer runtime never renumbers (frozen base + incremental\n * deltas), and a deleted page's number is retired, never recycled — so it\n * is the durable identity for the lifetime of a document. It is what every\n * `PageLayout.ref` and `PageHandle.ref` carries.\n *\n * It is deliberately the only kind. Pages are durable by construction (see\n * `PagesMutator`): a display index is never an identity, a page without an\n * object number is refused at open (`MalformedPdf`), and a `/Names /Pages`\n * key is a registry entry the layout already maps to a number, not a second\n * identity the engine would ever return. The discriminated shape keeps the\n * address consistent with the other refs and leaves room for an additive\n * kind should a real one ever appear.\n *\n * Records that mention a page (an annotation ref, event payloads, per-page\n * results, destinations, search matches) carry the same `page: PageRef`;\n * `toPageRef()` builds one from a page number you already hold.\n */\nexport type PageRef = { kind: 'objectNumber'; objectNumber: PageObjectNumber };\n\n/** Build the address for a page from its object number. */\nexport function toPageRef(pageObjectNumber: PageObjectNumber): PageRef {\n  return { kind: 'objectNumber', objectNumber: pageObjectNumber };\n}\n\n/** Structural equality for two page addresses. */\nexport function pageRefsEqual(a: PageRef, b: PageRef): boolean {\n  return a.kind === b.kind && a.objectNumber === b.objectNumber;\n}\n\n/**\n * URL-safe encoding of a `PageRef`, used by the cloud HTTP surface as the\n * `:pageKey` route parameter. Mirrors `encodeAnnotKey` (`obj:42` /\n * `base:2`) and `encodeFieldRefKey` (`obj:12` / `fqn:…`), so every identity\n * reads the same on the wire:\n *\n *   `{ kind: 'objectNumber', objectNumber: 3 }` -> `'obj:3'`\n *\n * The caller is responsible for `encodeURIComponent`-ing the result before\n * splicing it into a URL path; the `wirePaths` builders already do that.\n */\nexport function encodePageKey(ref: PageRef): string {\n  if (!isValidPageObjectNumber(ref.objectNumber)) {\n    throw new RangeError(\n      `encodePageKey: objectNumber must be a positive integer, got ${ref.objectNumber}`,\n    );\n  }\n  return `obj:${ref.objectNumber}`;\n}\n\n/**\n * Inverse of `encodePageKey`. Returns `null` for malformed input so the\n * server can answer 400 InvalidArg with a useful message instead of\n * throwing. The input is the already-`decodeURIComponent`-ed segment from\n * the route path.\n */\nexport function decodePageKey(key: string): PageRef | null {\n  if (!key.startsWith('obj:')) return null;\n  const rest = key.slice('obj:'.length);\n  const n = Number.parseInt(rest, 10);\n  if (!Number.isInteger(n) || n <= 0 || String(n) !== rest) return null;\n  return { kind: 'objectNumber', objectNumber: n };\n}\n","/**\n * Wire-stable annotation primitives that are not pure geometry.\n *\n * Geometry primitives (points, rects, sizes, quads, rotation) now live in\n * `../geometry` as the canonical `Pdf*` vocabulary. The aliases below are\n * transitional re-exports kept only so existing consumers keep compiling\n * during the geometry consolidation; new code should import `Pdf*` directly\n * from `../geometry`.\n *\n * These do not depend on PDFium or any browser/Node surface; they are\n * the lingua franca between local engine, cloud engine, and server.\n */\n\nimport type { PdfPoint, PdfRect, PdfRotation, PdfSize } from '../geometry/primitives';\n\n/** @deprecated Use `PdfPoint` from `../geometry`. */\nexport type Point = PdfPoint;\n/** @deprecated Use `PdfRect` from `../geometry`. */\nexport type Rect = PdfRect;\n/** @deprecated Use `PdfSize` from `../geometry`. */\nexport type Size = PdfSize;\n/** @deprecated Use `PdfRotation` from `../geometry`. */\nexport type Rotation = PdfRotation;\n\n/**\n * An sRGB color as `'#rrggbb'`: lowercase when the engine gives one, either\n * case when it takes one. A gray or CMYK color in the file reads as its sRGB\n * equivalent, and sent back unchanged it stays as the file has it.\n *\n * A color carries no alpha: transparency is the separate `opacity` field\n * (`/CA`), so there is one source of truth for it.\n */\nexport type Color = string;\n\n/**\n * /LE entries (line endings). Maps PDFium FPDFAnnot_GetLineEndings codes\n * onto the spec names. We use kebab-case so the wire format is stable\n * across language ports.\n */\nexport type LineEnding =\n  | 'none'\n  | 'square'\n  | 'circle'\n  | 'diamond'\n  | 'open-arrow'\n  | 'closed-arrow'\n  | 'butt'\n  | 'r-open-arrow'\n  | 'r-closed-arrow'\n  | 'slash';\n\n/**\n * The `/LE` pair carried by line and polyline annotations: the ending\n * drawn at the start point and the ending drawn at the end point.\n */\nexport interface LineEndings {\n  start: LineEnding;\n  end: LineEnding;\n}\n\n/**\n * The 14 standard PDF fonts a free-text annotation's `/DA` can name. We use\n * kebab-case so the wire format is stable across language ports; the engine\n * maps these onto PDFium's `FPDF_STANDARD_FONT` integer codes at write time.\n */\nexport const STANDARD_FONTS = [\n  'courier',\n  'courier-bold',\n  'courier-bold-oblique',\n  'courier-oblique',\n  'helvetica',\n  'helvetica-bold',\n  'helvetica-bold-oblique',\n  'helvetica-oblique',\n  'times-roman',\n  'times-bold',\n  'times-bold-italic',\n  'times-italic',\n  'symbol',\n  'zapf-dingbats',\n] as const;\n\nexport type StandardFont = (typeof STANDARD_FONTS)[number];\n\n/**\n * Font selector for a free-text annotation: either one of the 14 PDF\n * {@link StandardFont} names, or the `key` of a font registered through\n * `engine.fonts` (local/WASM engine only).\n *\n * The `(string & {})` arm keeps the standard-font literals auto-completing\n * while still accepting any registered key. Because the standard names are\n * matched first at write time, those 14 names are reserved: don't register a\n * custom font under a key like `'helvetica'`.\n */\nexport type FreeTextFont = StandardFont | (string & {});\n\n/**\n * Horizontal text alignment (`/Q`) for free-text annotations. Maps onto the\n * ISO 32000 §12.7.3.3 quadding codes 0/1/2 at write time.\n */\nexport type TextAlignment = 'left' | 'center' | 'right';\n\n/**\n * Free-text `/IT` intent. `free-text` is a plain text box; `free-text-callout`\n * adds a `/CL` leader line pointing at the called-out region;\n * `free-text-typewriter` is a typewriter box another app made, read and kept\n * but not created.\n */\nexport type FreeTextIntent = 'free-text' | 'free-text-callout' | 'free-text-typewriter';\n\n/** Where a free text's lines sit in its box, top to bottom. */\nexport type VerticalAlignment = 'top' | 'middle' | 'bottom';\n\n/** Caret `/IT` intent used by an Acrobat-compatible replace-text edit. */\nexport type CaretIntent = 'replace';\n\n/** Strikeout `/IT` intent used by the subordinate part of a replace-text edit. */\nexport type StrikeoutIntent = 'strikeout-text-edit';\n\n/** Ink `/IT` intent used by an Acrobat-compatible freehand highlighter. */\nexport type InkIntent = 'ink-highlight';\n\n/**\n * Effective blend mode of an annotation's normal appearance stream (`/AP /N`).\n * Values use CSS-compatible kebab-case so the wire vocabulary is portable; the\n * engine maps them onto PDFium's `FPDF_BLENDMODE` integer codes.\n */\nexport type BlendMode =\n  | 'normal'\n  | 'multiply'\n  | 'screen'\n  | 'overlay'\n  | 'darken'\n  | 'lighten'\n  | 'color-dodge'\n  | 'color-burn'\n  | 'hard-light'\n  | 'soft-light'\n  | 'difference'\n  | 'exclusion'\n  | 'hue'\n  | 'saturation'\n  | 'color'\n  | 'luminosity';\n\n/**\n * Border/line style for shape annotations — the `/BS /S` (border style)\n * subset PDFium can author. Maps onto the ISO 32000 §8.4.3.3 border style\n * names. Cloudy borders are a separate concern (`/BE` border effect),\n * surfaced as `cloudyIntensity` on the shape DTO, not as a border style.\n *\n * kebab-/lower-case so the wire format is stable across language ports;\n * the engine maps these onto PDFium's integer codes at write time.\n */\nexport type AnnotationBorderStyle = 'solid' | 'dashed' | 'beveled' | 'inset';\n\n/**\n * A form widget's border (`/BS /S`): the four annotation styles, and\n * `underline`, a line along the bottom only, which only a widget draws.\n */\nexport type WidgetBorderStyle = AnnotationBorderStyle | 'underline';\n\n/**\n * A symbol a checkbox or radio button shows while it's on (`/MK /CA`, a\n * ZapfDingbats character). Without one, a checkbox shows a check and a radio\n * button a circle.\n */\nexport type WidgetCheckStyle = 'check' | 'cross' | 'star' | 'circle' | 'square' | 'diamond';\n\n/** The border styles an annotation other than a widget draws: `beveled` and `inset` are read, not written. */\nexport type DrawnBorderStyle = Extract<AnnotationBorderStyle, 'solid' | 'dashed'>;\n\n/**\n * The `/RT` (reply type) relationship an annotation declares toward the\n * annotation its `/IRT` points at (ISO 32000 §12.5.6.2). Wire-stable\n * kebab/lower-case strings; the engine maps these onto PDFium's\n * `FPDF_ANNOT_REPLY_TYPE` integer codes at read/write time.\n *\n *   'reply' -> `/R`     a comment-thread reply (the ISO default when\n *                       `/IRT` is present but `/RT` is absent).\n *   'group' -> `/Group` a subordinate part of one logical annotation\n *                       group (e.g. the StrikeOut of a replace-text pair,\n *                       grouped under its Caret).\n */\nexport type AnnotationReplyType = 'reply' | 'group';\n\n/** The two ISO 32000 §12.5.6.3 standard state models (Table 174). */\nexport type KnownAnnotationStateModel = 'review' | 'marked';\n\n/**\n * The `/StateModel` of an annotation-state text annotation —\n * ISO 32000 §12.5.6.3. The standard models are `'review'` and `'marked'`, but the\n * PDF stores the entry as a free text string and Acrobat supports\n * registering custom state models, so the type stays open. The\n * `(string & {})` arm keeps the standard literals auto-completing while\n * accepting any custom model (the {@link FreeTextFont} pattern).\n *\n * Known values are wire-stable lowercase; the engine maps them onto the\n * capitalized PDF spellings (`Review`, `Marked`) at read/write time.\n * Unknown values round-trip verbatim in both directions.\n */\nexport type AnnotationStateModel = KnownAnnotationStateModel | (string & {});\n\n/** The ISO 32000 §12.5.6.3 standard states (Table 174). */\nexport type KnownAnnotationState =\n  | 'accepted'\n  | 'rejected'\n  | 'cancelled'\n  | 'completed'\n  | 'none'\n  | 'marked'\n  | 'unmarked';\n\n/**\n * The `/State` an annotation-state text annotation sets —\n * ISO 32000 §12.5.6.3. `'accepted' | 'rejected' | 'cancelled' | 'completed' |\n * 'none'` belong to the `'review'` model; `'marked' | 'unmarked'` to the\n * `'marked'` model. Open for the same reason as\n * {@link AnnotationStateModel}: custom models bring custom states.\n *\n * States are per user and live on separate text annotations replying\n * (`/IRT`) to their target — never on the target itself. The `/T` of the\n * state annotation names who set it; later changes by the same user\n * chain as replies to their previous state annotation, latest wins.\n */\nexport type AnnotationState = KnownAnnotationState | (string & {});\n\n/**\n * Bitset wrapper for the `/F` (Annotation Flags) PDF entry. We expose each\n * bit as its own boolean so callers don't have to know the bit positions.\n */\nexport interface AnnotationFlags {\n  invisible: boolean;\n  hidden: boolean;\n  print: boolean;\n  noZoom: boolean;\n  noRotate: boolean;\n  noView: boolean;\n  readOnly: boolean;\n  locked: boolean;\n  toggleNoView: boolean;\n  lockedContents: boolean;\n}\n\nexport const NO_ANNOTATION_FLAGS: AnnotationFlags = {\n  invisible: false,\n  hidden: false,\n  print: false,\n  noZoom: false,\n  noRotate: false,\n  noView: false,\n  readOnly: false,\n  locked: false,\n  toggleNoView: false,\n  lockedContents: false,\n};\n","import type { PageRef } from './PageRef';\nimport type { AnnotationRef } from './AnnotationRef';\n\n/**\n * How callers address a logical form field.\n *\n * - `objectNumber` — the indirect object number of the field dictionary.\n *   ISO 32000 guarantees every real AcroForm field dictionary is an\n *   indirect object, and the layer runtime never renumbers (frozen base +\n *   incremental deltas), so this is the durable identity for the lifetime\n *   of a document. Preferred for all engine calls.\n * - `fqn` — the fully qualified field name (\"billing.name\"). The portable,\n *   semantic identity used by interchange formats (FDF/XFDF) and analytics;\n *   survives document rewrites but is only as unique as the producer made\n *   it. The engine resolves it against the reconciled field tree.\n */\nexport type FormFieldRef =\n  | { kind: 'objectNumber'; objectNumber: number }\n  | { kind: 'fqn'; name: string };\n\n/** A ref to a field by its full name (`'billing.name'`), for a name you already know. */\nexport function toFieldRef(name: string): FormFieldRef {\n  return { kind: 'fqn', name };\n}\n\n/**\n * URL-safe encoding of a `FormFieldRef`, used by the cloud HTTP surface as\n * the `:fieldKey` route parameter. Decoded by the server back into a\n * `FormFieldRef` via `decodeFieldRefKey`. Mirrors the annotation plane's\n * `encodeAnnotKey` (`obj:42` / `base:2`) so the two member-key syntaxes\n * read the same on the wire:\n *\n *   `{ kind: 'objectNumber', objectNumber: 12 }` -> `'obj:12'`\n *   `{ kind: 'fqn', name: 'billing.name' }`           -> `'fqn:billing.name'`\n *\n * The caller is responsible for `encodeURIComponent`-ing the result before\n * splicing it into a URL path; the `wirePaths.layerFormField*` builders\n * already do that. FQNs are opaque strings and may contain anything; the\n * `fqn:` prefix keeps them unambiguous from numeric ids.\n */\nexport function encodeFieldRefKey(ref: FormFieldRef): string {\n  if (ref.kind === 'objectNumber') {\n    if (!Number.isInteger(ref.objectNumber) || ref.objectNumber <= 0) {\n      throw new RangeError(\n        `encodeFieldRefKey: objectNumber must be a positive integer, got ${ref.objectNumber}`,\n      );\n    }\n    return `obj:${ref.objectNumber}`;\n  }\n  return `fqn:${ref.name}`;\n}\n\n/**\n * Inverse of `encodeFieldRefKey`. Returns `null` for malformed input so the\n * server can answer 400 InvalidArg with a useful message instead of\n * throwing. The input is the already-`decodeURIComponent`-ed segment from\n * the route path. Empty FQNs are rejected: `fqn:` with no suffix is not a\n * valid identity.\n */\nexport function decodeFieldRefKey(key: string): FormFieldRef | null {\n  if (key.startsWith('obj:')) {\n    const rest = key.slice('obj:'.length);\n    const n = Number.parseInt(rest, 10);\n    if (!Number.isInteger(n) || n <= 0 || String(n) !== rest) return null;\n    return { kind: 'objectNumber', objectNumber: n };\n  }\n  if (key.startsWith('fqn:')) {\n    const name = key.slice('fqn:'.length);\n    if (name.length === 0) return null;\n    return { kind: 'fqn', name };\n  }\n  return null;\n}\n\n/**\n * A widget annotation of a field, as the field tree sees it. The forms reader\n * learns widgets from the field's `/Kids`, not from a page's `/Annots`, so it\n * must be able to report widgets the annotation subsystem cannot reach.\n *\n * `ref` is the widget as an annotation address, computed once by the engine:\n * present exactly when the widget is an indirect object (`objectNumber > 0`)\n * placed on a page (`page !== null`). In a conforming PDF every widget has\n * one. `objectNumber` stays beside it because a widget can be an object on no\n * page: it has a number but no annotation address, and the field still owns\n * it (signature checks join changed objects to fields by these numbers).\n */\nexport interface FormWidget {\n  /** The widget as an annotation address, or null when it cannot be addressed as one. */\n  ref: AnnotationRef | null;\n  /**\n   * The widget annotation's object number, whether or not it is on a page.\n   * `0` when the widget is stored as a direct object (spec-violating; it\n   * cannot be addressed).\n   */\n  objectNumber: number;\n  /**\n   * The page whose /Annots array references the widget; `null` when the\n   * widget is not reachable from any page (\"unplaced\").\n   */\n  page: PageRef | null;\n}\n\n/** The one place a widget record is built: computes `ref` from the raw facts. */\nexport function formWidget(objectNumber: number, page: PageRef | null): FormWidget {\n  return {\n    ref: objectNumber > 0 && page ? { kind: 'objectNumber', page, objectNumber } : null,\n    objectNumber,\n    page,\n  };\n}\n","import type { PdfNumberFormat } from '../dto/Measure';\nimport { EngineError } from '../errors/EngineError';\nimport { EngineErrorCode } from '../errors/EngineErrorCode';\n\nconst group = (value: string, separator: string): string =>\n  value.replace(/\\B(?=(\\d{3})+(?!\\d))/g, () => separator);\nconst gcd = (a: number, b: number): number => (b ? gcd(b, a % b) : a);\n\nexport function validNumberFormat(nf: PdfNumberFormat): boolean {\n  const c = Math.fround(nf.conversion ?? NaN);\n  if (!Number.isFinite(c) || c <= 0) return false;\n  const d = nf.precision ?? (nf.fraction === 'fraction' ? 16 : 100);\n  if (!Number.isInteger(d) || d < 1 || d > 2147483647) return false;\n  if ((nf.fraction ?? 'decimal') === 'decimal' && !Number.isInteger(Math.log10(d))) return false;\n  return true;\n}\n\nfunction last(value: number, nf: PdfNumberFormat): string {\n  const mode = nf.fraction ?? 'decimal';\n  const sep = nf.thousands ?? ',';\n  if (mode === 'round') return group(String(Math.round(value)), sep);\n  if (mode === 'truncate') return group(String(Math.trunc(value)), sep);\n  if (mode === 'fraction') {\n    const denominator = nf.precision ?? 16;\n    let whole = Math.floor(value);\n    let numerator = Math.round((value - whole) * denominator);\n    if (numerator === denominator) {\n      whole++;\n      numerator = 0;\n    }\n    if (!numerator) return group(String(whole), sep);\n    const divisor = nf.fixed ? 1 : gcd(numerator, denominator);\n    return `${whole ? `${group(String(whole), sep)} ` : ''}${numerator / divisor}/${denominator / divisor}`;\n  }\n  // Every digit /RD asks for, /FD or not, as Acrobat shows it (\"1.50 m\"):\n  // ISO 32000-2 would let a reader drop the trailing zeros without /FD.\n  const digits = Math.log10(nf.precision ?? 100);\n  const [integer, decimal = ''] = value.toFixed(digits).split('.');\n  return group(integer, sep) + (decimal ? (nf.decimal || '.') + decimal : '');\n}\n\n/** ISO 32000-2 §12.9.2 cascade. PDF float conversions are normalized before use.\n * Unit text and explicit spacing are preserved, including trailing unit spaces. */\nexport function formatMeasurement(value: number, formats: readonly PdfNumberFormat[]): string {\n  if (!Number.isFinite(value) || !formats.length || !formats.every(validNumberFormat)) {\n    throw new EngineError(\n      EngineErrorCode.InvalidArg,\n      'Measurement requires a finite value and valid number formats',\n    );\n  }\n  let remainder = Math.abs(value);\n  const parts: string[] = [];\n  for (const [index, nf] of formats.entries()) {\n    remainder *= Math.fround(nf.conversion!);\n    if (!Number.isFinite(remainder))\n      throw new EngineError(EngineErrorCode.InvalidArg, 'Measurement overflow');\n    const whole = Math.floor(remainder);\n    const fraction = remainder - whole;\n    const final = index === formats.length - 1;\n    const terminal = final || fraction === 0;\n    // A cascade that stops early on a whole unit shows it whole (\"2 ft\").\n    const number = final ? last(remainder, nf) : group(String(whole), nf.thousands ?? ',');\n    // Omit only the implicit outer padding, never trim the unit or explicit separators.\n    const prefix = nf.labelPosition === 'prefix';\n    const ps = nf.prefixSpacing ?? (prefix && index === 0 ? '' : ' ');\n    const ss = nf.suffixSpacing ?? (!prefix && terminal ? '' : ' ');\n    const label = ps + nf.unit + ss;\n    parts.push(prefix ? label + number : number + label);\n    if (terminal) break;\n    remainder = fraction;\n  }\n  return (value < 0 ? '-' : '') + parts.join('');\n}\n"],"mappings":"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"}