reamkit 1.15.0 → 1.15.2

package/dist/esm/core/converter/ream.d.ts

@@ -7,33 +7,140 @@ import { DocumentReader } from '../ir/adapters.js';
 import { FlowDoc } from '../ir/flow.js';
 import { SheetDoc } from '../ir/sheet.js';
 import { SignatureOptions, StyledRenderOptions } from '../../pdf/index.js';
+/** The output formats {@link Ream.convert} can produce. */
 export type ReamTarget = 'pdf' | 'svg' | 'html' | 'docx' | 'xlsx';
+/** Options for {@link Ream.parse}. */
 export interface ReamParseOptions {
+    /** Reader registry override; defaults to the built-in docx + xlsx readers. */
     readonly readers?: ReadonlyArray<DocumentReader<SourceDoc>>;
+    /**
+     * The user password for an encrypted PDF source (ISO 32000 §7.6). Defaults to
+     * the empty string, which opens the common permissions-only encryption (EP14).
+     */
     readonly password?: string;
 }
+/**
+ * Options for {@link Ream.convert} and {@link Ream.convertWithReport}. Extends
+ * the low-level {@link StyledRenderOptions} (minus the font `registry` and
+ * `styles`, which Ream builds itself) with font resolution and source-touching
+ * conveniences.
+ */
 export interface ReamConvertOptions extends Omit<StyledRenderOptions, 'registry' | 'styles'> {
+    /** Explicit font bytes per variant (regular/bold/italic/bold-italic). */
     readonly fonts?: FontBytesByVariant;
+    /** Shorthand for supplying a single regular-variant font as raw bytes. */
     readonly fontBytes?: Uint8Array;
+    /** Substitute family hint for the auto-download path. */
     readonly fontFamily?: string;
+    /** Injectable `fetch` for the auto-download path (defaults to the global `fetch`). */
     readonly fontFetch?: FetchLike;
+    /**
+     * Font resolution chain (caller/embedded/local/remote), used when neither
+     * `fonts` nor `fontBytes` is given. A remote or local winner records a
+     * substitution {@link Loss}.
+     */
     readonly fontProviders?: ReadonlyArray<FontProvider>;
+    /** Throw {@link ConversionLossError} on the first loss instead of reporting it. */
     readonly strict?: boolean;
+    /** PDF/A-3 only: embed the parsed source file (`/AFRelationship /Source`). */
     readonly embedSource?: boolean;
+    /** Digitally sign the output (ISO 32000 §12.8, WebCrypto). */
     readonly signature?: SignatureOptions;
+    /**
+     * Reference date for spreadsheet conditional-format `timePeriod` rules and for
+     * `TODAY()`/`NOW()` in `expression` rules (E-SHEET W9). Supplying it re-projects
+     * a spreadsheet source so those clock-relative rules resolve against this date —
+     * an explicit input, never the wall clock. Omitted, they no-op and the output is
+     * unchanged.
+     */
     readonly now?: Date;
 }
