taglib-wasm 2.2.3 → 2.3.0

package/dist/simple.browser.js

@@ -281,11 +281,29 @@ var init_base = __esm({
     "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 {
@@ -1875,6 +1893,463 @@ var init_audio_file_base = __esm({
   }
 });
 
+// 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;
@@ -1982,8 +2457,8 @@ function wrapEmbindHandle(raw) {
     // Text only — language/description are not surfaced by the PropertyMap.
     getLyrics() {
       const props = raw.getProperties();
-      return (props["LYRICS"] ?? []).map((text) => ({
-        text,
+      return (props["LYRICS"] ?? []).map((text2) => ({
+        text: text2,
         description: "",
         language: ""
       }));
@@ -2236,6 +2711,8 @@ var init_audio_file_impl = __esm({
     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) {
@@ -2248,6 +2725,9 @@ var init_audio_file_impl = __esm({
           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) {
@@ -2283,6 +2763,31 @@ var init_audio_file_impl = __esm({
           "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) {
@@ -2480,181 +2985,6 @@ var init_audio_file_impl = __esm({
   }
 });
 
-// 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 (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 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 isMpegFrameSync(bytes, at = 0) {
-  if (bytes.length < at + 4) return false;
-  if (bytes[at] !== 255 || (bytes[at + 1] & 224) !== 224) return false;
-  const version = bytes[at + 1] >> 3 & 3;
-  const layer = bytes[at + 1] >> 1 & 3;
-  if (version === 1 || layer === 0) return false;
-  const bitrateIndex = bytes[at + 2] >> 4 & 15;
-  const sampleRateIndex = bytes[at + 2] >> 2 & 3;
-  if (bitrateIndex === 0 || bitrateIndex === 15 || sampleRateIndex === 3) {
-    return false;
-  }
-  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;
-  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/load-audio-data.ts
 async function loadAudioData(input, opts) {
   if (opts.partial && typeof File !== "undefined" && input instanceof File) {
@@ -2941,7 +3271,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = "2.2.3";
+    VERSION = "2.3.0";
   }
 });
 
@@ -3063,30 +3393,19 @@ var init_taglib_class = __esm({
         const actualInput = isNamedAudioInput(input) ? input.data : input;
         const sourcePath = typeof actualInput === "string" ? actualInput : void 0;
         if (typeof actualInput === "string" && this.module.isWasi) {
-          const fileHandle2 = this.module.createFileHandle();
-          try {
-            const fh = fileHandle2;
-            if (fh.loadFromPath) {
-              const wasiPath = toWasiPath(actualInput);
-              const success = fh.loadFromPath(wasiPath);
-              if (!success) {
-                throw new InvalidFormatError(
-                  `Failed to load audio file. Path: ${actualInput}`
-                );
-              }
-              return new AudioFileImpl(
-                this.module,
-                fileHandle2,
-                sourcePath,
-                actualInput,
-                false
-              );
-            }
-          } catch (error) {
-            if (typeof fileHandle2.destroy === "function") {
-              fileHandle2.destroy();
-            }
-            throw error;
+          const 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 = {
@@ -3600,6 +3919,11 @@ async function editTagsBatch(files, mutator, options = {}) {
   );
 }
 
+// src/simple/checksum-operations.ts
+async function readMediaChecksum(file, options) {
+  return withAudioFile(file, (audioFile) => audioFile.mediaChecksum(options));
+}
+
 // src/simple/index.ts
 init_types2();
 export {
@@ -3618,6 +3942,7 @@ export {
   isValidAudioFile,
   readCoverArt,
   readFormat,
+  readMediaChecksum,
   readMetadata,
   readMetadataBatch,
   readPictureMetadata,