zip-writer 1.1.1 → 2.0.0

package/README.md

@@ -1,5 +1,9 @@
 # zip-writable
 
+[![npm version](https://img.shields.io/npm/v/zip-writer.svg)](https://www.npmjs.com/package/zip-writer)
+[![GitHub CI](https://github.com/gmaclennan/zip-writer/actions/workflows/test.yml/badge.svg)](https://github.com/gmaclennan/zip-writer/actions/workflows/test.yml)
+[![bundle size](https://deno.bundlejs.com/badge?q=zip-writer@1.1.2&treeshake=[*])](https://bundlejs.com/?q=zip-writer%401.1.2&treeshake=%5B*%5D)
+
 A modern streaming ZIP archive writer for JavaScript that uses the
 [Web Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API)
 and
@@ -7,12 +11,17 @@ and
 
 ## Features
 
-- **Streaming API** - Write ZIP archives using Web Streams
-- **Memory efficient** - Process large files without loading them entirely into
-  memory
+- **Streaming API** - Write ZIP archives without buffering entries our the
+  output zip into memory
+- **Browser & Node.js** - Works in both environments with the same API
+- **Small bundle size** - ~3KB minified and gzipped
+- **Minimal dependencies** - Only depends on
+  [p-mutex](https://www.npmjs.com/package/p-mutex) for mutex locking (adds ~390
+  bytes)
 - **ZIP64 support** - Automatic handling of large files and archives
-- **Modern JavaScript** - Built with TypeScript, uses native Web Streams API
-- **Flexible** - Reorder, rename, or remove entries before finalizing
+- **Editable Central Directory** - Reorder, rename, or remove entries before
+  finalizing
+- **100% test coverage** - Output validated against standard ZIP tools
 
 ## Installation
 
@@ -31,13 +40,16 @@ const zipWriter = new ZipWriter();
 zipWriter.readable.pipeTo(writableStream);
 
 // Add entries to the ZIP
-const entryWriter = zipWriter.createEntryStream({ name: "hello.txt" });
-const writer = entryWriter.writable.getWriter();
-await writer.write(new TextEncoder().encode("Hello, World!"));
-await writer.close();
-
-// Get entry info after writing
-const info = await entryWriter.getEntryInfo();
+const data = new TextEncoder().encode("Hello, World!");
+const info = await zipWriter.addEntry({
+  readable: new ReadableStream({
+    start(controller) {
+      controller.enqueue(data);
+      controller.close();
+    },
+  }),
+  name: "hello.txt",
+});
 console.log(info);
 
 // Finalize the ZIP archive
@@ -83,93 +95,66 @@ return new Response(zipWriter.readable, {
 });
 ```
 
-##### `entries: ReadonlyArray<Readonly<EntryInfo>>`
+##### `entries(): Promise<EntryInfo[]>`
 
-Array of all entries that have been written to the archive. Each entry contains
-metadata like size, CRC32, compression info, etc.
+Returns a promise that resolves to an array of all entries that have been
+written to the archive. Each entry contains metadata like size, CRC32,
+compression info, etc.
 
 #### Methods
 
-##### `createEntry(data: Uint8Array, options: EntryOptions): Promise<EntryInfo>`
-
-Convenience method to add a buffer as an entry to the zip archive. Returns a
-promise that resolves to the entry info once written. For more efficient
-streaming writes, use `createEntryStream()`.
-
-**Parameters:**
-
-- `data: Uint8Array` - Entry data to write
-- `options.name: string` - Entry name including internal path (required)
-- `options.comment?: string` - Entry comment
-- `options.date?: Date` - Entry date (defaults to current date)
-- `options.mode?: number` - Entry permissions (Unix-style mode)
-- `options.store?: boolean` - Set to `true` to disable compression (defaults to
-  `false`, using DEFLATE compression)
-
-**Example:**
-
-```ts
-const data = new TextEncoder().encode("Hello, World!");
-const entryInfo = await zipWriter.createEntry(data, { name: "hello.txt" });
-console.log(entryInfo);
-```
-
-##### `createEntryStream(options: EntryOptions): EntryWriter`
+##### `addEntry(entry: Entry): Promise<EntryInfo>`
 
-Create a new entry in the ZIP archive. Returns an `EntryWriter` that you can
-write data to via streams.
+Add an entry to the ZIP archive. Returns a promise that resolves to the entry
+info once written.
 
 **Parameters:**
 
-- `options.name: string` - Entry name including internal path (required)
-- `options.comment?: string` - Entry comment
-- `options.date?: Date` - Entry date (defaults to current date)
-- `options.mode?: number` - Entry permissions (Unix-style mode)
-- `options.store?: boolean` - Set to `true` to disable compression (defaults to
+- `entry.readable: ReadableStream<ArrayBufferView>` - Readable stream of entry
+  data
+- `entry.name: string` - Entry name including internal path (required)
+- `entry.comment?: string` - Entry comment
+- `entry.date?: Date` - Entry date (defaults to current date)
+- `entry.mode?: number` - Entry permissions (Unix-style mode)
+- `entry.store?: boolean` - Set to `true` to disable compression (defaults to
   `false`, using DEFLATE compression)
 
 **Examples:**
 
 ```ts
-// Simple text file
-const entry = zipWriter.createEntryStream({ name: "readme.txt" });
-const writer = entry.writable.getWriter();
-await writer.write(new TextEncoder().encode("Hello!"));
-await writer.close();
-
-// Stream a fetch response
+// Stream from a fetch response
 const response = await fetch(imageUrl);
-response.body.pipeTo(
-  zipWriter.createEntryStream({ name: "images/photo.jpg" }).writable,
-);
+await zipWriter.addEntry({
+  readable: response.body,
+  name: "images/photo.jpg",
+});
+
+// Stream from a Uint8Array
+const data = new TextEncoder().encode("Hello, World!");
+await zipWriter.addEntry({
+  readable: new ReadableStream({
+    start(controller) {
+      controller.enqueue(data);
+      controller.close();
+    },
+  }),
+  name: "hello.txt",
+});
 
 // With custom date and permissions
-zipWriter.createEntryStream({
+await zipWriter.addEntry({
+  readable: scriptStream,
   name: "script.sh",
   date: new Date("2024-01-01"),
   mode: 0o755, // executable
-}).writable;
+});
 
 // Disable compression for already-compressed files
-zipWriter.createEntryStream({
+await zipWriter.addEntry({
+  readable: videoStream,
   name: "video.mp4",
   store: true, // no compression
-}).writable;
-```
-
-##### `onceQueueEmpty(): Promise<void>`
-
-Wait until all currently queued entries have been written. Useful when you need
-to ensure entries are complete before continuing.
-
-```ts
-// Add multiple entries
-zipWriter.createEntryStream({ name: "file1.txt" }).writable;
-zipWriter.createEntryStream({ name: "file2.txt" }).writable;
-
-// Wait for all to complete
-await zipWriter.onceQueueEmpty();
-console.log(`Wrote ${zipWriter.entries.length} entries`);
+});
 ```
 
 ##### `finalize(options?): Promise<{ zip64: boolean, uncompressedEntriesSize: bigint, compressedEntriesSize: bigint, fileSize: bigint }>`
@@ -205,11 +190,8 @@ console.log(
 **Example with entries option:**
 
 ```ts
-// Wait for all entries to be written
-await zipWriter.onceQueueEmpty();
-
 // Get current entries and modify them
-const entries = [...zipWriter.entries];
+const entries = await zipWriter.entries();
 
 // Remove an entry
 const filtered = entries.filter((e) => e.name !== "temp.txt");
@@ -227,37 +209,11 @@ const sorted = [...entries].sort((a, b) => a.name.localeCompare(b.name));
 await zipWriter.finalize({ entries: sorted });
 ```
 
-### `EntryWriter`
-
-Returned by `ZipWriter.createEntryStream()`. Provides a writable stream to write
-entry data.
+### `EntryInfo`
 
-#### Properties
+Returned by `ZipWriter.addEntry()`. Contains metadata about a written entry.
 
-##### `writable: WritableStream<Uint8Array>`
-
-The writable stream to write entry data to. Close this stream when done writing.
-
-```ts
-const entryWriter = zipWriter.createEntryStream({ name: "data.txt" });
-
-// Using a writer
-const writer = entryWriter.writable.getWriter();
-await writer.write(new TextEncoder().encode("chunk 1"));
-await writer.write(new TextEncoder().encode("chunk 2"));
-await writer.close();
-
-// Using pipeTo
-someReadableStream.pipeTo(entryWriter.writable);
-```
-
-#### Methods
-
-##### `getEntryInfo(): Promise<EntryInfo>`
-
-Get entry info. Resolves once all data has been written to the ZIP stream.
-
-**Returns `EntryInfo`:**
+**Properties:**
 
 - `name: string` - Entry name
 - `comment?: string` - Entry comment
@@ -270,11 +226,13 @@ Get entry info. Resolves once all data has been written to the ZIP stream.
 - `compressedSize: bigint | number` - Compressed size in bytes
 - `zip64: boolean` - Whether this entry uses ZIP64 format
 
-```ts
-const entryWriter = zipWriter.createEntryStream({ name: "test.txt" });
-await someStream.pipeTo(entryWriter.writable);
+**Example:**
 
-const info = await entryWriter.getEntryInfo();
+```ts
+const info = await zipWriter.addEntry({
+  readable: dataStream,
+  name: "test.txt",
+});
 console.log(
   `Wrote ${info.name}: ${info.uncompressedSize} bytes (compressed to ${info.compressedSize})`,
 );
@@ -294,24 +252,41 @@ async function createZip() {
   const fileStream = Writable.toWeb(createWriteStream("output.zip"));
   zipWriter.readable.pipeTo(fileStream);
 
-  // Add a text file using createEntry
+  // Add a text file
   const data1 = new TextEncoder().encode("This is a readme");
-  await zipWriter.createEntry(data1, { name: "readme.txt" });
-
-  // Add files from URLs using createEntryStream
+  await zipWriter.addEntry({
+    readable: new ReadableStream({
+      start(controller) {
+        controller.enqueue(data1);
+        controller.close();
+      },
+    }),
+    name: "readme.txt",
+  });
+
+  // Add files from URLs
   const imageResponse = await fetch("https://example.com/image.png");
-  await imageResponse.body.pipeTo(
-    zipWriter.createEntryStream({ name: "images/photo.png" }).writable,
-  );
+  await zipWriter.addEntry({
+    readable: imageResponse.body,
+    name: "images/photo.png",
+  });
 
-  // Add a JSON file using createEntry
+  // Add a JSON file
   const data = { hello: "world" };
   const jsonData = new TextEncoder().encode(JSON.stringify(data, null, 2));
-  await zipWriter.createEntry(jsonData, { name: "data.json" });
+  await zipWriter.addEntry({
+    readable: new ReadableStream({
+      start(controller) {
+        controller.enqueue(jsonData);
+        controller.close();
+      },
+    }),
+    name: "data.json",
+  });
 
   // Wait for all entries and check results
-  await zipWriter.onceQueueEmpty();
-  console.log(`Added ${zipWriter.entries.length} entries`);
+  const entries = await zipWriter.entries();
+  console.log(`Added ${entries.length} entries`);
 
   // Finalize the archive
   const result = await zipWriter.finalize();
@@ -329,9 +304,16 @@ const zipWriter = new ZipWriter();
 
 // Add entries...
 const data = new TextEncoder().encode("Hello");
-zipWriter
-  .createEntry(data, { name: "file.txt" })
-  .then(() => zipWriter.finalize());
+await zipWriter.addEntry({
+  readable: new ReadableStream({
+    start(controller) {
+      controller.enqueue(data);
+      controller.close();
+    },
+  }),
+  name: "file.txt",
+});
+await zipWriter.finalize();
 
 // Create download link
 const blob = await new Response(zipWriter.readable).blob();
@@ -410,17 +392,15 @@ No special configuration is needed - it's handled automatically.
 
 ```ts
 try {
-  const entryWriter = zipWriter.entry({ name: "test.txt" });
-  await someStream.pipeTo(entryWriter.writable);
-  await entryWriter.getEntryInfo();
+  await zipWriter.addEntry({ readable: someStream, name: "test.txt" });
 } catch (error) {
   console.error("Failed to write entry:", error);
   // The ZIP stream is aborted on error - cannot add more entries
 }
 ```
 
-Once an error occurs during entry writing, the ZIP stream is corrupted and
-cannot be recovered. You must create a new `ZipWriter` instance.
+Once an error occurs during entry writing, the ZIP stream is in the errored
+state and cannot be recovered. You must create a new `ZipWriter` instance.
 
 ## License
 

package/dist/index.d.ts

@@ -10,7 +10,17 @@ export interface EntryOptions {
     /** Compression method to `STORE` (defaults to `DEFLATE`) */
     store?: boolean;
 }
-export interface EntryInfoZip64 extends EntryOptions {
+export interface EntryOptionsInternal extends EntryOptions {
+    /** Encoded entry name */
+    nameBytes: Uint8Array;
+    /** Encoded entry comment */
+    commentBytes: Uint8Array;
+}
+export interface Entry extends EntryOptions {
+    /** Readable stream of entry data */
+    readable: ReadableStream<ArrayBufferView<ArrayBufferLike>>;
+}
+export interface EntryInfoZip64 extends EntryOptionsInternal {
     /** Byte offset of the local file header within the ZIP archive */
     startOffset: bigint;
     /** CRC32 checksum of the uncompressed data */
@@ -22,10 +32,22 @@ export interface EntryInfoZip64 extends EntryOptions {
     /** Entry information is in ZIP64 format */
     zip64: true;
 }
+export interface ZipInfo {
+    /** Does the archive use ZIP64 format? */
+    zip64: boolean;
+    /** Total uncompressed size of all entries */
+    uncompressedEntriesSize: bigint;
+    /** Total compressed size of all entries */
+    compressedEntriesSize: bigint;
+    /** Total size of the ZIP file */
+    fileSize: bigint;
+}
 export type EntryInfoStandard = {
     [K in keyof EntryInfoZip64]: EntryInfoZip64[K] extends bigint ? number : K extends "zip64" ? false : EntryInfoZip64[K];
 };
-export type EntryInfo = EntryInfoZip64 | EntryInfoStandard;
+export type EntryInfoInternal = EntryInfoZip64 | EntryInfoStandard;
+type OmitUnion<T, U extends keyof T> = T extends U ? never : Omit<T, U>;
+export type EntryInfo = OmitUnion<EntryInfoInternal, "nameBytes" | "commentBytes">;
 export declare class ZipWriter<TIsZip64 extends boolean = false> {
     #private;
     /**
@@ -35,29 +57,10 @@ export declare class ZipWriter<TIsZip64 extends boolean = false> {
         crc32?: (data: Uint8Array<ArrayBuffer>, value?: number) => number;
     });
     get readable(): ReadableStream<ArrayBufferView<ArrayBufferLike>>;
-    get entries(): ReadonlyArray<Readonly<EntryInfo>>;
     /**
-     * Wait until all currently queued entries have been written.
+     * Get an array of entry information for all entries added so far to the ZIP archive.
      */
-    onceQueueEmpty(): Promise<void>;
-    /**
-     * Convenience wrapper around `createEntryStream` to write all data at once.
-     * Use `createEntryStream` for more efficient streaming writes. Calls to
-     * createEntry() will be queued internally and each will resolve once it's
-     * written to the archive.
-     *
-     * @example
-     * ```ts
-     * const data = new TextEncoder().encode("Hello, World!");
-     * const entryInfo = await zipWriter.createEntry(data, { name: "hello.txt" });
-     * console.log(entryInfo);
-     * ```
-     *
-     * @param data Entry data
-     * @param options Entry filename, comment, compression method, etc.
-     * @returns Entry information once the entry has been written.
-     */
-    createEntry(data: Uint8Array<ArrayBuffer>, options: EntryOptions): Promise<EntryInfo>;
+    entries(): Promise<EntryInfo[]>;
     /**
      * Create a new entry in the Zip archive. Use the returned
      * entryWriter.writable to write data to the entry. You can await
@@ -84,7 +87,7 @@ export declare class ZipWriter<TIsZip64 extends boolean = false> {
      *
      * @param options Entry options
      */
-    createEntryStream(options: EntryOptions): EntryWriter;
+    addEntry({ readable, ...entryOptions }: Entry): Promise<EntryInfo>;
     /**
      * Finalize the ZIP archive by writing the central directory and end of
      * central directory records. You may not add any more entries after calling
@@ -100,39 +103,9 @@ export declare class ZipWriter<TIsZip64 extends boolean = false> {
      *
      * @returns Information about the finalized archive.
      */
-    finalize({ entries, }?: {
-        entries?: ReadonlyArray<Readonly<EntryInfo>>;
-    }): Promise<{
-        /** Does the archive use ZIP64 format? */
-        zip64: boolean;
-        /** Total uncompressed size of all entries */
-        uncompressedEntriesSize: bigint;
-        /** Total compressed size of all entries */
-        compressedEntriesSize: bigint;
-        /** Total size of the ZIP file */
-        fileSize: bigint;
-    }>;
-}
-declare class EntryWriter {
-    #private;
-    /**
-     * @param enqueueAndPipe Function that enqueues the entry data readable, pipes it to the Zip stream, and returns a promise that resolves to the entry info once done.
-     */
-    constructor(enqueueAndPipe: (readable: ReadableStream<Uint8Array<ArrayBuffer>>) => Promise<EntryInfo>);
-    /**
-     * Writable stream to write entry data to.
-     *
-     * @example
-     * ```ts
-     * ReadableStream.from([new TextEncoder().encode("Hello, World!")])
-     *   .pipeTo(entryWriter.writable);
-     * ```
-     */
-    get writable(): WritableStream<Uint8Array<ArrayBuffer>>;
-    /**
-     * Get entry info. Resolves once all data has been written to the Zip stream.
-     */
-    getEntryInfo(): Promise<EntryInfo>;
+    finalize({ entries }?: {
+        entries?: EntryInfo[];
+    }): Promise<ZipInfo>;
 }
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAeA,MAAM,WAAW,YAAY;IAC3B,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iBAAiB;IACjB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,wBAAwB;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,4DAA4D;IAC5D,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,cAAe,SAAQ,YAAY;IAClD,kEAAkE;IAClE,WAAW,EAAE,MAAM,CAAC;IACpB,8CAA8C;IAC9C,KAAK,EAAE,MAAM,CAAC;IACd,iCAAiC;IACjC,gBAAgB,EAAE,MAAM,CAAC;IACzB,+BAA+B;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,2CAA2C;IAC3C,KAAK,EAAE,IAAI,CAAC;CACb;AAED,MAAM,MAAM,iBAAiB,GAAG;KAC7B,CAAC,IAAI,MAAM,cAAc,GAAG,cAAc,CAAC,CAAC,CAAC,SAAS,MAAM,GACzD,MAAM,GACN,CAAC,SAAS,OAAO,GACf,KAAK,GACL,cAAc,CAAC,CAAC,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,cAAc,GAAG,iBAAiB,CAAC;AAE3D,qBAAa,SAAS,CAAC,QAAQ,SAAS,OAAO,GAAG,KAAK;;IAqBrD;;OAEG;gBACS,EACV,KAAoB,GACrB,GAAE;QACD,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;KAC9D;IAIN,IAAI,QAAQ,qDAEX;IAED,IAAI,OAAO,IAAI,aAAa,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAEhD;IAED;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAMrC;;;;;;;;;;;;;;;;OAgBG;IACG,WAAW,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,EAAE,OAAO,EAAE,YAAY;IAWtE;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,iBAAiB,CAAC,OAAO,EAAE,YAAY;IAgGvC;;;;;;;;;;;;;;OAcG;IACG,QAAQ,CAAC,EACb,OAAO,GACR,GAAE;QAAE,OAAO,CAAC,EAAE,aAAa,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAA;KAAO,GAAG,OAAO,CAAC;QACjE,yCAAyC;QACzC,KAAK,EAAE,OAAO,CAAC;QACf,6CAA6C;QAC7C,uBAAuB,EAAE,MAAM,CAAC;QAChC,2CAA2C;QAC3C,qBAAqB,EAAE,MAAM,CAAC;QAC9B,iCAAiC;QACjC,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CA6EH;AAED,cAAM,WAAW;;IAQf;;OAEG;gBAED,cAAc,EAAE,CACd,QAAQ,EAAE,cAAc,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,KAC9C,OAAO,CAAC,SAAS,CAAC;IAazB;;;;;;;;OAQG;IACH,IAAI,QAAQ,4CAEX;IAED;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,SAAS,CAAC;CAGzC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAoBA,MAAM,WAAW,YAAY;IAC3B,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iBAAiB;IACjB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,wBAAwB;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,4DAA4D;IAC5D,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,oBAAqB,SAAQ,YAAY;IACxD,yBAAyB;IACzB,SAAS,EAAE,UAAU,CAAC;IACtB,4BAA4B;IAC5B,YAAY,EAAE,UAAU,CAAC;CAC1B;AAED,MAAM,WAAW,KAAM,SAAQ,YAAY;IACzC,oCAAoC;IACpC,QAAQ,EAAE,cAAc,CAAC,eAAe,CAAC,eAAe,CAAC,CAAC,CAAC;CAC5D;AAED,MAAM,WAAW,cAAe,SAAQ,oBAAoB;IAC1D,kEAAkE;IAClE,WAAW,EAAE,MAAM,CAAC;IACpB,8CAA8C;IAC9C,KAAK,EAAE,MAAM,CAAC;IACd,iCAAiC;IACjC,gBAAgB,EAAE,MAAM,CAAC;IACzB,+BAA+B;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,2CAA2C;IAC3C,KAAK,EAAE,IAAI,CAAC;CACb;AAED,MAAM,WAAW,OAAO;IACtB,yCAAyC;IACzC,KAAK,EAAE,OAAO,CAAC;IACf,6CAA6C;IAC7C,uBAAuB,EAAE,MAAM,CAAC;IAChC,2CAA2C;IAC3C,qBAAqB,EAAE,MAAM,CAAC;IAC9B,iCAAiC;IACjC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,iBAAiB,GAAG;KAC7B,CAAC,IAAI,MAAM,cAAc,GAAG,cAAc,CAAC,CAAC,CAAC,SAAS,MAAM,GACzD,MAAM,GACN,CAAC,SAAS,OAAO,GACf,KAAK,GACL,cAAc,CAAC,CAAC,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,cAAc,GAAG,iBAAiB,CAAC;AAEnE,KAAK,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAExE,MAAM,MAAM,SAAS,GAAG,SAAS,CAC/B,iBAAiB,EACjB,WAAW,GAAG,cAAc,CAC7B,CAAC;AAIF,qBAAa,SAAS,CAAC,QAAQ,SAAS,OAAO,GAAG,KAAK;;IAoBrD;;OAEG;gBACS,EACV,KAAoB,GACrB,GAAE;QACD,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;KAC9D;IAIN,IAAI,QAAQ,qDAEX;IAED;;OAEG;IACH,OAAO,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAS/B;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,QAAQ,CAAC,EAAE,QAAQ,EAAE,GAAG,YAAY,EAAE,EAAE,KAAK,GAAG,OAAO,CAAC,SAAS,CAAC;IAmKlE;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,EAAE,OAAO,EAAE,GAAE;QAAE,OAAO,CAAC,EAAE,SAAS,EAAE,CAAA;KAAO,GAAG,OAAO,CAAC,OAAO,CAAC;CAgFxE"}