taglib-wasm 1.0.7 → 1.1.0

package/dist/simple.browser.js

@@ -449,6 +449,215 @@ var init_write = __esm({
   }
 });
 
+// src/constants/additional-properties.ts
+var ADDITIONAL_PROPERTIES;
+var init_additional_properties = __esm({
+  "src/constants/additional-properties.ts"() {
+    "use strict";
+    ADDITIONAL_PROPERTIES = {
+      albumArtistSort: {
+        key: "ALBUMARTISTSORT",
+        description: "Sort name for album artist (for alphabetization)",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TSO2" },
+          vorbis: "ALBUMARTISTSORT",
+          mp4: "soaa"
+        }
+      },
+      composerSort: {
+        key: "COMPOSERSORT",
+        description: "Sort name for composer (for alphabetization)",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TSOC" },
+          vorbis: "COMPOSERSORT",
+          mp4: "soco"
+        }
+      },
+      subtitle: {
+        key: "SUBTITLE",
+        description: "Subtitle or description refinement",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TIT3" },
+          vorbis: "SUBTITLE",
+          mp4: "----:com.apple.iTunes:SUBTITLE"
+        }
+      },
+      label: {
+        key: "LABEL",
+        description: "Record label name",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis", "WAV"],
+        mappings: {
+          id3v2: { frame: "TPUB" },
+          vorbis: "LABEL",
+          mp4: "----:com.apple.iTunes:LABEL",
+          wav: "IPUB"
+        }
+      },
+      producer: {
+        key: "PRODUCER",
+        description: "Producer of the recording",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TXXX", description: "PRODUCER" },
+          vorbis: "PRODUCER",
+          mp4: "----:com.apple.iTunes:PRODUCER"
+        }
+      },
+      radioStationOwner: {
+        key: "RADIOSTATIONOWNER",
+        description: "Owner of the radio station",
+        type: "string",
+        supportedFormats: ["ID3v2"],
+        mappings: {
+          id3v2: { frame: "TRSO" }
+        }
+      },
+      asin: {
+        key: "ASIN",
+        description: "Amazon Standard Identification Number",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TXXX", description: "ASIN" },
+          vorbis: "ASIN",
+          mp4: "----:com.apple.iTunes:ASIN"
+        }
+      },
+      musicbrainzReleaseArtistId: {
+        key: "MUSICBRAINZ_ALBUMARTISTID",
+        description: "MusicBrainz Release Artist ID (UUID)",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: {
+            frame: "TXXX",
+            description: "MusicBrainz Album Artist Id"
+          },
+          vorbis: "MUSICBRAINZ_ALBUMARTISTID",
+          mp4: "----:com.apple.iTunes:MusicBrainz Album Artist Id"
+        }
+      },
+      musicbrainzWorkId: {
+        key: "MUSICBRAINZ_WORKID",
+        description: "MusicBrainz Work ID (UUID)",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TXXX", description: "MusicBrainz Work Id" },
+          vorbis: "MUSICBRAINZ_WORKID",
+          mp4: "----:com.apple.iTunes:MusicBrainz Work Id"
+        }
+      },
+      musicbrainzReleaseTrackId: {
+        key: "MUSICBRAINZ_RELEASETRACKID",
+        description: "MusicBrainz Release Track ID (UUID)",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: {
+            frame: "TXXX",
+            description: "MusicBrainz Release Track Id"
+          },
+          vorbis: "MUSICBRAINZ_RELEASETRACKID",
+          mp4: "----:com.apple.iTunes:MusicBrainz Release Track Id"
+        }
+      },
+      podcastId: {
+        key: "PODCASTID",
+        description: "Podcast episode identifier",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TGID" },
+          vorbis: "PODCASTID",
+          mp4: "egid"
+        }
+      },
+      podcastUrl: {
+        key: "PODCASTURL",
+        description: "Podcast feed URL",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "WFED" },
+          vorbis: "PODCASTURL",
+          mp4: "purl"
+        }
+      },
+      originalArtist: {
+        key: "ORIGINALARTIST",
+        description: "Original artist of a cover or remix",
+        type: "string",
+        supportedFormats: ["ID3v2", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TOPE" },
+          vorbis: "ORIGINALARTIST"
+        }
+      },
+      originalAlbum: {
+        key: "ORIGINALALBUM",
+        description: "Original album of a cover or remix",
+        type: "string",
+        supportedFormats: ["ID3v2", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TOAL" },
+          vorbis: "ORIGINALALBUM"
+        }
+      },
+      originalDate: {
+        key: "ORIGINALDATE",
+        description: "Original release date",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TDOR" },
+          vorbis: "ORIGINALDATE",
+          mp4: "----:com.apple.iTunes:ORIGINALDATE"
+        }
+      },
+      script: {
+        key: "SCRIPT",
+        description: "Writing script used for text (e.g., Latn, Jpan)",
+        type: "string",
+        supportedFormats: ["MP4", "Vorbis"],
+        mappings: {
+          vorbis: "SCRIPT",
+          mp4: "----:com.apple.iTunes:SCRIPT"
+        }
+      },
+      involvedPeople: {
+        key: "INVOLVEDPEOPLE",
+        description: "List of involved people and their roles",
+        type: "string",
+        supportedFormats: ["ID3v2"],
+        mappings: {
+          id3v2: { frame: "TIPL" }
+        }
+      },
+      encoding: {
+        key: "ENCODING",
+        description: "Encoding software or settings",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis", "WAV"],
+        mappings: {
+          id3v2: { frame: "TSSE" },
+          vorbis: "ENCODING",
+          mp4: "\xA9too",
+          wav: "ISFT"
+        }
+      }
+    };
+  }
+});
+
 // src/constants/basic-properties.ts
 var BASIC_PROPERTIES;
 var init_basic_properties = __esm({
@@ -698,12 +907,14 @@ var init_general_extended_properties = __esm({
         }
       },
       remixedBy: {
-        key: "REMIXEDBY",
+        key: "REMIXER",
         description: "Person who remixed the track",
         type: "string",
-        supportedFormats: ["Vorbis"],
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
         mappings: {
-          vorbis: "REMIXEDBY"
+          id3v2: { frame: "TPE4" },
+          vorbis: "REMIXER",
+          mp4: "----:com.apple.iTunes:REMIXER"
         }
       },
       language: {
@@ -953,13 +1164,15 @@ var PROPERTIES, _toTagLib, _fromTagLib;
 var init_properties = __esm({
   "src/constants/properties.ts"() {
     "use strict";
+    init_additional_properties();
     init_basic_properties();
     init_general_extended_properties();
     init_specialized_properties();
     PROPERTIES = {
       ...BASIC_PROPERTIES,
       ...GENERAL_EXTENDED_PROPERTIES,
-      ...SPECIALIZED_PROPERTIES
+      ...SPECIALIZED_PROPERTIES,
+      ...ADDITIONAL_PROPERTIES
     };
     _toTagLib = {};
     _fromTagLib = {};
@@ -1151,7 +1364,19 @@ var init_audio_file_base = __esm({
 });
 
 // src/taglib/audio-file-impl.ts
-var AudioFileImpl;
+function readFileSync(path) {
+  if (typeof Deno !== "undefined") return Deno.readFileSync(path);
+  if (_nodeFs === void 0) {
+    try {
+      _nodeFs = new Function("return require('node:fs')")();
+    } catch {
+      _nodeFs = null;
+    }
+  }
+  if (_nodeFs) return new Uint8Array(_nodeFs.readFileSync(path));
+  return new Uint8Array(0);
+}
+var _nodeFs, AudioFileImpl;
 var init_audio_file_impl = __esm({
   "src/taglib/audio-file-impl.ts"() {
     "use strict";
@@ -1170,6 +1395,7 @@ var init_audio_file_impl = __esm({
           isPartiallyLoaded,
           partialLoadOptions
         );
+        __publicField(this, "pathModeBuffer", null);
       }
       save() {
         if (this.isPartiallyLoaded && this.originalSource) {
@@ -1183,7 +1409,17 @@ var init_audio_file_impl = __esm({
       }
       getFileBuffer() {
         const buffer = this.handle.getBuffer();
-        return buffer ?? new Uint8Array(0);
+        if (buffer.length > 0) return buffer;
+        if (this.pathModeBuffer) return this.pathModeBuffer;
+        if (this.sourcePath) {
+          try {
+            this.pathModeBuffer = readFileSync(this.sourcePath);
+            return this.pathModeBuffer;
+          } catch {
+            return new Uint8Array(0);
+          }
+        }
+        return new Uint8Array(0);
       }
       async saveToFile(path) {
         const targetPath = path ?? this.sourcePath;
@@ -1194,14 +1430,15 @@ var init_audio_file_impl = __esm({
           );
         }
         if (this.isPartiallyLoaded && this.originalSource) {
-          const fullData = await readFileData(this.originalSource);
           const fullFileHandle = this.module.createFileHandle();
           try {
-            const success = fullFileHandle.loadFromBuffer(fullData);
+            const success = await (async () => {
+              const data = await readFileData(this.originalSource);
+              return fullFileHandle.loadFromBuffer(data);
+            })();
             if (!success) {
               throw new InvalidFormatError(
-                "Failed to load full audio file for saving",
-                fullData.byteLength
+                "Failed to load full audio file for saving"
               );
             }
             const partialTag = this.handle.getTag();
@@ -1237,7 +1474,10 @@ var init_audio_file_impl = __esm({
               "Failed to save changes to in-memory buffer"
             );
           }
-          await writeFileData(targetPath, this.getFileBuffer());
+          const buffer = this.handle.getBuffer();
+          if (buffer.length > 0) {
+            await writeFileData(targetPath, buffer);
+          }
         }
       }
       getPictures() {
@@ -1441,7 +1681,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = "1.0.7";
+    VERSION = "1.1.0";
   }
 });
 
@@ -1535,8 +1775,34 @@ var init_taglib_class = __esm({
         }
         const actualInput = isNamedAudioInput(input) ? input.data : input;
         const sourcePath = typeof actualInput === "string" ? actualInput : void 0;
+        if (typeof actualInput === "string" && this.module.isWasi) {
+          const fileHandle2 = this.module.createFileHandle();
+          try {
+            const fh = fileHandle2;
+            if (fh.loadFromPath) {
+              const success = fh.loadFromPath(actualInput);
+              if (!success) {
+                throw new InvalidFormatError(
+                  `Failed to load audio file. Path: ${actualInput}`
+                );
+              }
+              return new AudioFileImpl(
+                this.module,
+                fileHandle2,
+                sourcePath,
+                actualInput,
+                false
+              );
+            }
+          } catch (error) {
+            if (typeof fileHandle2.destroy === "function") {
+              fileHandle2.destroy();
+            }
+            throw error;
+          }
+        }
         const opts = {
-          partial: false,
+          partial: true,
           maxHeaderSize: 1024 * 1024,
           maxFooterSize: 128 * 1024,
           ...options
@@ -1545,18 +1811,19 @@ var init_taglib_class = __esm({
           actualInput,
           opts
         );
-        const buffer = audioData.buffer.slice(
-          audioData.byteOffset,
-          audioData.byteOffset + audioData.byteLength
-        );
-        const uint8Array = new Uint8Array(buffer);
+        const uint8Array = actualInput instanceof Uint8Array && audioData.buffer === actualInput.buffer ? new Uint8Array(
+          audioData.buffer.slice(
+            audioData.byteOffset,
+            audioData.byteOffset + audioData.byteLength
+          )
+        ) : audioData;
         const fileHandle = this.module.createFileHandle();
         try {
           const success = fileHandle.loadFromBuffer(uint8Array);
           if (!success) {
             throw new InvalidFormatError(
               "Failed to load audio file. File may be corrupted or in an unsupported format",
-              buffer.byteLength
+              uint8Array.byteLength
             );
           }
           return new AudioFileImpl(
@@ -1696,21 +1963,20 @@ async function getTagLib() {
 
 // src/simple/tag-operations.ts
 init_errors2();
-init_write();
 init_tag_mapping();
 
 // src/simple/with-audio-file.ts
 init_errors2();
-async function withAudioFile(file, fn) {
+async function withAudioFile(file, fn, options) {
   const taglib = await getTagLib();
-  const audioFile = await taglib.open(file);
+  const audioFile = await taglib.open(file, options);
   try {
     if (!audioFile.isValid()) {
       throw new InvalidFormatError(
         "File may be corrupted or in an unsupported format"
       );
     }
-    return fn(audioFile);
+    return await fn(audioFile);
   } finally {
     audioFile.dispose();
   }
@@ -1725,6 +1991,12 @@ async function withAudioFileSave(file, fn) {
       );
     }
     return audioFile.getFileBuffer();
+  }, { partial: false });
+}
+async function withAudioFileSaveToFile(file, fn) {
+  return withAudioFile(file, async (audioFile) => {
+    fn(audioFile);
+    await audioFile.saveToFile(file);
   });
 }
 
@@ -1747,8 +2019,9 @@ async function applyTagsToFile(file, tags) {
       "applyTagsToFile requires a file path string to save changes"
     );
   }
-  const modifiedBuffer = await applyTags(file, tags);
-  await writeFileData(file, modifiedBuffer);
+  await withAudioFileSaveToFile(file, (audioFile) => {
+    mergeTagUpdates(audioFile, tags);
+  });
 }
 async function readProperties(file) {
   return withAudioFile(file, (audioFile) => {

package/dist/src/constants/additional-properties.d.ts

@@ -0,0 +1,242 @@
+/**
+ * Additional audio metadata properties not covered by basic, general-extended,
+ * or specialized property files. Includes sorting extensions, identifiers,
+ * podcast metadata, original-release info, and miscellaneous properties.
+ *
+ * Wire names and format mappings sourced from TagLib's propertymapping.dox.
+ */
+export declare const ADDITIONAL_PROPERTIES: {
+    readonly albumArtistSort: {
+        readonly key: "ALBUMARTISTSORT";
+        readonly description: "Sort name for album artist (for alphabetization)";
+        readonly type: "string";
+        readonly supportedFormats: readonly ["ID3v2", "MP4", "Vorbis"];
+        readonly mappings: {
+            readonly id3v2: {
+                readonly frame: "TSO2";
+            };
+            readonly vorbis: "ALBUMARTISTSORT";
+            readonly mp4: "soaa";
+        };
+    };
+    readonly composerSort: {
+        readonly key: "COMPOSERSORT";
+        readonly description: "Sort name for composer (for alphabetization)";
+        readonly type: "string";
+        readonly supportedFormats: readonly ["ID3v2", "MP4", "Vorbis"];
+        readonly mappings: {
+            readonly id3v2: {
+                readonly frame: "TSOC";
+            };
+            readonly vorbis: "COMPOSERSORT";
+            readonly mp4: "soco";
+        };
+    };
+    readonly subtitle: {
+        readonly key: "SUBTITLE";
+        readonly description: "Subtitle or description refinement";
+        readonly type: "string";
+        readonly supportedFormats: readonly ["ID3v2", "MP4", "Vorbis"];
+        readonly mappings: {
+            readonly id3v2: {
+                readonly frame: "TIT3";
+            };
+            readonly vorbis: "SUBTITLE";
+            readonly mp4: "----:com.apple.iTunes:SUBTITLE";
+        };
+    };
+    readonly label: {
+        readonly key: "LABEL";
+        readonly description: "Record label name";
+        readonly type: "string";
+        readonly supportedFormats: readonly ["ID3v2", "MP4", "Vorbis", "WAV"];
+        readonly mappings: {
+            readonly id3v2: {
+                readonly frame: "TPUB";
+            };
+            readonly vorbis: "LABEL";
+            readonly mp4: "----:com.apple.iTunes:LABEL";
+            readonly wav: "IPUB";
+        };
+    };
+    readonly producer: {
+        readonly key: "PRODUCER";
+        readonly description: "Producer of the recording";
+        readonly type: "string";
+        readonly supportedFormats: readonly ["ID3v2", "MP4", "Vorbis"];
+        readonly mappings: {
+            readonly id3v2: {
+                readonly frame: "TXXX";
+                readonly description: "PRODUCER";
+            };
+            readonly vorbis: "PRODUCER";
+            readonly mp4: "----:com.apple.iTunes:PRODUCER";
+        };
+    };
+    readonly radioStationOwner: {
+        readonly key: "RADIOSTATIONOWNER";
+        readonly description: "Owner of the radio station";
+        readonly type: "string";
+        readonly supportedFormats: readonly ["ID3v2"];
+        readonly mappings: {
+            readonly id3v2: {
+                readonly frame: "TRSO";
+            };
+        };
+    };
+    readonly asin: {
+        readonly key: "ASIN";
+        readonly description: "Amazon Standard Identification Number";
+        readonly type: "string";
+        readonly supportedFormats: readonly ["ID3v2", "MP4", "Vorbis"];
+        readonly mappings: {
+            readonly id3v2: {
+                readonly frame: "TXXX";
+                readonly description: "ASIN";
+            };
+            readonly vorbis: "ASIN";
+            readonly mp4: "----:com.apple.iTunes:ASIN";
+        };
+    };
+    readonly musicbrainzReleaseArtistId: {
+        readonly key: "MUSICBRAINZ_ALBUMARTISTID";
+        readonly description: "MusicBrainz Release Artist ID (UUID)";
+        readonly type: "string";
+        readonly supportedFormats: readonly ["ID3v2", "MP4", "Vorbis"];
+        readonly mappings: {
+            readonly id3v2: {
+                readonly frame: "TXXX";
+                readonly description: "MusicBrainz Album Artist Id";
+            };
+            readonly vorbis: "MUSICBRAINZ_ALBUMARTISTID";
+            readonly mp4: "----:com.apple.iTunes:MusicBrainz Album Artist Id";
+        };
+    };
+    readonly musicbrainzWorkId: {
+        readonly key: "MUSICBRAINZ_WORKID";
+        readonly description: "MusicBrainz Work ID (UUID)";
+        readonly type: "string";
+        readonly supportedFormats: readonly ["ID3v2", "MP4", "Vorbis"];
+        readonly mappings: {
+            readonly id3v2: {
+                readonly frame: "TXXX";
+                readonly description: "MusicBrainz Work Id";
+            };
+            readonly vorbis: "MUSICBRAINZ_WORKID";
+            readonly mp4: "----:com.apple.iTunes:MusicBrainz Work Id";
+        };
+    };
+    readonly musicbrainzReleaseTrackId: {
+        readonly key: "MUSICBRAINZ_RELEASETRACKID";
+        readonly description: "MusicBrainz Release Track ID (UUID)";
+        readonly type: "string";
+        readonly supportedFormats: readonly ["ID3v2", "MP4", "Vorbis"];
+        readonly mappings: {
+            readonly id3v2: {
+                readonly frame: "TXXX";
+                readonly description: "MusicBrainz Release Track Id";
+            };
+            readonly vorbis: "MUSICBRAINZ_RELEASETRACKID";
+            readonly mp4: "----:com.apple.iTunes:MusicBrainz Release Track Id";
+        };
+    };
+    readonly podcastId: {
+        readonly key: "PODCASTID";
+        readonly description: "Podcast episode identifier";
+        readonly type: "string";
+        readonly supportedFormats: readonly ["ID3v2", "MP4", "Vorbis"];
+        readonly mappings: {
+            readonly id3v2: {
+                readonly frame: "TGID";
+            };
+            readonly vorbis: "PODCASTID";
+            readonly mp4: "egid";
+        };
+    };
+    readonly podcastUrl: {
+        readonly key: "PODCASTURL";
+        readonly description: "Podcast feed URL";
+        readonly type: "string";
+        readonly supportedFormats: readonly ["ID3v2", "MP4", "Vorbis"];
+        readonly mappings: {
+            readonly id3v2: {
+                readonly frame: "WFED";
+            };
+            readonly vorbis: "PODCASTURL";
+            readonly mp4: "purl";
+        };
+    };
+    readonly originalArtist: {
+        readonly key: "ORIGINALARTIST";
+        readonly description: "Original artist of a cover or remix";
+        readonly type: "string";
+        readonly supportedFormats: readonly ["ID3v2", "Vorbis"];
+        readonly mappings: {
+            readonly id3v2: {
+                readonly frame: "TOPE";
+            };
+            readonly vorbis: "ORIGINALARTIST";
+        };
+    };
+    readonly originalAlbum: {
+        readonly key: "ORIGINALALBUM";
+        readonly description: "Original album of a cover or remix";
+        readonly type: "string";
+        readonly supportedFormats: readonly ["ID3v2", "Vorbis"];
+        readonly mappings: {
+            readonly id3v2: {
+                readonly frame: "TOAL";
+            };
+            readonly vorbis: "ORIGINALALBUM";
+        };
+    };
+    readonly originalDate: {
+        readonly key: "ORIGINALDATE";
+        readonly description: "Original release date";
+        readonly type: "string";
+        readonly supportedFormats: readonly ["ID3v2", "MP4", "Vorbis"];
+        readonly mappings: {
+            readonly id3v2: {
+                readonly frame: "TDOR";
+            };
+            readonly vorbis: "ORIGINALDATE";
+            readonly mp4: "----:com.apple.iTunes:ORIGINALDATE";
+        };
+    };
+    readonly script: {
+        readonly key: "SCRIPT";
+        readonly description: "Writing script used for text (e.g., Latn, Jpan)";
+        readonly type: "string";
+        readonly supportedFormats: readonly ["MP4", "Vorbis"];
+        readonly mappings: {
+            readonly vorbis: "SCRIPT";
+            readonly mp4: "----:com.apple.iTunes:SCRIPT";
+        };
+    };
+    readonly involvedPeople: {
+        readonly key: "INVOLVEDPEOPLE";
+        readonly description: "List of involved people and their roles";
+        readonly type: "string";
+        readonly supportedFormats: readonly ["ID3v2"];
+        readonly mappings: {
+            readonly id3v2: {
+                readonly frame: "TIPL";
+            };
+        };
+    };
+    readonly encoding: {
+        readonly key: "ENCODING";
+        readonly description: "Encoding software or settings";
+        readonly type: "string";
+        readonly supportedFormats: readonly ["ID3v2", "MP4", "Vorbis", "WAV"];
+        readonly mappings: {
+            readonly id3v2: {
+                readonly frame: "TSSE";
+            };
+            readonly vorbis: "ENCODING";
+            readonly mp4: "©too";
+            readonly wav: "ISFT";
+        };
+    };
+};
+//# sourceMappingURL=additional-properties.d.ts.map

package/dist/src/constants/additional-properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"additional-properties.d.ts","sourceRoot":"","sources":["../../../src/constants/additional-properties.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwMxB,CAAC"}