+/**
+ * The object face of the library: parse a document once into the format-neutral
+ * {@link FlowDoc} interlayer, then convert it to any number of targets without
+ * re-reading the source.
+ *
+ * ```ts
+ * const doc = Ream.parse(bytes); // sniff → reader → FlowDoc
+ * const pdf = await doc.convert('pdf', { fonts });
+ * const svg = await doc.convert('svg', { fonts });
+ * ```
+ *
+ * It is a thin GRASP Controller: readers parse, `flowRenderOptions` projects the
+ * FlowDoc, and layout/emit plus the writers do the work. As a deliberate
+ * composition root, importing it pulls in every format module — prefer the
+ * per-format functions when bundle size matters more than convenience. The
+ * source bytes are retained only for the two source-touching features: docx
+ * substitute-font auto-detection and PDF/A-3 `embedSource`.
+ */
 export declare class Ream {
     readonly flow: FlowDoc;
     readonly sheet: SheetDoc | undefined;
     readonly losses: ReadonlyArray<Loss>;
     private readonly source;
     private readonly readerId;
+    /**
+     * @param flow     The interlayer — the parsed, format-neutral document tree.
+     * @param sheet    The native SpreadsheetML tree when the source is a spreadsheet
+     *                 (xlsx); {@link Ream.flow} is its projection through the print model.
+     * @param losses   Losses recorded while reading the source.
+     * @param source   The original source bytes (kept only for docx auto-fonts and
+     *                 PDF/A-3 `embedSource`).
+     * @param readerId The id of the reader that parsed the source.
+     */
     private constructor();
+    /**
+     * Sniff the format and parse the bytes once into the {@link FlowDoc} interlayer.
+     *
+     * @param bytes   The raw document bytes; the format is detected by sniffing.
+     * @param options Optional reader-registry override and/or password for an
+     *                encrypted source.
+     * @returns A reusable {@link Ream} instance.
+     * @throws Error when no registered reader recognizes the bytes.
+     */
     static parse(bytes: Uint8Array, options?: ReamParseOptions): Ream;
+    /** The source format id (`'docx'`, `'xlsx'`, …). */
     get format(): string;
+    /**
+     * Convert the parsed document to `to` and return just the output bytes. A thin
+     * wrapper over {@link Ream.convertWithReport} that drops the loss report.
+     *
+     * @param to      The target format.
+     * @param options Font resolution and target-specific options.
+     * @returns The encoded output bytes.
+     */
     convert(to: ReamTarget, options?: ReamConvertOptions): Promise<Uint8Array>;
+    /**
+     * Convert the parsed document to `to`, returning the output bytes together with
+     * the accumulated {@link Loss} report (read-time losses plus any added while
+     * writing). HTML, DOCX and XLSX are produced straight from the interlayer — no
+     * layout, no fonts, zero I/O; SVG and PDF run the layout engine and resolve
+     * fonts first.
+     *
+     * @param to      The target format. `'xlsx'` requires a spreadsheet source.
+     * @param options Font resolution and target-specific options.
+     * @returns The encoded bytes and the loss report.
+     * @throws Error when `to` is `'xlsx'` but the source has no grid.
+     * @throws ConversionLossError when `options.strict` is set and any loss was recorded.
+     */
     convertWithReport(to: ReamTarget, options?: ReamConvertOptions): Promise<ConvertResult>;
+    /**
+     * Resolve the font set for a layout/PDF conversion. Explicit `fonts`/`fontBytes`
+     * win; otherwise the provider chain is tried, then an open substitute set is
+     * auto-downloaded (per detected family for docx). Any substitution is appended
+     * to `losses`.
+     *
+     * @param options The convert options carrying the font preferences.
+     * @param losses  The mutable loss list a substitution is appended to.
+     * @returns The font bytes and, for docx, optional per-family registries.
+     */
     private resolveFonts;
+    /**
+     * In strict mode, throw {@link ConversionLossError} for the first recorded loss.
+     *
+     * @param options The convert options (checked for `strict`).
+     * @param losses  The losses accumulated so far.
+     * @throws ConversionLossError when `options.strict` is set and `losses` is non-empty.
+     */
     private enforceStrict;
 }

package/dist/esm/core/converter/ream.js

@@ -14,6 +14,7 @@ import { writeSvg } from "../../svg/svg-writer.js";
 import { resolveDocxAutoFonts } from "../../word/docx-to-pdf.js";
 import { DEFAULT_READERS, resolveFontsViaChain, toFlowDoc } from "./facade.js";
 //#region src/core/converter/ream.ts
