taglib-wasm 0.3.3 → 0.3.9

package/dist/src/web-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-utils.d.ts","sourceRoot":"","sources":["../../src/web-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGzC;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAIzD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,WAAoC,EAC1C,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAsBT;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,IAAI,EAC9C,MAAM,EAAE,iBAAiB,EACzB,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,YAAY,GAAG,WAAW,GAAG,YAAY,CAAC;IACnD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACjB,GACL,OAAO,CAAC,UAAU,CAAC,CAgBrB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,iBAAiB,EACzB,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,YAAY,GAAG,WAAW,GAAG,YAAY,CAAC;IACnD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACjB,GACL,OAAO,CAAC,OAAO,CAAC,CA+BlB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,IAAI,EACV,IAAI,GAAE,WAAoC,EAC1C,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,OAAO,CAAC,CAUlB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,gBAAgB,GAC3B,IAAI,CAkBN;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,OAAO,EAChB,QAAQ,GAAE,MAAgB,GACzB,MAAM,CAGR;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,IAAI,EAC9C,SAAS,EAAE,WAAW,EACtB,OAAO,GAAE;IACP,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAChD,GACL,OAAO,CAAC,IAAI,CAAC,CA6Bf"}

package/dist/src/web-utils.ts

@@ -0,0 +1,347 @@
+/**
+ * @fileoverview Web browser utilities for working with cover art in taglib-wasm
+ *
+ * This module provides browser-specific helpers for integrating taglib-wasm
+ * with web applications, including canvas integration and data URL support.
+ *
+ * @example
+ * ```typescript
+ * import { pictureToDataURL, setCoverArtFromCanvas } from "taglib-wasm/web-utils";
+ *
+ * // Display cover art in an <img> element
+ * const pictures = await readPictures("song.mp3");
+ * if (pictures.length > 0) {
+ *   const dataURL = pictureToDataURL(pictures[0]);
+ *   document.getElementById('cover').src = dataURL;
+ * }
+ *
+ * // Set cover art from a canvas
+ * const canvas = document.getElementById('myCanvas') as HTMLCanvasElement;
+ * const modifiedBuffer = await setCoverArtFromCanvas("song.mp3", canvas);
+ * ```
+ */
+
+import type { Picture } from "./types.ts";
+import { PictureType } from "./types.ts";
+import { applyPictures, readPictures } from "./simple.ts";
+
+/**
+ * Convert a Picture object to a data URL for display in web browsers
+ *
+ * @param picture - Picture object from taglib-wasm
+ * @returns Data URL string that can be used as src for <img> elements
+ *
+ * @example
+ * ```typescript
+ * const pictures = await readPictures("song.mp3");
+ * const imgElement = document.getElementById('coverArt') as HTMLImageElement;
+ * imgElement.src = pictureToDataURL(pictures[0]);
+ * ```
+ */
+export function pictureToDataURL(picture: Picture): string {
+  // Convert Uint8Array to base64
+  const base64 = btoa(String.fromCharCode(...picture.data));
+  return `data:${picture.mimeType};base64,${base64}`;
+}
+
+/**
+ * Convert a data URL to a Picture object
+ *
+ * @param dataURL - Data URL string (e.g., "data:image/jpeg;base64,...")
+ * @param type - Picture type (defaults to FrontCover)
+ * @param description - Optional description
+ * @returns Picture object
+ *
+ * @example
+ * ```typescript
+ * const dataURL = canvas.toDataURL('image/jpeg');
+ * const picture = dataURLToPicture(dataURL, PictureType.FrontCover);
+ * const modifiedBuffer = await applyPictures("song.mp3", [picture]);
+ * ```
+ */
+export function dataURLToPicture(
+  dataURL: string,
+  type: PictureType = PictureType.FrontCover,
+  description?: string,
+): Picture {
+  // Parse data URL
+  const matches = dataURL.match(/^data:([^;]+);base64,(.+)$/);
+  if (!matches) {
+    throw new Error("Invalid data URL format");
+  }
+
+  const [, mimeType, base64] = matches;
+  
+  // Convert base64 to Uint8Array
+  const binaryString = atob(base64);
+  const data = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    data[i] = binaryString.charCodeAt(i);
+  }
+
+  return {
+    mimeType,
+    data,
+    type,
+    description,
+  };
+}
+
+/**
+ * Set cover art from an HTML canvas element
+ *
+ * @param file - File path, Uint8Array buffer, ArrayBuffer, or File object
+ * @param canvas - HTMLCanvasElement containing the image
+ * @param options - Options for image format and quality
+ * @returns Modified file buffer with cover art from canvas
+ *
+ * @example
+ * ```typescript
+ * const canvas = document.getElementById('albumArt') as HTMLCanvasElement;
+ * const modifiedBuffer = await setCoverArtFromCanvas("song.mp3", canvas, {
+ *   format: 'image/jpeg',
+ *   quality: 0.9
+ * });
+ * ```
+ */
+export async function setCoverArtFromCanvas(
+  file: string | Uint8Array | ArrayBuffer | File,
+  canvas: HTMLCanvasElement,
+  options: {
+    format?: 'image/jpeg' | 'image/png' | 'image/webp';
+    quality?: number;
+    type?: PictureType;
+    description?: string;
+  } = {},
+): Promise<Uint8Array> {
+  const {
+    format = 'image/jpeg',
+    quality = 0.92,
+    type = PictureType.FrontCover,
+    description = "Front Cover",
+  } = options;
+
+  // Convert canvas to data URL
+  const dataURL = canvas.toDataURL(format, quality);
+  
+  // Convert to Picture object
+  const picture = dataURLToPicture(dataURL, type, description);
+  
+  // Apply to file
+  return applyPictures(file, [picture]);
+}
+
+/**
+ * Convert canvas to Picture object using blob for better performance
+ *
+ * This is more efficient than toDataURL for large images as it avoids
+ * the base64 encoding/decoding step.
+ *
+ * @param canvas - HTMLCanvasElement containing the image
+ * @param options - Options for image format and quality
+ * @returns Promise resolving to Picture object
+ *
+ * @example
+ * ```typescript
+ * const canvas = document.getElementById('albumArt') as HTMLCanvasElement;
+ * const picture = await canvasToPicture(canvas, {
+ *   format: 'image/png',
+ *   type: PictureType.BackCover
+ * });
+ * ```
+ */
+export async function canvasToPicture(
+  canvas: HTMLCanvasElement,
+  options: {
+    format?: 'image/jpeg' | 'image/png' | 'image/webp';
+    quality?: number;
+    type?: PictureType;
+    description?: string;
+  } = {},
+): Promise<Picture> {
+  const {
+    format = 'image/jpeg',
+    quality = 0.92,
+    type = PictureType.FrontCover,
+    description,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    canvas.toBlob(
+      async (blob) => {
+        if (!blob) {
+          reject(new Error("Failed to convert canvas to blob"));
+          return;
+        }
+
+        // Convert blob to Uint8Array
+        const arrayBuffer = await blob.arrayBuffer();
+        const data = new Uint8Array(arrayBuffer);
+
+        resolve({
+          mimeType: format,
+          data,
+          type,
+          description,
+        });
+      },
+      format,
+      quality,
+    );
+  });
+}
+
+/**
+ * Load an image file into a Picture object
+ *
+ * @param file - File object from <input type="file"> or drag-and-drop
+ * @param type - Picture type (defaults to FrontCover)
+ * @param description - Optional description
+ * @returns Promise resolving to Picture object
+ *
+ * @example
+ * ```typescript
+ * // From file input
+ * const input = document.getElementById('fileInput') as HTMLInputElement;
+ * input.addEventListener('change', async (e) => {
+ *   const file = e.target.files[0];
+ *   const picture = await imageFileToPicture(file);
+ *   const modifiedBuffer = await applyPictures("song.mp3", [picture]);
+ * });
+ * ```
+ */
+export async function imageFileToPicture(
+  file: File,
+  type: PictureType = PictureType.FrontCover,
+  description?: string,
+): Promise<Picture> {
+  const arrayBuffer = await file.arrayBuffer();
+  const data = new Uint8Array(arrayBuffer);
+  
+  return {
+    mimeType: file.type,
+    data,
+    type,
+    description: description || file.name,
+  };
+}
+
+/**
+ * Display a Picture in an HTML img element
+ *
+ * @param picture - Picture object from taglib-wasm
+ * @param imgElement - HTMLImageElement to display the picture in
+ *
+ * @example
+ * ```typescript
+ * const pictures = await readPictures("song.mp3");
+ * const img = document.getElementById('coverArt') as HTMLImageElement;
+ * displayPicture(pictures[0], img);
+ * ```
+ */
+export function displayPicture(
+  picture: Picture,
+  imgElement: HTMLImageElement,
+): void {
+  // Clean up previous object URL if any
+  if (imgElement.src.startsWith('blob:')) {
+    URL.revokeObjectURL(imgElement.src);
+  }
+
+  // Create blob and object URL
+  const blob = new Blob([picture.data], { type: picture.mimeType });
+  const objectURL = URL.createObjectURL(blob);
+  
+  // Set the src
+  imgElement.src = objectURL;
+  
+  // Clean up object URL when image is no longer needed
+  imgElement.addEventListener('load', () => {
+    // Keep the URL alive for a bit to ensure image is rendered
+    setTimeout(() => URL.revokeObjectURL(objectURL), 100);
+  }, { once: true });
+}
+
+/**
+ * Create a download link for a Picture
+ *
+ * @param picture - Picture object to download
+ * @param filename - Suggested filename for download
+ * @returns Temporary download URL (remember to revoke it after use)
+ *
+ * @example
+ * ```typescript
+ * const pictures = await readPictures("song.mp3");
+ * const downloadUrl = createPictureDownloadURL(pictures[0], "cover.jpg");
+ * 
+ * const link = document.createElement('a');
+ * link.href = downloadUrl;
+ * link.download = "cover.jpg";
+ * link.click();
+ * 
+ * // Clean up
+ * URL.revokeObjectURL(downloadUrl);
+ * ```
+ */
+export function createPictureDownloadURL(
+  picture: Picture,
+  filename: string = "cover",
+): string {
+  const blob = new Blob([picture.data], { type: picture.mimeType });
+  return URL.createObjectURL(blob);
+}
+
+/**
+ * Extract all pictures and create a gallery
+ *
+ * @param file - Audio file to extract pictures from
+ * @param container - HTML element to append gallery items to
+ * @param options - Gallery display options
+ *
+ * @example
+ * ```typescript
+ * const galleryDiv = document.getElementById('pictureGallery');
+ * await createPictureGallery("song.mp3", galleryDiv, {
+ *   className: 'album-art',
+ *   includeDescription: true
+ * });
+ * ```
+ */
+export async function createPictureGallery(
+  file: string | Uint8Array | ArrayBuffer | File,
+  container: HTMLElement,
+  options: {
+    className?: string;
+    includeDescription?: boolean;
+    onClick?: (picture: Picture, index: number) => void;
+  } = {},
+): Promise<void> {
+  const pictures = await readPictures(file);
+  
+  // Clear container
+  container.innerHTML = '';
+  
+  pictures.forEach((picture, index) => {
+    const wrapper = document.createElement('div');
+    wrapper.className = options.className || 'picture-item';
+    
+    const img = document.createElement('img');
+    displayPicture(picture, img);
+    img.alt = picture.description || `Picture ${index + 1}`;
+    
+    if (options.onClick) {
+      img.style.cursor = 'pointer';
+      img.addEventListener('click', () => options.onClick!(picture, index));
+    }
+    
+    wrapper.appendChild(img);
+    
+    if (options.includeDescription && picture.description) {
+      const caption = document.createElement('p');
+      caption.textContent = picture.description;
+      wrapper.appendChild(caption);
+    }
+    
+    container.appendChild(wrapper);
+  });
+}

