taglib-wasm 1.5.2 → 1.6.0

package/dist/simple.browser.js

@@ -1375,6 +1375,26 @@ var init_specialized_properties = __esm({
           vorbis: "ITUNNORM",
           mp4: "----:com.apple.iTunes:iTunNORM"
         }
+      },
+      /**
+       * Apple gapless-playback data (encoder delay, padding, original sample count).
+       *
+       * Exists so the two Apple freeform atoms are presented consistently: without
+       * it, `properties()` answered `appleSoundCheck` for iTunNORM but the raw
+       * uppercased `ITUNSMPB` for its sibling, because only one had an alias. The
+       * name mirrors `appleSoundCheck` — vendor-prefixed, feature-named rather than
+       * atom-named (tuneup-ibo).
+       */
+      appleGaplessInfo: {
+        key: "ITUNSMPB",
+        description: "Apple gapless playback data (encoder delay and padding)",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TXXX", description: "iTunSMPB" },
+          vorbis: "ITUNSMPB",
+          mp4: "----:com.apple.iTunes:iTunSMPB"
+        }
       }
     };
   }
@@ -1384,6 +1404,17 @@ var init_specialized_properties = __esm({
 function toTagLibKey(key) {
   return _toTagLib[key] ?? key;
 }
+function mp4AtomWireKey(atom) {
+  return _mp4AtomToWireKey[atom];
+}
+function mp4FreeformAtomNames(wireKeys) {
+  const names = [];
+  for (const key of wireKeys) {
+    const atom = _mp4FreeformAtoms[key];
+    if (atom !== void 0) names.push(atom);
+  }
+  return names;
+}
 function fromTagLibKey(key) {
   return _fromTagLib[key] ?? key;
 }
@@ -1394,7 +1425,7 @@ function remapKeysFromTagLib(obj) {
   }
   return result;
 }
-var PROPERTIES, _toTagLib, _fromTagLib;
+var PROPERTIES, _toTagLib, _fromTagLib, _mp4FreeformAtoms, _mp4AtomToWireKey;
 var init_properties = __esm({
   "src/constants/properties.ts"() {
     "use strict";
@@ -1418,6 +1449,129 @@ var init_properties = __esm({
     _toTagLib["year"] = "DATE";
     _toTagLib["track"] = "TRACKNUMBER";
     _fromTagLib["disc"] = "discNumber";
+    _mp4FreeformAtoms = {};
+    for (const meta of Object.values(PROPERTIES)) {
+      const { key, mappings } = meta;
+      const atom = mappings?.mp4;
+      if (typeof atom !== "string" || !atom.startsWith("----:")) continue;
+      const bare = atom.slice(atom.lastIndexOf(":") + 1);
+      if (bare === bare.toUpperCase()) continue;
+      _mp4FreeformAtoms[key] = atom;
+      const readKey = bare.toUpperCase();
+      const camel = _fromTagLib[key];
+      if (camel !== void 0 && _fromTagLib[readKey] === void 0) {
+        _fromTagLib[readKey] = camel;
+      }
+    }
+    _mp4AtomToWireKey = {};
+    for (const meta of Object.values(PROPERTIES)) {
+      const { key, mappings } = meta;
+      const atom = mappings?.mp4;
+      if (typeof atom !== "string" || atom.startsWith("----:")) continue;
+      if (_mp4AtomToWireKey[atom] === void 0) _mp4AtomToWireKey[atom] = key;
+    }
+  }
+});
+
+// src/taglib/mp4-item-names.ts
+var MP4_ITEM_NAMES_KEY;
+var init_mp4_item_names = __esm({
+  "src/taglib/mp4-item-names.ts"() {
+    "use strict";
+    MP4_ITEM_NAMES_KEY = "_mp4ItemNames";
+  }
+});
+
+// src/taglib/mutable-tag-impl.ts
+function buildMutableTag(handle) {
+  let data = handle.getTagData();
+  const tag = {
+    get title() {
+      return data.title;
+    },
+    get artist() {
+      return data.artist;
+    },
+    get album() {
+      return data.album;
+    },
+    get comment() {
+      return data.comment;
+    },
+    get genre() {
+      return data.genre;
+    },
+    get year() {
+      return data.year;
+    },
+    get track() {
+      return data.track;
+    },
+    get date() {
+      return handle.getProperty("DATE") || void 0;
+    },
+    setTitle: (value) => {
+      handle.setTagData({ title: value });
+      data = handle.getTagData();
+      return tag;
+    },
+    setArtist: (value) => {
+      handle.setTagData({ artist: value });
+      data = handle.getTagData();
+      return tag;
+    },
+    setAlbum: (value) => {
+      handle.setTagData({ album: value });
+      data = handle.getTagData();
+      return tag;
+    },
+    setComment: (value) => {
+      handle.setTagData({ comment: value });
+      data = handle.getTagData();
+      return tag;
+    },
+    setGenre: (value) => {
+      handle.setTagData({ genre: value });
+      data = handle.getTagData();
+      return tag;
+    },
+    setYear: (value) => {
+      handle.setTagData({ year: value });
+      data = handle.getTagData();
+      return tag;
+    },
+    setTrack: (value) => {
+      const existing = value > 0 ? handle.getProperty(RAW_TRACK_WIRE_KEY) : "";
+      const slash = existing.indexOf("/");
+      if (slash !== -1) {
+        handle.setProperty(
+          RAW_TRACK_WIRE_KEY,
+          `${value}${existing.slice(slash)}`
+        );
+      } else {
+        handle.setTagData({ track: value });
+      }
+      data = handle.getTagData();
+      return tag;
+    },
+    setDate: (value) => {
+      if (value === "") {
+        handle.setTagData({ year: 0 });
+      } else {
+        handle.setProperty("DATE", value);
+      }
+      data = handle.getTagData();
+      return tag;
+    }
+  };
+  return tag;
+}
+var RAW_TRACK_WIRE_KEY;
+var init_mutable_tag_impl = __esm({
+  "src/taglib/mutable-tag-impl.ts"() {
+    "use strict";
+    init_properties();
+    RAW_TRACK_WIRE_KEY = toTagLibKey("trackNumber");
   }
 });
 
@@ -1428,6 +1582,8 @@ var init_audio_file_base = __esm({
     "use strict";
     init_properties();
     init_errors2();
+    init_mp4_item_names();
+    init_mutable_tag_impl();
     LYRICS_PROPERTY_KEY = "lyrics";
     LYRICS_WIRE_KEY = toTagLibKey(LYRICS_PROPERTY_KEY);
     EMPTY_KEY_SET = /* @__PURE__ */ new Set();
@@ -1478,79 +1634,7 @@ var init_audio_file_base = __esm({
         return this.getFormat() === format;
       }
       tag() {
-        const handle = this.handle;
-        let data = handle.getTagData();
-        const tag = {
-          get title() {
-            return data.title;
-          },
-          get artist() {
-            return data.artist;
-          },
-          get album() {
-            return data.album;
-          },
-          get comment() {
-            return data.comment;
-          },
-          get genre() {
-            return data.genre;
-          },
-          get year() {
-            return data.year;
-          },
-          get track() {
-            return data.track;
-          },
-          get date() {
-            return handle.getProperty("DATE") || void 0;
-          },
-          setTitle: (value) => {
-            handle.setTagData({ title: value });
-            data = handle.getTagData();
-            return tag;
-          },
-          setArtist: (value) => {
-            handle.setTagData({ artist: value });
-            data = handle.getTagData();
-            return tag;
-          },
-          setAlbum: (value) => {
-            handle.setTagData({ album: value });
-            data = handle.getTagData();
-            return tag;
-          },
-          setComment: (value) => {
-            handle.setTagData({ comment: value });
-            data = handle.getTagData();
-            return tag;
-          },
-          setGenre: (value) => {
-            handle.setTagData({ genre: value });
-            data = handle.getTagData();
-            return tag;
-          },
-          setYear: (value) => {
-            handle.setTagData({ year: value });
-            data = handle.getTagData();
-            return tag;
-          },
-          setTrack: (value) => {
-            handle.setTagData({ track: value });
-            data = handle.getTagData();
-            return tag;
-          },
-          setDate: (value) => {
-            if (value === "") {
-              handle.setTagData({ year: 0 });
-            } else {
-              handle.setProperty("DATE", value);
-            }
-            data = handle.getTagData();
-            return tag;
-          }
-        };
-        return tag;
+        return buildMutableTag(this.handle);
       }
       audioProperties() {
         if (!this.cachedAudioProperties) {
@@ -1572,14 +1656,29 @@ var init_audio_file_base = __esm({
           const existing = this.handle.getProperties()[LYRICS_WIRE_KEY];
           if (existing !== void 0) translated[LYRICS_WIRE_KEY] = existing;
         }
+        const atomNames = mp4FreeformAtomNames(Object.keys(translated));
+        if (atomNames.length > 0) translated[MP4_ITEM_NAMES_KEY] = atomNames;
         this.handle.setProperties(translated);
       }
       getProperty(key) {
         const value = this.handle.getProperty(toTagLibKey(key));
-        return value === "" ? void 0 : value;
+        if (value !== "") return value;
+        if (!this.isMP4()) return void 0;
+        const remapped = this.properties()[key]?.[0];
+        return remapped === "" ? void 0 : remapped;
       }
       setProperty(key, value) {
-        this.handle.setProperty(toTagLibKey(key), value);
+        const wireKey = toTagLibKey(key);
+        const atomNames = mp4FreeformAtomNames([wireKey]);
+        if (atomNames.length > 0 && this.isMP4()) {
+          this.handle.setProperties({
+            ...this.handle.getProperties(),
+            [wireKey]: [value],
+            [MP4_ITEM_NAMES_KEY]: atomNames
+          });
+          return;
+        }
+        this.handle.setProperty(wireKey, value);
       }
       isMP4() {
         return this.handle.isMP4();
@@ -1588,13 +1687,19 @@ var init_audio_file_base = __esm({
         if (!this.isMP4()) {
           throw new UnsupportedFormatError(this.getFormat(), ["MP4", "M4A"]);
         }
-        const value = this.handle.getMP4Item(key);
+        const wireKey = mp4AtomWireKey(key);
+        const value = wireKey !== void 0 ? this.handle.getProperty(wireKey) : this.handle.getMP4Item(key);
         return value === "" ? void 0 : value;
       }
       setMP4Item(key, value) {
         if (!this.isMP4()) {
           throw new UnsupportedFormatError(this.getFormat(), ["MP4", "M4A"]);
         }
+        const wireKey = mp4AtomWireKey(key);
+        if (wireKey !== void 0) {
+          this.handle.setProperty(wireKey, value);
+          return;
+        }
         this.handle.setMP4Item(key, value);
       }
       removeMP4Item(key) {
@@ -1877,6 +1982,8 @@ function copyEditedState(target, source, sourceComplete, deletedKeys) {
   target.setTagData(source.getTagData());
   const merged = sourceComplete ? source.getProperties() : { ...target.getProperties(), ...source.getProperties() };
   for (const key of deletedKeys) delete merged[key];
+  const atomNames = mp4FreeformAtomNames(Object.keys(merged));
+  if (atomNames.length > 0) merged[MP4_ITEM_NAMES_KEY] = atomNames;
   target.setProperties(merged);
   copyExtraState(target, source, sourceComplete);
 }
@@ -1912,6 +2019,8 @@ var init_save_reconstruct = __esm({
     init_write();
     init_embind_adapter();
     init_extra_state_registry();
+    init_properties();
+    init_mp4_item_names();
   }
 });
 
@@ -2217,11 +2326,25 @@ var init_load_audio_data = __esm({
   }
 });
 
-// src/utils/tag-mapping.ts
-function parseNumeric(value) {
-  const parsed = Number.parseInt(value, 10);
+// src/utils/mirror-fields.ts
+function parseLeadingInt(raw) {
+  const parsed = Number.parseInt(raw, 10);
   return Number.isNaN(parsed) ? void 0 : parsed;
 }
+var MIRROR_FIELDS, DATE_MIRROR, TRACK_MIRROR;
+var init_mirror_fields = __esm({
+  "src/utils/mirror-fields.ts"() {
+    "use strict";
+    MIRROR_FIELDS = [
+      { raw: "date", numeric: "year" },
+      { raw: "trackNumber", numeric: "track" }
+    ];
+    DATE_MIRROR = MIRROR_FIELDS[0];
+    TRACK_MIRROR = MIRROR_FIELDS[1];
+  }
+});
+
+// src/utils/tag-mapping.ts
 function readExtendedTag(audioFile) {
   const tag = mapPropertiesToExtendedTag(audioFile.properties());
   const pictures = audioFile.getPictures();
@@ -2246,21 +2369,35 @@ function mapPropertiesToExtendedTag(props) {
     const values = props[propKey];
     if (!values || values.length === 0) continue;
     if (tagField === "year" || tagField === "track") {
-      const num = parseNumeric(values[0]);
+      const num = parseLeadingInt(values[0]);
       if (num !== void 0) tag[tagField] = num;
       if (propKey === "date") {
         tag.date = values.length === 1 ? values[0] : values;
       }
+      if (propKey === "trackNumber") {
+        tag.trackNumber = values.length === 1 ? values[0] : values;
+      }
     } else {
       tag[tagField] = values;
     }
   }
+  for (const [propKey, totalField] of [
+    ["trackNumber", "totalTracks"],
+    ["discNumber", "totalDiscs"]
+  ]) {
+    if (tag[totalField] !== void 0) continue;
+    const raw = props[propKey]?.[0];
+    const slash = raw?.indexOf("/") ?? -1;
+    if (raw === void 0 || slash === -1) continue;
+    const total = parseLeadingInt(raw.slice(slash + 1));
+    if (total !== void 0) tag[totalField] = total;
+  }
   for (const [key, values] of Object.entries(props)) {
     if (BASIC_PROPERTY_KEYS[key]) continue;
     if (!values || values.length === 0) continue;
     const camelKey = fromTagLibKey(key);
     if (NUMERIC_FIELDS.has(camelKey)) {
-      const num = parseNumeric(values[0]);
+      const num = parseLeadingInt(values[0]);
       if (num !== void 0) tag[camelKey] = num;
     } else if (camelKey === "compilation") {
       tag[camelKey] = values[0] === "1";
@@ -2273,8 +2410,29 @@ function mapPropertiesToExtendedTag(props) {
 function mergeTagUpdates(file, tags) {
   const currentProps = file.properties();
   const newProps = normalizeTagInput(tags);
+  reconcilePairFields(currentProps, newProps, tags);
   file.setProperties({ ...currentProps, ...newProps });
 }
+function reconcilePairFields(currentProps, newProps, input) {
+  const pairs = [
+    ["trackNumber", "totalTracks", "track"],
+    ["discNumber", "totalDiscs", "discNumber"]
+  ];
+  for (const [rawKey, totalKey, numericKey] of pairs) {
+    const incoming = newProps[rawKey]?.[0];
+    if (incoming?.includes("/")) {
+      newProps[totalKey] = [];
+      continue;
+    }
+    const numericOnly = input[numericKey] !== void 0 && input[rawKey] === void 0;
+    if (!numericOnly || incoming === void 0) continue;
+    const existing = currentProps[rawKey]?.[0];
+    const slash = existing?.indexOf("/") ?? -1;
+    if (existing !== void 0 && slash !== -1) {
+      newProps[rawKey] = [`${incoming}${existing.slice(slash)}`];
+    }
+  }
+}
 function normalizeTagInput(input) {
   const props = {};
   for (const field of [
@@ -2297,6 +2455,9 @@ function normalizeTagInput(input) {
   if (input.track !== void 0) {
     props.trackNumber = [String(input.track)];
   }
+  if (input.trackNumber !== void 0) {
+    props.trackNumber = Array.isArray(input.trackNumber) ? input.trackNumber : [input.trackNumber];
+  }
   for (const [field, val] of Object.entries(input)) {
     if (BASIC_FIELDS.has(field) || val === void 0) continue;
     if (field === "compilation") {
@@ -2309,6 +2470,12 @@ function normalizeTagInput(input) {
       props[field] = val;
     }
   }
+  for (const [rawField, totalField] of [
+    ["trackNumber", "totalTracks"],
+    ["discNumber", "totalDiscs"]
+  ]) {
+    if (props[rawField]?.[0]?.includes("/")) delete props[totalField];
+  }
   return props;
 }
 var BASIC_PROPERTY_KEYS, BASIC_FIELDS, NUMERIC_FIELDS;
@@ -2316,6 +2483,7 @@ var init_tag_mapping = __esm({
   "src/utils/tag-mapping.ts"() {
     "use strict";
     init_properties();
+    init_mirror_fields();
     BASIC_PROPERTY_KEYS = {
       title: "title",
       artist: "artist",
@@ -2333,7 +2501,8 @@ var init_tag_mapping = __esm({
       "genre",
       "year",
       "date",
-      "track"
+      "track",
+      "trackNumber"
     ]);
     NUMERIC_FIELDS = /* @__PURE__ */ new Set([
       "year",
@@ -2351,7 +2520,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = "1.5.2";
+    VERSION = "1.6.0";
   }
 });
 

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

@@ -3,18 +3,22 @@
  * These are properties that contain multiple fields and cannot be
  * represented as simple string values.
  *
+ * These constants describe the shape of each complex property. Values are read
+ * and written through dedicated typed accessors, not a generic property call.
+ *
  * @example
  * ```typescript
- * import { COMPLEX_PROPERTIES, COMPLEX_PROPERTY_KEY, Rating } from 'taglib-wasm';
+ * import type { Rating } from 'taglib-wasm';
  *
- * // Type-safe property access
- * const ratings = file.getComplexProperty(COMPLEX_PROPERTY_KEY.RATING);
+ * // Read via the typed accessor
+ * const ratings = file.getRatings();
  * console.log(ratings[0].rating); // 0.0-1.0 normalized
  *
  * // Set a rating
- * file.setComplexProperty(COMPLEX_PROPERTY_KEY.RATING, [
- *   { rating: 0.8, email: "user@example.com" }
- * ]);
+ * file.setRating(0.8, "user@example.com");
+ *
+ * // Or replace the full list
+ * file.setRatings([{ rating: 0.8, email: "user@example.com" }]);
  * ```
  */
 import type { Picture } from "../types.js";
@@ -74,13 +78,15 @@ export interface UnsyncedLyrics {
 export type VariantMap = Record<string, unknown>;
 /**
  * Type map linking complex property keys to their value types.
- * Enables type-safe generic methods for getComplexProperty/setComplexProperty.
+ *
+ * This is a descriptive type map, not the accessor surface — each complex
+ * property is reached through its own typed method:
  *
  * @example
  * ```typescript
- * // TypeScript knows the return type based on key
- * const ratings = file.getComplexProperty("RATING"); // Rating[]
- * const pictures = file.getComplexProperty("PICTURE"); // Picture[]
+ * const ratings = file.getRatings(); // Rating[]
+ * const pictures = file.getPictures(); // Picture[]
+ * const chapters = file.getChapters(); // Chapter[]
  * ```
  *
  * Consumers can extend via module augmentation:
@@ -177,8 +183,8 @@ export type ComplexPropertyKeyMap = {
  *
  * @example
  * ```typescript
- * // Instead of: file.getComplexProperty(COMPLEX_PROPERTIES.RATING.key)
- * file.getComplexProperty(COMPLEX_PROPERTY_KEY.RATING);
+ * // Instead of: COMPLEX_PROPERTIES.RATING.key
+ * COMPLEX_PROPERTY_KEY.RATING; // "RATING"
  * ```
  */
 export declare const COMPLEX_PROPERTY_KEY: ComplexPropertyKeyMap;

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

@@ -1 +1 @@
-{"version":3,"file":"complex-properties.d.ts","sourceRoot":"","sources":["../../../src/constants/complex-properties.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEpD;;;;;;;;GAQG;AACH,MAAM,WAAW,MAAM;IACrB,6DAA6D;IAC7D,MAAM,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4CAA4C;IAC5C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,qEAAqE;IACrE,EAAE,EAAE,MAAM,CAAC;IACX,0DAA0D;IAC1D,IAAI,EAAE,UAAU,CAAC;IACjB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,uBAAuB;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,kCAAkC;IAClC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,uBAAuB;IACtC,oCAAoC;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,8CAA8C;IAC9C,MAAM,EAAE,MAAM,CAAC;IACf,iCAAiC;IACjC,MAAM,EAAE,cAAc,CAAC;IACvB,0CAA0C;IAC1C,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,uBAAuB,CAAC;AAE/D;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CrB,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,EAAE,CAAC,IAAI,kBAAkB,GAAG,CAAC;CACtC,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,EAAE,qBAKzB,CAAC"}
+{"version":3,"file":"complex-properties.d.ts","sourceRoot":"","sources":["../../../src/constants/complex-properties.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEpD;;;;;;;;GAQG;AACH,MAAM,WAAW,MAAM;IACrB,6DAA6D;IAC7D,MAAM,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4CAA4C;IAC5C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,qEAAqE;IACrE,EAAE,EAAE,MAAM,CAAC;IACX,0DAA0D;IAC1D,IAAI,EAAE,UAAU,CAAC;IACjB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,uBAAuB;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,kCAAkC;IAClC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,uBAAuB;IACtC,oCAAoC;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,8CAA8C;IAC9C,MAAM,EAAE,MAAM,CAAC;IACf,iCAAiC;IACjC,MAAM,EAAE,cAAc,CAAC;IACvB,0CAA0C;IAC1C,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,uBAAuB,CAAC;AAE/D;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CrB,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,EAAE,CAAC,IAAI,kBAAkB,GAAG,CAAC;CACtC,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,EAAE,qBAKzB,CAAC"}

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

@@ -395,6 +395,20 @@ export declare const PROPERTIES: {
             readonly mp4: "----:com.apple.iTunes:iTunNORM";
         };
     };
+    readonly appleGaplessInfo: {
+        readonly key: "ITUNSMPB";
+        readonly description: "Apple gapless playback data (encoder delay and padding)";
+        readonly type: "string";
+        readonly supportedFormats: readonly ["ID3v2", "MP4", "Vorbis"];
+        readonly mappings: {
+            readonly id3v2: {
+                readonly frame: "TXXX";
+                readonly description: "iTunSMPB";
+            };
+            readonly vorbis: "ITUNSMPB";
+            readonly mp4: "----:com.apple.iTunes:iTunSMPB";
+        };
+    };
     readonly albumArtist: {
         readonly key: "ALBUMARTIST";
         readonly description: "The album artist (band/orchestra/ensemble)";
@@ -775,6 +789,16 @@ export type PropertyKey = keyof typeof PROPERTIES;
 export type PropertyValue<K extends PropertyKey> = typeof PROPERTIES[K]["type"] extends "string" ? string : typeof PROPERTIES[K]["type"] extends "number" ? number : typeof PROPERTIES[K]["type"] extends "boolean" ? boolean : string;
 /** Translate a camelCase property key to TagLib's ALL_CAPS wire key. Unknown keys pass through. */
 export declare function toTagLibKey(key: string): string;
+/**
+ * TagLib wire key for a standard MP4 atom name, or `undefined` for a freeform
+ * atom or one we do not model.
+ */
+export declare function mp4AtomWireKey(atom: string): string | undefined;
+/**
+ * Exact MP4 atom names for the given TagLib wire keys, for keys backed by a
+ * mixed-case freeform atom. Empty when none apply, which is the common case.
+ */
+export declare function mp4FreeformAtomNames(wireKeys: Iterable<string>): string[];
 /** Translate a TagLib ALL_CAPS wire key to a camelCase property key. Unknown keys pass through. */
 export declare function fromTagLibKey(key: string): string;
 /** Remap all keys of an object from TagLib ALL_CAPS to camelCase. */

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

@@ -1 +1 @@
-{"version":3,"file":"properties.d.ts","sourceRoot":"","sources":["../../../src/constants/properties.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAQH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKb,CAAC;AAEX;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,UAAU,CAAC;AAElD;;;GAGG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,WAAW,IAC7C,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,QAAQ,GAAG,MAAM,GAClD,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,QAAQ,GAAG,MAAM,GACtD,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,SAAS,GAAG,OAAO,GACxD,MAAM,CAAC;AAmBb,mGAAmG;AACnG,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED,mGAAmG;AACnG,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,qEAAqE;AACrE,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,GACrB,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAMnB;AAGD,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"properties.d.ts","sourceRoot":"","sources":["../../../src/constants/properties.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAQH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKb,CAAC;AAEX;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,UAAU,CAAC;AAElD;;;GAGG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,WAAW,IAC7C,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,QAAQ,GAAG,MAAM,GAClD,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,QAAQ,GAAG,MAAM,GACtD,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,SAAS,GAAG,OAAO,GACxD,MAAM,CAAC;AAmBb,mGAAmG;AACnG,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AAsDD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE/D;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAOzE;AAED,mGAAmG;AACnG,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,qEAAqE;AACrE,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,GACrB,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAMnB;AAGD,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/src/constants/properties.js

@@ -21,6 +21,38 @@ _fromTagLib["disc"] = "discNumber";
 function toTagLibKey(key) {
   return _toTagLib[key] ?? key;
 }
+const _mp4FreeformAtoms = {};
+for (const meta of Object.values(PROPERTIES)) {
+  const { key, mappings } = meta;
+  const atom = mappings?.mp4;
+  if (typeof atom !== "string" || !atom.startsWith("----:")) continue;
+  const bare = atom.slice(atom.lastIndexOf(":") + 1);
+  if (bare === bare.toUpperCase()) continue;
+  _mp4FreeformAtoms[key] = atom;
+  const readKey = bare.toUpperCase();
+  const camel = _fromTagLib[key];
+  if (camel !== void 0 && _fromTagLib[readKey] === void 0) {
+    _fromTagLib[readKey] = camel;
+  }
+}
+const _mp4AtomToWireKey = {};
+for (const meta of Object.values(PROPERTIES)) {
+  const { key, mappings } = meta;
+  const atom = mappings?.mp4;
+  if (typeof atom !== "string" || atom.startsWith("----:")) continue;
+  if (_mp4AtomToWireKey[atom] === void 0) _mp4AtomToWireKey[atom] = key;
+}
+function mp4AtomWireKey(atom) {
+  return _mp4AtomToWireKey[atom];
+}
+function mp4FreeformAtomNames(wireKeys) {
+  const names = [];
+  for (const key of wireKeys) {
+    const atom = _mp4FreeformAtoms[key];
+    if (atom !== void 0) names.push(atom);
+  }
+  return names;
+}
 function fromTagLibKey(key) {
   return _fromTagLib[key] ?? key;
 }
@@ -34,6 +66,8 @@ function remapKeysFromTagLib(obj) {
 export {
   PROPERTIES,
   fromTagLibKey,
+  mp4AtomWireKey,
+  mp4FreeformAtomNames,
   remapKeysFromTagLib,
   toTagLibKey
 };

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

@@ -157,5 +157,28 @@ export declare const SPECIALIZED_PROPERTIES: {
             readonly mp4: "----:com.apple.iTunes:iTunNORM";
         };
     };
+    /**
+     * Apple gapless-playback data (encoder delay, padding, original sample count).
+     *
+     * Exists so the two Apple freeform atoms are presented consistently: without
+     * it, `properties()` answered `appleSoundCheck` for iTunNORM but the raw
+     * uppercased `ITUNSMPB` for its sibling, because only one had an alias. The
+     * name mirrors `appleSoundCheck` — vendor-prefixed, feature-named rather than
+     * atom-named (tuneup-ibo).
+     */
+    readonly appleGaplessInfo: {
+        readonly key: "ITUNSMPB";
+        readonly description: "Apple gapless playback data (encoder delay and padding)";
+        readonly type: "string";
+        readonly supportedFormats: readonly ["ID3v2", "MP4", "Vorbis"];
+        readonly mappings: {
+            readonly id3v2: {
+                readonly frame: "TXXX";
+                readonly description: "iTunSMPB";
+            };
+            readonly vorbis: "ITUNSMPB";
+            readonly mp4: "----:com.apple.iTunes:iTunSMPB";
+        };
+    };
 };
 //# sourceMappingURL=specialized-properties.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"specialized-properties.d.ts","sourceRoot":"","sources":["../../../src/constants/specialized-properties.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiIzB,CAAC"}
+{"version":3,"file":"specialized-properties.d.ts","sourceRoot":"","sources":["../../../src/constants/specialized-properties.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiIjC;;;;;;;;OAQG;;;;;;;;;;;;;;;CAYK,CAAC"}