@storyteller-platform/epub 0.2.1 → 0.4.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import { Entry } from '@zip.js/zip.js';
+import { NativePath } from '@yarnpkg/fslib';
+import { ZipFS } from '@yarnpkg/libzip';
 import { XMLParser, XMLBuilder } from 'fast-xml-parser';
 
 declare global {
@@ -14,9 +15,10 @@ type Letter = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" |
 type QuestionMark = "?";
 /** A valid name for an XML element (must start with a letter) */
 type ElementName = `${Letter | Uppercase<Letter> | QuestionMark}${string}`;
+type PropertyPrefix = "@_";
 /** An XML element */
 type XmlElement<Name extends ElementName = ElementName> = {
-    ":@"?: Record<string, string>;
+    ":@"?: Record<`${PropertyPrefix}${string}`, string>;
 } & {
     [key in Name]: ParsedXml;
 };
@@ -36,17 +38,6 @@ type ManifestItem = {
     mediaOverlay?: string | undefined;
     properties?: string[] | undefined;
 };
-declare class EpubEntry {
-    filename: string;
-    private entry;
-    private data;
-    getData(): Promise<Uint8Array<ArrayBufferLike>>;
-    setData(data: Uint8Array): void;
-    constructor(entry: Entry | {
-        filename: string;
-        data: Uint8Array;
-    });
-}
 type MetadataEntry = {
     id?: string | undefined;
     type: ElementName;
@@ -94,7 +85,7 @@ type PackageElement = XmlElement<"package"> | XmlElement<"opf:package">;
  * Example usage:
  *
  * ```ts
- * import { Epub, getBody, findByName, textContent } from '@smoores/epub';
+ * import { Epub, getBody, findByName, textContent } from '@storyteller-platform/epub';
  *
  * const epub = await Epub.from('./path/to/book.epub');
  * const title = await epub.getTitle();
@@ -114,8 +105,9 @@ type PackageElement = XmlElement<"package"> | XmlElement<"opf:package">;
  * @link https://www.w3.org/TR/epub-33/
  */
 declare class Epub {
-    private entries;
-    private onClose?;
+    protected zipFs: ZipFS;
+    protected zipPath: NativePath;
+    protected inputPath: string | undefined;
     static xmlParser: XMLParser;
     static xhtmlParser: XMLParser;
     static xmlBuilder: XMLBuilder;
@@ -171,18 +163,11 @@ declare class Epub {
      * a text node or an XML element.
      */
     static isXmlTextNode(node: XmlNode): node is XmlTextNode;
-    private zipWriter;
-    private dataWriter;
     private rootfile;
     private manifest;
     private spine;
     private packageMutex;
-    protected constructor(entries: EpubEntry[], onClose?: (() => Promise<void> | void) | undefined);
-    /**
-     * Close the Epub. Must be called before the Epub goes out
-     * of scope/is garbage collected.
-     */
-    close(): Promise<void>;
+    protected constructor(zipFs: ZipFS, zipPath: NativePath, inputPath: string | undefined);
     /**
      * Construct an Epub instance, optionally beginning
      * with the provided metadata.
@@ -190,7 +175,7 @@ declare class Epub {
      * @param dublinCore Core metadata terms
      * @param additionalMetadata An array of additional metadata entries
      */
-    static create({ title, language, identifier, date, subjects, type, creators, contributors, }: DublinCore, additionalMetadata?: EpubMetadata): Promise<Epub>;
+    static create(path: string, { title, language, identifier, date, subjects, type, creators, contributors, }: DublinCore, additionalMetadata?: EpubMetadata): Promise<Epub>;
     /**
      * Construct an Epub instance by reading an existing EPUB
      * publication.
@@ -200,7 +185,6 @@ declare class Epub {
      *        the data of the EPUB publication.
      */
     static from(pathOrData: string | Uint8Array): Promise<Epub>;
-    private getEntry;
     private removeEntry;
     private getFileData;
     private getRootfile;
@@ -277,6 +261,24 @@ declare class Epub {
      * @link https://www.w3.org/TR/epub-33/#sec-pkg-metadata
      */
     getMetadata(): Promise<EpubMetadata>;
+    /**
+     * Retrieve the identifier from the dc:identifier element
+     * in the EPUB metadata.
+     *
+     * If there is no dc:identifier element, returns null.
+     *
+     * @link https://www.w3.org/TR/epub-33/#sec-opf-dcidentifier
+     */
+    getIdentifier(): Promise<string | null>;
+    /**
+     * Set the dc:identifier metadata element with the provided string.
+     *
+     * Updates the existing dc:identifier element if one exists.
+     * Otherwise creates a new element
+     *
+     * @link https://www.w3.org/TR/epub-33/#sec-opf-dcidentifier
+     */
+    setIdentifier(identifier: string): Promise<void>;
     /**
      * Even "EPUB 3" publications sometimes still only use the
      * EPUB 2 specification for identifying the cover image.
@@ -601,7 +603,7 @@ declare class Epub {
      * @param head Optional - the XMl nodes to place in the head
      * @param language Optional - defaults to the EPUB's language
      */
-    createXhtmlDocument(body: ParsedXml, head?: ParsedXml, language?: Intl.Locale): Promise<(XmlElement<"?xml"> | XmlElement<"html">)[]>;
+    createXhtmlDocument(body: ParsedXml, head?: ParsedXml, language?: Intl.Locale): Promise<(XmlElement<"html"> | XmlElement<"?xml">)[]>;
     /**
      * Retrieves the contents of an XHTML item, given its manifest id.
      *
@@ -697,18 +699,29 @@ declare class Epub {
      */
     replaceMetadata(predicate: (entry: MetadataEntry) => boolean, entry: MetadataEntry): Promise<void>;
     /**
-     * Write the current contents of the Epub to a new
-     * Uint8Array.
+     * Remove one or more metadata entries.
+     *
+     * The `predicate` argument will be used to determine which entries
+     * to remove. The all metadata entries that match the
+     * predicate will be removed.
+     *
+     * @param predicate Calls predicate once for each metadata entry,
+     *  removing any for which it returns true
      *
-     * This _does not_ close the Epub. It can continue to
-     * be modified after it has been written to disk. Use
-     * `epub.close()` to close the Epub.
+     * @link https://www.w3.org/TR/epub-33/#sec-pkg-metadata
+     */
+    removeMetadata(predicate: (entry: MetadataEntry) => boolean): Promise<void>;
+    discardAndClose(): void;
+    /**
+     * Write the current contents of the Epub to a new
+     * EPUB archive on disk.
      *
      * When this method is called, the "dcterms:modified"
      * meta tag is automatically updated to the current UTC
      * timestamp.
      */
-    writeToArray(): Promise<Uint8Array<ArrayBufferLike>>;
+    saveAndClose(): Promise<void>;
+    [Symbol.dispose](): void;
 }
 
 export { type AlternateScript, type Collection, type DcCreator, type DcSubject, type DublinCore, type ElementName, Epub, type EpubMetadata, type ManifestItem, type MetadataEntry, type PackageElement, type ParsedXml, type XmlElement, type XmlNode, type XmlTextNode };

package/dist/index.js

@@ -1,45 +1,19 @@
-import {
-  ERR_DUPLICATED_NAME,
-  Uint8ArrayReader,
-  Uint8ArrayWriter,
-  ZipReader,
-  ZipWriter
-} from "@zip.js/zip.js";
+import { randomUUID } from "node:crypto";
+import { rmSync } from "node:fs";
+import { cp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { PortablePath, npath, ppath } from "@yarnpkg/fslib";
+import { DEFAULT_COMPRESSION_LEVEL, ZipFS } from "@yarnpkg/libzip";
 import { Mutex } from "async-mutex";
 import { XMLBuilder, XMLParser } from "fast-xml-parser";
 import memoize from "mem";
 import { lookup } from "mime-types";
 import { nanoid } from "nanoid";
-import { dirname, resolve } from "@storyteller-platform/path";
-class EpubEntry {
-  filename;
-  entry = null;
-  data = null;
-  async getData() {
-    if (this.data) return this.data;
-    const writer = new Uint8ArrayWriter();
-    const data = await this.entry.getData(writer);
-    this.data = data;
-    return this.data;
-  }
-  setData(data) {
-    this.data = data;
-  }
-  constructor(entry) {
-    this.filename = entry.filename;
-    if ("data" in entry) {
-      this.data = entry.data;
-    } else {
-      this.entry = entry;
-    }
-  }
-}
 class Epub {
-  constructor(entries, onClose) {
-    this.entries = entries;
-    this.onClose = onClose;
-    this.dataWriter = new Uint8ArrayWriter();
-    this.zipWriter = new ZipWriter(this.dataWriter);
+  constructor(zipFs, zipPath, inputPath) {
+    this.zipFs = zipFs;
+    this.zipPath = zipPath;
+    this.inputPath = inputPath;
     this.readXhtmlItemContents = memoize(
       this.readXhtmlItemContents.bind(this),
       // This isn't unnecessary, the generic here just isn't handling the
@@ -194,21 +168,10 @@ ${JSON.stringify(element, null, 2)}`
   static isXmlTextNode(node) {
     return "#text" in node;
   }
-  zipWriter;
-  dataWriter;
   rootfile = null;
   manifest = null;
   spine = null;
   packageMutex = new Mutex();
-  /**
-   * Close the Epub. Must be called before the Epub goes out
-   * of scope/is garbage collected.
-   */
-  async close() {
-    var _a;
-    await ((_a = this.onClose) == null ? void 0 : _a.call(this));
-    await this.zipWriter.close();
-  }
   /**
    * Construct an Epub instance, optionally beginning
    * with the provided metadata.
@@ -216,7 +179,7 @@ ${JSON.stringify(element, null, 2)}`
    * @param dublinCore Core metadata terms
    * @param additionalMetadata An array of additional metadata entries
    */
-  static async create({
+  static async create(path, {
     title,
     language,
     identifier,
@@ -226,7 +189,11 @@ ${JSON.stringify(element, null, 2)}`
     creators,
     contributors
   }, additionalMetadata = []) {
-    const entries = [];
+    const tmp = npath.join(
+      tmpdir(),
+      `storyteller-platform-epub-${randomUUID()}.epub`
+    );
+    const zipFs = new ZipFS(npath.toPortablePath(tmp), { create: true });
     const encoder = new TextEncoder();
     const container = encoder.encode(`<?xml version="1.0"?>
 <container>
@@ -235,8 +202,10 @@ ${JSON.stringify(element, null, 2)}`
   </rootfiles>
 </container>
 `);
-    entries.push(
-      new EpubEntry({ filename: "META-INF/container.xml", data: container })
+    await zipFs.mkdirpPromise(ppath.join(PortablePath.root, "META-INF"));
+    await zipFs.writeFilePromise(
+      ppath.join(PortablePath.root, "META-INF", "container.xml"),
+      container
     );
     const packageDocument = encoder.encode(`<?xml version="1.0"?>
 <package unique-identifier="pub-id" dir="${language.textInfo.direction}" xml:lang=${language.toString()} version="3.0">
@@ -248,10 +217,12 @@ ${JSON.stringify(element, null, 2)}`
   </spine>
 </package>
 `);
-    entries.push(
-      new EpubEntry({ filename: "OEBPS/content.opf", data: packageDocument })
+    await zipFs.mkdirpPromise(ppath.join(PortablePath.root, "OEBPS"));
+    await zipFs.writeFilePromise(
+      ppath.join(PortablePath.root, "OEBPS", "content.opf"),
+      packageDocument
     );
-    const epub = new this(entries);
+    const epub = new this(zipFs, tmp, path);
     const metadata = [
       {
         id: "pub-id",
@@ -287,42 +258,37 @@ ${JSON.stringify(element, null, 2)}`
    *        path to an EPUB file on disk, or a Uint8Array representing
    *        the data of the EPUB publication.
    */
+  // eslint-disable-next-line @typescript-eslint/require-await
   static async from(pathOrData) {
-    if (typeof pathOrData === "string") {
-      throw new Error("Import from /node to construct from a file");
+    const tmp = npath.join(
+      tmpdir(),
+      `storyteller-platform-epub-${randomUUID()}.epub`
+    );
+    if (typeof pathOrData !== "string") {
+      await writeFile(tmp, pathOrData);
+    } else {
+      await cp(pathOrData, tmp);
     }
-    const fileData = pathOrData;
-    const dataReader = new Uint8ArrayReader(fileData);
-    const zipReader = new ZipReader(dataReader);
-    const zipEntries = await zipReader.getEntries();
-    const epubEntries = zipEntries.map((entry) => new EpubEntry(entry));
-    const epub = new this(epubEntries, () => zipReader.close());
-    return epub;
-  }
-  getEntry(path) {
-    return this.entries.find((entry) => entry.filename === path);
+    const zipFs = new ZipFS(npath.toPortablePath(tmp));
+    return new this(
+      zipFs,
+      tmp,
+      typeof pathOrData === "string" ? pathOrData : void 0
+    );
   }
   async removeEntry(href) {
     const rootfile = await this.getRootfile();
     const filename = this.resolveHref(rootfile, href);
-    const index = this.entries.findIndex((entry) => entry.filename === filename);
-    if (index === -1) return;
-    this.entries.splice(index, 1);
+    await this.zipFs.removePromise(filename);
   }
   async getFileData(path, encoding) {
-    const containerEntry = this.getEntry(path);
-    if (!containerEntry)
-      throw new Error(
-        `Could not get file data for entry ${path}: entry not found`
-      );
-    const containerContents = await containerEntry.getData();
-    return encoding === "utf-8" ? new TextDecoder("utf-8").decode(containerContents) : containerContents;
+    return await this.zipFs.readFilePromise(path, encoding);
   }
   async getRootfile() {
     var _a;
     if (this.rootfile !== null) return this.rootfile;
     const containerString = await this.getFileData(
-      "META-INF/container.xml",
+      ppath.join(PortablePath.root, "META-INF", "container.xml"),
       "utf-8"
     );
     if (!containerString)
@@ -349,11 +315,12 @@ ${JSON.stringify(element, null, 2)}`
         return !Epub.isXmlTextNode(node) && ((_a2 = node[":@"]) == null ? void 0 : _a2["@_media-type"]) === "application/oebps-package+xml";
       }
     );
-    if (!((_a = rootfile == null ? void 0 : rootfile[":@"]) == null ? void 0 : _a["@_full-path"]))
+    const fullPath = (_a = rootfile == null ? void 0 : rootfile[":@"]) == null ? void 0 : _a["@_full-path"];
+    if (!fullPath)
       throw new Error(
         "Failed to parse EPUB container.xml: Found no rootfile element"
       );
-    this.rootfile = rootfile[":@"]["@_full-path"];
+    this.rootfile = ppath.resolve(PortablePath.root, fullPath);
     return this.rootfile;
   }
   migratePackageDocument(packageDocument) {
@@ -416,7 +383,7 @@ ${JSON.stringify(element, null, 2)}`
         produced ?? packageDocument
       );
       const rootfile = await this.getRootfile();
-      this.writeEntryContents(rootfile, updatedPackageDocument, "utf-8");
+      await this.writeEntryContents(rootfile, updatedPackageDocument, "utf-8");
     });
   }
   /**
@@ -555,6 +522,34 @@ ${JSON.stringify(element, null, 2)}`
     const metadata = metadataElement.metadata.map((node) => Epub.parseMetadataItem(node)).filter((node) => !!node);
     return metadata;
   }
+  /**
+   * Retrieve the identifier from the dc:identifier element
+   * in the EPUB metadata.
+   *
+   * If there is no dc:identifier element, returns null.
+   *
+   * @link https://www.w3.org/TR/epub-33/#sec-opf-dcidentifier
+   */
+  async getIdentifier() {
+    const metadata = await this.getMetadata();
+    const entry = metadata.find(({ type }) => type === "dc:identifier");
+    return (entry == null ? void 0 : entry.value) ?? null;
+  }
+  /**
+   * Set the dc:identifier metadata element with the provided string.
+   *
+   * Updates the existing dc:identifier element if one exists.
+   * Otherwise creates a new element
+   *
+   * @link https://www.w3.org/TR/epub-33/#sec-opf-dcidentifier
+   */
+  async setIdentifier(identifier) {
+    await this.replaceMetadata(({ type }) => type === "dc:identifier", {
+      type: "dc:identifier",
+      properties: {},
+      value: identifier
+    });
+  }
   /**
    * Even "EPUB 3" publications sometimes still only use the
    * EPUB 2 specification for identifying the cover image.
@@ -1448,9 +1443,8 @@ ${JSON.stringify(element, null, 2)}`
    * Returns a Zip Entry path for an HREF
    */
   resolveHref(from, href) {
-    const startPath = dirname(from);
-    const absoluteStartPath = startPath.startsWith("/") ? startPath : `/${startPath}`;
-    return resolve(absoluteStartPath, href).slice(1);
+    const startPath = ppath.dirname(from);
+    return ppath.resolve(PortablePath.root, startPath, href);
   }
   async readItemContents(id, encoding) {
     const rootfile = await this.getRootfile();
@@ -1495,11 +1489,9 @@ ${JSON.stringify(element, null, 2)}`
     const body = Epub.getXhtmlBody(xml);
     return Epub.getXhtmlTextContent(body);
   }
-  writeEntryContents(path, contents, encoding) {
-    const data = encoding === "utf-8" ? new TextEncoder().encode(contents) : contents;
-    const entry = this.getEntry(path);
-    if (!entry) throw new Error(`Could not find file at ${path} in EPUB`);
-    entry.setData(data);
+  async writeEntryContents(path, contents, encoding) {
+    await this.zipFs.mkdirpPromise(ppath.dirname(path));
+    await this.zipFs.writeFilePromise(path, contents, encoding);
   }
   async writeItemContents(id, contents, encoding) {
     const rootfile = await this.getRootfile();
@@ -1510,9 +1502,9 @@ ${JSON.stringify(element, null, 2)}`
     memoize.clear(this.readXhtmlItemContents);
     const href = this.resolveHref(rootfile, manifestItem.href);
     if (encoding === "utf-8") {
-      this.writeEntryContents(href, contents, encoding);
+      await this.writeEntryContents(href, contents, encoding);
     } else {
-      this.writeEntryContents(href, contents);
+      await this.writeEntryContents(href, contents);
     }
   }
   /**
@@ -1575,7 +1567,9 @@ ${JSON.stringify(element, null, 2)}`
           ...item.mediaType && { "media-type": item.mediaType },
           ...item.fallback && { fallback: item.fallback },
           ...item.mediaOverlay && { "media-overlay": item.mediaOverlay },
-          ...item.properties && { properties: item.properties.join(" ") }
+          ...item.properties && {
+            properties: item.properties.join(" ")
+          }
         })
       );
     });
@@ -1587,7 +1581,8 @@ ${JSON.stringify(element, null, 2)}`
         contents
       )
     ) : contents;
-    this.entries.push(new EpubEntry({ filename, data }));
+    await this.zipFs.mkdirpPromise(ppath.dirname(filename));
+    await this.zipFs.writeFilePromise(filename, data);
   }
   /**
    * Update the manifest entry for an existing item.
@@ -1737,19 +1732,25 @@ ${JSON.stringify(element, null, 2)}`
       }
     });
   }
+  discardAndClose() {
+    this.zipFs.discardAndClose();
+    this.rootfile = null;
+    this.manifest = null;
+    this.spine = null;
+    rmSync(this.zipPath, { recursive: true, force: true });
+  }
   /**
    * Write the current contents of the Epub to a new
-   * Uint8Array.
-   *
-   * This _does not_ close the Epub. It can continue to
-   * be modified after it has been written to disk. Use
-   * `epub.close()` to close the Epub.
+   * EPUB archive on disk.
    *
    * When this method is called, the "dcterms:modified"
    * meta tag is automatically updated to the current UTC
    * timestamp.
    */
-  async writeToArray() {
+  async saveAndClose() {
+    if (!this.inputPath) {
+      throw new Error("In-memory EPUB files cannot be saved to disk");
+    }
     await this.replaceMetadata(
       (entry) => entry.properties["property"] === "dcterms:modified",
       {
@@ -1759,48 +1760,20 @@ ${JSON.stringify(element, null, 2)}`
         value: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d+/, "")
       }
     );
-    let mimetypeEntry = this.getEntry("mimetype");
-    if (!mimetypeEntry) {
-      mimetypeEntry = new EpubEntry({
-        filename: "mimetype",
-        data: new TextEncoder().encode("application/epub+zip")
-      });
-      this.entries.push(mimetypeEntry);
-    }
-    const mimetypeReader = new Uint8ArrayReader(await mimetypeEntry.getData());
-    try {
-      await this.zipWriter.add(mimetypeEntry.filename, mimetypeReader, {
-        level: 0,
-        extendedTimestamp: false
-      });
-    } catch (e) {
-      if (e instanceof Error && e.message === ERR_DUPLICATED_NAME) {
-        throw new Error(
-          `Failed to add file "${mimetypeEntry.filename}" to zip archive: ${e.message}`
-        );
-      }
-      throw e;
-    }
-    await Promise.all(
-      this.entries.map(async (entry) => {
-        if (entry.filename === "mimetype") return;
-        const reader = new Uint8ArrayReader(await entry.getData());
-        try {
-          return await this.zipWriter.add(entry.filename, reader);
-        } catch (e) {
-          if (e instanceof Error && e.message === ERR_DUPLICATED_NAME) {
-            throw new Error(
-              `Failed to add file "${entry.filename}" to zip archive: ${e.message}`
-            );
-          }
-          throw e;
-        }
-      })
+    this.zipFs.level = 0;
+    await this.zipFs.writeFilePromise(
+      ppath.join(PortablePath.root, "mimetype"),
+      "application/epub+zip",
+      "utf-8"
     );
-    const data = await this.zipWriter.close();
-    this.dataWriter = new Uint8ArrayWriter();
-    this.zipWriter = new ZipWriter(this.dataWriter);
-    return data;
+    this.zipFs.level = DEFAULT_COMPRESSION_LEVEL;
+    this.zipFs.saveAndClose();
+    await cp(this.zipPath, this.inputPath, { force: true });
+  }
+  [Symbol.dispose]() {
+    if (this.zipFs.ready) {
+      this.discardAndClose();
+    }
   }
 }
 export {

package/package.json

@@ -1,34 +1,18 @@
 {
   "name": "@storyteller-platform/epub",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "type": "module",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "MIT",
   "exports": {
-    ".": {
-      "@storyteller": "./index.ts",
-      "@storyteller-node": "./node.ts",
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
+    "import": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
-    "./node": {
-      "@storyteller": "./node.ts",
-      "@storyteller-node": "./node.ts",
-      "import": {
-        "types": "./dist/node.d.ts",
-        "default": "./dist/node.js"
-      },
-      "require": {
-        "types": "./dist/node.d.cts",
-        "default": "./dist/node.cjs"
-      }
+    "require": {
+      "types": "./dist/index.d.cts",
+      "default": "./dist/index.cjs"
     }
   },
   "files": [
@@ -47,19 +31,21 @@
     "@storyteller-platform/tsup": "^0.1.0",
     "@tsconfig/strictest": "^2.0.5",
     "@types/mime-types": "^2",
-    "@types/node": "^22.10.1",
+    "@types/node": "^24.0.0",
     "markdown-toc": "^1.2.0",
     "remark-toc": "^9.0.0",
     "tsup": "^8.5.0",
     "tsx": "^4.19.2",
-    "typedoc": "^0.28.4",
+    "typedoc": "^0.28.13",
     "typedoc-plugin-markdown": "^4.6.3",
     "typedoc-plugin-remark": "^1.2.0",
-    "typescript": "^5.8.3"
+    "typescript": "^5.9.2"
   },
   "dependencies": {
-    "@storyteller-platform/fs": "^0.1.2",
-    "@storyteller-platform/path": "^0.1.0",
+    "@storyteller-platform/fs": "^0.1.3",
+    "@storyteller-platform/path": "^0.1.1",
+    "@yarnpkg/fslib": "^3.1.3",
+    "@yarnpkg/libzip": "^3.2.2",
     "@zip.js/zip.js": "^2.0.0",
     "async-mutex": "^0.5.0",
     "fast-xml-parser": "^4.0.0",
@@ -68,6 +54,16 @@
     "nanoid": "^5.1.5"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "exports": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
   }
 }