+/** OOXML / legacy MIME types by reader id, for the PDF/A-3 embedded source file. */
 var SOURCE_MIME = {
 	docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
 	doc: "application/msword",
@@ -23,7 +24,34 @@ var SOURCE_MIME = {
 	ppt: "application/vnd.ms-powerpoint",
 	pdf: "application/pdf"
 };
+/**
+* The object face of the library: parse a document once into the format-neutral
+* {@link FlowDoc} interlayer, then convert it to any number of targets without
+* re-reading the source.
+*
+* ```ts
+* const doc = Ream.parse(bytes); // sniff → reader → FlowDoc
+* const pdf = await doc.convert('pdf', { fonts });
+* const svg = await doc.convert('svg', { fonts });
+* ```
+*
+* It is a thin GRASP Controller: readers parse, `flowRenderOptions` projects the
+* FlowDoc, and layout/emit plus the writers do the work. As a deliberate
+* composition root, importing it pulls in every format module — prefer the
+* per-format functions when bundle size matters more than convenience. The
+* source bytes are retained only for the two source-touching features: docx
+* substitute-font auto-detection and PDF/A-3 `embedSource`.
+*/
 var Ream = class Ream {
+	/**
+	* @param flow     The interlayer — the parsed, format-neutral document tree.
+	* @param sheet    The native SpreadsheetML tree when the source is a spreadsheet
+	*                 (xlsx); {@link Ream.flow} is its projection through the print model.
+	* @param losses   Losses recorded while reading the source.
+	* @param source   The original source bytes (kept only for docx auto-fonts and
+	*                 PDF/A-3 `embedSource`).
+	* @param readerId The id of the reader that parsed the source.
+	*/
 	constructor(flow, sheet, losses, source, readerId) {
 		this.flow = flow;
 		this.sheet = sheet;
@@ -31,6 +59,15 @@ var Ream = class Ream {
 		this.source = source;
 		this.readerId = readerId;
 	}
+	/**
+	* Sniff the format and parse the bytes once into the {@link FlowDoc} interlayer.
+	*
+	* @param bytes   The raw document bytes; the format is detected by sniffing.
+	* @param options Optional reader-registry override and/or password for an
+	*                encrypted source.
+	* @returns A reusable {@link Ream} instance.
+	* @throws Error when no registered reader recognizes the bytes.
+	*/
 	static parse(bytes, options = {}) {
 		const readers = options.readers ?? DEFAULT_READERS;
 		const reader = readers.find((r) => r.sniff(bytes));
@@ -39,12 +76,34 @@ var Ream = class Ream {
 		const sheet = doc.kind === "sheet" ? doc : void 0;
 		return new Ream(toFlowDoc(doc), sheet, losses, bytes, reader.id);
 	}
+	/** The source format id (`'docx'`, `'xlsx'`, …). */
 	get format() {
 		return this.readerId;
 	}
+	/**
+	* Convert the parsed document to `to` and return just the output bytes. A thin
+	* wrapper over {@link Ream.convertWithReport} that drops the loss report.
+	*
+	* @param to      The target format.
+	* @param options Font resolution and target-specific options.
+	* @returns The encoded output bytes.
+	*/
 	async convert(to, options = {}) {
 		return (await this.convertWithReport(to, options)).bytes;
 	}
+	/**
+	* Convert the parsed document to `to`, returning the output bytes together with
+	* the accumulated {@link Loss} report (read-time losses plus any added while
+	* writing). HTML, DOCX and XLSX are produced straight from the interlayer — no
+	* layout, no fonts, zero I/O; SVG and PDF run the layout engine and resolve
+	* fonts first.
+	*
+	* @param to      The target format. `'xlsx'` requires a spreadsheet source.
+	* @param options Font resolution and target-specific options.
+	* @returns The encoded bytes and the loss report.
+	* @throws Error when `to` is `'xlsx'` but the source has no grid.
+	* @throws ConversionLossError when `options.strict` is set and any loss was recorded.
+	*/
 	async convertWithReport(to, options = {}) {
 		const losses = [...this.losses];
 		const flow = this.sheet && options.now ? projectSheetDoc(this.sheet, { now: options.now }) : this.flow;
@@ -120,6 +179,16 @@ var Ream = class Ream {
 			losses
 		};
 	}
+	/**
+	* Resolve the font set for a layout/PDF conversion. Explicit `fonts`/`fontBytes`
+	* win; otherwise the provider chain is tried, then an open substitute set is
+	* auto-downloaded (per detected family for docx). Any substitution is appended
+	* to `losses`.
+	*
+	* @param options The convert options carrying the font preferences.
+	* @param losses  The mutable loss list a substitution is appended to.
+	* @returns The font bytes and, for docx, optional per-family registries.
+	*/
 	async resolveFonts(options, losses) {
 		const explicit = options.fonts ?? (options.fontBytes ? { regular: options.fontBytes } : void 0);
 		if (explicit) return { fonts: explicit };
@@ -134,6 +203,13 @@ var Ream = class Ream {
 			...options.fontFetch ? { fetch: options.fontFetch } : {}
 		}) };
 	}
+	/**
+	* In strict mode, throw {@link ConversionLossError} for the first recorded loss.
+	*
+	* @param options The convert options (checked for `strict`).
+	* @param losses  The losses accumulated so far.
+	* @throws ConversionLossError when `options.strict` is set and `losses` is non-empty.
+	*/
 	enforceStrict(options, losses) {
 		if (options.strict && losses.length > 0) throw new ConversionLossError(losses[0]);
 	}

package/dist/esm/core/crypto/asn1.d.ts

@@ -1,22 +1,99 @@
+/**
+ * Concatenate a list of byte arrays into a single {@link Uint8Array}.
+ *
+ * @param arrays The arrays to join, in order.
+ * @returns A new array holding every input back to back.
+ */
 export declare function concat(arrays: ReadonlyArray<Uint8Array>): Uint8Array;
+/**
+ * Tag-length-value: wrap `content` in an identifier octet + definite-form length.
+ *
+ * @param tag     The identifier octet (tag class + constructed bit + number).
+ * @param content The already-encoded value bytes.
+ * @returns The complete `tag || length || content` encoding.
+ */
 export declare function tlv(tag: number, content: Uint8Array): Uint8Array;
+/** SEQUENCE (tag `0x30`) wrapping the concatenated `items`. */
 export declare const seq: (...items: Array<Uint8Array>) => Uint8Array;
+/** SET (tag `0x31`) wrapping the concatenated `items`. */
 export declare const set: (...items: Array<Uint8Array>) => Uint8Array;
+/** OCTET STRING (tag `0x04`) wrapping raw `bytes`. */
 export declare const octetString: (bytes: Uint8Array) => Uint8Array;
+/** NULL (tag `0x05`, empty content). */
 export declare const nullValue: () => Uint8Array;
+/** `[n]` context-tag, constructed (EXPLICIT or IMPLICIT-over-constructed). */
 export declare const explicit: (tagNum: number, content: Uint8Array) => Uint8Array;
+/**
+ * Encode a dotted OBJECT IDENTIFIER (§8.19). The first two arcs fold into
+ * `40*a + b`; each subsequent arc is base-128 big-endian.
+ *
+ * @param dotted The OID in dotted form, e.g. `"1.2.840.113549.1.7.2"`.
+ * @returns The OID TLV (tag `0x06`).
+ */
 export declare function oid(dotted: string): Uint8Array;
+/**
+ * Encode an INTEGER (§8.3) in minimal two's-complement form. Accepts a small
+ * non-negative number or raw magnitude bytes; prepends `0x00` when the top bit
+ * is set so the value stays positive.
+ *
+ * @param value A non-negative number, or big-endian magnitude bytes.
+ * @returns The INTEGER TLV (tag `0x02`).
+ */
 export declare function integer(value: number | Uint8Array): Uint8Array;
+/**
+ * Encode a CMS Time (RFC 5652 §11.3): `UTCTime` (`YYMMDDHHMMSSZ`) for years
+ * 1950–2049, `GeneralizedTime` (`YYYYMMDDHHMMSSZ`) otherwise.
+ *
+ * @param d The instant to encode (formatted in UTC).
+ * @returns The time TLV (tag `0x17` or `0x18`).
+ */
 export declare function cmsTime(d: Date): Uint8Array;
+/**
+ * The sorted, concatenated content of a `SET OF` (§11.6) — without the outer
+ * tag, so the same canonical body can be wrapped once as SET (`0x31`, for
+ * signing) and once as `[0]` IMPLICIT (`0xa0`, inside the `SignerInfo`).
+ *
+ * @param items The set members (each a full DER encoding).
+ * @returns The members sorted ascending by encoding and concatenated.
+ */
 export declare function setOfBody(items: ReadonlyArray<Uint8Array>): Uint8Array;
+/** A parsed DER tag-length-value, as byte offsets into the source buffer. */
 export interface Tlv {
+    /** The identifier octet. */
     readonly tag: number;
+    /** Offset of the first content byte. */
     readonly contentStart: number;
+    /** Offset one past the last content byte. */
     readonly contentEnd: number;
+    /** Offset one past the whole TLV (same as `contentEnd` for definite lengths). */
     readonly end: number;
 }
+/**
+ * Parse the immediate child TLVs of a constructed `parent`, in order.
+ *
+ * @param buf    The buffer the offsets index into.
+ * @param parent The constructed TLV whose content is walked.
+ * @returns Each child {@link Tlv}, left to right.
+ */
 export declare function children(buf: Uint8Array, parent: Tlv): Array<Tlv>;
+/**
+ * Read a single TLV header at `offset`, decoding short- and long-form lengths.
+ *
+ * @param buf    The source buffer.
+ * @param offset The offset of the identifier octet.
+ * @returns The parsed {@link Tlv} (offsets relative to `buf`).
+ */
 export declare function readTlv(buf: Uint8Array, offset: number): Tlv;
+/**
+ * Pull the issuer Name and serialNumber out of an X.509 certificate, as raw DER
+ * TLV slices (verbatim, for the CMS `IssuerAndSerialNumber`).
+ *
+ * `Certificate ::= SEQ { tbsCertificate SEQ { [0] version?, serialNumber INTEGER,
+ * signature AlgId, issuer Name, ... }, ... }`.
+ *
+ * @param cert The DER-encoded certificate.
+ * @returns The `issuer` Name and `serial` INTEGER, each a verbatim DER slice.
+ */
 export declare function certIssuerAndSerial(cert: Uint8Array): {
     readonly issuer: Uint8Array;
     readonly serial: Uint8Array;

package/dist/esm/core/crypto/asn1.js

@@ -1,5 +1,11 @@
 //#region src/core/crypto/asn1.ts
 var textEncoder = new TextEncoder();
+/**
+* Concatenate a list of byte arrays into a single {@link Uint8Array}.
+*
+* @param arrays The arrays to join, in order.
+* @returns A new array holding every input back to back.
+*/
 function concat(arrays) {
 	let total = 0;
 	for (const a of arrays) total += a.length;
@@ -21,6 +27,13 @@ function encodeLength(len) {
 	}
 	return new Uint8Array([128 | bytes.length, ...bytes]);
 }
+/**
+* Tag-length-value: wrap `content` in an identifier octet + definite-form length.
+*
+* @param tag     The identifier octet (tag class + constructed bit + number).
+* @param content The already-encoded value bytes.
+* @returns The complete `tag || length || content` encoding.
+*/
 function tlv(tag, content) {
 	const len = encodeLength(content.length);
 	const out = new Uint8Array(1 + len.length + content.length);
@@ -29,10 +42,15 @@ function tlv(tag, content) {
 	out.set(content, 1 + len.length);
 	return out;
 }
+/** SEQUENCE (tag `0x30`) wrapping the concatenated `items`. */
 var seq = (...items) => tlv(48, concat(items));
+/** SET (tag `0x31`) wrapping the concatenated `items`. */
 var set = (...items) => tlv(49, concat(items));
+/** OCTET STRING (tag `0x04`) wrapping raw `bytes`. */
 var octetString = (bytes) => tlv(4, bytes);
+/** NULL (tag `0x05`, empty content). */
 var nullValue = () => tlv(5, new Uint8Array(0));
+/** `[n]` context-tag, constructed (EXPLICIT or IMPLICIT-over-constructed). */
 var explicit = (tagNum, content) => tlv(160 | tagNum, content);
 function base128(v) {
 	const out = [v & 127];
@@ -43,12 +61,27 @@ function base128(v) {
 	}
 	return out;
 }
+/**
+* Encode a dotted OBJECT IDENTIFIER (§8.19). The first two arcs fold into
+* `40*a + b`; each subsequent arc is base-128 big-endian.
+*
+* @param dotted The OID in dotted form, e.g. `"1.2.840.113549.1.7.2"`.
+* @returns The OID TLV (tag `0x06`).
+*/
 function oid(dotted) {
 	const parts = dotted.split(".").map((p) => Number(p));
 	const body = [...base128(40 * parts[0] + parts[1])];
 	for (let i = 2; i < parts.length; i++) body.push(...base128(parts[i]));
 	return tlv(6, new Uint8Array(body));
 }
+/**
+* Encode an INTEGER (§8.3) in minimal two's-complement form. Accepts a small
+* non-negative number or raw magnitude bytes; prepends `0x00` when the top bit
+* is set so the value stays positive.
+*
+* @param value A non-negative number, or big-endian magnitude bytes.
+* @returns The INTEGER TLV (tag `0x02`).
+*/
 function integer(value) {
 	let bytes;
 	if (typeof value === "number") {
@@ -68,6 +101,13 @@ function integer(value) {
 	return tlv(2, new Uint8Array(bytes));
 }
 var pad2 = (n) => n.toString().padStart(2, "0");
+/**
+* Encode a CMS Time (RFC 5652 §11.3): `UTCTime` (`YYMMDDHHMMSSZ`) for years
+* 1950–2049, `GeneralizedTime` (`YYYYMMDDHHMMSSZ`) otherwise.
+*
+* @param d The instant to encode (formatted in UTC).
+* @returns The time TLV (tag `0x17` or `0x18`).
+*/
 function cmsTime(d) {
 	const y = d.getUTCFullYear();
 	const mmddhhmmss = pad2(d.getUTCMonth() + 1) + pad2(d.getUTCDate()) + pad2(d.getUTCHours()) + pad2(d.getUTCMinutes()) + pad2(d.getUTCSeconds());
@@ -79,9 +119,24 @@ function compareDer(a, b) {
 	for (let i = 0; i < n; i++) if (a[i] !== b[i]) return a[i] - b[i];
 	return a.length - b.length;
 }
+/**
+* The sorted, concatenated content of a `SET OF` (§11.6) — without the outer
+* tag, so the same canonical body can be wrapped once as SET (`0x31`, for
+* signing) and once as `[0]` IMPLICIT (`0xa0`, inside the `SignerInfo`).
+*
+* @param items The set members (each a full DER encoding).
+* @returns The members sorted ascending by encoding and concatenated.
+*/
 function setOfBody(items) {
 	return concat([...items].sort(compareDer));
 }
+/**
+* Read a single TLV header at `offset`, decoding short- and long-form lengths.
+*
+* @param buf    The source buffer.
+* @param offset The offset of the identifier octet.
+* @returns The parsed {@link Tlv} (offsets relative to `buf`).
+*/
 function readTlv(buf, offset) {
 	const tag = buf[offset];
 	let i = offset + 1;
@@ -102,6 +157,16 @@ function readTlv(buf, offset) {
 		end: i + len
 	};
 }
+/**
+* Pull the issuer Name and serialNumber out of an X.509 certificate, as raw DER
+* TLV slices (verbatim, for the CMS `IssuerAndSerialNumber`).
+*
+* `Certificate ::= SEQ { tbsCertificate SEQ { [0] version?, serialNumber INTEGER,
+* signature AlgId, issuer Name, ... }, ... }`.
+*
+* @param cert The DER-encoded certificate.
+* @returns The `issuer` Name and `serial` INTEGER, each a verbatim DER slice.
+*/
 function certIssuerAndSerial(cert) {
 	let p = readTlv(cert, readTlv(cert, 0).contentStart).contentStart;
 	let t = readTlv(cert, p);

package/dist/esm/core/crypto/cms.d.ts

@@ -1,9 +1,34 @@
+/** Inputs to {@link buildPkcs7Detached} for a detached PDF signature. */
 export interface CmsParams {
+    /**
+     * Signer's X.509 certificate (DER). Included in the CMS so a verifier can
+     * build the trust path; its issuer + serial identify the signer.
+     */
     readonly certificate: Uint8Array;
+    /** Optional additional chain certificates (DER), e.g. intermediates. */
     readonly extraCertificates?: ReadonlyArray<Uint8Array>;
+    /** SHA-256 digest of the signed PDF byte range (the detached content). */
     readonly messageDigest: Uint8Array;
     readonly signingTime: Date;
+    /**
+     * Public-key algorithm of the signer's key (default `'rsa'`). Selects the
+     * `SignerInfo` signatureAlgorithm (`rsaEncryption` vs `ecdsa-with-SHA256`); the
+     * digest stays SHA-256 either way.
+     */
     readonly signatureAlgorithm?: 'rsa' | 'ecdsa';
+    /**
+     * Signs the DER of the `signedAttrs` over SHA-256. For `'rsa'` this is
+     * RSASSA-PKCS1-v1_5; for `'ecdsa'` it must return a DER `Ecdsa-Sig-Value`
+     * (`SEQUENCE { r INTEGER, s INTEGER }`), not the raw r‖s.
+     */
     readonly sign: (signedAttrsDer: Uint8Array) => Promise<Uint8Array>;
 }
+/**
+ * Build a complete CMS `ContentInfo` (`id-signedData`) wrapping a single
+ * `SignerInfo` with authenticated attributes (`contentType`, `messageDigest`,
+ * `signingTime`). Detached: the signed PDF bytes are not carried in the CMS.
+ *
+ * @param params The certificate(s), message digest, signing time and sign callback.
+ * @returns The DER-encoded PKCS#7 blob for the signature dictionary's `/Contents`.
+ */
 export declare function buildPkcs7Detached(params: CmsParams): Promise<Uint8Array>;

package/dist/esm/core/crypto/cms.js

@@ -14,6 +14,14 @@ var sha256AlgId = () => seq(oid(OID.sha256));
 var rsaAlgId = () => seq(oid(OID.rsaEncryption), nullValue());
 var ecdsaAlgId = () => seq(oid(OID.ecdsaWithSHA256));
 var attribute = (oidStr, value) => seq(oid(oidStr), set(value));
+/**
+* Build a complete CMS `ContentInfo` (`id-signedData`) wrapping a single
+* `SignerInfo` with authenticated attributes (`contentType`, `messageDigest`,
+* `signingTime`). Detached: the signed PDF bytes are not carried in the CMS.
+*
+* @param params The certificate(s), message digest, signing time and sign callback.
+* @returns The DER-encoded PKCS#7 blob for the signature dictionary's `/Contents`.
+*/
 async function buildPkcs7Detached(params) {
 	const { issuer, serial } = certIssuerAndSerial(params.certificate);
 	const attrsBody = setOfBody([

package/dist/esm/core/document-model/index.d.ts

@@ -1 +1,8 @@
+/**
+ * The typed document model — the OOXML-faithful node types (paragraphs, runs,
+ * tables, sections, drawings, charts, math) that the readers populate and the
+ * writers consume. Imported via the `reamkit/document-model` subpath.
+ *
+ * @packageDocumentation
+ */
 export type { AbstractNumbering, Alignment, Border, BorderStyle, BodyElement, Comment, CellBorders, CellMerge, DocumentInfo, CellMargins, CellProperties, CellShading, CellDataBar, CellIcon, CellIconShape, CellSparkline, Chart, ChartBlock, ChartDataPoint, ChartSeries, ChartType, CustomGeometry, CustomPathCmd, DocumentModel, FontFamilyMap, HeaderFooterReference, HeaderFooterType, ImageBlock, InlineImage, MathAccent, MathBar, MathDelimiter, MathEqArray, MathFraction, MathFunc, MathGroupChr, MathLimit, MathMatrix, MathNary, MathNode, MathRadical, MathRow, MathRun, MathScript, Numbering, NumberingFormat, NumberingInstance, NumberingLevel, NumberingReference, PageMargins, PageSize, Paragraph, ParagraphProperties, Run, RunProperties, RowProperties, Section, FloatAnchor, SectionColumns, SectionProperties, ShapeBlock, ShapeDash, ShapeFill, ShapeFillKind, ShapeGeometry, ShapeLine, ShapeTextBody, ShapeTransform, Style, StyleSheet, StyleType, Table, TableCell, TableLook, TableProperties, TableStyleCondition, TableStyleConditionType, TableStyleLayer, TableRow, UnderlineStyle, VerticalAlign, } from './types.js';