taglib-wasm 2.2.3 → 2.3.0

package/dist/web.browser.js

@@ -0,0 +1,3630 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/errors/base.ts
+var SUPPORTED_FORMATS, TagLibError;
+var init_base = __esm({
+  "src/errors/base.ts"() {
+    "use strict";
+    SUPPORTED_FORMATS = [
+      "MP3",
+      "AAC",
+      "MP4",
+      "M4A",
+      "FLAC",
+      "OGG",
+      "OPUS",
+      "OggFLAC",
+      "SPEEX",
+      "WAV",
+      "AIFF",
+      "ASF",
+      "APE",
+      "DSF",
+      "DSDIFF",
+      "WV",
+      "MPC",
+      "TTA",
+      "SHN",
+      "MOD",
+      "S3M",
+      "IT",
+      "XM",
+      "MATROSKA",
+      "MKA"
+    ];
+    TagLibError = class _TagLibError extends Error {
+      /**
+       * Creates a new TagLibError
+       * @param code - Error code for programmatic handling
+       * @param message - Human-readable error message
+       * @param details - Additional context about the error
+       */
+      constructor(code, message, details) {
+        super(message);
+        __publicField(this, "code", code);
+        __publicField(this, "details", details);
+        this.name = "TagLibError";
+        Object.setPrototypeOf(this, _TagLibError.prototype);
+      }
+    };
+  }
+});
+
+// src/errors/classes.ts
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function createErrorMessage(prefix, details) {
+  return `${prefix}: ${details}`;
+}
+function formatFileSize(bytes) {
+  if (bytes < 1024) return `${bytes} bytes`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+var TagLibInitializationError, InvalidFormatError, UnsupportedFormatError, FileOperationError, MetadataError, MemoryError, EnvironmentError;
+var init_classes = __esm({
+  "src/errors/classes.ts"() {
+    "use strict";
+    init_base();
+    TagLibInitializationError = class _TagLibInitializationError extends TagLibError {
+      /**
+       * Creates a new TagLibInitializationError
+       * @param message - Description of the initialization failure
+       * @param details - Additional context about the error
+       */
+      constructor(message, details) {
+        super(
+          "INITIALIZATION",
+          createErrorMessage("Failed to initialize TagLib Wasm module", message),
+          details
+        );
+        this.name = "TagLibInitializationError";
+        Object.setPrototypeOf(this, _TagLibInitializationError.prototype);
+      }
+    };
+    InvalidFormatError = class _InvalidFormatError extends TagLibError {
+      /**
+       * Creates a new InvalidFormatError
+       * @param message - Description of the format error
+       * @param bufferSize - Size of the audio buffer in bytes
+       * @param details - Additional context about the error
+       */
+      constructor(message, bufferSize, details) {
+        const errorDetails = [`Invalid audio file format: ${message}`];
+        if (bufferSize !== void 0) {
+          errorDetails.push(`Buffer size: ${formatFileSize(bufferSize)}`);
+          if (bufferSize < 1024) {
+            errorDetails.push(
+              "Audio files must be at least 1KB to contain valid headers."
+            );
+          }
+        }
+        super(
+          "INVALID_FORMAT",
+          errorDetails.join(". "),
+          { ...details, bufferSize }
+        );
+        __publicField(this, "bufferSize", bufferSize);
+        this.name = "InvalidFormatError";
+        Object.setPrototypeOf(this, _InvalidFormatError.prototype);
+      }
+    };
+    UnsupportedFormatError = class _UnsupportedFormatError extends TagLibError {
+      /**
+       * Creates a new UnsupportedFormatError
+       * @param format - The unsupported format that was encountered
+       * @param supportedFormats - List of formats that are supported
+       * @param details - Additional context about the error
+       */
+      constructor(format, supportedFormats = SUPPORTED_FORMATS, details) {
+        super(
+          "UNSUPPORTED_FORMAT",
+          `Unsupported audio format: ${format}. Supported formats: ${supportedFormats.join(", ")}`,
+          { ...details, format, supportedFormats }
+        );
+        __publicField(this, "format", format);
+        __publicField(this, "supportedFormats", supportedFormats);
+        this.name = "UnsupportedFormatError";
+        Object.setPrototypeOf(this, _UnsupportedFormatError.prototype);
+      }
+    };
+    FileOperationError = class _FileOperationError extends TagLibError {
+      /**
+       * Creates a new FileOperationError
+       * @param operation - The file operation that failed
+       * @param message - Description of the failure
+       * @param path - File path involved in the operation
+       * @param details - Additional context about the error
+       */
+      constructor(operation, message, path, details) {
+        const errorDetails = [`Failed to ${operation} file`];
+        if (path) {
+          errorDetails.push(`Path: ${path}`);
+        }
+        errorDetails.push(message);
+        super(
+          "FILE_OPERATION",
+          errorDetails.join(". "),
+          { ...details, operation, path }
+        );
+        __publicField(this, "operation", operation);
+        __publicField(this, "path", path);
+        this.name = "FileOperationError";
+        Object.setPrototypeOf(this, _FileOperationError.prototype);
+      }
+    };
+    MetadataError = class _MetadataError extends TagLibError {
+      /**
+       * Creates a new MetadataError
+       * @param operation - The metadata operation that failed
+       * @param message - Description of the failure
+       * @param field - The metadata field involved
+       * @param details - Additional context about the error
+       */
+      constructor(operation, message, field, details) {
+        const errorDetails = [`Failed to ${operation} metadata`];
+        if (field) {
+          errorDetails.push(`Field: ${field}`);
+        }
+        errorDetails.push(message);
+        super(
+          "METADATA",
+          errorDetails.join(". "),
+          { ...details, operation, field }
+        );
+        __publicField(this, "operation", operation);
+        __publicField(this, "field", field);
+        this.name = "MetadataError";
+        Object.setPrototypeOf(this, _MetadataError.prototype);
+      }
+    };
+    MemoryError = class _MemoryError extends TagLibError {
+      /**
+       * Creates a new MemoryError
+       * @param message - Description of the memory failure
+       * @param details - Additional context about the error
+       */
+      constructor(message, details) {
+        super(
+          "MEMORY",
+          createErrorMessage("Memory allocation failed", message),
+          details
+        );
+        this.name = "MemoryError";
+        Object.setPrototypeOf(this, _MemoryError.prototype);
+      }
+    };
+    EnvironmentError = class _EnvironmentError extends TagLibError {
+      /**
+       * Creates a new EnvironmentError
+       * @param environment - The runtime environment name
+       * @param reason - Why the environment is incompatible
+       * @param requiredFeature - The feature that is missing
+       */
+      constructor(environment, reason, requiredFeature) {
+        const message = requiredFeature ? `Environment '${environment}' ${reason}. Required feature: ${requiredFeature}.` : `Environment '${environment}' ${reason}.`;
+        super("ENVIRONMENT", message);
+        __publicField(this, "environment", environment);
+        __publicField(this, "reason", reason);
+        __publicField(this, "requiredFeature", requiredFeature);
+        this.name = "EnvironmentError";
+        Object.setPrototypeOf(this, _EnvironmentError.prototype);
+      }
+    };
+  }
+});
+
+// src/types/audio-formats.ts
+function isNamedAudioInput(input) {
+  return typeof input === "object" && input !== null && "name" in input && "data" in input && !(input instanceof File) && !(input instanceof Uint8Array) && !(input instanceof ArrayBuffer);
+}
+var init_audio_formats = __esm({
+  "src/types/audio-formats.ts"() {
+    "use strict";
+  }
+});
+
+// src/types/tags.ts
+var init_tags = __esm({
+  "src/types/tags.ts"() {
+    "use strict";
+  }
+});
+
+// src/types/metadata-mappings.ts
+var init_metadata_mappings = __esm({
+  "src/types/metadata-mappings.ts"() {
+    "use strict";
+  }
+});
+
+// src/types/pictures.ts
+var PICTURE_TYPE_VALUES, PICTURE_TYPE_NAMES;
+var init_pictures = __esm({
+  "src/types/pictures.ts"() {
+    "use strict";
+    PICTURE_TYPE_VALUES = {
+      Other: 0,
+      FileIcon: 1,
+      OtherFileIcon: 2,
+      FrontCover: 3,
+      BackCover: 4,
+      LeafletPage: 5,
+      Media: 6,
+      LeadArtist: 7,
+      Artist: 8,
+      Conductor: 9,
+      Band: 10,
+      Composer: 11,
+      Lyricist: 12,
+      RecordingLocation: 13,
+      DuringRecording: 14,
+      DuringPerformance: 15,
+      MovieScreenCapture: 16,
+      ColouredFish: 17,
+      Illustration: 18,
+      BandLogo: 19,
+      PublisherLogo: 20
+    };
+    PICTURE_TYPE_NAMES = {
+      0: "Other",
+      1: "FileIcon",
+      2: "OtherFileIcon",
+      3: "FrontCover",
+      4: "BackCover",
+      5: "LeafletPage",
+      6: "Media",
+      7: "LeadArtist",
+      8: "Artist",
+      9: "Conductor",
+      10: "Band",
+      11: "Composer",
+      12: "Lyricist",
+      13: "RecordingLocation",
+      14: "DuringRecording",
+      15: "DuringPerformance",
+      16: "MovieScreenCapture",
+      17: "ColouredFish",
+      18: "Illustration",
+      19: "BandLogo",
+      20: "PublisherLogo"
+    };
+  }
+});
+
+// src/types/chapters.ts
+var init_chapters = __esm({
+  "src/types/chapters.ts"() {
+    "use strict";
+  }
+});
+
+// src/types/bwf.ts
+var init_bwf = __esm({
+  "src/types/bwf.ts"() {
+    "use strict";
+  }
+});
+
+// src/types/config.ts
+var init_config = __esm({
+  "src/types/config.ts"() {
+    "use strict";
+  }
+});
+
+// src/types/format-property-keys.ts
+var init_format_property_keys = __esm({
+  "src/types/format-property-keys.ts"() {
+    "use strict";
+  }
+});
+
+// src/types/index.ts
+var init_types = __esm({
+  "src/types/index.ts"() {
+    "use strict";
+    init_audio_formats();
+    init_tags();
+    init_metadata_mappings();
+    init_pictures();
+    init_chapters();
+    init_bwf();
+    init_config();
+    init_format_property_keys();
+  }
+});
+
+// src/types.ts
+var init_types2 = __esm({
+  "src/types.ts"() {
+    "use strict";
+    init_types();
+  }
+});
+
+// src/bwf/bext.ts
+function readFixedString(bytes, offset, len) {
+  let end = offset;
+  const max = Math.min(offset + len, bytes.length);
+  while (end < max && bytes[end] !== 0) end++;
+  let s = "";
+  for (let i = offset; i < end; i++) s += String.fromCharCode(bytes[i]);
+  return s;
+}
+function writeFixedString(bytes, offset, len, value) {
+  for (let i = 0; i < len; i++) {
+    bytes[offset + i] = i < value.length ? value.charCodeAt(i) & 255 : 0;
+  }
+}
+function clampInt16(n) {
+  return Math.max(-32768, Math.min(32767, Math.round(n)));
+}
+function loudnessRaw(v) {
+  return v === void 0 ? LOUDNESS_UNSET : clampInt16(v * 100);
+}
+function loudnessFromRaw(raw) {
+  return raw === LOUDNESS_UNSET ? void 0 : raw / 100;
+}
+function bytesToHex(bytes) {
+  let s = "";
+  for (const b of bytes) s += b.toString(16).padStart(2, "0");
+  return s;
+}
+function hexToBytes(hex, outLen) {
+  const clean = hex.replace(/[^0-9a-fA-F]/g, "");
+  const out = new Uint8Array(outLen);
+  for (let i = 0; i + 1 < clean.length + 1 && i / 2 < outLen; i += 2) {
+    const pair = clean.slice(i, i + 2);
+    if (pair.length === 2) out[i / 2] = parseInt(pair, 16);
+  }
+  return out;
+}
+function decodeBext(bytes) {
+  if (bytes.length < VERSION_OFFSET + 2) return void 0;
+  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const timeRefLow = dv.getUint32(338, true);
+  const timeRefHigh = dv.getUint32(342, true);
+  const version = dv.getUint16(VERSION_OFFSET, true);
+  const result = {
+    description: readFixedString(bytes, 0, 256),
+    originator: readFixedString(bytes, 256, 32),
+    originatorReference: readFixedString(bytes, 288, 32),
+    originationDate: readFixedString(bytes, 320, 10),
+    originationTime: readFixedString(bytes, 330, 8),
+    timeReferenceSamples: BigInt(timeRefHigh) << 32n | BigInt(timeRefLow),
+    version,
+    codingHistory: bytes.length > FIXED_PREFIX_LEN ? readFixedString(
+      bytes,
+      FIXED_PREFIX_LEN,
+      bytes.length - FIXED_PREFIX_LEN
+    ) : ""
+  };
+  if (version >= 1 && bytes.length >= UMID_OFFSET + UMID_LEN) {
+    result.umid = bytesToHex(
+      bytes.subarray(UMID_OFFSET, UMID_OFFSET + UMID_LEN)
+    );
+  }
+  if (version >= 2 && bytes.length >= LOUDNESS_OFFSET + 10) {
+    const lv = loudnessFromRaw(dv.getInt16(LOUDNESS_OFFSET, true));
+    const lr = loudnessFromRaw(dv.getInt16(LOUDNESS_OFFSET + 2, true));
+    const mtp = loudnessFromRaw(dv.getInt16(LOUDNESS_OFFSET + 4, true));
+    const mml = loudnessFromRaw(dv.getInt16(LOUDNESS_OFFSET + 6, true));
+    const msl = loudnessFromRaw(dv.getInt16(LOUDNESS_OFFSET + 8, true));
+    if (lv !== void 0) result.loudnessValueDb = lv;
+    if (lr !== void 0) result.loudnessRangeDb = lr;
+    if (mtp !== void 0) result.maxTruePeakLevelDbtp = mtp;
+    if (mml !== void 0) result.maxMomentaryLoudnessDb = mml;
+    if (msl !== void 0) result.maxShortTermLoudnessDb = msl;
+  }
+  return result;
+}
+function encodeBext(b) {
+  const codingHistory = b.codingHistory ?? "";
+  const bytes = new Uint8Array(FIXED_PREFIX_LEN + codingHistory.length);
+  const dv = new DataView(bytes.buffer);
+  const hasLoudness = b.loudnessValueDb !== void 0 || b.loudnessRangeDb !== void 0 || b.maxTruePeakLevelDbtp !== void 0 || b.maxMomentaryLoudnessDb !== void 0 || b.maxShortTermLoudnessDb !== void 0;
+  const version = Number.isInteger(b.version) ? b.version : hasLoudness ? 2 : b.umid ? 1 : 0;
+  writeFixedString(bytes, 0, 256, b.description ?? "");
+  writeFixedString(bytes, 256, 32, b.originator ?? "");
+  writeFixedString(bytes, 288, 32, b.originatorReference ?? "");
+  writeFixedString(bytes, 320, 10, b.originationDate ?? "");
+  writeFixedString(bytes, 330, 8, b.originationTime ?? "");
+  const tr = b.timeReferenceSamples ?? 0n;
+  dv.setUint32(338, Number(tr & 0xffffffffn), true);
+  dv.setUint32(342, Number(tr >> 32n & 0xffffffffn), true);
+  dv.setUint16(VERSION_OFFSET, version, true);
+  if (version >= 1 && b.umid) {
+    bytes.set(hexToBytes(b.umid, UMID_LEN), UMID_OFFSET);
+  }
+  if (version >= 2) {
+    dv.setInt16(LOUDNESS_OFFSET, loudnessRaw(b.loudnessValueDb), true);
+    dv.setInt16(LOUDNESS_OFFSET + 2, loudnessRaw(b.loudnessRangeDb), true);
+    dv.setInt16(LOUDNESS_OFFSET + 4, loudnessRaw(b.maxTruePeakLevelDbtp), true);
+    dv.setInt16(
+      LOUDNESS_OFFSET + 6,
+      loudnessRaw(b.maxMomentaryLoudnessDb),
+      true
+    );
+    dv.setInt16(
+      LOUDNESS_OFFSET + 8,
+      loudnessRaw(b.maxShortTermLoudnessDb),
+      true
+    );
+  }
+  writeFixedString(
+    bytes,
+    FIXED_PREFIX_LEN,
+    codingHistory.length,
+    codingHistory
+  );
+  return bytes;
+}
+var FIXED_PREFIX_LEN, VERSION_OFFSET, UMID_OFFSET, UMID_LEN, LOUDNESS_OFFSET, LOUDNESS_UNSET;
+var init_bext = __esm({
+  "src/bwf/bext.ts"() {
+    "use strict";
+    FIXED_PREFIX_LEN = 602;
+    VERSION_OFFSET = 346;
+    UMID_OFFSET = 348;
+    UMID_LEN = 64;
+    LOUDNESS_OFFSET = 412;
+    LOUDNESS_UNSET = 32767;
+  }
+});
+
+// src/errors/guards.ts
+function isTagLibError(error) {
+  return error instanceof TagLibError;
+}
+function isInvalidFormatError(error) {
+  return error instanceof InvalidFormatError;
+}
+function isUnsupportedFormatError(error) {
+  return error instanceof UnsupportedFormatError;
+}
+function isFileOperationError(error) {
+  return error instanceof FileOperationError;
+}
+function isMetadataError(error) {
+  return error instanceof MetadataError;
+}
+function isMemoryError(error) {
+  return error instanceof MemoryError;
+}
+function isEnvironmentError(error) {
+  return error instanceof EnvironmentError;
+}
+var init_guards = __esm({
+  "src/errors/guards.ts"() {
+    "use strict";
+    init_base();
+    init_classes();
+  }
+});
+
+// src/errors/index.ts
+var init_errors = __esm({
+  "src/errors/index.ts"() {
+    "use strict";
+    init_base();
+    init_classes();
+    init_guards();
+  }
+});
+
+// src/errors.ts
+var init_errors2 = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    init_errors();
+  }
+});
+
+// src/taglib/audio-file-bwf.ts
+function requireBwf(format) {
+  if (!BWF_FORMATS.has(format)) {
+    throw new UnsupportedFormatError(format, ["WAV", "FLAC"], {
+      operation: "BWF metadata"
+    });
+  }
+}
+function getBextData(handle) {
+  const raw = handle.getBextData();
+  return raw && raw.length > 0 ? raw : void 0;
+}
+function setBextData(handle, format, data) {
+  requireBwf(format);
+  handle.setBextData(data);
+}
+function getBext(handle) {
+  const raw = handle.getBextData();
+  return raw && raw.length > 0 ? decodeBext(raw) : void 0;
+}
+function setBext(handle, format, bext) {
+  requireBwf(format);
+  handle.setBextData(encodeBext(bext));
+}
+function getIxml(handle) {
+  return handle.getIxml();
+}
+function setIxml(handle, format, data) {
+  requireBwf(format);
+  handle.setIxml(data);
+}
+var BWF_FORMATS;
+var init_audio_file_bwf = __esm({
+  "src/taglib/audio-file-bwf.ts"() {
+    "use strict";
+    init_bext();
+    init_errors2();
+    BWF_FORMATS = /* @__PURE__ */ new Set(["WAV", "FLAC"]);
+  }
+});
+
+// src/taglib/id3v2-frames.ts
+function assertMp3(format) {
+  if (format !== "MP3" && format !== "AAC") {
+    throw new UnsupportedFormatError(format, ["MP3", "AAC"], {
+      operation: "id3v2Frames"
+    });
+  }
+}
+function assertFrameId(id, operation) {
+  if (!FRAME_ID_PATTERN.test(id)) {
+    throw new MetadataError(
+      operation,
+      `Invalid ID3v2 frame ID: "${id}". Frame IDs must match [A-Z0-9]{4}`,
+      id
+    );
+  }
+}
+function assertFrameBodies(id, data) {
+  for (const body of data) {
+    if (body.length === 0) {
+      throw new MetadataError(
+        "write",
+        "Frame data must not be empty: zero-size ID3v2 frames are invalid",
+        id
+      );
+    }
+  }
+}
+function toPublicFrame(frame) {
+  return {
+    id: frame.id,
+    data: frame.data,
+    ...frame.flags ? { flags: frame.flags } : {}
+  };
+}
+var FRAME_ID_PATTERN;
+var init_id3v2_frames = __esm({
+  "src/taglib/id3v2-frames.ts"() {
+    "use strict";
+    init_classes();
+    FRAME_ID_PATTERN = /^[A-Z0-9]{4}$/;
+  }
+});
+
+// browser-stub:platform-io-browser-stub
+function getPlatformIO() {
+  throw new Error("Filesystem operations are not available in the browser.");
+}
+var init_platform_io_browser_stub = __esm({
+  "browser-stub:platform-io-browser-stub"() {
+  }
+});
+
+// src/utils/write.ts
+async function writeFileData(path, data) {
+  try {
+    await getPlatformIO().writeFile(path, data);
+  } catch (error) {
+    if (error instanceof EnvironmentError) throw error;
+    throw new FileOperationError(
+      "write",
+      error.message,
+      path
+    );
+  }
+}
+var init_write = __esm({
+  "src/utils/write.ts"() {
+    "use strict";
+    init_errors2();
+    init_platform_io_browser_stub();
+  }
+});
+
+// browser-stub:node-fs-browser-stub
+function getNodeFsSync() {
+  return null;
+}
+var init_node_fs_browser_stub = __esm({
+  "browser-stub:node-fs-browser-stub"() {
+  }
+});
+
+// src/utils/rating.ts
+function normalized(value) {
+  return value;
+}
+var init_rating = __esm({
+  "src/utils/rating.ts"() {
+    "use strict";
+  }
+});
+
+// src/runtime/detector.ts
+function isDeno() {
+  return g.Deno !== void 0;
+}
+var g, EXNREF_PROBE;
+var init_detector = __esm({
+  "src/runtime/detector.ts"() {
+    "use strict";
+    g = globalThis;
+    EXNREF_PROBE = new Uint8Array([
+      0,
+      97,
+      115,
+      109,
+      1,
+      0,
+      0,
+      0,
+      // Wasm header
+      6,
+      6,
+      // Global section, 6 bytes
+      1,
+      // 1 global
+      105,
+      0,
+      // exnref, const
+      208,
+      105,
+      11
+      // ref.null exnref, end
+    ]);
+  }
+});
+
+// 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({
+  "src/constants/basic-properties.ts"() {
+    "use strict";
+    BASIC_PROPERTIES = {
+      title: {
+        key: "TITLE",
+        description: "The title of the track",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis", "WAV"],
+        mappings: {
+          id3v2: { frame: "TIT2" },
+          vorbis: "TITLE",
+          mp4: "\xA9nam",
+          wav: "INAM"
+        }
+      },
+      artist: {
+        key: "ARTIST",
+        description: "The primary performer(s) of the track",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis", "WAV"],
+        mappings: {
+          id3v2: { frame: "TPE1" },
+          vorbis: "ARTIST",
+          mp4: "\xA9ART",
+          wav: "IART"
+        }
+      },
+      album: {
+        key: "ALBUM",
+        description: "The album/collection name",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis", "WAV"],
+        mappings: {
+          id3v2: { frame: "TALB" },
+          vorbis: "ALBUM",
+          mp4: "\xA9alb",
+          wav: "IPRD"
+        }
+      },
+      date: {
+        key: "DATE",
+        description: "The date of recording (typically year)",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis", "WAV"],
+        mappings: {
+          id3v2: { frame: "TDRC" },
+          vorbis: "DATE",
+          mp4: "\xA9day",
+          wav: "ICRD"
+        }
+      },
+      trackNumber: {
+        key: "TRACKNUMBER",
+        description: "The track number within the album",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis", "WAV"],
+        mappings: {
+          id3v2: { frame: "TRCK" },
+          vorbis: "TRACKNUMBER",
+          mp4: "trkn",
+          wav: "ITRK"
+        }
+      },
+      genre: {
+        key: "GENRE",
+        description: "The musical genre",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis", "WAV"],
+        mappings: {
+          id3v2: { frame: "TCON" },
+          vorbis: "GENRE",
+          mp4: "\xA9gen",
+          wav: "IGNR"
+        }
+      },
+      comment: {
+        key: "COMMENT",
+        description: "Comments or notes about the track",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis", "WAV"],
+        mappings: {
+          id3v2: { frame: "COMM" },
+          vorbis: "COMMENT",
+          mp4: "\xA9cmt",
+          wav: "ICMT"
+        }
+      }
+    };
+  }
+});
+
+// src/constants/general-extended-properties.ts
+var GENERAL_EXTENDED_PROPERTIES;
+var init_general_extended_properties = __esm({
+  "src/constants/general-extended-properties.ts"() {
+    "use strict";
+    GENERAL_EXTENDED_PROPERTIES = {
+      albumArtist: {
+        key: "ALBUMARTIST",
+        description: "The album artist (band/orchestra/ensemble)",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TPE2" },
+          vorbis: "ALBUMARTIST",
+          mp4: "aART"
+        }
+      },
+      composer: {
+        key: "COMPOSER",
+        description: "The original composer(s) of the track",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TCOM" },
+          vorbis: "COMPOSER",
+          mp4: "\xA9wrt"
+        }
+      },
+      copyright: {
+        key: "COPYRIGHT",
+        description: "Copyright information",
+        type: "string",
+        supportedFormats: ["ID3v2", "Vorbis"],
+        mappings: {
+          vorbis: "COPYRIGHT"
+        }
+      },
+      encodedBy: {
+        key: "ENCODEDBY",
+        description: "The encoding software or person",
+        type: "string",
+        supportedFormats: ["ID3v2", "Vorbis"],
+        mappings: {
+          vorbis: "ENCODEDBY"
+        }
+      },
+      discNumber: {
+        key: "DISCNUMBER",
+        description: "The disc number for multi-disc sets",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TPOS" },
+          vorbis: "DISCNUMBER",
+          mp4: "disk"
+        }
+      },
+      bpm: {
+        key: "BPM",
+        description: "Beats per minute",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TBPM" },
+          vorbis: "BPM",
+          mp4: "tmpo"
+        }
+      },
+      totalTracks: {
+        key: "TRACKTOTAL",
+        description: "Total number of tracks on the album",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TRCK" },
+          vorbis: "TRACKTOTAL",
+          mp4: "trkn"
+        }
+      },
+      totalDiscs: {
+        key: "DISCTOTAL",
+        description: "Total number of discs in the set",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TPOS" },
+          vorbis: "DISCTOTAL",
+          mp4: "disk"
+        }
+      },
+      compilation: {
+        key: "COMPILATION",
+        description: "Whether the album is a compilation (various artists)",
+        type: "boolean",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TCMP" },
+          vorbis: "COMPILATION",
+          mp4: "cpil"
+        }
+      },
+      // Sorting Properties
+      titleSort: {
+        key: "TITLESORT",
+        description: "Sort name for title (for alphabetization)",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TSOT" },
+          vorbis: "TITLESORT",
+          mp4: "sonm"
+        }
+      },
+      artistSort: {
+        key: "ARTISTSORT",
+        description: "Sort name for artist (for alphabetization)",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TSOP" },
+          vorbis: "ARTISTSORT",
+          mp4: "soar"
+        }
+      },
+      albumSort: {
+        key: "ALBUMSORT",
+        description: "Sort name for album (for alphabetization)",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TSOA" },
+          vorbis: "ALBUMSORT",
+          mp4: "soal"
+        }
+      },
+      // Additional common properties
+      lyricist: {
+        key: "LYRICIST",
+        description: "The lyrics/text writer(s)",
+        type: "string",
+        supportedFormats: ["Vorbis"],
+        mappings: {
+          vorbis: "LYRICIST"
+        }
+      },
+      conductor: {
+        key: "CONDUCTOR",
+        description: "The conductor",
+        type: "string",
+        supportedFormats: ["Vorbis"],
+        mappings: {
+          vorbis: "CONDUCTOR"
+        }
+      },
+      remixedBy: {
+        key: "REMIXER",
+        description: "Person who remixed the track",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TPE4" },
+          vorbis: "REMIXER",
+          mp4: "----:com.apple.iTunes:REMIXER"
+        }
+      },
+      language: {
+        key: "LANGUAGE",
+        description: "Language of vocals/lyrics",
+        type: "string",
+        supportedFormats: ["Vorbis"],
+        mappings: {
+          vorbis: "LANGUAGE"
+        }
+      },
+      publisher: {
+        key: "PUBLISHER",
+        description: "The publisher",
+        type: "string",
+        supportedFormats: ["Vorbis"],
+        mappings: {
+          vorbis: "PUBLISHER"
+        }
+      },
+      mood: {
+        key: "MOOD",
+        description: "The mood/atmosphere of the track",
+        type: "string",
+        supportedFormats: ["Vorbis"],
+        mappings: {
+          vorbis: "MOOD"
+        }
+      },
+      media: {
+        key: "MEDIA",
+        description: "Media type (CD, vinyl, etc.)",
+        type: "string",
+        supportedFormats: ["Vorbis"],
+        mappings: {
+          vorbis: "MEDIA"
+        }
+      },
+      grouping: {
+        key: "GROUPING",
+        description: "Content group/work",
+        type: "string",
+        supportedFormats: ["Vorbis"],
+        mappings: {
+          vorbis: "GROUPING"
+        }
+      },
+      work: {
+        key: "WORK",
+        description: "Work name",
+        type: "string",
+        supportedFormats: ["Vorbis"],
+        mappings: {
+          vorbis: "WORK"
+        }
+      },
+      lyrics: {
+        key: "LYRICS",
+        description: "Lyrics content",
+        type: "string",
+        supportedFormats: ["Vorbis"],
+        mappings: {
+          vorbis: "LYRICS"
+        }
+      },
+      isrc: {
+        key: "ISRC",
+        description: "International Standard Recording Code",
+        type: "string",
+        supportedFormats: ["Vorbis"],
+        mappings: {
+          vorbis: "ISRC"
+        }
+      },
+      catalogNumber: {
+        key: "CATALOGNUMBER",
+        description: "Catalog number",
+        type: "string",
+        supportedFormats: ["Vorbis"],
+        mappings: {
+          vorbis: "CATALOGNUMBER"
+        }
+      },
+      barcode: {
+        key: "BARCODE",
+        description: "Barcode (EAN/UPC)",
+        type: "string",
+        supportedFormats: ["Vorbis"],
+        mappings: {
+          vorbis: "BARCODE"
+        }
+      }
+    };
+  }
+});
+
+// src/constants/specialized-properties.ts
+var SPECIALIZED_PROPERTIES;
+var init_specialized_properties = __esm({
+  "src/constants/specialized-properties.ts"() {
+    "use strict";
+    SPECIALIZED_PROPERTIES = {
+      // MusicBrainz Identifiers
+      musicbrainzArtistId: {
+        key: "MUSICBRAINZ_ARTISTID",
+        description: "MusicBrainz Artist ID (UUID)",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TXXX", description: "MusicBrainz Artist Id" },
+          vorbis: "MUSICBRAINZ_ARTISTID",
+          mp4: "----:com.apple.iTunes:MusicBrainz Artist Id"
+        }
+      },
+      musicbrainzReleaseId: {
+        key: "MUSICBRAINZ_ALBUMID",
+        description: "MusicBrainz Release ID (UUID)",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TXXX", description: "MusicBrainz Album Id" },
+          vorbis: "MUSICBRAINZ_ALBUMID",
+          mp4: "----:com.apple.iTunes:MusicBrainz Album Id"
+        }
+      },
+      musicbrainzTrackId: {
+        key: "MUSICBRAINZ_TRACKID",
+        description: "MusicBrainz Recording ID (UUID)",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "UFID", description: "http://musicbrainz.org" },
+          vorbis: "MUSICBRAINZ_TRACKID",
+          mp4: "----:com.apple.iTunes:MusicBrainz Track Id"
+        }
+      },
+      musicbrainzReleaseGroupId: {
+        key: "MUSICBRAINZ_RELEASEGROUPID",
+        description: "MusicBrainz Release Group ID (UUID)",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TXXX", description: "MusicBrainz Release Group Id" },
+          vorbis: "MUSICBRAINZ_RELEASEGROUPID",
+          mp4: "----:com.apple.iTunes:MusicBrainz Release Group Id"
+        }
+      },
+      releaseType: {
+        key: "RELEASETYPE",
+        description: "Release type (album, single, EP, compilation, ...). Multi-value (e.g. 'album' + 'EP'). TagLib 2.3.2 translates the RELEASETYPE key per format: ID3v2 TXXX 'MUSICBRAINZ ALBUM TYPE' (TagLib's description casing), MP4 freeform atom, APEv2 MUSICBRAINZ_ALBUMTYPE, ASF 'MusicBrainz/Album Type', Vorbis/Matroska raw RELEASETYPE",
+        type: "string",
+        supportedFormats: [
+          "ID3v2",
+          "MP4",
+          "Vorbis",
+          "APE",
+          "ASF",
+          "Matroska"
+        ],
+        mappings: {
+          id3v2: { frame: "TXXX", description: "MusicBrainz Album Type" },
+          vorbis: "RELEASETYPE",
+          mp4: "----:com.apple.iTunes:MusicBrainz Album Type"
+        }
+      },
+      releaseCountry: {
+        key: "RELEASECOUNTRY",
+        description: "Release country (ISO 3166-1 code, e.g. 'US'). TagLib 2.3.2 translates the RELEASECOUNTRY key per format: ID3v2 TXXX 'MUSICBRAINZ ALBUM RELEASE COUNTRY' (TagLib's description casing; an uppercase TXXX:RELEASECOUNTRY description also reads back), MP4 freeform atom 'MusicBrainz Album Release Country', APEv2 raw RELEASECOUNTRY, ASF 'MusicBrainz/Album Release Country', WAV ICNT, Vorbis/Matroska raw RELEASECOUNTRY",
+        type: "string",
+        supportedFormats: [
+          "ID3v2",
+          "MP4",
+          "Vorbis",
+          "APE",
+          "ASF",
+          "Matroska",
+          "WAV"
+        ],
+        mappings: {
+          id3v2: {
+            frame: "TXXX",
+            description: "MusicBrainz Album Release Country"
+          },
+          vorbis: "RELEASECOUNTRY",
+          mp4: "----:com.apple.iTunes:MusicBrainz Album Release Country"
+        }
+      },
+      itunesAdvisory: {
+        key: "ITUNESADVISORY",
+        description: "Content advisory in the ITUNESADVISORY convention ('1' = explicit, '2' = clean, '0' = unspecified). On MP4 the value is stored in the native rtng atom and surfaced here. The typed tri-state lives on ExtendedTag.advisory; aliases CONTENTADVISORY and EXPLICIT resolve here",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis", "APE", "ASF"],
+        mappings: {
+          id3v2: { frame: "TXXX", description: "ITUNESADVISORY" },
+          vorbis: "ITUNESADVISORY",
+          mp4: "----:com.apple.iTunes:ITUNESADVISORY"
+        }
+      },
+      // ReplayGain Properties
+      replayGainTrackGain: {
+        key: "REPLAYGAIN_TRACK_GAIN",
+        description: "ReplayGain track gain in dB (e.g., '-6.54 dB')",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TXXX", description: "ReplayGain_Track_Gain" },
+          vorbis: "REPLAYGAIN_TRACK_GAIN",
+          mp4: "----:com.apple.iTunes:replaygain_track_gain"
+        }
+      },
+      replayGainTrackPeak: {
+        key: "REPLAYGAIN_TRACK_PEAK",
+        description: "ReplayGain track peak value (0.0-1.0)",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TXXX", description: "ReplayGain_Track_Peak" },
+          vorbis: "REPLAYGAIN_TRACK_PEAK",
+          mp4: "----:com.apple.iTunes:replaygain_track_peak"
+        }
+      },
+      replayGainAlbumGain: {
+        key: "REPLAYGAIN_ALBUM_GAIN",
+        description: "ReplayGain album gain in dB",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TXXX", description: "ReplayGain_Album_Gain" },
+          vorbis: "REPLAYGAIN_ALBUM_GAIN",
+          mp4: "----:com.apple.iTunes:replaygain_album_gain"
+        }
+      },
+      replayGainAlbumPeak: {
+        key: "REPLAYGAIN_ALBUM_PEAK",
+        description: "ReplayGain album peak value (0.0-1.0)",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TXXX", description: "ReplayGain_Album_Peak" },
+          vorbis: "REPLAYGAIN_ALBUM_PEAK",
+          mp4: "----:com.apple.iTunes:replaygain_album_peak"
+        }
+      },
+      r128TrackGain: {
+        key: "R128_TRACK_GAIN",
+        description: "EBU R128 track loudness gain (RFC 7845), raw wire value: signed Q7.8 integer (dB x 256, e.g. '-573' = -2.23828125 dB). readTags() converts to a decibel number (see ExtendedTag.r128TrackGain)",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis", "ASF"],
+        mappings: {
+          id3v2: { frame: "TXXX", description: "R128_TRACK_GAIN" },
+          vorbis: "R128_TRACK_GAIN",
+          mp4: "----:com.apple.iTunes:R128_TRACK_GAIN"
+        }
+      },
+      r128AlbumGain: {
+        key: "R128_ALBUM_GAIN",
+        description: "EBU R128 album loudness gain (RFC 7845), raw wire value: signed Q7.8 integer (dB x 256). readTags() converts to a decibel number",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis", "ASF"],
+        mappings: {
+          id3v2: { frame: "TXXX", description: "R128_ALBUM_GAIN" },
+          vorbis: "R128_ALBUM_GAIN",
+          mp4: "----:com.apple.iTunes:R128_ALBUM_GAIN"
+        }
+      },
+      // AcoustID Properties
+      acoustidFingerprint: {
+        key: "ACOUSTID_FINGERPRINT",
+        description: "AcoustID fingerprint (Chromaprint)",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TXXX", description: "Acoustid Fingerprint" },
+          vorbis: "ACOUSTID_FINGERPRINT",
+          mp4: "----:com.apple.iTunes:Acoustid Fingerprint"
+        }
+      },
+      acoustidId: {
+        key: "ACOUSTID_ID",
+        description: "AcoustID UUID",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TXXX", description: "Acoustid Id" },
+          vorbis: "ACOUSTID_ID",
+          mp4: "----:com.apple.iTunes:Acoustid Id"
+        }
+      },
+      // Apple Sound Check
+      appleSoundCheck: {
+        key: "ITUNNORM",
+        description: "Apple Sound Check normalization data",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TXXX", description: "iTunNORM" },
+          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"
+        }
+      }
+    };
+  }
+});
+
+// src/constants/properties.ts
+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;
+}
+function remapKeysFromTagLib(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const canonical = READ_ALIASES[key];
+    if (canonical !== void 0 && canonical in obj) continue;
+    result[fromTagLibKey(key)] = value;
+  }
+  return result;
+}
+var PROPERTIES, _toTagLib, _fromTagLib, READ_ALIASES, _mp4FreeformAtoms, _mp4AtomToWireKey;
+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,
+      ...ADDITIONAL_PROPERTIES
+    };
+    _toTagLib = {};
+    _fromTagLib = {};
+    for (const [camelKey, meta] of Object.entries(PROPERTIES)) {
+      const wireKey = meta.key;
+      _toTagLib[camelKey] = wireKey;
+      _fromTagLib[wireKey] = camelKey;
+    }
+    _toTagLib["year"] = "DATE";
+    _toTagLib["track"] = "TRACKNUMBER";
+    _fromTagLib["disc"] = "discNumber";
+    READ_ALIASES = {
+      "ALBUM ARTIST": "ALBUMARTIST",
+      ALBUM_ARTIST: "ALBUMARTIST",
+      ORGANIZATION: "LABEL",
+      PUBLISHER: "LABEL",
+      UPC: "BARCODE",
+      EAN: "BARCODE",
+      GTIN: "BARCODE",
+      TOTALTRACKS: "TRACKTOTAL",
+      TOTALDISCS: "DISCTOTAL",
+      MUSICBRAINZ_ALBUMTYPE: "RELEASETYPE",
+      "MusicBrainz Album Type": "RELEASETYPE",
+      CONTENTADVISORY: "ITUNESADVISORY",
+      EXPLICIT: "ITUNESADVISORY"
+    };
+    for (const [alias, canonical] of Object.entries(READ_ALIASES)) {
+      if (_fromTagLib[alias] === void 0) {
+        _fromTagLib[alias] = _fromTagLib[canonical];
+      }
+    }
+    _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");
+  }
+});
+
+// src/taglib/auto-dispose.ts
+function registerAutoDispose(target, handle) {
+  registry.register(target, handle, target);
+}
+function unregisterAutoDispose(target) {
+  registry.unregister(target);
+}
+var registry;
+var init_auto_dispose = __esm({
+  "src/taglib/auto-dispose.ts"() {
+    "use strict";
+    registry = new FinalizationRegistry((handle) => {
+      handle.destroy();
+    });
+  }
+});
+
+// src/taglib/audio-file-base.ts
+var LYRICS_PROPERTY_KEY, LYRICS_WIRE_KEY, EMPTY_KEY_SET, BaseAudioFileImpl;
+var init_audio_file_base = __esm({
+  "src/taglib/audio-file-base.ts"() {
+    "use strict";
+    init_properties();
+    init_errors2();
+    init_mp4_item_names();
+    init_mutable_tag_impl();
+    init_auto_dispose();
+    LYRICS_PROPERTY_KEY = "lyrics";
+    LYRICS_WIRE_KEY = toTagLibKey(LYRICS_PROPERTY_KEY);
+    EMPTY_KEY_SET = /* @__PURE__ */ new Set();
+    BaseAudioFileImpl = class {
+      constructor(module, fileHandle, sourcePath, originalSource, isPartiallyLoaded = false, partialLoadOptions) {
+        __publicField(this, "module", module);
+        __publicField(this, "fileHandle");
+        __publicField(this, "cachedAudioProperties", null);
+        __publicField(this, "sourcePath");
+        __publicField(this, "originalSource");
+        __publicField(this, "isPartiallyLoaded", false);
+        __publicField(this, "partialLoadOptions");
+        /** Text-property wire keys in the partial header at load; undefined if full. */
+        __publicField(this, "partialKeysAtLoad");
+        this.fileHandle = fileHandle;
+        this.sourcePath = sourcePath;
+        this.originalSource = originalSource;
+        this.isPartiallyLoaded = isPartiallyLoaded;
+        this.partialLoadOptions = partialLoadOptions;
+        this.partialKeysAtLoad = isPartiallyLoaded ? new Set(Object.keys(fileHandle.getProperties())) : void 0;
+        registerAutoDispose(this, fileHandle);
+      }
+      /**
+       * Wire-key text properties present in the partial header at load but now
+       * absent — the user deleted them. The partial-load reconstruct subtracts these
+       * from its preserve-the-original merge so a deletion persists without wiping
+       * frames beyond the loaded header (taglib-d14). Lyrics are excluded (they ride
+       * their own reconstruct path); empty for a full load.
+       */
+      partialDeletedPropertyKeys() {
+        if (!this.partialKeysAtLoad) return EMPTY_KEY_SET;
+        const current = new Set(Object.keys(this.handle.getProperties()));
+        const deleted = /* @__PURE__ */ new Set();
+        for (const key of this.partialKeysAtLoad) {
+          if (key !== LYRICS_WIRE_KEY && !current.has(key)) deleted.add(key);
+        }
+        return deleted;
+      }
+      get handle() {
+        if (!this.fileHandle) {
+          throw new MetadataError("read", "File handle has been disposed");
+        }
+        return this.fileHandle;
+      }
+      getFormat() {
+        return this.handle.getFormat();
+      }
+      isFormat(format) {
+        return this.getFormat() === format;
+      }
+      tag() {
+        return buildMutableTag(this.handle);
+      }
+      audioProperties() {
+        if (!this.cachedAudioProperties) {
+          this.cachedAudioProperties = this.handle.getAudioProperties() ?? null;
+        }
+        return this.cachedAudioProperties ?? void 0;
+      }
+      properties() {
+        const remapped = remapKeysFromTagLib(this.handle.getProperties());
+        delete remapped[LYRICS_PROPERTY_KEY];
+        return remapped;
+      }
+      setProperties(properties) {
+        const translated = {};
+        for (const [key, values] of Object.entries(properties)) {
+          if (values !== void 0) {
+            translated[toTagLibKey(fromTagLibKey(key))] = values;
+          }
+        }
+        if (!(LYRICS_WIRE_KEY in translated)) {
+          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 wireKey = toTagLibKey(fromTagLibKey(key));
+        const values = this.handle.getProperties()[wireKey]?.filter(
+          (v) => v !== ""
+        );
+        if (values !== void 0 && values.length > 0) return values;
+        if (!this.isMP4()) return void 0;
+        const remapped = this.properties()[key]?.filter((v) => v !== "");
+        return remapped !== void 0 && remapped.length > 0 ? remapped : void 0;
+      }
+      setProperty(key, value) {
+        const wireKey = toTagLibKey(fromTagLibKey(key));
+        const atomNames = mp4FreeformAtomNames([wireKey]);
+        if (atomNames.length > 0 && this.isMP4()) {
+          if (value === "") {
+            const prior = this.handle.getMp4ItemRemovals?.() ?? [];
+            this.handle.setMp4ItemRemovals?.([
+              .../* @__PURE__ */ new Set([...prior, ...atomNames])
+            ]);
+            if (this.module.isWasi) {
+              this.handle.setProperties({
+                ...this.handle.getProperties(),
+                [wireKey]: []
+              });
+            } else {
+              const rest = { ...this.handle.getProperties() };
+              delete rest[wireKey];
+              this.handle.setProperties(rest);
+            }
+            return;
+          }
+          this.handle.setProperties({
+            ...this.handle.getProperties(),
+            [wireKey]: [value],
+            [MP4_ITEM_NAMES_KEY]: atomNames
+          });
+          return;
+        }
+        this.handle.setProperty(wireKey, value);
+      }
+      /**
+       * The empty-string clearing contract, named (taglib-qyw2): both backends
+       * remove the property when the written value is empty, and setProperty's
+       * wire-key normalization + MP4 freeform atom-name handling apply unchanged.
+       */
+      removeProperty(key) {
+        this.setProperty(key, "");
+      }
+      isMP4() {
+        return this.handle.isMP4();
+      }
+      getMP4Item(key) {
+        if (!this.isMP4()) {
+          throw new UnsupportedFormatError(this.getFormat(), ["MP4", "M4A"]);
+        }
+        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) {
+        if (!this.isMP4()) {
+          throw new UnsupportedFormatError(this.getFormat(), ["MP4", "M4A"]);
+        }
+        this.handle.removeMP4Item(key);
+      }
+      isValid() {
+        return this.handle.isValid();
+      }
+      dispose() {
+        unregisterAutoDispose(this);
+        if (this.fileHandle) {
+          this.fileHandle.destroy();
+          this.fileHandle = null;
+          this.cachedAudioProperties = null;
+        }
+      }
+      [Symbol.dispose]() {
+        this.dispose();
+      }
+    };
+  }
+});
+
+// src/taglib/metadata-extent.ts
+function be32(b, offset) {
+  return (b[offset] << 24 | b[offset + 1] << 16 | b[offset + 2] << 8 | b[offset + 3]) >>> 0;
+}
+function startsWith(bytes, magic, at = 0) {
+  if (bytes.length < at + magic.length) return false;
+  for (let i = 0; i < magic.length; i++) {
+    if (bytes[at + i] !== magic.charCodeAt(i)) return false;
+  }
+  return true;
+}
+function id3v2End(bytes) {
+  if (!startsWith(bytes, "ID3") || bytes.length < 10) return void 0;
+  const size = bytes[6] << 21 | bytes[7] << 14 | bytes[8] << 7 | bytes[9];
+  const hasFooter = (bytes[5] & 16) !== 0;
+  return 10 + size + (hasFooter ? 10 : 0);
+}
+function flacEnd(bytes, limit, start) {
+  let offset = start + 4;
+  for (; ; ) {
+    if (offset + 4 > bytes.length) return void 0;
+    const isLast = (bytes[offset] & 128) !== 0;
+    const length = bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3];
+    offset += 4 + length;
+    if (offset > limit) return offset;
+    if (isLast) return offset;
+  }
+}
+function flacMarkerOffset(bytes) {
+  const at = startsWith(bytes, "ID3") ? id3v2End(bytes) : 0;
+  if (at === void 0) return void 0;
+  return startsWith(bytes, "fLaC", at) ? at : void 0;
+}
+function flacAudioStart(bytes) {
+  const at = flacMarkerOffset(bytes);
+  if (at === void 0) return void 0;
+  return flacEnd(bytes, bytes.length, at);
+}
+function mp4MoovEnd(bytes, limit, start) {
+  let offset = start;
+  const readable = Math.min(bytes.length, limit);
+  while (offset + 8 <= readable) {
+    const size = be32(bytes, offset);
+    const type = String.fromCharCode(
+      bytes[offset + 4],
+      bytes[offset + 5],
+      bytes[offset + 6],
+      bytes[offset + 7]
+    );
+    if (size < 8) return void 0;
+    if (type === "moov") return offset + size;
+    offset += size;
+  }
+  return void 0;
+}
+function oggMetadataEnd(bytes, limit, start) {
+  let offset = start;
+  let packetsCompleted = 0;
+  let first = true;
+  for (; ; ) {
+    if (offset + 27 > bytes.length || !startsWith(bytes, "OggS", offset)) {
+      return void 0;
+    }
+    const segmentCount = bytes[offset + 26];
+    const tableStart = offset + 27;
+    if (tableStart + segmentCount > bytes.length) return void 0;
+    let payload = 0;
+    for (let i = 0; i < segmentCount; i++) {
+      const segment = bytes[tableStart + i];
+      payload += segment;
+      if (segment < 255) packetsCompleted++;
+    }
+    if (first) {
+      const payloadStart = tableStart + segmentCount;
+      if (payloadStart + 5 > bytes.length) return void 0;
+      if (bytes[payloadStart] === 127 && startsWith(bytes, "FLAC", payloadStart + 1)) {
+        return void 0;
+      }
+      first = false;
+    }
+    offset = tableStart + segmentCount + payload;
+    if (packetsCompleted >= 2 || offset > limit) return offset;
+  }
+}
+function mpegFrameLength(bytes, at) {
+  if (bytes.length < at + 4) return 0;
+  if (bytes[at] !== 255 || (bytes[at + 1] & 224) !== 224) return 0;
+  const version = bytes[at + 1] >> 3 & 3;
+  const layer = bytes[at + 1] >> 1 & 3;
+  if (version === 1 || layer === 0) return 0;
+  const bitrateIndex = bytes[at + 2] >> 4 & 15;
+  const sampleRateIndex = bytes[at + 2] >> 2 & 3;
+  if (bitrateIndex === 0 || bitrateIndex === 15 || sampleRateIndex === 3) {
+    return 0;
+  }
+  const mpeg1 = version === 3;
+  const layerIndex = layer ^ 3;
+  const bitrate = MPEG_BITRATES[mpeg1 ? 0 : 1][layerIndex][bitrateIndex];
+  const sampleRateTable = mpeg1 ? 0 : version === 2 ? 1 : 2;
+  const sampleRate = MPEG_SAMPLE_RATES[sampleRateTable][sampleRateIndex];
+  const samplesPerFrame = layerIndex === 2 ? mpeg1 ? 1152 : 576 : layerIndex === 1 ? 1152 : 384;
+  let frameLength = Math.floor(samplesPerFrame * bitrate * 125 / sampleRate);
+  if ((bytes[at + 2] & 2) !== 0) frameLength += layerIndex === 0 ? 4 : 1;
+  return frameLength === 0 ? 0 : frameLength;
+}
+function isMpegFrameSync(bytes, at = 0) {
+  const frameLength = mpegFrameLength(bytes, at);
+  if (frameLength === 0) return false;
+  const next = at + frameLength;
+  if (bytes.length < next + 4) return false;
+  const mask = 4294839296;
+  const header = ((bytes[at] << 24 | bytes[at + 1] << 16 | bytes[at + 2] << 8 | bytes[at + 3]) >>> 0 & mask) >>> 0;
+  const nextHeader = ((bytes[next] << 24 | bytes[next + 1] << 16 | bytes[next + 2] << 8 | bytes[next + 3]) >>> 0 & mask) >>> 0;
+  return header === nextHeader;
+}
+function containerEnd(bytes, at, limit) {
+  if (at >= bytes.length) return bytes.length < limit ? null : void 0;
+  if (at + 8 > bytes.length) return void 0;
+  if (startsWith(bytes, "fLaC", at)) return flacEnd(bytes, limit, at);
+  if (startsWith(bytes, "ftyp", at + 4)) return mp4MoovEnd(bytes, limit, at);
+  if (startsWith(bytes, "OggS", at)) return oggMetadataEnd(bytes, limit, at);
+  return null;
+}
+function metadataFitsInHeader(header, limit) {
+  let end;
+  if (startsWith(header, "ID3")) {
+    const tagEnd = id3v2End(header);
+    if (tagEnd === void 0) return false;
+    end = tagEnd;
+    if (tagEnd <= limit) {
+      const behind = containerEnd(header, tagEnd, limit);
+      if (behind === void 0) return false;
+      if (behind !== null) end = behind;
+    }
+  } else {
+    const container = containerEnd(header, 0, limit);
+    if (container === null) {
+      end = isMpegFrameSync(header) ? 0 : void 0;
+    } else {
+      end = container;
+    }
+  }
+  if (end === void 0 || end > header.length) return false;
+  return end <= limit;
+}
+function trailerFitsInFooter(tail, footerSize) {
+  if (tail.length < Math.min(footerSize, 32)) return false;
+  for (const offsetFromEnd of [32, 32 + 128]) {
+    const at = tail.length - offsetFromEnd;
+    if (at < 0 || !startsWith(tail, "APETAGEX", at)) continue;
+    const size = (tail[at + 12] | tail[at + 13] << 8 | tail[at + 14] << 16 | tail[at + 15] << 24) >>> 0;
+    const trailing = offsetFromEnd === 32 ? 0 : 128;
+    if (size + 32 + trailing > footerSize) return false;
+  }
+  return true;
+}
+var MPEG_BITRATES, MPEG_SAMPLE_RATES;
+var init_metadata_extent = __esm({
+  "src/taglib/metadata-extent.ts"() {
+    "use strict";
+    MPEG_BITRATES = [
+      [
+        [0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0],
+        // Layer I
+        [0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0],
+        // Layer II
+        [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0]
+        // Layer III
+      ],
+      [
+        [0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0],
+        // Layer I
+        [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0],
+        // Layer II
+        [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0]
+        // Layer III
+      ]
+    ];
+    MPEG_SAMPLE_RATES = [
+      [44100, 48e3, 32e3],
+      // MPEG-1
+      [22050, 24e3, 16e3],
+      // MPEG-2
+      [11025, 12e3, 8e3]
+      // MPEG-2.5
+    ];
+  }
+});
+
+// src/taglib/media-ranges.ts
+function adtsFrameLength(bytes, at) {
+  if (bytes.length < at + 7) return 0;
+  if (bytes[at] !== 255 || (bytes[at + 1] & 246) !== 240) return 0;
+  const length = (bytes[at + 3] & 3) << 11 | bytes[at + 4] << 3 | bytes[at + 5] >> 5;
+  return length >= 7 ? length : 0;
+}
+function trailingTagStart(bytes, end = bytes.length) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let at = Math.max(0, Math.min(end, bytes.length));
+  for (; ; ) {
+    if (at >= 128 && text(bytes, at - 128, 3) === "TAG") {
+      at -= 128;
+      continue;
+    }
+    if (at >= 32 && text(bytes, at - 32, 8) === "APETAGEX") {
+      const size = view.getUint32(at - 32 + 12, true);
+      const flags = view.getUint32(at - 32 + 20, true);
+      const start = at - size - ((flags & 2147483648) !== 0 ? 32 : 0);
+      if (start < 0 || start >= at) return at;
+      at = start;
+      continue;
+    }
+    return at;
+  }
+}
+function firstFrame(bytes) {
+  const from = id3v2End(bytes) ?? 0;
+  const limit = Math.min(bytes.length - 6, from + MPEG_SCAN_LIMIT);
+  for (let o = from; o < limit; o++) {
+    const len = frameLengthAt(bytes, o);
+    if (len > 0 && frameLengthAt(bytes, o + len) > 0) return o;
+  }
+  return -1;
+}
+function forwardLastFrame(bytes, from, end) {
+  let o = from;
+  let start = -1;
+  let length = 0;
+  let frames = 0;
+  while (o + 6 <= end) {
+    const len = frameLengthAt(bytes, o);
+    if (len === 0 || o + len > end) break;
+    start = o;
+    length = len;
+    frames++;
+    o += len;
+  }
+  return { start, length, frames };
+}
+function walkMpeg(bytes) {
+  const from = firstFrame(bytes);
+  if (from < 0) return fallback("no valid first frame");
+  const end = trailingTagStart(bytes);
+  const last = forwardLastFrame(bytes, from, end);
+  if (last.start < 0) return fallback("no valid frames");
+  return {
+    kind: "ranges",
+    ranges: [{ offset: from, length: last.start + last.length - from }],
+    detail: `first=${from} last=${last.start}+${last.length} frames=${last.frames}`
+  };
+}
+function flacStreamInfoMd5(bytes) {
+  const marker = flacMarkerOffset(bytes);
+  if (marker === void 0) return void 0;
+  const header = marker + 4;
+  if (header + 4 > bytes.length) return void 0;
+  if ((bytes[header] & 127) !== 0) return void 0;
+  const blockLength = bytes[header + 1] << 16 | bytes[header + 2] << 8 | bytes[header + 3];
+  if (blockLength < 34) return void 0;
+  const payload = header + 4;
+  if (payload + 34 > bytes.length) return void 0;
+  let hex = "";
+  for (const byte of bytes.subarray(payload + 18, payload + 34)) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function walkFlac(bytes) {
+  const start = flacAudioStart(bytes);
+  if (start === void 0) return fallback("no fLaC marker");
+  const end = trailingTagStart(bytes);
+  if (end <= start) return fallback("no audio bytes");
+  return {
+    kind: "ranges",
+    ranges: [{ offset: start, length: end - start }],
+    detail: `audioStart=${start} end=${end}`
+  };
+}
+function atomLength(bytes, view, o) {
+  const size = view.getUint32(o, false);
+  if (size === 0) return { length: bytes.length - o, headerSize: 8 };
+  if (size === 1) {
+    if (o + 16 > bytes.length) return void 0;
+    const big = view.getBigUint64(o + 8, false);
+    if (big > BigInt(Number.MAX_SAFE_INTEGER)) return void 0;
+    return { length: Number(big), headerSize: 16 };
+  }
+  return { length: size, headerSize: 8 };
+}
+function walkMp4(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const ranges = [];
+  let o = 0;
+  while (o + 8 <= bytes.length) {
+    const type = text(bytes, o + 4, 4);
+    const atom = atomLength(bytes, view, o);
+    if (atom === void 0) return fallback(`malformed ${type} size`);
+    if (atom.length < atom.headerSize) {
+      return fallback(`malformed ${type} size`);
+    }
+    if (o + atom.length > bytes.length) return fallback(`oversized ${type}`);
+    if (type === "mdat" && atom.length > atom.headerSize) {
+      ranges.push({
+        offset: o + atom.headerSize,
+        length: atom.length - atom.headerSize
+      });
+    }
+    o += atom.length;
+  }
+  if (o !== bytes.length) return fallback("trailing bytes after the last atom");
+  if (ranges.length === 0) return fallback("no non-empty mdat");
+  return { kind: "ranges", ranges, detail: `${ranges.length} mdat(s)` };
+}
+function walkWav(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (text(bytes, 0, 4) !== "RIFF") return fallback("not RIFF");
+  if (text(bytes, 8, 4) !== "WAVE") return fallback("not WAVE");
+  const ranges = [];
+  let o = 12;
+  while (o + 8 <= bytes.length) {
+    const id = text(bytes, o, 4);
+    const size = view.getUint32(o + 4, true);
+    const dataStart = o + 8;
+    if (dataStart + size > bytes.length) return fallback(`truncated ${id}`);
+    if (id === "data" && size > 0) {
+      ranges.push({ offset: dataStart, length: size });
+    }
+    o = dataStart + size + size % 2;
+  }
+  if (ranges.length === 0) return fallback("no data chunk");
+  return { kind: "ranges", ranges, detail: `${ranges.length} data chunk(s)` };
+}
+function mediaRanges(format, bytes) {
+  const walked = (() => {
+    switch (format.toUpperCase()) {
+      case "MP3":
+      case "AAC":
+        return walkMpeg(bytes);
+      case "FLAC":
+        return walkFlac(bytes);
+      case "MP4":
+      case "M4A":
+        return walkMp4(bytes);
+      case "WAV":
+        return walkWav(bytes);
+      default:
+        return { kind: "fallback", ranges: [], detail: "format not covered" };
+    }
+  })();
+  if (walked.kind === "fallback") {
+    return {
+      kind: "fallback",
+      ranges: [{ offset: 0, length: bytes.length }],
+      detail: `${walked.detail} \u2192 whole file`
+    };
+  }
+  return walked;
+}
+var decoder, text, fallback, frameLengthAt, MPEG_SCAN_LIMIT;
+var init_media_ranges = __esm({
+  "src/taglib/media-ranges.ts"() {
+    "use strict";
+    init_metadata_extent();
+    decoder = new TextDecoder();
+    text = (b, o, n) => decoder.decode(b.subarray(o, o + n));
+    fallback = (detail) => ({
+      kind: "fallback",
+      ranges: [],
+      detail
+    });
+    frameLengthAt = (bytes, at) => mpegFrameLength(bytes, at) || adtsFrameLength(bytes, at);
+    MPEG_SCAN_LIMIT = 65536;
+  }
+});
+
+// src/taglib/audio-file-checksum.ts
+async function fileBytes(source, io) {
+  if (source.path) return await io.readFile(source.path);
+  if (source.blob) return new Uint8Array(await source.blob.arrayBuffer());
+  if (!source.partiallyLoaded && source.bytes.length > 0) return source.bytes;
+  throw new MetadataError(
+    "read",
+    "the handle holds no file bytes and has no readable source; a partial handle that has been saved drops its source \u2014 checksum the saved path instead"
+  );
+}
+function joinRanges(bytes, ranges) {
+  const total = ranges.reduce((n, r) => n + r.length, 0);
+  const overrun = ranges.find((r) => r.offset + r.length > bytes.length);
+  if (overrun || total > bytes.length) {
+    throw new MetadataError(
+      "read",
+      `range walk overran the buffer (${overrun ? `range ${overrun.offset}+${overrun.length}` : `${total} bytes`} past the ${bytes.length}-byte buffer)`
+    );
+  }
+  if (ranges.length === 1) {
+    const only = ranges[0];
+    const view = bytes.subarray(only.offset, only.offset + only.length);
+    return view.buffer instanceof ArrayBuffer ? view : new Uint8Array(view);
+  }
+  const out = new Uint8Array(total);
+  let at = 0;
+  for (const r of ranges) {
+    out.set(bytes.subarray(r.offset, r.offset + r.length), at);
+    at += r.length;
+  }
+  return out;
+}
+async function mediaChecksum(source, format, io, options = {}) {
+  if (options.basis === "pcm") {
+    if (format.toUpperCase() !== "FLAC") {
+      throw new UnsupportedFormatError(format, ["FLAC"], {
+        operation: "media checksum (basis: pcm)"
+      });
+    }
+    const windowed = source.bytes.length > 0 ? source.bytes : source.path && io.readPartial ? await io.readPartial(source.path, STREAMINFO_WINDOW, 0) : void 0;
+    let md5 = windowed === void 0 ? void 0 : flacStreamInfoMd5(windowed);
+    if (md5 === void 0 && windowed !== source.bytes) {
+      md5 = flacStreamInfoMd5(await fileBytes(source, io));
+    }
+    if (md5 === void 0) {
+      throw new MetadataError(
+        "read",
+        "STREAMINFO digest unavailable"
+      );
+    }
+    return {
+      source: "flac-streaminfo-md5",
+      algorithm: "md5",
+      hex: md5,
+      bytesHashed: 16
+    };
+  }
+  const bytes = await fileBytes(source, io);
+  const walk = mediaRanges(format, bytes);
+  const payload = joinRanges(bytes, walk.ranges);
+  const digest = new Uint8Array(
+    await crypto.subtle.digest("SHA-256", payload)
+  );
+  let hex = "";
+  for (const byte of digest) hex += byte.toString(16).padStart(2, "0");
+  return {
+    source: walk.kind === "ranges" ? "audio-payload" : "file",
+    algorithm: "sha256",
+    hex,
+    bytesHashed: payload.length
+  };
+}
+var STREAMINFO_WINDOW;
+var init_audio_file_checksum = __esm({
+  "src/taglib/audio-file-checksum.ts"() {
+    "use strict";
+    init_media_ranges();
+    init_errors2();
+    STREAMINFO_WINDOW = 65536;
+  }
+});
+
+// src/utils/file.ts
+async function readFileData(file) {
+  if (file instanceof Uint8Array) return file;
+  if (file instanceof ArrayBuffer) return new Uint8Array(file);
+  if (typeof File !== "undefined" && file instanceof File) {
+    return new Uint8Array(await file.arrayBuffer());
+  }
+  if (typeof file === "string") {
+    try {
+      return await getPlatformIO().readFile(file);
+    } catch (error) {
+      if (error instanceof EnvironmentError) throw error;
+      throw new FileOperationError("read", error.message, file);
+    }
+  }
+  const inputType = Object.prototype.toString.call(file);
+  throw new FileOperationError(
+    "read",
+    `Invalid file input type: ${inputType}. Expected string path, Uint8Array, ArrayBuffer, or File object.`
+  );
+}
+async function getFileSize(path) {
+  try {
+    const s = await getPlatformIO().stat(path);
+    return s.size;
+  } catch (error) {
+    if (error instanceof EnvironmentError) throw error;
+    throw new FileOperationError("stat", error.message, path);
+  }
+}
+async function readPartialFileData(path, headerSize, footerSize) {
+  const io = getPlatformIO();
+  if (!io.readPartial) {
+    throw new EnvironmentError(
+      "current runtime",
+      "does not support partial file reading",
+      "filesystem access with seek support"
+    );
+  }
+  try {
+    return await io.readPartial(path, headerSize, footerSize);
+  } catch (error) {
+    if (error instanceof EnvironmentError) throw error;
+    throw new FileOperationError("read", error.message, path);
+  }
+}
+var init_file = __esm({
+  "src/utils/file.ts"() {
+    "use strict";
+    init_errors2();
+    init_platform_io_browser_stub();
+  }
+});
+
+// src/taglib/embind-adapter.ts
+function isValidBitrateMode(value) {
+  return value === "CBR" || value === "VBR" || value === "ABR";
+}
+function wrapEmbindHandle(raw) {
+  const stagedId3v2Frames = {};
+  let destroyed = false;
+  const overrides = {
+    getTagData() {
+      const tw = raw.getTag();
+      return {
+        title: tw.title(),
+        artist: tw.artist(),
+        album: tw.album(),
+        comment: tw.comment(),
+        genre: tw.genre(),
+        year: tw.year(),
+        track: tw.track()
+      };
+    },
+    setTagData(data) {
+      const tw = raw.getTag();
+      if (data.title !== void 0) tw.setTitle(data.title);
+      if (data.artist !== void 0) tw.setArtist(data.artist);
+      if (data.album !== void 0) tw.setAlbum(data.album);
+      if (data.comment !== void 0) tw.setComment(data.comment);
+      if (data.genre !== void 0) tw.setGenre(data.genre);
+      if (data.year !== void 0) tw.setYear(data.year);
+      if (data.track !== void 0) tw.setTrack(data.track);
+    },
+    getBextData() {
+      const v = raw.getBextData();
+      if (v === void 0 || v === null) return void 0;
+      const u8 = v instanceof Uint8Array ? v : new Uint8Array(v);
+      return u8.length > 0 ? u8 : void 0;
+    },
+    setBextData(data) {
+      raw.setBextData(data ?? null);
+    },
+    getIxml() {
+      const v = raw.getIxml();
+      return typeof v === "string" && v.length > 0 ? v : void 0;
+    },
+    setIxml(data) {
+      raw.setIxml(
+        data ?? null
+      );
+    },
+    // Emscripten exposes USLT only through the PropertyMap "LYRICS" key (no
+    // dedicated Embind binding), so bridge get/setLyrics to get/setProperties.
+    // Text only — language/description are not surfaced by the PropertyMap.
+    getLyrics() {
+      const props = raw.getProperties();
+      return (props["LYRICS"] ?? []).map((text2) => ({
+        text: text2,
+        description: "",
+        language: ""
+      }));
+    },
+    setLyrics(lyrics) {
+      const handle = raw;
+      const props = handle.getProperties();
+      if (lyrics.length > 0) props["LYRICS"] = lyrics.map((l) => l.text);
+      else delete props["LYRICS"];
+      handle.setProperties(props);
+    },
+    setId3v2Frames(id, data) {
+      stagedId3v2Frames[id] = data.map((d) => new Uint8Array(d));
+      raw.setId3v2Frames(id, data);
+    },
+    removeId3v2Frames(id) {
+      stagedId3v2Frames[id] = [];
+      raw.removeId3v2Frames(id);
+    },
+    getStagedId3v2Frames() {
+      return Object.keys(stagedId3v2Frames).length > 0 ? { ...stagedId3v2Frames } : void 0;
+    },
+    hasId3Tags() {
+      const v = raw.hasId3Tags();
+      if (!v || typeof v !== "object") return { v1: false, v2: false };
+      const o = v;
+      return { v1: o.v1 === true, v2: o.v2 === true };
+    },
+    stripId3Tags(opts) {
+      raw.stripId3Tags(opts);
+    },
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      raw.destroy();
+    },
+    get destroyed() {
+      return destroyed;
+    },
+    // taglib-qyw2: the PropertyMap erase pass computes freeform item names
+    // from the property table (upper-cased) and misses the restored exact-case
+    // atom (taglib-bnhl), so clears queue the exact name here; the imperative
+    // Embind model applies removeItem immediately, before setProperties.
+    setMp4ItemRemovals(removals) {
+      const handle = raw;
+      for (const name of removals) handle.removeMP4Item(name);
+    },
+    getAudioProperties() {
+      const pw = raw.getAudioProperties();
+      if (!pw) return null;
+      const containerFormat = pw.containerFormat() || "unknown";
+      const codec = pw.codec() || "unknown";
+      const mpegVersion = pw.mpegVersion();
+      const formatVersion = pw.formatVersion();
+      const bitrateMode = pw.bitrateMode();
+      return {
+        duration: pw.lengthInSeconds(),
+        durationMs: pw.lengthInMilliseconds(),
+        bitrate: pw.bitrate(),
+        sampleRate: pw.sampleRate(),
+        channels: pw.channels(),
+        bitsPerSample: pw.bitsPerSample(),
+        codec,
+        containerFormat,
+        isLossless: pw.isLossless(),
+        ...mpegVersion > 0 ? { mpegVersion, mpegLayer: pw.mpegLayer() } : {},
+        ...containerFormat === "MP4" || containerFormat === "ASF" ? { isEncrypted: pw.isEncrypted() } : {},
+        ...formatVersion > 0 ? { formatVersion } : {},
+        ...isValidBitrateMode(bitrateMode) ? { bitrateMode } : {},
+        // OpusHead gain exists only in an Ogg Opus stream. Gating on codec
+        // alone fabricated outputGainDb: 0 for MP4 tracks once the MP4 codec
+        // enum was mapped (the WASI side never emitted it there) — taglib-kswf.
+        ...containerFormat === "OGG" && codec === "Opus" ? { outputGainDb: pw.outputGainDb() } : {}
+      };
+    }
+  };
+  return new Proxy(raw, {
+    get(target, prop, receiver) {
+      if (prop in overrides) return overrides[prop];
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+var init_embind_adapter = __esm({
+  "src/taglib/embind-adapter.ts"() {
+    "use strict";
+  }
+});
+
+// src/taglib/extra-state-registry.ts
+function chapterStyle(chapters) {
+  const s = chapters[0]?.source;
+  return s === "nero" || s === "both" ? s : "quicktime";
+}
+function copyExtraState(target, source, sourceComplete) {
+  for (const field of EXTRA_FIELDS) {
+    field.copy(target, source, sourceComplete);
+  }
+}
+var EXTRA_FIELDS;
+var init_extra_state_registry = __esm({
+  "src/taglib/extra-state-registry.ts"() {
+    "use strict";
+    EXTRA_FIELDS = [
+      {
+        name: "pictures",
+        copy(target, source, complete) {
+          const v = source.getPictures();
+          if (complete || v.length > 0) target.setPictures(v);
+        }
+      },
+      {
+        name: "ratings",
+        copy(target, source, complete) {
+          const v = source.getRatings();
+          if (complete || v.length > 0) target.setRatings(v);
+        }
+      },
+      {
+        name: "lyrics",
+        copy(target, source, complete) {
+          const v = source.getLyrics();
+          if (complete || v.length > 0) target.setLyrics(v);
+        }
+      },
+      {
+        name: "chapters",
+        copy(target, source, complete) {
+          const v = source.getChapters();
+          if (complete || v.length > 0) target.setChapters(v, chapterStyle(v));
+        }
+      },
+      {
+        name: "bextData",
+        copy(target, source, complete) {
+          const v = source.getBextData();
+          if (v !== void 0) target.setBextData(v);
+          else if (complete) target.setBextData(null);
+        }
+      },
+      {
+        name: "ixml",
+        copy(target, source, complete) {
+          const v = source.getIxml();
+          if (v !== void 0) target.setIxml(v);
+          else if (complete) target.setIxml(null);
+        }
+      },
+      {
+        name: "_mp4ItemRemovals",
+        copy(target, source, complete) {
+          const v = source.getMp4ItemRemovals?.();
+          if (complete || v !== void 0 && v.length > 0) {
+            target.setMp4ItemRemovals?.(v ?? []);
+          }
+        }
+      },
+      {
+        name: "id3v2Frames",
+        copy(target, source) {
+          const staged = source.getStagedId3v2Frames?.();
+          if (!staged) return;
+          for (const [id, bodies] of Object.entries(staged)) {
+            target.setId3v2Frames(id, bodies);
+          }
+        }
+      }
+    ];
+  }
+});
+
+// src/taglib/save-reconstruct.ts
+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);
+}
+async function saveViaFreshHandle(module, editing, source, targetPath, sourceComplete, deletedKeys = /* @__PURE__ */ new Set()) {
+  const rawFullHandle = module.createFileHandle();
+  const fullFileHandle = module.isWasi ? rawFullHandle : wrapEmbindHandle(rawFullHandle);
+  try {
+    {
+      const data = await readFileData(source);
+      if (!fullFileHandle.loadFromBuffer(data)) {
+        throw new InvalidFormatError(
+          "Failed to load full audio file for saving"
+        );
+      }
+    }
+    copyEditedState(fullFileHandle, editing, sourceComplete, deletedKeys);
+    if (!fullFileHandle.save()) {
+      throw new FileOperationError(
+        "save",
+        "Failed to save changes to full file"
+      );
+    }
+    await writeFileData(targetPath, fullFileHandle.getBuffer());
+  } finally {
+    fullFileHandle.destroy();
+  }
+}
+var init_save_reconstruct = __esm({
+  "src/taglib/save-reconstruct.ts"() {
+    "use strict";
+    init_errors2();
+    init_file();
+    init_write();
+    init_embind_adapter();
+    init_extra_state_registry();
+    init_properties();
+    init_mp4_item_names();
+  }
+});
+
+// src/taglib/audio-file-impl.ts
+function sortChapters(list) {
+  return [...list].sort((a, b) => a.startTimeMs - b.startTimeMs);
+}
+function inferEndTimeMs(sorted, index, trackEndMs) {
+  const own = sorted[index].endTimeMs;
+  if (own !== void 0) return own;
+  const next = sorted[index + 1];
+  return next ? next.startTimeMs : trackEndMs;
+}
+function readFileSync(path) {
+  if (isDeno()) return Deno.readFileSync(path);
+  const fs = getNodeFsSync();
+  if (fs) return new Uint8Array(fs.readFileSync(path));
+  throw new FileOperationError(
+    "read",
+    "node:fs is unavailable in this runtime: cannot read file data from disk",
+    path
+  );
+}
+var AudioFileImpl;
+var init_audio_file_impl = __esm({
+  "src/taglib/audio-file-impl.ts"() {
+    "use strict";
+    init_types2();
+    init_audio_file_bwf();
+    init_id3v2_frames();
+    init_errors2();
+    init_write();
+    init_node_fs_browser_stub();
+    init_rating();
+    init_detector();
+    init_audio_file_base();
+    init_audio_file_checksum();
+    init_platform_io_browser_stub();
+    init_save_reconstruct();
+    AudioFileImpl = class extends BaseAudioFileImpl {
+      constructor(module, fileHandle, sourcePath, originalSource, isPartiallyLoaded = false, partialLoadOptions) {
+        super(
+          module,
+          fileHandle,
+          sourcePath,
+          originalSource,
+          isPartiallyLoaded,
+          partialLoadOptions
+        );
+        __publicField(this, "pathModeBuffer", null);
+        /** How the handle was loaded — `isPartiallyLoaded` is mutated by saveToFile(). */
+        __publicField(this, "partiallyLoadedAtConstruction");
+        this.partiallyLoadedAtConstruction = isPartiallyLoaded;
+      }
+      save() {
+        if (this.isPartiallyLoaded && this.originalSource) {
+          throw new FileOperationError(
+            "save",
+            "Cannot save partially loaded file directly. Use saveToFile() instead"
+          );
+        }
+        this.cachedAudioProperties = null;
+        this.pathModeBuffer = null;
+        return this.handle.save();
+      }
+      getFileBuffer() {
+        const buffer = this.handle.getBuffer();
+        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 (error) {
+            if (error instanceof FileOperationError) throw error;
+            throw new FileOperationError(
+              "read",
+              `Cannot return file data: ${errorMessage(error)}`,
+              this.sourcePath,
+              { cause: error }
+            );
+          }
+        }
+        throw new FileOperationError(
+          "read",
+          "No file data available: in-memory buffer is empty and no source path is set"
+        );
+      }
+      mediaChecksum(options) {
+        return mediaChecksum(
+          {
+            // The cheap, no-IO accessor — `getFileBuffer()` would read the whole
+            // file from disk in path mode (and cache it), which the source rule is
+            // about to read for itself.
+            bytes: this.handle.getBuffer(),
+            // empty in path mode: the data is on disk
+            // Both optional fields are conditional: they are `undefined` far more
+            // often than not, and `exactOptionalPropertyTypes` refuses an explicit
+            // `undefined` on an optional property.
+            ...this.sourcePath !== void 0 ? { path: this.sourcePath } : {},
+            // originalSource is the File when the caller passed one. A partial File
+            // has no path, so this is the only way back to the real bytes.
+            ...this.originalSource instanceof Blob ? { blob: this.originalSource } : {},
+            // Captured at construction, NOT this.isPartiallyLoaded: saveToFile() sets
+            // that flag false (and clears originalSource) while the handle still holds
+            // the spliced image, which would make the source rule hash the image.
+            partiallyLoaded: this.partiallyLoadedAtConstruction
+          },
+          this.getFormat(),
+          getPlatformIO(),
+          options
+        );
+      }
+      async saveToFile(path) {
+        const targetPath = path ?? this.sourcePath;
+        if (!targetPath) {
+          throw new FileOperationError(
+            "save",
+            "No file path available. Provide a path or open the file from a path"
+          );
+        }
+        if (this.isPartiallyLoaded && this.originalSource) {
+          await saveViaFreshHandle(
+            this.module,
+            this.handle,
+            this.originalSource,
+            targetPath,
+            false,
+            this.partialDeletedPropertyKeys()
+          );
+          this.isPartiallyLoaded = false;
+          this.originalSource = void 0;
+        } else if (this.module.isWasi && this.sourcePath && targetPath !== this.sourcePath) {
+          await saveViaFreshHandle(
+            this.module,
+            this.handle,
+            this.sourcePath,
+            targetPath,
+            true
+          );
+        } else {
+          if (!this.save()) {
+            throw new FileOperationError(
+              "save",
+              "Failed to save changes to in-memory buffer"
+            );
+          }
+          const buffer = this.handle.getBuffer();
+          if (buffer.length > 0) {
+            await writeFileData(targetPath, buffer);
+          }
+        }
+        this.pathModeBuffer = null;
+      }
+      getPictures() {
+        const picturesArray = this.handle.getPictures();
+        return picturesArray.map((pic) => ({
+          mimeType: pic.mimeType,
+          data: pic.data,
+          type: PICTURE_TYPE_NAMES[pic.type] ?? "Other",
+          ...pic.description !== void 0 ? { description: pic.description } : {}
+        }));
+      }
+      setPictures(pictures) {
+        this.handle.setPictures(pictures.map((pic) => ({
+          mimeType: pic.mimeType,
+          data: pic.data,
+          type: PICTURE_TYPE_VALUES[pic.type] ?? 0,
+          description: pic.description ?? ""
+        })));
+      }
+      addPicture(picture) {
+        this.handle.addPicture({
+          mimeType: picture.mimeType,
+          data: picture.data,
+          type: PICTURE_TYPE_VALUES[picture.type] ?? 0,
+          description: picture.description ?? ""
+        });
+      }
+      removePictures() {
+        this.handle.removePictures();
+      }
+      getChapters() {
+        const sorted = sortChapters(this.handle.getChapters());
+        const trackEndMs = this.audioProperties()?.durationMs;
+        return sorted.map((c, i) => {
+          const endTimeMs = inferEndTimeMs(sorted, i, trackEndMs);
+          return {
+            startTimeMs: c.startTimeMs,
+            ...endTimeMs !== void 0 ? { endTimeMs } : {},
+            // Truthiness, not !== undefined: an empty CHAP title/id must read back
+            // as ABSENT (the old `c.title || undefined` contract; the Embind
+            // reader emits "" unconditionally, WASI omits — coalescing keeps the
+            // backends agreeing).
+            ...c.title ? { title: c.title } : {},
+            ...c.id ? { id: c.id } : {},
+            ...c.source !== void 0 ? { source: c.source } : {}
+          };
+        });
+      }
+      setChapters(chapters, options) {
+        const fmt = this.getFormat();
+        if (fmt !== "MP3" && fmt !== "AAC" && fmt !== "MP4") {
+          throw new UnsupportedFormatError(fmt, ["MP3", "AAC", "MP4"], {
+            operation: "setChapters"
+          });
+        }
+        const sorted = sortChapters(chapters);
+        const trackEndMs = this.audioProperties()?.durationMs;
+        const style = options?.mp4ChapterStyle ?? "quicktime";
+        const source = fmt === "MP4" ? style : "id3";
+        const raw = sorted.map((c, i) => ({
+          ...c.id !== void 0 ? { id: c.id } : {},
+          startTimeMs: c.startTimeMs,
+          endTimeMs: inferEndTimeMs(sorted, i, trackEndMs) ?? c.startTimeMs,
+          ...c.title !== void 0 ? { title: c.title } : {},
+          source
+        }));
+        this.handle.setChapters(raw, style);
+      }
+      getBext() {
+        return getBext(this.handle);
+      }
+      setBext(bext) {
+        setBext(this.handle, this.getFormat(), bext);
+      }
+      getBextData() {
+        return getBextData(this.handle);
+      }
+      setBextData(data) {
+        setBextData(this.handle, this.getFormat(), data);
+      }
+      getIxml() {
+        return getIxml(this.handle);
+      }
+      setIxml(data) {
+        setIxml(this.handle, this.getFormat(), data);
+      }
+      getRatings() {
+        return this.handle.getRatings().map(
+          (r) => ({
+            rating: r.rating,
+            ...r.email !== void 0 && r.email !== "" ? { email: r.email } : {},
+            // 0 must read back as ABSENT (old `r.counter || undefined` contract).
+            ...r.counter !== 0 ? { counter: r.counter } : {}
+          })
+        );
+      }
+      setRatings(ratings) {
+        this.handle.setRatings(ratings.map((r) => ({
+          rating: r.rating,
+          email: r.email ?? "",
+          counter: r.counter ?? 0
+        })));
+      }
+      getLyrics() {
+        return this.handle.getLyrics().map((l) => {
+          const out = { text: l.text };
+          if (l.description) out.description = l.description;
+          if (l.language) out.language = l.language;
+          return out;
+        });
+      }
+      setLyrics(lyrics) {
+        this.handle.setLyrics(lyrics.map((l) => ({
+          text: l.text,
+          description: l.description ?? "",
+          language: l.language ?? ""
+        })));
+      }
+      getRating() {
+        const ratings = this.getRatings();
+        return ratings.length > 0 ? normalized(ratings[0].rating) : void 0;
+      }
+      setRating(rating, email) {
+        this.setRatings([{
+          rating,
+          ...email !== void 0 ? { email } : {},
+          counter: 0
+        }]);
+      }
+      getId3v2Frames(id) {
+        assertMp3(this.getFormat());
+        if (id !== void 0) assertFrameId(id, "read");
+        return this.handle.getId3v2Frames(id ?? "").map(toPublicFrame);
+      }
+      setId3v2Frames(id, data) {
+        assertMp3(this.getFormat());
+        assertFrameId(id, "write");
+        assertFrameBodies(id, data);
+        this.handle.setId3v2Frames(id, data);
+      }
+      removeId3v2Frames(id) {
+        assertMp3(this.getFormat());
+        assertFrameId(id, "write");
+        this.handle.removeId3v2Frames(id);
+      }
+      hasId3Tags() {
+        return this.handle.hasId3Tags();
+      }
+      stripId3Tags(opts) {
+        this.handle.stripId3Tags({
+          v1: opts?.v1 ?? true,
+          v2: opts?.v2 ?? true
+        });
+      }
+    };
+  }
+});
+
+// src/taglib/load-audio-data.ts
+async function loadAudioData(input, opts) {
+  if (opts.partial && typeof File !== "undefined" && input instanceof File) {
+    const headerSize = Math.min(opts.maxHeaderSize, input.size);
+    const footerSize = Math.min(opts.maxFooterSize, input.size);
+    if (input.size <= headerSize + footerSize) {
+      return { data: await readFileData(input), isPartiallyLoaded: false };
+    }
+    const header = new Uint8Array(
+      await input.slice(0, headerSize).arrayBuffer()
+    );
+    if (!metadataFitsInHeader(header, headerSize)) {
+      return { data: await readFileData(input), isPartiallyLoaded: false };
+    }
+    const footerStart = Math.max(0, input.size - footerSize);
+    const footer = new Uint8Array(await input.slice(footerStart).arrayBuffer());
+    if (!trailerFitsInFooter(footer, footerSize)) {
+      return { data: await readFileData(input), isPartiallyLoaded: false };
+    }
+    const combined = new Uint8Array(header.byteLength + footer.byteLength);
+    combined.set(header, 0);
+    combined.set(footer, header.byteLength);
+    return { data: combined, isPartiallyLoaded: true };
+  }
+  if (opts.partial && typeof input === "string") {
+    const fileSize = await getFileSize(input);
+    if (fileSize > opts.maxHeaderSize + opts.maxFooterSize) {
+      const data = await readPartialFileData(
+        input,
+        opts.maxHeaderSize,
+        opts.maxFooterSize
+      );
+      if (metadataFitsInHeader(data, opts.maxHeaderSize) && trailerFitsInFooter(data, opts.maxFooterSize)) {
+        return { data, isPartiallyLoaded: true };
+      }
+    }
+    return { data: await readFileData(input), isPartiallyLoaded: false };
+  }
+  return { data: await readFileData(input), isPartiallyLoaded: false };
+}
+var init_load_audio_data = __esm({
+  "src/taglib/load-audio-data.ts"() {
+    "use strict";
+    init_file();
+    init_metadata_extent();
+  }
+});
+
+// src/utils/tag-mapping.ts
+function mergeTagUpdatesInto(currentProps, tags) {
+  const newProps = normalizeTagInput(tags);
+  reconcilePairFields(currentProps, newProps, tags);
+  if (newProps.date !== void 0 || newProps.year !== void 0) {
+    currentProps.YEAR = [];
+  }
+  return { ...currentProps, ...newProps };
+}
+function mergeTagUpdates(file, tags) {
+  file.setProperties(mergeTagUpdatesInto(file.properties(), tags));
+}
+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 [
+    "title",
+    "artist",
+    "album",
+    "comment",
+    "genre"
+  ]) {
+    const val = input[field];
+    if (val === void 0) continue;
+    props[field] = Array.isArray(val) ? val : [val];
+  }
+  if (input.year !== void 0) {
+    props.date = [String(input.year)];
+  }
+  if (input.date !== void 0) {
+    props.date = Array.isArray(input.date) ? input.date : [input.date];
+  }
+  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 === "extraProperties") continue;
+    if (field === "compilation") {
+      props[field] = [val ? "1" : "0"];
+    } else if (field === "advisory") {
+      if (val === "explicit") props.itunesAdvisory = ["1"];
+      else if (val === "clean") props.itunesAdvisory = ["2"];
+      else if (val === "unspecified") props.itunesAdvisory = [];
+    } else if (field === "bpm") {
+      props[field] = [String(Math.trunc(val))];
+    } else if (NUMERIC_FIELDS.has(field)) {
+      props[field] = [String(val)];
+    } else if (field === "r128TrackGain" || field === "r128AlbumGain") {
+      props[field] = Array.isArray(val) ? val : [String(Math.round(val * 256))];
+    } else if (typeof val === "string") {
+      props[field] = [val];
+    } else if (Array.isArray(val)) {
+      props[field] = val;
+    }
+  }
+  for (const [rawField, totalField] of [
+    ["trackNumber", "totalTracks"],
+    ["discNumber", "totalDiscs"]
+  ]) {
+    if (props[rawField]?.[0]?.includes("/")) delete props[totalField];
+  }
+  return props;
+}
+var BASIC_FIELDS, NUMERIC_FIELDS;
+var init_tag_mapping = __esm({
+  "src/utils/tag-mapping.ts"() {
+    "use strict";
+    BASIC_FIELDS = /* @__PURE__ */ new Set([
+      "title",
+      "artist",
+      "album",
+      "comment",
+      "genre",
+      "year",
+      "date",
+      "track",
+      "trackNumber"
+    ]);
+    NUMERIC_FIELDS = /* @__PURE__ */ new Set([
+      "year",
+      "track",
+      "discNumber",
+      "totalTracks",
+      "totalDiscs",
+      "bpm"
+    ]);
+  }
+});
+
+// src/version.ts
+var VERSION;
+var init_version = __esm({
+  "src/version.ts"() {
+    "use strict";
+    VERSION = "2.3.0";
+  }
+});
+
+// src/runtime/module-loader-browser.ts
+var module_loader_browser_exports = {};
+__export(module_loader_browser_exports, {
+  loadTagLibModule: () => loadTagLibModule
+});
+async function loadTagLibModule(options) {
+  let createTagLibModule;
+  try {
+    const module2 = await import("./taglib-wrapper.js");
+    createTagLibModule = module2.default;
+  } catch {
+    try {
+      const module2 = await import("./taglib-wrapper.js");
+      createTagLibModule = module2.default;
+    } catch {
+      throw new TagLibInitializationError(
+        "Could not load taglib-wrapper.js. Ensure it is co-located with the browser bundle."
+      );
+    }
+  }
+  const moduleConfig = {};
+  if (options?.wasmBinary) {
+    moduleConfig.wasmBinary = options.wasmBinary;
+  }
+  if (options?.wasmUrl) {
+    moduleConfig.locateFile = (path) => {
+      if (path.endsWith(".wasm")) {
+        return options.wasmUrl;
+      }
+      return path;
+    };
+  } else if (!options?.wasmBinary) {
+    const wasmUrl = new URL("./taglib-web.wasm", import.meta.url);
+    moduleConfig.locateFile = (path) => path.endsWith(".wasm") ? wasmUrl.href : path;
+  }
+  const module = await createTagLibModule(moduleConfig);
+  return module;
+}
+var init_module_loader_browser = __esm({
+  "src/runtime/module-loader-browser.ts"() {
+    init_classes();
+  }
+});
+
+// src/taglib/taglib-class.ts
+function toWasiPath(osPath) {
+  if (osPath.startsWith("\\\\") || osPath.startsWith("//")) {
+    throw new FileOperationError(
+      "read",
+      `UNC paths are not supported. Path: ${osPath}`
+    );
+  }
+  let p = osPath;
+  if (!p.startsWith("/") && !/^[A-Za-z]:/.test(p)) {
+    const g2 = globalThis;
+    const cwd = isDeno() ? Deno.cwd() : g2.process?.cwd?.();
+    if (cwd) {
+      p = cwd.replace(/[/\\]+$/, "") + "/" + p;
+    }
+  }
+  p = p.replaceAll("\\", "/");
+  const driveMatch = p.match(/^([A-Za-z]):\//);
+  if (driveMatch) {
+    p = `/${driveMatch[1].toUpperCase()}${p.slice(2)}`;
+  }
+  p = p.replace(/\/\.\//g, "/").replace(/\/+/g, "/");
+  if (!p.startsWith("/")) p = "/" + p;
+  return p;
+}
+async function createTagLib(module) {
+  return new TagLib(module);
+}
+var TagLib;
+var init_taglib_class = __esm({
+  "src/taglib/taglib-class.ts"() {
+    "use strict";
+    init_audio_formats();
+    init_errors2();
+    init_detector();
+    init_audio_file_impl();
+    init_load_audio_data();
+    init_tag_mapping();
+    init_errors2();
+    init_version();
+    init_embind_adapter();
+    TagLib = class _TagLib {
+      constructor(module) {
+        __publicField(this, "module");
+        this.module = module;
+      }
+      /**
+       * Initialize the TagLib Wasm module and return a ready-to-use instance.
+       * @param options - Wasm loading configuration (binary, URL, backend selection).
+       * @returns A configured TagLib instance.
+       * @throws {TagLibInitializationError} If the Wasm module fails to load.
+       */
+      static async initialize(options) {
+        const { loadTagLibModule: loadTagLibModule2 } = await Promise.resolve().then(() => (init_module_loader_browser(), module_loader_browser_exports));
+        const module = await loadTagLibModule2(options);
+        return new _TagLib(module);
+      }
+      /**
+       * Open an audio file for reading and writing metadata.
+       * @param input - File path, Uint8Array, ArrayBuffer, File object, or NamedAudioInput.
+       * @param options - Partial-loading options for large files.
+       * @returns An AudioFile instance (use `using` for automatic cleanup).
+       * @throws {TagLibInitializationError} If the module is not properly initialized.
+       * @throws {InvalidFormatError} If the file is corrupted or unsupported.
+       */
+      async open(input, options) {
+        if (!this.module.createFileHandle) {
+          throw new TagLibInitializationError(
+            "TagLib module not properly initialized: createFileHandle not found. Make sure the module is fully loaded before calling open."
+          );
+        }
+        const actualInput = isNamedAudioInput(input) ? input.data : input;
+        const sourcePath = typeof actualInput === "string" ? actualInput : void 0;
+        if (typeof actualInput === "string" && this.module.isWasi) {
+          const wasiPath = toWasiPath(actualInput);
+          if (this.module.loadAudioPath) {
+            const fileHandle2 = await this.module.loadAudioPath(
+              wasiPath,
+              actualInput
+            );
+            return new AudioFileImpl(
+              this.module,
+              fileHandle2,
+              sourcePath,
+              actualInput,
+              false
+            );
+          }
+        }
+        const opts = {
+          partial: true,
+          maxHeaderSize: 1024 * 1024,
+          maxFooterSize: 128 * 1024,
+          ...options
+        };
+        const { data: audioData, isPartiallyLoaded } = await loadAudioData(
+          actualInput,
+          opts
+        );
+        const uint8Array = actualInput instanceof Uint8Array && audioData.buffer === actualInput.buffer ? new Uint8Array(
+          audioData.buffer.slice(
+            audioData.byteOffset,
+            audioData.byteOffset + audioData.byteLength
+          )
+        ) : audioData;
+        const rawHandle = this.module.createFileHandle();
+        const fileHandle = this.module.isWasi ? rawHandle : wrapEmbindHandle(rawHandle);
+        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",
+              uint8Array.byteLength
+            );
+          }
+          return new AudioFileImpl(
+            this.module,
+            fileHandle,
+            sourcePath,
+            actualInput,
+            isPartiallyLoaded,
+            opts
+          );
+        } catch (error) {
+          if (typeof fileHandle.destroy === "function") {
+            fileHandle.destroy();
+          }
+          throw error;
+        }
+      }
+      async edit(input, fn) {
+        const file = await this.open(input);
+        try {
+          await fn(file);
+          if (typeof input === "string") {
+            await file.saveToFile();
+          } else {
+            file.save();
+            return file.getFileBuffer();
+          }
+        } finally {
+          file.dispose();
+        }
+      }
+      /**
+       * Update tags in a file and save to disk in one operation.
+       * @param path - Path to the audio file.
+       * @param tags - Tag fields to update (partial update supported).
+       * @throws {InvalidFormatError} If the file is corrupted or unsupported.
+       * @throws {FileOperationError} If saving to disk fails.
+       */
+      async updateFile(path, tags) {
+        const file = await this.open(path);
+        try {
+          mergeTagUpdates(file, tags);
+          await file.saveToFile();
+        } finally {
+          file.dispose();
+        }
+      }
+      /**
+       * Copy an audio file to a new path with updated tags.
+       * @param sourcePath - Path to the source audio file.
+       * @param destPath - Destination path for the tagged copy.
+       * @param tags - Tag fields to set on the copy.
+       * @throws {InvalidFormatError} If the source file is corrupted or unsupported.
+       * @throws {FileOperationError} If reading or writing fails.
+       */
+      async copyWithTags(sourcePath, destPath, tags) {
+        const file = await this.open(sourcePath);
+        try {
+          mergeTagUpdates(file, tags);
+          await file.saveToFile(destPath);
+        } finally {
+          file.dispose();
+        }
+      }
+      /** Returns the taglib-wasm version with embedded TagLib version. */
+      version() {
+        return `${VERSION} (TagLib ${this.taglibVersion()})`;
+      }
+      taglibVersion() {
+        if (this.module.getVersion) {
+          return this.module.getVersion();
+        }
+        if (this.module.version) {
+          return this.module.version();
+        }
+        return "unknown";
+      }
+    };
+  }
+});
+
+// src/taglib/index.ts
+var init_taglib = __esm({
+  "src/taglib/index.ts"() {
+    "use strict";
+    init_audio_file_impl();
+    init_taglib_class();
+    init_errors2();
+  }
+});
+
+// src/taglib.ts
+var taglib_exports = {};
+__export(taglib_exports, {
+  AudioFileImpl: () => AudioFileImpl,
+  EnvironmentError: () => EnvironmentError,
+  FileOperationError: () => FileOperationError,
+  InvalidFormatError: () => InvalidFormatError,
+  MemoryError: () => MemoryError,
+  MetadataError: () => MetadataError,
+  SUPPORTED_FORMATS: () => SUPPORTED_FORMATS,
+  TagLib: () => TagLib,
+  TagLibError: () => TagLibError,
+  TagLibInitializationError: () => TagLibInitializationError,
+  UnsupportedFormatError: () => UnsupportedFormatError,
+  createTagLib: () => createTagLib,
+  isEnvironmentError: () => isEnvironmentError,
+  isFileOperationError: () => isFileOperationError,
+  isInvalidFormatError: () => isInvalidFormatError,
+  isMemoryError: () => isMemoryError,
+  isMetadataError: () => isMetadataError,
+  isTagLibError: () => isTagLibError,
+  isUnsupportedFormatError: () => isUnsupportedFormatError
+});
+var init_taglib2 = __esm({
+  "src/taglib.ts"() {
+    "use strict";
+    init_taglib();
+  }
+});
+
+// src/web-utils/data-url.ts
+init_classes();
+function pictureToDataURL(picture) {
+  const data = picture.data;
+  const CHUNK = 32768;
+  let binary = "";
+  for (let i = 0; i < data.length; i += CHUNK) {
+    binary += String.fromCharCode(...data.subarray(i, i + CHUNK));
+  }
+  const base64 = btoa(binary);
+  return `data:${picture.mimeType};base64,${base64}`;
+}
+function dataURLToPicture(dataURL, type = "FrontCover", description) {
+  const regex = /^data:([^;]+);base64,(.+)$/;
+  const matches = regex.exec(dataURL);
+  if (!matches) {
+    throw new InvalidFormatError("Invalid data URL format");
+  }
+  const [, mimeType, base64] = matches;
+  const binaryString = atob(base64);
+  const data = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    data[i] = binaryString.codePointAt(i);
+  }
+  return {
+    mimeType,
+    data,
+    type,
+    ...description !== void 0 ? { description } : {}
+  };
+}
+
+// src/simple/config.ts
+var cachedTagLib = null;
+var bufferModeEnabled = false;
+async function getTagLib() {
+  if (!cachedTagLib) {
+    const { TagLib: TagLib2 } = await Promise.resolve().then(() => (init_taglib2(), taglib_exports));
+    const initOptions = bufferModeEnabled ? { forceWasmType: "emscripten" } : void 0;
+    cachedTagLib = await TagLib2.initialize(initOptions);
+  }
+  return cachedTagLib;
+}
+
+// src/simple/with-audio-file.ts
+init_errors2();
+async function withAudioFile(file, fn, options) {
+  const taglib = await getTagLib();
+  const audioFile = await taglib.open(file, options);
+  try {
+    if (!audioFile.isValid()) {
+      throw new InvalidFormatError(
+        "File may be corrupted or in an unsupported format"
+      );
+    }
+    return await fn(audioFile);
+  } finally {
+    audioFile.dispose();
+  }
+}
+async function withAudioFileSave(file, fn) {
+  return withAudioFile(file, (audioFile) => {
+    fn(audioFile);
+    if (!audioFile.save()) {
+      throw new FileOperationError(
+        "save",
+        "Failed to save metadata changes. The file may be read-only or corrupted."
+      );
+    }
+    return audioFile.getFileBuffer();
+  }, { partial: false });
+}
+
+// src/simple/picture-operations.ts
+async function readPictures(file) {
+  return withAudioFile(file, (audioFile) => audioFile.getPictures());
+}
+async function applyPictures(file, pictures) {
+  return withAudioFileSave(file, (audioFile) => {
+    audioFile.setPictures(pictures);
+  });
+}
+
+// src/web-utils/canvas.ts
+async function setCoverArtFromCanvas(file, canvas, options = {}) {
+  const {
+    format = "image/jpeg",
+    quality = 0.92,
+    type = "FrontCover",
+    description = "Front Cover"
+  } = options;
+  const dataURL = canvas.toDataURL(format, quality);
+  const picture = dataURLToPicture(dataURL, type, description);
+  return applyPictures(file, [picture]);
+}
+async function canvasToPicture(canvas, options = {}) {
+  const {
+    format = "image/jpeg",
+    quality = 0.92,
+    type = "FrontCover",
+    description
+  } = options;
+  return new Promise((resolve, reject) => {
+    canvas.toBlob(
+      (blob) => {
+        if (!blob) {
+          reject(new Error("Failed to convert canvas to blob"));
+          return;
+        }
+        blob.arrayBuffer().then(
+          (arrayBuffer) => {
+            const data = new Uint8Array(arrayBuffer);
+            resolve({
+              mimeType: format,
+              data,
+              type,
+              ...description !== void 0 ? { description } : {}
+            });
+          },
+          reject
+        );
+      },
+      format,
+      quality
+    );
+  });
+}
+async function imageFileToPicture(file, type = "FrontCover", description) {
+  const arrayBuffer = await file.arrayBuffer();
+  const data = new Uint8Array(arrayBuffer);
+  return {
+    mimeType: file.type,
+    data,
+    type,
+    description: description ?? file.name
+  };
+}
+
+// src/web-utils/dom-integration.ts
+function ensureArrayBufferBacked(data) {
+  if (data.buffer instanceof ArrayBuffer) {
+    return data;
+  }
+  const copy = new Uint8Array(data.length);
+  copy.set(data);
+  return copy;
+}
+function displayPicture(picture, imgElement) {
+  if (imgElement.src.startsWith("blob:")) {
+    URL.revokeObjectURL(imgElement.src);
+  }
+  const data = ensureArrayBufferBacked(picture.data);
+  const blob = new Blob([data], { type: picture.mimeType });
+  const objectURL = URL.createObjectURL(blob);
+  imgElement.src = objectURL;
+  imgElement.addEventListener("load", () => {
+    setTimeout(() => URL.revokeObjectURL(objectURL), 100);
+  }, { once: true });
+}
+function createPictureDownloadURL(picture, filename = "cover") {
+  const data = ensureArrayBufferBacked(picture.data);
+  const blob = new Blob([data], { type: picture.mimeType });
+  return URL.createObjectURL(blob);
+}
+async function createPictureGallery(file, container, options = {}) {
+  const pictures = await readPictures(file);
+  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);
+  });
+}
+export {
+  canvasToPicture,
+  createPictureDownloadURL,
+  createPictureGallery,
+  dataURLToPicture,
+  displayPicture,
+  imageFileToPicture,
+  pictureToDataURL,
+  setCoverArtFromCanvas
+};