package/dist/src/workers.d.ts

@@ -0,0 +1,219 @@
+/**
+ * @fileoverview Cloudflare Workers-specific TagLib API
+ *
+ * This module provides a specialized API for using TagLib in Cloudflare Workers
+ * and other edge computing environments where the standard Emscripten module
+ * loading may not work. It uses C-style function exports for compatibility.
+ *
+ * @module taglib-wasm/workers
+ */
+import type { AudioFormat, AudioProperties, ExtendedTag, Tag, TagLibConfig } from "./types.ts";
+import { type TagLibModule } from "./wasm-workers.ts";
+/**
+ * Represents an audio file with metadata and properties (Workers-compatible).
+ * This implementation uses C-style function calls for Cloudflare Workers compatibility.
+ *
+ * @example
+ * ```typescript
+ * const file = taglib.openFile(audioBuffer);
+ *
+ * // Get metadata
+ * const tag = file.tag();
+ * console.log(tag.title);
+ *
+ * // Modify metadata
+ * file.setTitle("New Title");
+ * file.save();
+ *
+ * // Clean up
+ * file.dispose();
+ * ```
+ */
+export declare class AudioFileWorkers {
+    private module;
+    private fileId;
+    private tagPtr;
+    private propsPtr;
+    constructor(module: TagLibModule, fileId: number);
+    /**
+     * Check if the file is valid and was loaded successfully.
+     * @returns true if the file is valid and can be processed
+     */
+    isValid(): boolean;
+    /**
+     * Get the file format.
+     * @returns Audio format (e.g., "MP3", "FLAC", "OGG")
+     */
+    format(): AudioFormat;
+    /**
+     * Get basic tag information.
+     * @returns Object containing title, artist, album, etc.
+     */
+    tag(): Tag;
+    /**
+     * Get audio properties (duration, bitrate, etc.).
+     * @returns Audio properties or null if unavailable
+     */
+    audioProperties(): AudioProperties | null;
+    /**
+     * Set the title tag.
+     * @param title - New title value
+     */
+    setTitle(title: string): void;
+    /**
+     * Set the artist tag.
+     * @param artist - New artist value
+     */
+    setArtist(artist: string): void;
+    /**
+     * Set the album tag.
+     * @param album - New album value
+     */
+    setAlbum(album: string): void;
+    /**
+     * Set the comment tag.
+     * @param comment - New comment value
+     */
+    setComment(comment: string): void;
+    /**
+     * Set the genre tag.
+     * @param genre - New genre value
+     */
+    setGenre(genre: string): void;
+    /**
+     * Set the year tag.
+     * @param year - Release year
+     */
+    setYear(year: number): void;
+    /**
+     * Set the track number tag.
+     * @param track - Track number
+     */
+    setTrack(track: number): void;
+    /**
+     * Save changes to the file.
+     * Note: In Workers context, this saves to the in-memory buffer only.
+     * @returns true if save was successful
+     */
+    save(): boolean;
+    /**
+     * Get the current file buffer after modifications.
+     * Note: This is not implemented in the Workers API.
+     * @returns Empty Uint8Array (not implemented)
+     * @deprecated Use the Core API for this functionality
+     */
+    getFileBuffer(): Uint8Array;
+    /**
+     * Get extended metadata with format-agnostic field names.
+     * Note: Currently returns only basic fields in Workers API.
+     * @returns Extended tag object with basic fields populated
+     */
+    extendedTag(): ExtendedTag;
+    /**
+     * Set extended metadata using format-agnostic field names.
+     * Note: Currently only supports basic fields in Workers API.
+     * @param tag - Partial extended tag object with fields to update
+     */
+    setExtendedTag(tag: Partial<ExtendedTag>): void;
+    /**
+     * Clean up resources.
+     * Always call this when done to prevent memory leaks.
+     */
+    dispose(): void;
+}
+/**
+ * Main TagLib class for Cloudflare Workers.
+ * Provides methods to initialize the library and open audio files
+ * in edge computing environments.
+ *
+ * @example
+ * ```typescript
+ * import wasmBinary from "../build/taglib.wasm";
+ *
+ * // Initialize TagLib
+ * const taglib = await TagLibWorkers.initialize(wasmBinary);
+ *
+ * // Process audio file
+ * const file = taglib.openFile(audioBuffer);
+ * const metadata = file.tag();
+ * file.dispose();
+ * ```
+ */
+export declare class TagLibWorkers {
+    private module;
+    private constructor();
+    /**
+     * Initialize TagLib for Workers with Wasm binary
+     *
+     * @param wasmBinary - The WebAssembly binary as Uint8Array
+     * @param config - Optional configuration for the Wasm module
+     *
+     * @example
+     * ```typescript
+     * // In a Cloudflare Worker
+     * import wasmBinary from "../build/taglib.wasm";
+     *
+     * const taglib = await TagLibWorkers.initialize(wasmBinary);
+     * const file = taglib.open(audioBuffer);
+     * const metadata = file.tag();
+     * ```
+     */
+    static initialize(wasmBinary: Uint8Array, config?: TagLibConfig): Promise<TagLibWorkers>;
+    /**
+     * Open an audio file from a buffer.
+     *
+     * @param buffer - Audio file data as Uint8Array
+     * @returns AudioFileWorkers instance
+     * @throws {Error} If Wasm module is not initialized
+     * @throws {Error} If file format is invalid or unsupported
+     * @throws {Error} If Workers API C-style functions are not available
+     *
+     * @example
+     * ```typescript
+     * const audioData = new Uint8Array(await request.arrayBuffer());
+     * const file = taglib.open(audioData);
+     * ```
+     */
+    open(buffer: Uint8Array): AudioFileWorkers;
+    /**
+     * @deprecated Use `open()` instead. This method will be removed in the next major version.
+     * Open an audio file from a buffer (backward compatibility).
+     * @param buffer Audio file data as Uint8Array
+     * @returns Audio file instance
+     */
+    openFile(buffer: Uint8Array): AudioFileWorkers;
+    /**
+     * Get the underlying Wasm module for advanced usage.
+     * @returns The initialized TagLib Wasm module
+     */
+    getModule(): TagLibModule;
+}
+/**
+ * Utility function to process audio metadata in a Cloudflare Worker
+ *
+ * @example
+ * ```typescript
+ * export default {
+ *   async fetch(request: Request): Promise<Response> {
+ *     if (request.method === "POST") {
+ *       const audioData = new Uint8Array(await request.arrayBuffer());
+ *       const metadata = await processAudioMetadata(wasmBinary, audioData);
+ *       return Response.json(metadata);
+ *     }
+ *     return new Response("Method not allowed", { status: 405 });
+ *   }
+ * };
+ * ```
+ */
+export declare function processAudioMetadata(wasmBinary: Uint8Array, audioData: Uint8Array, config?: TagLibConfig): Promise<{
+    tag: Tag;
+    properties: AudioProperties | null;
+    format: AudioFormat;
+}>;
+/**
+ * Re-export commonly used types for convenience.
+ * These types define the structure of metadata, audio properties,
+ * and configuration options.
+ */
+export type { AudioFormat, AudioProperties, ExtendedTag, Tag, TagLibConfig };
+//# sourceMappingURL=workers.d.ts.map

