@docmentis/udoc-node 0.0.1 → 0.8.0

package/LICENSE-APACHE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/LICENSE-MIT

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

package/README.md

@@ -0,0 +1,51 @@
+# @docmentis/udoc-node
+
+**Document processing for Node.js, powered by the udoc engine.**
+
+Use docMentis document capabilities programmatically in Node.js applications and services. Open documents, render pages, export images, and save document content without embedding a browser-based viewer.
+
+[![npm version](https://img.shields.io/npm/v/@docmentis/udoc-node)](https://www.npmjs.com/package/@docmentis/udoc-node)
+[![license](https://img.shields.io/npm/l/@docmentis/udoc-node)](https://github.com/docMentis/docmentis-udoc#open-source-packages-shared-runtime)
+
+**[Docs](https://www.docmentis.com/docs)** · **[API Reference](https://www.docmentis.com/docs/api/udoc-node)** · **[Changelog](https://github.com/docMentis/docmentis-udoc/blob/main/CHANGELOG.md)** · **[Report Issue](https://github.com/docMentis/docmentis-udoc/issues)**
+
+---
+
+## When to use it
+
+- **Backend document workflows.** Inspect and process documents inside your existing Node.js application.
+- **Rendering and previews.** Export document pages as images for thumbnails, previews, or other workflows.
+- **Document operations.** Read and save supported document formats, including udoc document packages.
+- **Custom integrations.** Build document functionality into your own services and automation tools.
+
+## Quick start
+
+```sh
+npm install @docmentis/udoc-node
+```
+
+```ts
+import { readFile, writeFile } from "node:fs/promises";
+import { UDocNode } from "@docmentis/udoc-node";
+
+const udoc = await UDocNode.create({ license: "YOUR_LICENSE", domain: "example.com" });
+const session = await udoc.open(await readFile("report.docx"));
+try {
+    const png = await session.exportPageToBytes(0, { png: { scale: 2 } });
+    await writeFile("page-1.png", png);
+} finally {
+    await session.close();
+}
+```
+
+A commercial license is shown for illustration; the runtime also supports online-authorized free use. See the API documentation for session management, supported formats, and licensing options. Requires a supported Node.js version.
+
+## Related packages
+
+Use [`@docmentis/udoc-cli`](https://www.npmjs.com/package/@docmentis/udoc-cli) for ready-made commands, or [`@docmentis/udoc-server`](https://www.npmjs.com/package/@docmentis/udoc-server) to expose document operations and collaboration through a hosted service.
+
+## Licensing
+
+The Node.js integration is open source under **MIT OR Apache-2.0**. The underlying [`@docmentis/udoc-wasm`](https://www.npmjs.com/package/@docmentis/udoc-wasm) runtime is proprietary and separately licensed. Free use requires online authorization; commercial licensing is available for offline use.
+
+[Source and documentation](https://github.com/docMentis/docmentis-udoc)

package/dist/blocking-fetch.d.ts

@@ -0,0 +1,8 @@
+import type { FetchChannel } from "./protocol.js";
+/**
+ * The engine's fetch over `channel`: post the URL, block this thread until the
+ * session's side counts an answer in, and take that answer off the port — the
+ * bytes, or a throw saying why they didn't come.
+ */
+export declare function blockingFetch({ port, answered }: FetchChannel): (url: string) => Uint8Array;
+//# sourceMappingURL=blocking-fetch.d.ts.map

package/dist/blocking-fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocking-fetch.d.ts","sourceRoot":"","sources":["../src/blocking-fetch.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAe,YAAY,EAAE,MAAM,eAAe,CAAC;AAE/D;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,YAAY,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,UAAU,CAY3F"}

package/dist/blocking-fetch.js

@@ -0,0 +1,30 @@
+// The worker's side of a remote open: the engine's fetch, made synchronous.
+//
+// The engine asks for a part the moment it needs one, and waits for it; Node
+// has no synchronous HTTP. So this thread posts the part's URL to the session's
+// side, which fetches it on the embedder's thread, and blocks until the answer
+// is counted in.
+//
+// Nothing here imports a sibling at runtime, so the tests run it from `src`.
+import { receiveMessageOnPort } from "node:worker_threads";
+/**
+ * The engine's fetch over `channel`: post the URL, block this thread until the
+ * session's side counts an answer in, and take that answer off the port — the
+ * bytes, or a throw saying why they didn't come.
+ */
+export function blockingFetch({ port, answered }) {
+    return (url) => {
+        // Read before posting, so an answer counted before the wait begins
+        // still ends it.
+        const seen = Atomics.load(answered, 0);
+        port.postMessage(url);
+        Atomics.wait(answered, 0, seen);
+        const answer = receiveMessageOnPort(port)?.message;
+        if (answer === undefined)
+            throw new Error("the session's side answered nothing");
+        if (!answer.ok)
+            throw new Error(answer.message);
+        return new Uint8Array(answer.body);
+    };
+}
+//# sourceMappingURL=blocking-fetch.js.map

package/dist/blocking-fetch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocking-fetch.js","sourceRoot":"","sources":["../src/blocking-fetch.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,EAAE;AACF,6EAA6E;AAC7E,gFAAgF;AAChF,+EAA+E;AAC/E,iBAAiB;AACjB,EAAE;AACF,6EAA6E;AAE7E,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAI3D;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAgB;IAC1D,OAAO,CAAC,GAAG,EAAE,EAAE;QACX,mEAAmE;QACnE,iBAAiB;QACjB,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;QACvC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QACtB,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;QAChC,MAAM,MAAM,GAAG,oBAAoB,CAAC,IAAI,CAAC,EAAE,OAAkC,CAAC;QAC9E,IAAI,MAAM,KAAK,SAAS;YAAE,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;QACjF,IAAI,CAAC,MAAM,CAAC,EAAE;YAAE,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAChD,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACvC,CAAC,CAAC;AACN,CAAC"}

package/dist/engine.d.ts

@@ -0,0 +1,3 @@
+/** The engine binary bundled in `@docmentis/udoc-wasm`, compiled. */
+export declare function compileEngine(): Promise<WebAssembly.Module>;
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAcA,qEAAqE;AACrE,wBAAgB,aAAa,IAAI,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAO3D"}

package/dist/engine.js

@@ -0,0 +1,20 @@
+// The bundled engine, compiled once per process.
+//
+// Compiling the ~30 MB binary is most of what loading it costs, and a compiled
+// `WebAssembly.Module` can be handed to a worker thread as is. So the module is
+// compiled here, on whichever thread builds the `UDocNode`, and every session's
+// worker instantiates that one module rather than reading and compiling its own.
+import { readFile } from "node:fs/promises";
+import { UDocError } from "@docmentis/udoc-wasm/error";
+import { bundledWasmUrl } from "@docmentis/udoc-wasm/meta-url";
+let compiled;
+/** The engine binary bundled in `@docmentis/udoc-wasm`, compiled. */
+export function compileEngine() {
+    // `bundledWasmUrl` is resolved against the wasm package's own module URL,
+    // which under Node is a `file:` URL that `readFile` takes directly.
+    compiled ??= readFile(new URL(bundledWasmUrl))
+        .then((bytes) => WebAssembly.compile(bytes))
+        .catch((error) => Promise.reject(UDocError.from(error)));
+    return compiled;
+}
+//# sourceMappingURL=engine.js.map

package/dist/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.js","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA,iDAAiD;AACjD,EAAE;AACF,+EAA+E;AAC/E,gFAAgF;AAChF,gFAAgF;AAChF,iFAAiF;AAEjF,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,IAAI,QAAiD,CAAC;AAEtD,qEAAqE;AACrE,MAAM,UAAU,aAAa;IACzB,0EAA0E;IAC1E,oEAAoE;IACpE,QAAQ,KAAK,QAAQ,CAAC,IAAI,GAAG,CAAC,cAAc,CAAC,CAAC;SACzC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;SAC3C,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACtE,OAAO,QAAQ,CAAC;AACpB,CAAC"}

package/dist/font-cache.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Font files fetched by URL, kept up to `limit` bytes; the least recently used
+ * goes first.
+ */
+export declare class FontCache {
+    #private;
+    /** Keep up to `limit` bytes of what `fetch` downloads. */
+    constructor(limit: number, fetch: (url: string) => Promise<Uint8Array>);
+    /**
+     * The file at `url`: kept, or fetched, kept and the oldest dropped until
+     * it fits. A failed fetch rejects and is not kept, so the next ask tries
+     * again; a file larger than `limit` is not kept.
+     */
+    get(url: string): Promise<Uint8Array>;
+}
+//# sourceMappingURL=font-cache.d.ts.map

package/dist/font-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"font-cache.d.ts","sourceRoot":"","sources":["../src/font-cache.ts"],"names":[],"mappings":"AAUA;;;GAGG;AACH,qBAAa,SAAS;;IAUlB,0DAA0D;gBAC9C,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC;IAKtE;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;CAkCxC"}

package/dist/font-cache.js

@@ -0,0 +1,66 @@
+// The font files every session a `UDocNode` opens shares.
+//
+// Each document runs in a worker and a wasm instance of its own, so what one
+// document downloaded goes when it closes, and the next document naming the
+// same family downloads it again. The files are kept here instead, on the
+// embedder's thread, where each session's worker asks for them by URL.
+//
+// Only files are kept. A css2 stylesheet is fetched each time — it is small,
+// and what it names is what gets downloaded.
+/**
+ * Font files fetched by URL, kept up to `limit` bytes; the least recently used
+ * goes first.
+ */
+export class FontCache {
+    #limit;
+    #fetch;
+    /** The bytes of every file in {@link #files}. */
+    #size = 0;
+    /** Oldest use first: a hit moves its file to the end. */
+    #files = new Map();
+    /** Downloads in flight, so two documents asking at once download once. */
+    #fetching = new Map();
+    /** Keep up to `limit` bytes of what `fetch` downloads. */
+    constructor(limit, fetch) {
+        this.#limit = limit;
+        this.#fetch = fetch;
+    }
+    /**
+     * The file at `url`: kept, or fetched, kept and the oldest dropped until
+     * it fits. A failed fetch rejects and is not kept, so the next ask tries
+     * again; a file larger than `limit` is not kept.
+     */
+    get(url) {
+        const kept = this.#files.get(url);
+        if (kept) {
+            this.#files.delete(url);
+            this.#files.set(url, kept);
+            return Promise.resolve(kept);
+        }
+        const fetching = this.#fetching.get(url);
+        if (fetching)
+            return fetching;
+        const fetched = this.#fetch(url).then((bytes) => {
+            this.#keep(url, bytes);
+            return bytes;
+        });
+        this.#fetching.set(url, fetched);
+        // Settled either way: a failure is not remembered.
+        void fetched.then(() => this.#fetching.delete(url), () => this.#fetching.delete(url));
+        return fetched;
+    }
+    /** Keep `bytes` as the newest file, dropping the oldest until all fit. */
+    #keep(url, bytes) {
+        if (bytes.byteLength > this.#limit)
+            return;
+        this.#files.set(url, bytes);
+        this.#size += bytes.byteLength;
+        for (const [oldest, file] of this.#files) {
+            if (this.#size <= this.#limit)
+                break;
+            this.#files.delete(oldest);
+            this.#size -= file.byteLength;
+        }
+    }
+}
+//# sourceMappingURL=font-cache.js.map

package/dist/font-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"font-cache.js","sourceRoot":"","sources":["../src/font-cache.ts"],"names":[],"mappings":"AAAA,0DAA0D;AAC1D,EAAE;AACF,6EAA6E;AAC7E,4EAA4E;AAC5E,0EAA0E;AAC1E,uEAAuE;AACvE,EAAE;AACF,6EAA6E;AAC7E,6CAA6C;AAE7C;;;GAGG;AACH,MAAM,OAAO,SAAS;IACT,MAAM,CAAS;IACf,MAAM,CAAuC;IACtD,iDAAiD;IACjD,KAAK,GAAG,CAAC,CAAC;IACV,yDAAyD;IAChD,MAAM,GAAG,IAAI,GAAG,EAAsB,CAAC;IAChD,0EAA0E;IACjE,SAAS,GAAG,IAAI,GAAG,EAA+B,CAAC;IAE5D,0DAA0D;IAC1D,YAAY,KAAa,EAAE,KAA2C;QAClE,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACxB,CAAC;IAED;;;;OAIG;IACH,GAAG,CAAC,GAAW;QACX,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,IAAI,EAAE,CAAC;YACP,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACxB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;YAC3B,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACjC,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACzC,IAAI,QAAQ;YAAE,OAAO,QAAQ,CAAC;QAE9B,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;YAC5C,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YACvB,OAAO,KAAK,CAAC;QACjB,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;QACjC,mDAAmD;QACnD,KAAK,OAAO,CAAC,IAAI,CACb,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,EAChC,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CACnC,CAAC;QACF,OAAO,OAAO,CAAC;IACnB,CAAC;IAED,0EAA0E;IAC1E,KAAK,CAAC,GAAW,EAAE,KAAiB;QAChC,IAAI,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,MAAM;YAAE,OAAO;QAC3C,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC5B,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,UAAU,CAAC;QAC/B,KAAK,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YACvC,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,MAAM;gBAAE,MAAM;YACrC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YAC3B,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,UAAU,CAAC;QAClC,CAAC;IACL,CAAC;CACJ"}

package/dist/format.d.ts

@@ -0,0 +1,4 @@
+import type { FileFormat } from "@docmentis/udoc-wasm";
+/** Whether `value` is a file format's name (`"pdf"`, `"pptx"`, `"jpg"`, …). */
+export declare function isFileFormat(value: string): value is FileFormat;
+//# sourceMappingURL=format.d.ts.map

package/dist/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../src/format.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAuBvD,+EAA+E;AAC/E,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,UAAU,CAE/D"}

package/dist/format.js

@@ -0,0 +1,30 @@
+// The file formats at run time. The schema's `FileFormat` is a type only, so a
+// host that receives one as text — a query parameter, a command-line flag —
+// checks it here.
+//
+// Nothing here imports a sibling at runtime, so the tests can load it from `src`.
+/** Every file format, held to the engine's `FileFormat`: a format added there
+ *  or dropped from it fails to typecheck here. */
+const FILE_FORMATS = {
+    pdf: true,
+    docx: true,
+    pptx: true,
+    xlsx: true,
+    csv: true,
+    tsv: true,
+    psv: true,
+    jpg: true,
+    png: true,
+    gif: true,
+    bmp: true,
+    tiff: true,
+    webp: true,
+    svg: true,
+    emf: true,
+    wmf: true,
+};
+/** Whether `value` is a file format's name (`"pdf"`, `"pptx"`, `"jpg"`, …). */
+export function isFileFormat(value) {
+    return Object.hasOwn(FILE_FORMATS, value);
+}
+//# sourceMappingURL=format.js.map

package/dist/format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.js","sourceRoot":"","sources":["../src/format.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,4EAA4E;AAC5E,kBAAkB;AAClB,EAAE;AACF,kFAAkF;AAIlF;kDACkD;AAClD,MAAM,YAAY,GAAG;IACjB,GAAG,EAAE,IAAI;IACT,IAAI,EAAE,IAAI;IACV,IAAI,EAAE,IAAI;IACV,IAAI,EAAE,IAAI;IACV,GAAG,EAAE,IAAI;IACT,GAAG,EAAE,IAAI;IACT,GAAG,EAAE,IAAI;IACT,GAAG,EAAE,IAAI;IACT,GAAG,EAAE,IAAI;IACT,GAAG,EAAE,IAAI;IACT,GAAG,EAAE,IAAI;IACT,IAAI,EAAE,IAAI;IACV,IAAI,EAAE,IAAI;IACV,GAAG,EAAE,IAAI;IACT,GAAG,EAAE,IAAI;IACT,GAAG,EAAE,IAAI;CACuB,CAAC;AAErC,+EAA+E;AAC/E,MAAM,UAAU,YAAY,CAAC,KAAa;IACtC,OAAO,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;AAC9C,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { UDocNode } from "./node.js";
+export type { UDocNodeOptions } from "./node.js";
+export type { RemoteCheckpointResponse, UDocSession } from "./session.js";
+export { UDocError } from "@docmentis/udoc-wasm/error";
+export type { UDocErrorCode, UDocErrorDetail } from "@docmentis/udoc-wasm/error";
+export type { ExportFormat, FileFormat, PageExportFormat, SaveStrategy, UDocType } from "@docmentis/udoc-wasm";
+export type { Entitlements, Feature } from "@docmentis/udoc-wasm";
+export { isFileFormat } from "./format.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrC,YAAY,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,YAAY,EAAE,wBAAwB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE1E,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAGjF,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,gBAAgB,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAE/G,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export { UDocNode } from "./node.js";
+// The error every failure is reported as.
+export { UDocError } from "@docmentis/udoc-wasm/error";
+export { isFileFormat } from "./format.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAIrC,0CAA0C;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAOvD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC"}

package/dist/node.d.ts

@@ -0,0 +1,101 @@
+import type { FileFormat, GoogleFontFamily, UrlFont } from "@docmentis/udoc-wasm";
+import { UDocSession } from "./session.js";
+/**
+ * What the engine is told about who is running it, under what license, and
+ * which fonts it may draw with beyond a document's own. Every session started
+ * through the same {@link UDocNode} carries it.
+ */
+export interface UDocNodeOptions {
+    /** Commercial license key. Absent is free usage, which is metered: every
+     *  {@link UDocNode.open} then needs a permit from the docMentis service. */
+    license?: string;
+    /** The domain the license is issued for. A browser host has a page to read
+     *  it from and a Node host does not, so here it is declared. Defaults to
+     *  `"unknown"`. */
+    domain?: string;
+    /** Ask for usage not to be reported. Honored only with a license;
+     *  otherwise ignored. */
+    disableTelemetry?: boolean;
+    /** Anonymous per-user id, so usage attributes to one user across sessions.
+     *  Without one, usage attributes to the domain. */
+    distinctId?: string;
+    /** The docMentis component embedding the engine, reported with every
+     *  permit request and usage event. Defaults to this package; `udoc-cli`
+     *  and `udoc-server` name themselves. */
+    wrapper?: {
+        name: string;
+        version: string;
+    };
+    /** Fonts of the host's own, offered to every document — each a font
+     *  file's bytes or a {@link UrlFont}, fetched once a document's text asks
+     *  for it; a `file:` URL is read from disk. Default none. */
+    fonts?: ReadonlyArray<Uint8Array | UrlFont>;
+    /** Fetch from Google Fonts the families a document names that no font of
+     *  its own or the host's ({@link fonts}) covers. `false` offers no Google
+     *  font family at all, so nothing is ever asked of Google. Default `true`. */
+    enableGoogleFonts?: boolean;
+    /** The Google font families offered, each its name, the `[bold, italic]`
+     *  faces Google serves for it and its subsets — to narrow the catalog
+     *  `@docmentis/udoc-wasm` ships (`GOOGLE_FONT_CATALOG`), extend it or keep it
+     *  current. Ignored when {@link enableGoogleFonts} is `false`. Default that
+     *  catalog. */
+    googleFontFamilies?: GoogleFontFamily[];
+    /** Where the Google Fonts css2 API is asked for a family's faces — a
+     *  mirror's, for a host that can't or won't reach Google. The font files
+     *  are fetched from the URLs its `@font-face` blocks give, so a mirror that
+     *  also stands in for `fonts.gstatic.com` rewrites them. An absolute URL.
+     *  Ignored when {@link enableGoogleFonts} is `false`. Default
+     *  `https://fonts.googleapis.com/css2`. */
+    googleFontEndpoint?: string | URL;
+    /** Bytes of downloaded font files kept for every session to reuse — a
+     *  Google font's files and each {@link UrlFont} fetched over the network —
+     *  the least recently used dropped first. `0` keeps none. Default 64 MiB. */
+    fontCacheSize?: number;
+}
+/**
+ * The udoc engine in this process: the host's identity, and the compiled
+ * engine every session instantiates. Build one per host identity and open as
+ * many documents through it as needed — each is a session of its own, on a
+ * thread of its own.
+ */
+export declare class UDocNode {
+    #private;
+    private constructor();
+    /** Compile the bundled engine (once per process) and return a `UDocNode` for it. */
+    static create(options?: UDocNodeOptions): Promise<UDocNode>;
+    /**
+     * Open a document from its bytes in a session of its own — as `format` when
+     * given, which skips detection; otherwise the format is detected, and a
+     * `.udoc` zip opens as a package. `delimiter` is the character a CSV's
+     * fields are split by; without it, a comma, or a semicolon where the first
+     * record is split by more of them. No other format takes one.
+     *
+     * Starts the session first, so this is where a license is checked and,
+     * without one, where a permit is spent — on this document, whether or not
+     * it then parses. Rejects with a `UDocError`: a licensing code when the
+     * engine refuses, or the engine's own when the bytes don't open.
+     *
+     * A PDF that needs a password opens waiting for one: the session's
+     * `needsPassword` says so, and its `authenticate` takes the password.
+     */
+    open(bytes: Uint8Array, format?: FileFormat, delimiter?: string): Promise<UDocSession>;
+    /**
+     * Open the package a server keeps at `url` in a session of its own, without
+     * downloading it — `url` is its package resource, udoc-server's
+     * `…/documents/{id}/package`, and absolute. Each part is fetched the first
+     * time the document needs it: the open fetches the few it starts from, and a
+     * call that composes a page fetches that page's, rejecting if one can't be
+     * fetched.
+     *
+     * A remote open is an open: this is where a license is checked and, without
+     * one, where a permit is spent. Rejects with a `UDocError`: a licensing code
+     * when the engine refuses, or the engine's own when the package can't be
+     * fetched or read.
+     *
+     * Each URL is fetched with the global `fetch`, unless `fetch` answers it —
+     * the whole body, as the route serves it — which is how udoc-server opens
+     * a session over the store it keeps, with no request to itself.
+     */
+    openRemote(url: string, fetch?: (url: string) => Promise<Uint8Array>): Promise<UDocSession>;
+}
+//# sourceMappingURL=node.d.ts.map

package/dist/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../src/node.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAiB,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAMjG,OAAO,EAAE,WAAW,EAAc,MAAM,cAAc,CAAC;AAGvD;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC5B;gFAC4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;uBAEmB;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;6BACyB;IACzB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;uDACmD;IACnD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;6CAEyC;IACzC,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAE5C;;iEAE6D;IAC7D,KAAK,CAAC,EAAE,aAAa,CAAC,UAAU,GAAG,OAAO,CAAC,CAAC;IAC5C;;kFAE8E;IAC9E,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;mBAIe;IACf,kBAAkB,CAAC,EAAE,gBAAgB,EAAE,CAAC;IACxC;;;;;+CAK2C;IAC3C,kBAAkB,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC;IAClC;;iFAE6E;IAC7E,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AAQD;;;;;GAKG;AACH,qBAAa,QAAQ;;IAUjB,OAAO;IAiBP,oFAAoF;WACvE,MAAM,CAAC,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAIrE;;;;;;;;;;;;;;OAcG;IACH,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAItF;;;;;;;;;;;;;;;;OAgBG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC;CAc9F"}