taglib-wasm 1.0.7 → 1.1.0

package/dist/index.browser.js

@@ -461,6 +461,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({
@@ -710,12 +919,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: {
@@ -965,13 +1176,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 = {};
@@ -1163,7 +1376,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";
@@ -1182,6 +1407,7 @@ var init_audio_file_impl = __esm({
           isPartiallyLoaded,
           partialLoadOptions
         );
+        __publicField(this, "pathModeBuffer", null);
       }
       save() {
         if (this.isPartiallyLoaded && this.originalSource) {
@@ -1195,7 +1421,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;
@@ -1206,14 +1442,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();
@@ -1249,7 +1486,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() {
@@ -1453,7 +1693,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = "1.0.7";
+    VERSION = "1.1.0";
   }
 });
 
@@ -1548,8 +1788,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
@@ -1558,18 +1824,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(
@@ -1714,21 +1981,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();
   }
@@ -1743,6 +2009,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);
   });
 }
 
@@ -1765,8 +2037,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) => {
@@ -2021,36 +2294,36 @@ var Tags = {
   Publisher: "publisher",
   Mood: "mood",
   Media: "media",
-  RadioStationOwner: "RADIOSTATIONOWNER",
-  Producer: "PRODUCER",
-  Subtitle: "SUBTITLE",
-  Label: "LABEL",
+  RadioStationOwner: "radioStationOwner",
+  Producer: "producer",
+  Subtitle: "subtitle",
+  Label: "label",
   // Sorting Properties
   TitleSort: "titleSort",
   ArtistSort: "artistSort",
-  AlbumArtistSort: "ALBUMARTISTSORT",
+  AlbumArtistSort: "albumArtistSort",
   AlbumSort: "albumSort",
-  ComposerSort: "COMPOSERSORT",
+  ComposerSort: "composerSort",
   // Identifiers
   Isrc: "isrc",
-  Asin: "ASIN",
+  Asin: "asin",
   CatalogNumber: "catalogNumber",
   Barcode: "barcode",
   // MusicBrainz Identifiers
   MusicBrainzArtistId: "musicbrainzArtistId",
-  MusicBrainzReleaseArtistId: "MUSICBRAINZ_ALBUMARTISTID",
-  MusicBrainzWorkId: "MUSICBRAINZ_WORKID",
+  MusicBrainzReleaseArtistId: "musicbrainzReleaseArtistId",
+  MusicBrainzWorkId: "musicbrainzWorkId",
   MusicBrainzReleaseId: "musicbrainzReleaseId",
   MusicBrainzRecordingId: "musicbrainzTrackId",
   MusicBrainzTrackId: "musicbrainzTrackId",
   MusicBrainzReleaseGroupId: "musicbrainzReleaseGroupId",
-  MusicBrainzReleaseTrackId: "MUSICBRAINZ_RELEASETRACKID",
+  MusicBrainzReleaseTrackId: "musicbrainzReleaseTrackId",
   // AcoustID
   AcoustidFingerprint: "acoustidFingerprint",
   AcoustidId: "acoustidId",
   // Podcast Properties
-  PodcastId: "PODCASTID",
-  PodcastUrl: "PODCASTURL",
+  PodcastId: "podcastId",
+  PodcastUrl: "podcastUrl",
   // Grouping and Work
   Grouping: "grouping",
   Work: "work",
@@ -2060,15 +2333,14 @@ var Tags = {
   AlbumPeak: "replayGainAlbumPeak",
   TrackGain: "replayGainTrackGain",
   TrackPeak: "replayGainTrackPeak",
-  // Special handling
-  OriginalArtist: "ORIGINALARTIST",
-  OriginalAlbum: "ORIGINALALBUM",
-  OriginalDate: "ORIGINALDATE",
-  Script: "SCRIPT",
-  InvolvedPeopleList: "INVOLVEDPEOPLELIST",
-  // Technical Properties
-  EncoderSettings: "ENCODERSETTINGS",
-  SourceMedia: "SOURCEMEDIA"
+  // Original release
+  OriginalArtist: "originalArtist",
+  OriginalAlbum: "originalAlbum",
+  OriginalDate: "originalDate",
+  // Miscellaneous
+  Script: "script",
+  InvolvedPeople: "involvedPeople",
+  Encoding: "encoding"
 };
 function isValidTagName(name) {
   return Object.values(Tags).includes(name);

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * @fileoverview Main module exports for TagLib-Wasm
  *
- * TagLib v2.1 compiled to WebAssembly with TypeScript bindings
+ * TagLib v2.2 compiled to WebAssembly with TypeScript bindings
  * for universal audio metadata handling across all JavaScript runtimes.
  *
  * @module TagLib-Wasm