package/dist/src/workers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workers.d.ts","sourceRoot":"","sources":["../../src/workers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,eAAe,EACf,WAAW,EACX,GAAG,EACH,YAAY,EACb,MAAM,YAAY,CAAC;AACpB,OAAO,EAIL,KAAK,YAAY,EAClB,MAAM,mBAAmB,CAAC;AAO3B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAS;gBAEb,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM;IAOhD;;;OAGG;IACH,OAAO,IAAI,OAAO;IAIlB;;;OAGG;IACH,MAAM,IAAI,WAAW;IAOrB;;;OAGG;IACH,GAAG,IAAI,GAAG;IAsBV;;;OAGG;IACH,eAAe,IAAI,eAAe,GAAG,IAAI;IAsBzC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAO7B;;;OAGG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAO/B;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAO7B;;;OAGG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAOjC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAO7B;;;OAGG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAK3B;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAK7B;;;;OAIG;IACH,IAAI,IAAI,OAAO;IAOf;;;;;OAKG;IACH,aAAa,IAAI,UAAU;IAO3B;;;;OAIG;IACH,WAAW,IAAI,WAAW;IA8B1B;;;;OAIG;IACH,cAAc,CAAC,GAAG,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,IAAI;IAU/C;;;OAGG;IACH,OAAO,IAAI,IAAI;CAMhB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAe;IAE7B,OAAO;IAIP;;;;;;;;;;;;;;;OAeG;WACU,UAAU,CACrB,UAAU,EAAE,UAAU,EACtB,MAAM,CAAC,EAAE,YAAY,GACpB,OAAO,CAAC,aAAa,CAAC;IAKzB;;;;;;;;;;;;;;OAcG;IACH,IAAI,CAAC,MAAM,EAAE,UAAU,GAAG,gBAAgB;IA6C1C;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,gBAAgB;IAI9C;;;OAGG;IACH,SAAS,IAAI,YAAY;CAG1B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,UAAU,EACrB,MAAM,CAAC,EAAE,YAAY,GACpB,OAAO,CACR;IAAE,GAAG,EAAE,GAAG,CAAC;IAAC,UAAU,EAAE,eAAe,GAAG,IAAI,CAAC;IAAC,MAAM,EAAE,WAAW,CAAA;CAAE,CACtE,CAaA;AAED;;;;GAIG;AACH,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,WAAW,EAAE,GAAG,EAAE,YAAY,EAAE,CAAC"}