taglib-wasm 1.8.3 → 2.0.0

package/README.md

@@ -205,7 +205,6 @@ const result = await scanFolder("/path/to/music", {
     console.log(`Processing ${processed}/${total}: ${file}`);
   },
 });
-
 console.log(`Found ${result.items.length} audio files`);
 console.log(
   `Successfully processed ${
@@ -241,6 +240,14 @@ for (const album of albums) {
 console.log(`${singles.length} singles, ${unmatched.length} unmatched`);
 ```
 
+The disc-folder grammar (`discFolderInfo`) and the pure `groupAlbums` core are
+Wasm-free — import them from the dedicated subpath in browser/UI contexts
+(no TagLib runtime is loaded):
+
+```typescript
+import { discFolderInfo, groupAlbums } from "taglib-wasm/disc-folder";
+```
+
 ### Working with Cover Art
 
 ```typescript

package/dist/disc-folder.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Pure disc-folder grammar and album grouping — no Wasm, no runtime deps.
+ *
+ * @module disc-folder
+ *
+ * Import from this subpath when all you need is `discFolderInfo` (or the pure
+ * `groupAlbums` core): unlike the main entry or `./folder`, this module's
+ * graph contains no Wasm loader, so it works in browsers and UI contexts
+ * without ever loading TagLib. CI guards the property (taglib-cd7b) — if a
+ * future change pulls a non-pure import into this graph, the build fails.
+ *
+ * ```typescript
+ * import { discFolderInfo } from "taglib-wasm/disc-folder";
+ * discFolderInfo("CD1"); // { kind: "exact", number: 1, ... }
+ * ```
+ */
+export * from "./src/folder-api/group-albums.js";
+export type { FolderScanResult } from "./src/folder-api/types.js";
+//# sourceMappingURL=disc-folder.d.ts.map

package/dist/disc-folder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disc-folder.d.ts","sourceRoot":"","sources":["../disc-folder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,cAAc,kCAAkC,CAAC;AACjD,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/disc-folder.js

@@ -0,0 +1,550 @@
+// src/utils/path.ts
+function basename(path) {
+  const i = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+  return i === -1 ? path : path.slice(i + 1);
+}
+
+// src/folder-api/group-albums.ts
+function discFolderInfo(name) {
+  const parse = parseDiscName(name);
+  if (!parse) return void 0;
+  return {
+    kind: parse.kind,
+    gated: parse.gated,
+    number: parse.number,
+    total: parse.total,
+    title: parse.title,
+    discTitle: parse.discTitle,
+    confidence: parse.gated ? "low" : baseConfidence(parse)
+  };
+}
+function dirname(path) {
+  const i = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+  return i === -1 ? path : path.slice(0, i);
+}
+var UNCONDITIONAL_MARKERS = [
+  "cd",
+  "disc",
+  "disk",
+  "dvd",
+  "sacd",
+  "blu-ray",
+  "bd",
+  "digital media"
+];
+var GATED_MARKERS = ["tape", "vinyl", "cassette", "lp", "record"];
+var MARKERS = [...UNCONDITIONAL_MARKERS, ...GATED_MARKERS];
+var GATED_MARKER_SET = new Set(GATED_MARKERS);
+var WORD_NUMBERS = {
+  one: 1,
+  two: 2,
+  three: 3,
+  four: 4,
+  five: 5,
+  six: 6,
+  seven: 7,
+  eight: 8,
+  nine: 9,
+  ten: 10,
+  eleven: 11,
+  twelve: 12
+};
+function romanToInt(s) {
+  const values = {
+    i: 1,
+    v: 5,
+    x: 10,
+    l: 50,
+    c: 100,
+    d: 500,
+    m: 1e3
+  };
+  let total = 0;
+  let prev = 0;
+  for (let i = s.length - 1; i >= 0; i--) {
+    const v = values[s[i]];
+    if (v === void 0) return NaN;
+    total += v < prev ? -v : v;
+    prev = v;
+  }
+  return total;
+}
+function parseNumberToken(token) {
+  if (/^\d+$/.test(token)) return parseInt(token, 10);
+  const word = WORD_NUMBERS[token.toLowerCase()];
+  if (word) return word;
+  const roman = romanToInt(token.toLowerCase());
+  return Number.isFinite(roman) ? roman : void 0;
+}
+var SEP = String.raw`[\s._#-]*`;
+var NUM = String.raw`(?:\d+|(?:[ivxlcdm]+|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|[a-z])(?![a-z]))`;
+function parseDiscName(name) {
+  const trimmed = name.trim();
+  if (/^(?:extras?|bonus)$/i.test(trimmed)) return void 0;
+  for (const marker of MARKERS) {
+    const left = String.raw`(?:^|[^a-z0-9])`;
+    const esc = marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const re = new RegExp(
+      left + String.raw`(${esc})(?![a-z])${SEP}(${NUM})`,
+      "i"
+    );
+    const m = trimmed.match(re);
+    if (!m) continue;
+    const sideLetter = /^[a-z]$/i.test(m[2]);
+    const number = sideLetter ? void 0 : parseNumberToken(m[2]);
+    if (number === void 0 && !sideLetter) continue;
+    if (!sideLetter && /^[ivxlcdm]{2,}$/i.test(m[2]) && (number ?? 0) > 100) continue;
+    const isGated = GATED_MARKER_SET.has(marker.toLowerCase()) || sideLetter;
+    const markerStart = m.index + m[1].length - marker.length;
+    const rawPrefix = trimmed.slice(0, markerStart).trim();
+    const title = rawPrefix.replace(/[()[\]]/g, "").replace(/[\s._#-]+$/, "") || void 0;
+    const isExact = title === void 0;
+    const after = trimmed.slice(m.index + m[0].length).trim();
+    const discTitle = after.replace(/^[()[\],:;\-–—\s]+/, "").replace(/[)\]\[,:;\-–—\s]+$/, "").trim() || void 0;
+    const ofMatch = after.trim().match(/^of\s+(\d+)\b/i);
+    const total = ofMatch ? parseInt(ofMatch[1], 10) : void 0;
+    return {
+      kind: isExact ? "exact" : "embedded",
+      number: sideLetter ? void 0 : number,
+      total,
+      title,
+      discTitle,
+      gated: isGated,
+      sideLetter,
+      digit: /^\d+$/.test(m[2])
+    };
+  }
+  const volume = trimmed.match(
+    /^(?:volume|vol\.?|part|pt\.?)\s*(\d+)(?:\s*of\s*(\d+))?$/i
+  );
+  if (volume) {
+    return {
+      kind: "volume",
+      number: parseInt(volume[1], 10),
+      total: volume[2] ? parseInt(volume[2], 10) : void 0,
+      title: void 0,
+      discTitle: void 0,
+      gated: false,
+      sideLetter: false,
+      digit: true
+    };
+  }
+  if (/^bonus\s+disc$/i.test(trimmed)) {
+    return {
+      kind: "bonus",
+      number: void 0,
+      total: void 0,
+      title: void 0,
+      discTitle: void 0,
+      gated: true,
+      sideLetter: false,
+      digit: false
+    };
+  }
+  if (/^(?:\d+|v\d+|p\d+|[ab])$/i.test(trimmed)) {
+    return {
+      kind: "bare",
+      number: /^\d+$/i.test(trimmed) ? parseInt(trimmed, 10) : void 0,
+      total: void 0,
+      title: void 0,
+      discTitle: void 0,
+      gated: true,
+      sideLetter: false,
+      digit: false
+    };
+  }
+  return void 0;
+}
+function baseConfidence(parse) {
+  switch (parse.kind) {
+    case "exact":
+      return parse.digit ? "high" : "low";
+    case "embedded":
+      return "medium";
+    case "volume":
+      return "medium";
+    case "bonus":
+    case "bare":
+      return "low";
+  }
+}
+function corroborated(parse, siblings) {
+  if (!parse.gated && parse.kind === "exact") return true;
+  if (siblings.length === 0) return false;
+  const siblingParses = siblings.map((s) => parseDiscName(basename(s))).filter((p) => p !== void 0);
+  const hasExactSibling = siblingParses.some(
+    (p) => !p.gated && p.kind === "exact"
+  );
+  const hasNumberedSibling = siblingParses.some(
+    (p) => p.number !== void 0
+  );
+  if (parse.number !== void 0 && hasNumberedSibling) return true;
+  if (!parse.gated && parse.kind === "embedded" && hasExactSibling) return true;
+  if (!parse.gated && parse.kind === "volume" && hasNumberedSibling) {
+    return true;
+  }
+  if (parse.sideLetter) {
+    return siblingParses.some((p) => p.sideLetter);
+  }
+  if (parse.kind === "bonus" || parse.kind === "bare") {
+    const numberedCount = siblingParses.filter((p) => p.number !== void 0).length;
+    if (numberedCount >= 2) return true;
+    if (parse.number !== void 0 && hasNumberedSibling) return true;
+  }
+  return false;
+}
+function flatPrefix(filename) {
+  const separated = filename.match(/^(\d{1,2})[\s._-](\d{1,2})/);
+  if (separated) return { disc: parseInt(separated[1], 10), form: "separated" };
+  const compact = filename.match(/^(\d)(\d{2})(?:\D|$)/);
+  if (compact) return { disc: parseInt(compact[1], 10), form: "compact" };
+  return void 0;
+}
+function normalizeKey(s) {
+  return s.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function isGenericAlbumArtist(albumArtist) {
+  if (!albumArtist || albumArtist.trim() === "") return true;
+  const n = normalizeKey(albumArtist);
+  return n === "various artists" || n === "va";
+}
+var CONFIDENCE_RANK = {
+  low: 0,
+  medium: 1,
+  high: 2
+};
+function groupAlbums(result, options = {}) {
+  const minRank = CONFIDENCE_RANK[options.minFolderConfidence ?? "low"];
+  const useFlatPrefixes = options.flatDiscPrefixes ?? true;
+  const useFolderFallback = options.folderFallback ?? true;
+  const okItems = [];
+  const errors = [];
+  for (const item of result.items) {
+    if (item.status === "ok") {
+      okItems.push({ path: item.path, tags: item.tags, metadata: item });
+    } else {
+      errors.push({ path: item.path, error: item.error });
+    }
+  }
+  if (okItems.length === 0) {
+    return { albums: [], singles: [], unmatched: [], errors };
+  }
+  const scanRoot = options.scanRoot;
+  const tree = /* @__PURE__ */ new Map();
+  for (const item of okItems) {
+    const dir = dirname(item.path);
+    let node = tree.get(dir);
+    if (!node) {
+      node = { files: [], parent: dirname(dir) };
+      tree.set(dir, node);
+    }
+    node.files.push(item);
+  }
+  const confirmedDiscs = /* @__PURE__ */ new Map();
+  for (const [dir, node] of tree) {
+    if (node.files.length === 0) continue;
+    const parse = parseDiscName(basename(dir));
+    if (!parse) continue;
+    const siblings = [...tree.keys()].filter(
+      (d) => d !== dir && dirname(d) === dirname(dir)
+    );
+    const corroboratedBySiblings = corroborated(parse, siblings);
+    let confidence = parse.gated ? "low" : baseConfidence(parse);
+    if (parse.gated) {
+      if (!corroboratedBySiblings) continue;
+    } else if (parse.kind === "bonus" || parse.kind === "bare") {
+      if (!corroboratedBySiblings) continue;
+    } else if (corroboratedBySiblings) {
+      confidence = "high";
+    }
+    if (CONFIDENCE_RANK[confidence] < minRank) continue;
+    confirmedDiscs.set(dir, { parse, confidence });
+  }
+  const flatSubdivisions = /* @__PURE__ */ new Map();
+  if (useFlatPrefixes) {
+    for (const [dir, node] of tree) {
+      if (node.files.length === 0 || confirmedDiscs.has(dir)) continue;
+      const byFile = /* @__PURE__ */ new Map();
+      const forms = /* @__PURE__ */ new Set();
+      for (const item of node.files) {
+        const prefix = flatPrefix(basename(item.path));
+        if (prefix) {
+          byFile.set(item.path, prefix.disc);
+          forms.add(prefix.form);
+        }
+      }
+      if (byFile.size < 2) continue;
+      const distinct = [...new Set(byFile.values())].sort((a, b) => a - b);
+      const allCompact = forms.size === 1 && forms.has("compact");
+      const plausible = allCompact ? distinct.every((d) => d >= 1 && d <= distinct.length) : true;
+      if (plausible) flatSubdivisions.set(dir, byFile);
+    }
+  }
+  const albums = /* @__PURE__ */ new Map();
+  const unmatched = [];
+  const evidenceFor = (item) => {
+    const dir = dirname(item.path);
+    const own = confirmedDiscs.get(dir);
+    if (own) {
+      return {
+        folderDiscNumber: own.parse.number,
+        total: own.parse.total,
+        folderDiscTitle: own.parse.discTitle,
+        confidence: own.confidence,
+        albumDir: dirname(dir)
+      };
+    }
+    let cursor = dirname(dir);
+    while (cursor !== void 0) {
+      const entry = confirmedDiscs.get(cursor);
+      if (entry) {
+        return {
+          folderDiscNumber: entry.parse.number,
+          total: entry.parse.total,
+          folderDiscTitle: entry.parse.discTitle,
+          confidence: entry.confidence,
+          albumDir: dirname(cursor)
+        };
+      }
+      const parent = dirname(cursor);
+      if (parent === cursor) break;
+      cursor = parent;
+    }
+    const flat = flatSubdivisions.get(dir)?.get(item.path);
+    if (flat !== void 0) {
+      return {
+        folderDiscNumber: flat,
+        total: void 0,
+        folderDiscTitle: void 0,
+        confidence: "medium",
+        albumDir: dir
+      };
+    }
+    return void 0;
+  };
+  const folderIdentity = (dir) => {
+    const own = confirmedDiscs.get(dir);
+    if (!own) {
+      const title2 = basename(dir);
+      return title2 ? { title: title2, titleSource: dir } : void 0;
+    }
+    if (own.parse.title !== void 0) {
+      return { title: own.parse.title, titleSource: dirname(dir) };
+    }
+    const source = dirname(dir);
+    if (source === scanRoot || source === dir) return void 0;
+    const title = basename(source);
+    return title ? { title, titleSource: source } : void 0;
+  };
+  for (const item of okItems) {
+    const dir = dirname(item.path);
+    const albumTag = item.tags.album?.[0]?.trim();
+    const albumArtistTag = item.tags.albumArtist?.[0]?.trim();
+    if (albumTag) {
+      const artistPart = isGenericAlbumArtist(albumArtistTag) ? "" : normalizeKey(albumArtistTag ?? "");
+      const key2 = `${artistPart}::${normalizeKey(albumTag)}`;
+      let acc2 = albums.get(key2);
+      if (!acc2) {
+        acc2 = {
+          key: key2,
+          album: albumTag,
+          albumArtist: isGenericAlbumArtist(albumArtistTag) ? void 0 : albumArtistTag,
+          source: "tags",
+          directory: void 0,
+          items: [],
+          evidence: /* @__PURE__ */ new Map()
+        };
+        albums.set(key2, acc2);
+      }
+      const evidence2 = evidenceFor(item);
+      acc2.evidence.set(item.path, evidence2);
+      acc2.items.push({
+        ...item.metadata,
+        albumDir: evidence2?.albumDir ?? dir,
+        discNumber: evidence2?.folderDiscNumber
+      });
+      continue;
+    }
+    if (!useFolderFallback) {
+      unmatched.push(item.metadata);
+      continue;
+    }
+    const identity = folderIdentity(dir);
+    if (!identity) {
+      unmatched.push(item.metadata);
+      continue;
+    }
+    const key = `${identity.titleSource}::${normalizeKey(identity.title)}`;
+    let acc = albums.get(key);
+    if (!acc) {
+      acc = {
+        key,
+        album: identity.title,
+        albumArtist: void 0,
+        source: "folder",
+        directory: identity.titleSource,
+        items: [],
+        evidence: /* @__PURE__ */ new Map()
+      };
+      albums.set(key, acc);
+    }
+    const evidence = evidenceFor(item);
+    acc.evidence.set(item.path, evidence);
+    acc.items.push({
+      ...item.metadata,
+      albumDir: evidence?.albumDir ?? dir,
+      discNumber: evidence?.folderDiscNumber
+    });
+  }
+  for (const [key, acc] of [...albums]) {
+    if (acc.source === "tags") continue;
+    for (const other of albums.values()) {
+      if (other === acc || other.source !== "tags") continue;
+      if (normalizeKey(other.album) !== normalizeKey(acc.album)) continue;
+      const albumDir = acc.directory;
+      const sharesChain = albumDir !== void 0 && other.items.some((o) => {
+        const od = dirname(o.path);
+        return od === albumDir || od.startsWith(albumDir + "/");
+      });
+      if (!sharesChain) continue;
+      for (const item of acc.items) {
+        other.items.push(item);
+        other.evidence.set(item.path, acc.evidence.get(item.path));
+      }
+      albums.delete(key);
+      break;
+    }
+  }
+  const groups = [];
+  for (const acc of albums.values()) {
+    const dirTagCommon = /* @__PURE__ */ new Map();
+    const resolvedByFile = /* @__PURE__ */ new Map();
+    for (const item of acc.items) {
+      const dir = dirname(item.path);
+      if (!dirTagCommon.has(dir)) {
+        const tagged = acc.items.filter((i) => dirname(i.path) === dir).map((i) => i.tags.discNumber).filter((d) => d !== void 0 && d > 0);
+        dirTagCommon.set(
+          dir,
+          tagged.length > 0 && tagged.every((d) => d === tagged[0]) ? tagged[0] : void 0
+        );
+      }
+      const evidence = acc.evidence.get(item.path);
+      const tagCommon = dirTagCommon.get(dir);
+      resolvedByFile.set(
+        item.path,
+        tagCommon ?? evidence?.folderDiscNumber
+      );
+    }
+    const discs = /* @__PURE__ */ new Map();
+    const order = [];
+    const noEvidenceItems = [];
+    for (const item of acc.items) {
+      const evidence = acc.evidence.get(item.path);
+      if (evidence === void 0) {
+        noEvidenceItems.push(item);
+        continue;
+      }
+      const resolved = resolvedByFile.get(item.path);
+      const discKey = resolved === void 0 ? `dir:${dirname(item.path)}` : String(resolved);
+      let disc = discs.get(discKey);
+      if (!disc) {
+        disc = {
+          discNumber: resolved,
+          totalDiscs: evidence.total,
+          folderDiscNumber: evidence.folderDiscNumber,
+          folderDiscTitle: evidence.folderDiscTitle,
+          tagDiscNumber: void 0,
+          confidence: evidence.confidence,
+          items: []
+        };
+        discs.set(discKey, disc);
+        order.push(discKey);
+      }
+      disc.items.push(item);
+    }
+    if (noEvidenceItems.length > 0) {
+      const numbered = [...discs.values()].filter((d) => d.folderDiscNumber !== void 0).sort((a, b) => a.folderDiscNumber - b.folderDiscNumber);
+      if (numbered.length > 0) {
+        numbered[0].items.push(...noEvidenceItems);
+      } else {
+        const key = "dir:__none__";
+        let disc = discs.get(key);
+        if (!disc) {
+          disc = {
+            discNumber: void 0,
+            totalDiscs: void 0,
+            folderDiscNumber: void 0,
+            folderDiscTitle: void 0,
+            tagDiscNumber: void 0,
+            confidence: "high",
+            items: []
+          };
+          discs.set(key, disc);
+          order.push(key);
+        }
+        disc.items.push(...noEvidenceItems);
+      }
+    }
+    for (const disc of discs.values()) {
+      const tagged = disc.items.map((i) => i.tags.discNumber).filter((d) => d !== void 0 && d > 0);
+      const common = tagged.length > 0 && tagged.every((d) => d === tagged[0]) ? tagged[0] : void 0;
+      disc.tagDiscNumber = common;
+      disc.discNumber = common ?? disc.folderDiscNumber;
+      for (const item of disc.items) item.discNumber = disc.discNumber;
+    }
+    const albumTaggedTotals = acc.items.map((i) => i.tags.totalDiscs).filter((t) => t !== void 0 && t > 0);
+    const commonTotal = albumTaggedTotals.length > 0 && albumTaggedTotals.every((t) => t === albumTaggedTotals[0]) ? albumTaggedTotals[0] : void 0;
+    const ofN = [...discs.values()].map((d) => d.totalDiscs).find(
+      (t) => t !== void 0
+    );
+    const maxSibling = [...discs.values()].map((d) => d.discNumber).filter((n) => n !== void 0).reduce((a, b) => Math.max(a, b), 0) || void 0;
+    for (const disc of discs.values()) {
+      disc.totalDiscs = commonTotal ?? ofN ?? maxSibling;
+    }
+    const sortedDiscs = [...discs.values()].sort((a, b) => {
+      const an = a.discNumber === void 0 ? -1 : a.discNumber;
+      const bn = b.discNumber === void 0 ? -1 : b.discNumber;
+      if (an !== bn) return an - bn;
+      return (a.folderDiscTitle ?? "").localeCompare(b.folderDiscTitle ?? "");
+    });
+    for (const disc of sortedDiscs) {
+      disc.items.sort((a, b) => {
+        const at = a.tags.track ?? Infinity;
+        const bt = b.tags.track ?? Infinity;
+        if (at !== bt) return at - bt;
+        return a.path.localeCompare(b.path);
+      });
+    }
+    const flags = acc.items.map((i) => i.tags.compilation).filter((c) => c !== void 0);
+    const compilation = flags.length > 0 && flags.every((f) => f === flags[0]) ? flags[0] : void 0;
+    const albumDirs = new Set(acc.items.map((i) => i.albumDir));
+    const directory = albumDirs.size === 1 ? [...albumDirs][0] : acc.directory;
+    groups.push({
+      key: acc.key,
+      albumArtist: acc.albumArtist,
+      album: acc.album,
+      source: acc.source,
+      compilation,
+      directory,
+      discs: sortedDiscs,
+      items: sortedDiscs.flatMap((d) => d.items)
+    });
+  }
+  const albumsOut = [];
+  const singles = [];
+  for (const group of groups) {
+    if (group.items.length === 1) {
+      singles.push(group.items[0]);
+    } else {
+      albumsOut.push(group);
+    }
+  }
+  albumsOut.sort(
+    (a, b) => (a.albumArtist ?? "").localeCompare(b.albumArtist ?? "") || (a.album ?? "").localeCompare(b.album ?? "")
+  );
+  return { albums: albumsOut, singles, unmatched, errors };
+}
+export {
+  discFolderInfo,
+  groupAlbums
+};

package/dist/index.browser.d.ts

@@ -13,15 +13,14 @@ export { isNamedAudioInput } from "./src/types/audio-formats.js";
 export { EnvironmentError, FileOperationError, InvalidFormatError, isEnvironmentError, isFileOperationError, isInvalidFormatError, isMemoryError, isMetadataError, isTagLibError, isUnsupportedFormatError, MemoryError, MetadataError, SUPPORTED_FORMATS, TagLibError, TagLibInitializationError, UnsupportedFormatError, } from "./src/errors.js";
 export type { TagLibErrorCode } from "./src/errors.js";
 export { addPicture, applyCoverArt, applyPictures, applyTags, applyTagsToFile, type BatchItem, type BatchOptions, type BatchResult, clearPictures, clearTags, type FileMetadata, findPictureByType, isValidAudioFile, readCoverArt, readFormat, readMetadata, readMetadataBatch, readPictureMetadata, readPictures, readProperties, readPropertiesBatch, readTags, readTagsBatch, replacePictureByType, setBufferMode, } from "./src/simple/index.js";
-export { FormatMappings, getAllProperties, getAllPropertyKeys, getAllTagNames, getPropertiesByFormat, getPropertyMetadata, isValidProperty, isValidTagName, PROPERTIES, Tags, } from "./src/constants.js";
+export { FormatMappings, getAllProperties, getAllPropertyKeys, getPropertiesByFormat, getPropertyMetadata, isValidProperty, PROPERTIES, } from "./src/constants.js";
 export type { PropertyMetadata } from "./src/constants/property-types.js";
 export { canvasToPicture, createPictureDownloadURL, createPictureGallery, dataURLToPicture, displayPicture, imageFileToPicture, pictureToDataURL, setCoverArtFromCanvas, } from "./src/web-utils/index.js";
-export type { AudioCodec, AudioFileInput, AudioProperties, BitrateControlMode, ContainerFormat, ExtendedTag, FieldMapping, FileType, NamedAudioInput, OpenOptions, Picture, PictureType, PropertyMap, Tag, TagInput, TagName, } from "./src/types.js";
+export type { AudioCodec, AudioFileInput, AudioProperties, BitrateControlMode, ContainerFormat, ExtendedTag, FieldMapping, FileType, NamedAudioInput, OpenOptions, Picture, PictureType, PropertyMap, Tag, TagInput, } from "./src/types.js";
 export { BITRATE_CONTROL_MODE_NAMES, BITRATE_CONTROL_MODE_VALUES, PICTURE_TYPE_NAMES, PICTURE_TYPE_VALUES, } from "./src/types.js";
 export type { PropertyKey, PropertyValue } from "./src/constants.js";
 export type { FormatPropertyKey, TagFormat, } from "./src/types/format-property-keys.js";
-export { COMPLEX_PROPERTIES, COMPLEX_PROPERTY_KEY, } from "./src/constants/complex-properties.js";
-export type { ComplexPropertyKey, ComplexPropertyKeyMap, ComplexPropertyValueMap, Rating, UnsyncedLyrics, VariantMap, } from "./src/constants/complex-properties.js";
+export type { Rating, UnsyncedLyrics, VariantMap, } from "./src/constants/complex-properties.js";
 export { RatingUtils } from "./src/utils/rating.js";
 export type { NormalizedRating, PopmRating } from "./src/utils/rating.js";
 export type { TagLibModule, WasmModule } from "./src/wasm.js";

package/dist/index.browser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.browser.d.ts","sourceRoot":"","sources":["../index.browser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,YAAY,EACV,SAAS,EACT,cAAc,GACf,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACtE,YAAY,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAGjE,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,aAAa,EACb,eAAe,EACf,aAAa,EACb,wBAAwB,EACxB,WAAW,EACX,aAAa,EACb,iBAAiB,EACjB,WAAW,EACX,yBAAyB,EACzB,sBAAsB,GACvB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGvD,OAAO,EACL,UAAU,EACV,aAAa,EACb,aAAa,EACb,SAAS,EACT,eAAe,EACf,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,aAAa,EACb,SAAS,EACT,KAAK,YAAY,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,EACZ,cAAc,EACd,mBAAmB,EACnB,QAAQ,EACR,aAAa,EACb,oBAAoB,EACpB,aAAa,GACd,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EACd,qBAAqB,EACrB,mBAAmB,EACnB,eAAe,EACf,cAAc,EACd,UAAU,EACV,IAAI,GACL,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAG1E,OAAO,EACL,eAAe,EACf,wBAAwB,EACxB,oBAAoB,EACpB,gBAAgB,EAChB,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,0BAA0B,CAAC;AAGlC,YAAY,EACV,UAAU,EACV,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,WAAW,EACX,YAAY,EACZ,QAAQ,EACR,eAAe,EACf,WAAW,EACX,OAAO,EACP,WAAW,EACX,WAAW,EACX,GAAG,EACH,QAAQ,EACR,OAAO,GACR,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,0BAA0B,EAC1B,2BAA2B,EAC3B,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,gBAAgB,CAAC;AAExB,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACrE,YAAY,EACV,iBAAiB,EACjB,SAAS,GACV,MAAM,qCAAqC,CAAC;AAG7C,OAAO,EACL,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,uCAAuC,CAAC;AAC/C,YAAY,EACV,kBAAkB,EAClB,qBAAqB,EACrB,uBAAuB,EACvB,MAAM,EACN,cAAc,EACd,UAAU,GACX,MAAM,uCAAuC,CAAC;AAG/C,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,YAAY,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAG1E,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC9D,YAAY,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wCAAwC,CAAC"}
+{"version":3,"file":"index.browser.d.ts","sourceRoot":"","sources":["../index.browser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,YAAY,EACV,SAAS,EACT,cAAc,GACf,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACtE,YAAY,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAGjE,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,aAAa,EACb,eAAe,EACf,aAAa,EACb,wBAAwB,EACxB,WAAW,EACX,aAAa,EACb,iBAAiB,EACjB,WAAW,EACX,yBAAyB,EACzB,sBAAsB,GACvB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGvD,OAAO,EACL,UAAU,EACV,aAAa,EACb,aAAa,EACb,SAAS,EACT,eAAe,EACf,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,aAAa,EACb,SAAS,EACT,KAAK,YAAY,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,EACZ,cAAc,EACd,mBAAmB,EACnB,QAAQ,EACR,aAAa,EACb,oBAAoB,EACpB,aAAa,GACd,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAClB,qBAAqB,EACrB,mBAAmB,EACnB,eAAe,EACf,UAAU,GACX,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAG1E,OAAO,EACL,eAAe,EACf,wBAAwB,EACxB,oBAAoB,EACpB,gBAAgB,EAChB,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,0BAA0B,CAAC;AAGlC,YAAY,EACV,UAAU,EACV,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,WAAW,EACX,YAAY,EACZ,QAAQ,EACR,eAAe,EACf,WAAW,EACX,OAAO,EACP,WAAW,EACX,WAAW,EACX,GAAG,EACH,QAAQ,GACT,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,0BAA0B,EAC1B,2BAA2B,EAC3B,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,gBAAgB,CAAC;AAExB,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACrE,YAAY,EACV,iBAAiB,EACjB,SAAS,GACV,MAAM,qCAAqC,CAAC;AAG7C,YAAY,EACV,MAAM,EACN,cAAc,EACd,UAAU,GACX,MAAM,uCAAuC,CAAC;AAG/C,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,YAAY,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAG1E,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC9D,YAAY,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wCAAwC,CAAC"}