taglib-wasm 1.5.3 → 1.6.1

package/dist/index.browser.js

@@ -1443,6 +1443,26 @@ var init_specialized_properties = __esm({
           vorbis: "ITUNNORM",
           mp4: "----:com.apple.iTunes:iTunNORM"
         }
+      },
+      /**
+       * Apple gapless-playback data (encoder delay, padding, original sample count).
+       *
+       * Exists so the two Apple freeform atoms are presented consistently: without
+       * it, `properties()` answered `appleSoundCheck` for iTunNORM but the raw
+       * uppercased `ITUNSMPB` for its sibling, because only one had an alias. The
+       * name mirrors `appleSoundCheck` — vendor-prefixed, feature-named rather than
+       * atom-named (tuneup-ibo).
+       */
+      appleGaplessInfo: {
+        key: "ITUNSMPB",
+        description: "Apple gapless playback data (encoder delay and padding)",
+        type: "string",
+        supportedFormats: ["ID3v2", "MP4", "Vorbis"],
+        mappings: {
+          id3v2: { frame: "TXXX", description: "iTunSMPB" },
+          vorbis: "ITUNSMPB",
+          mp4: "----:com.apple.iTunes:iTunSMPB"
+        }
       }
     };
   }
@@ -1452,6 +1472,17 @@ var init_specialized_properties = __esm({
 function toTagLibKey(key) {
   return _toTagLib[key] ?? key;
 }
+function mp4AtomWireKey(atom) {
+  return _mp4AtomToWireKey[atom];
+}
+function mp4FreeformAtomNames(wireKeys) {
+  const names = [];
+  for (const key of wireKeys) {
+    const atom = _mp4FreeformAtoms[key];
+    if (atom !== void 0) names.push(atom);
+  }
+  return names;
+}
 function fromTagLibKey(key) {
   return _fromTagLib[key] ?? key;
 }
@@ -1462,7 +1493,7 @@ function remapKeysFromTagLib(obj) {
   }
   return result;
 }
-var PROPERTIES, _toTagLib, _fromTagLib;
+var PROPERTIES, _toTagLib, _fromTagLib, _mp4FreeformAtoms, _mp4AtomToWireKey;
 var init_properties = __esm({
   "src/constants/properties.ts"() {
     "use strict";
@@ -1486,6 +1517,129 @@ var init_properties = __esm({
     _toTagLib["year"] = "DATE";
     _toTagLib["track"] = "TRACKNUMBER";
     _fromTagLib["disc"] = "discNumber";
+    _mp4FreeformAtoms = {};
+    for (const meta of Object.values(PROPERTIES)) {
+      const { key, mappings } = meta;
+      const atom = mappings?.mp4;
+      if (typeof atom !== "string" || !atom.startsWith("----:")) continue;
+      const bare = atom.slice(atom.lastIndexOf(":") + 1);
+      if (bare === bare.toUpperCase()) continue;
+      _mp4FreeformAtoms[key] = atom;
+      const readKey = bare.toUpperCase();
+      const camel = _fromTagLib[key];
+      if (camel !== void 0 && _fromTagLib[readKey] === void 0) {
+        _fromTagLib[readKey] = camel;
+      }
+    }
+    _mp4AtomToWireKey = {};
+    for (const meta of Object.values(PROPERTIES)) {
+      const { key, mappings } = meta;
+      const atom = mappings?.mp4;
+      if (typeof atom !== "string" || atom.startsWith("----:")) continue;
+      if (_mp4AtomToWireKey[atom] === void 0) _mp4AtomToWireKey[atom] = key;
+    }
+  }
+});
+
+// src/taglib/mp4-item-names.ts
+var MP4_ITEM_NAMES_KEY;
+var init_mp4_item_names = __esm({
+  "src/taglib/mp4-item-names.ts"() {
+    "use strict";
+    MP4_ITEM_NAMES_KEY = "_mp4ItemNames";
+  }
+});
+
+// src/taglib/mutable-tag-impl.ts
+function buildMutableTag(handle) {
+  let data = handle.getTagData();
+  const tag = {
+    get title() {
+      return data.title;
+    },
+    get artist() {
+      return data.artist;
+    },
+    get album() {
+      return data.album;
+    },
+    get comment() {
+      return data.comment;
+    },
+    get genre() {
+      return data.genre;
+    },
+    get year() {
+      return data.year;
+    },
+    get track() {
+      return data.track;
+    },
+    get date() {
+      return handle.getProperty("DATE") || void 0;
+    },
+    setTitle: (value) => {
+      handle.setTagData({ title: value });
+      data = handle.getTagData();
+      return tag;
+    },
+    setArtist: (value) => {
+      handle.setTagData({ artist: value });
+      data = handle.getTagData();
+      return tag;
+    },
+    setAlbum: (value) => {
+      handle.setTagData({ album: value });
+      data = handle.getTagData();
+      return tag;
+    },
+    setComment: (value) => {
+      handle.setTagData({ comment: value });
+      data = handle.getTagData();
+      return tag;
+    },
+    setGenre: (value) => {
+      handle.setTagData({ genre: value });
+      data = handle.getTagData();
+      return tag;
+    },
+    setYear: (value) => {
+      handle.setTagData({ year: value });
+      data = handle.getTagData();
+      return tag;
+    },
+    setTrack: (value) => {
+      const existing = value > 0 ? handle.getProperty(RAW_TRACK_WIRE_KEY) : "";
+      const slash = existing.indexOf("/");
+      if (slash !== -1) {
+        handle.setProperty(
+          RAW_TRACK_WIRE_KEY,
+          `${value}${existing.slice(slash)}`
+        );
+      } else {
+        handle.setTagData({ track: value });
+      }
+      data = handle.getTagData();
+      return tag;
+    },
+    setDate: (value) => {
+      if (value === "") {
+        handle.setTagData({ year: 0 });
+      } else {
+        handle.setProperty("DATE", value);
+      }
+      data = handle.getTagData();
+      return tag;
+    }
+  };
+  return tag;
+}
+var RAW_TRACK_WIRE_KEY;
+var init_mutable_tag_impl = __esm({
+  "src/taglib/mutable-tag-impl.ts"() {
+    "use strict";
+    init_properties();
+    RAW_TRACK_WIRE_KEY = toTagLibKey("trackNumber");
   }
 });
 
@@ -1496,6 +1650,8 @@ var init_audio_file_base = __esm({
     "use strict";
     init_properties();
     init_errors2();
+    init_mp4_item_names();
+    init_mutable_tag_impl();
     LYRICS_PROPERTY_KEY = "lyrics";
     LYRICS_WIRE_KEY = toTagLibKey(LYRICS_PROPERTY_KEY);
     EMPTY_KEY_SET = /* @__PURE__ */ new Set();
@@ -1546,79 +1702,7 @@ var init_audio_file_base = __esm({
         return this.getFormat() === format;
       }
       tag() {
-        const handle = this.handle;
-        let data = handle.getTagData();
-        const tag = {
-          get title() {
-            return data.title;
-          },
-          get artist() {
-            return data.artist;
-          },
-          get album() {
-            return data.album;
-          },
-          get comment() {
-            return data.comment;
-          },
-          get genre() {
-            return data.genre;
-          },
-          get year() {
-            return data.year;
-          },
-          get track() {
-            return data.track;
-          },
-          get date() {
-            return handle.getProperty("DATE") || void 0;
-          },
-          setTitle: (value) => {
-            handle.setTagData({ title: value });
-            data = handle.getTagData();
-            return tag;
-          },
-          setArtist: (value) => {
-            handle.setTagData({ artist: value });
-            data = handle.getTagData();
-            return tag;
-          },
-          setAlbum: (value) => {
-            handle.setTagData({ album: value });
-            data = handle.getTagData();
-            return tag;
-          },
-          setComment: (value) => {
-            handle.setTagData({ comment: value });
-            data = handle.getTagData();
-            return tag;
-          },
-          setGenre: (value) => {
-            handle.setTagData({ genre: value });
-            data = handle.getTagData();
-            return tag;
-          },
-          setYear: (value) => {
-            handle.setTagData({ year: value });
-            data = handle.getTagData();
-            return tag;
-          },
-          setTrack: (value) => {
-            handle.setTagData({ track: value });
-            data = handle.getTagData();
-            return tag;
-          },
-          setDate: (value) => {
-            if (value === "") {
-              handle.setTagData({ year: 0 });
-            } else {
-              handle.setProperty("DATE", value);
-            }
-            data = handle.getTagData();
-            return tag;
-          }
-        };
-        return tag;
+        return buildMutableTag(this.handle);
       }
       audioProperties() {
         if (!this.cachedAudioProperties) {
@@ -1640,14 +1724,29 @@ var init_audio_file_base = __esm({
           const existing = this.handle.getProperties()[LYRICS_WIRE_KEY];
           if (existing !== void 0) translated[LYRICS_WIRE_KEY] = existing;
         }
+        const atomNames = mp4FreeformAtomNames(Object.keys(translated));
+        if (atomNames.length > 0) translated[MP4_ITEM_NAMES_KEY] = atomNames;
         this.handle.setProperties(translated);
       }
       getProperty(key) {
         const value = this.handle.getProperty(toTagLibKey(key));
-        return value === "" ? void 0 : value;
+        if (value !== "") return value;
+        if (!this.isMP4()) return void 0;
+        const remapped = this.properties()[key]?.[0];
+        return remapped === "" ? void 0 : remapped;
       }
       setProperty(key, value) {
-        this.handle.setProperty(toTagLibKey(key), value);
+        const wireKey = toTagLibKey(key);
+        const atomNames = mp4FreeformAtomNames([wireKey]);
+        if (atomNames.length > 0 && this.isMP4()) {
+          this.handle.setProperties({
+            ...this.handle.getProperties(),
+            [wireKey]: [value],
+            [MP4_ITEM_NAMES_KEY]: atomNames
+          });
+          return;
+        }
+        this.handle.setProperty(wireKey, value);
       }
       isMP4() {
         return this.handle.isMP4();
@@ -1656,13 +1755,19 @@ var init_audio_file_base = __esm({
         if (!this.isMP4()) {
           throw new UnsupportedFormatError(this.getFormat(), ["MP4", "M4A"]);
         }
-        const value = this.handle.getMP4Item(key);
+        const wireKey = mp4AtomWireKey(key);
+        const value = wireKey !== void 0 ? this.handle.getProperty(wireKey) : this.handle.getMP4Item(key);
         return value === "" ? void 0 : value;
       }
       setMP4Item(key, value) {
         if (!this.isMP4()) {
           throw new UnsupportedFormatError(this.getFormat(), ["MP4", "M4A"]);
         }
+        const wireKey = mp4AtomWireKey(key);
+        if (wireKey !== void 0) {
+          this.handle.setProperty(wireKey, value);
+          return;
+        }
         this.handle.setMP4Item(key, value);
       }
       removeMP4Item(key) {
@@ -1945,6 +2050,8 @@ function copyEditedState(target, source, sourceComplete, deletedKeys) {
   target.setTagData(source.getTagData());
   const merged = sourceComplete ? source.getProperties() : { ...target.getProperties(), ...source.getProperties() };
   for (const key of deletedKeys) delete merged[key];
+  const atomNames = mp4FreeformAtomNames(Object.keys(merged));
+  if (atomNames.length > 0) merged[MP4_ITEM_NAMES_KEY] = atomNames;
   target.setProperties(merged);
   copyExtraState(target, source, sourceComplete);
 }
@@ -1980,6 +2087,8 @@ var init_save_reconstruct = __esm({
     init_write();
     init_embind_adapter();
     init_extra_state_registry();
+    init_properties();
+    init_mp4_item_names();
   }
 });
 
@@ -2248,6 +2357,137 @@ 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;
+  return bitrateIndex !== 0 && bitrateIndex !== 15 && sampleRateIndex !== 3;
+}
+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 init_metadata_extent = __esm({
+  "src/taglib/metadata-extent.ts"() {
+    "use strict";
+  }
+});
+
 // src/taglib/load-audio-data.ts
 async function loadAudioData(input, opts) {
   if (opts.partial && typeof File !== "undefined" && input instanceof File) {
@@ -2256,12 +2496,20 @@ async function loadAudioData(input, opts) {
     if (input.size <= headerSize + footerSize) {
       return { data: await readFileData(input), isPartiallyLoaded: false };
     }
-    const header = await input.slice(0, headerSize).arrayBuffer();
+    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 = await input.slice(footerStart).arrayBuffer();
+    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(new Uint8Array(header), 0);
-    combined.set(new Uint8Array(footer), header.byteLength);
+    combined.set(header, 0);
+    combined.set(footer, header.byteLength);
     return { data: combined, isPartiallyLoaded: true };
   }
   if (opts.partial && typeof input === "string") {
@@ -2272,7 +2520,9 @@ async function loadAudioData(input, opts) {
         opts.maxHeaderSize,
         opts.maxFooterSize
       );
-      return { data, isPartiallyLoaded: true };
+      if (metadataFitsInHeader(data, opts.maxHeaderSize) && trailerFitsInFooter(data, opts.maxFooterSize)) {
+        return { data, isPartiallyLoaded: true };
+      }
     }
     return { data: await readFileData(input), isPartiallyLoaded: false };
   }
@@ -2282,14 +2532,29 @@ 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 parseNumeric(value) {
-  const parsed = Number.parseInt(value, 10);
+// src/utils/mirror-fields.ts
+function parseLeadingInt(raw) {
+  const parsed = Number.parseInt(raw, 10);
   return Number.isNaN(parsed) ? void 0 : parsed;
 }
+var MIRROR_FIELDS, DATE_MIRROR, TRACK_MIRROR;
+var init_mirror_fields = __esm({
+  "src/utils/mirror-fields.ts"() {
+    "use strict";
+    MIRROR_FIELDS = [
+      { raw: "date", numeric: "year" },
+      { raw: "trackNumber", numeric: "track" }
+    ];
+    DATE_MIRROR = MIRROR_FIELDS[0];
+    TRACK_MIRROR = MIRROR_FIELDS[1];
+  }
+});
+
+// src/utils/tag-mapping.ts
 function readExtendedTag(audioFile) {
   const tag = mapPropertiesToExtendedTag(audioFile.properties());
   const pictures = audioFile.getPictures();
@@ -2314,21 +2579,35 @@ function mapPropertiesToExtendedTag(props) {
     const values = props[propKey];
     if (!values || values.length === 0) continue;
     if (tagField === "year" || tagField === "track") {
-      const num = parseNumeric(values[0]);
+      const num = parseLeadingInt(values[0]);
       if (num !== void 0) tag[tagField] = num;
       if (propKey === "date") {
         tag.date = values.length === 1 ? values[0] : values;
       }
+      if (propKey === "trackNumber") {
+        tag.trackNumber = values.length === 1 ? values[0] : values;
+      }
     } else {
       tag[tagField] = values;
     }
   }
+  for (const [propKey, totalField] of [
+    ["trackNumber", "totalTracks"],
+    ["discNumber", "totalDiscs"]
+  ]) {
+    if (tag[totalField] !== void 0) continue;
+    const raw = props[propKey]?.[0];
+    const slash = raw?.indexOf("/") ?? -1;
+    if (raw === void 0 || slash === -1) continue;
+    const total = parseLeadingInt(raw.slice(slash + 1));
+    if (total !== void 0) tag[totalField] = total;
+  }
   for (const [key, values] of Object.entries(props)) {
     if (BASIC_PROPERTY_KEYS[key]) continue;
     if (!values || values.length === 0) continue;
     const camelKey = fromTagLibKey(key);
     if (NUMERIC_FIELDS.has(camelKey)) {
-      const num = parseNumeric(values[0]);
+      const num = parseLeadingInt(values[0]);
       if (num !== void 0) tag[camelKey] = num;
     } else if (camelKey === "compilation") {
       tag[camelKey] = values[0] === "1";
@@ -2341,8 +2620,29 @@ function mapPropertiesToExtendedTag(props) {
 function mergeTagUpdates(file, tags) {
   const currentProps = file.properties();
   const newProps = normalizeTagInput(tags);
+  reconcilePairFields(currentProps, newProps, tags);
   file.setProperties({ ...currentProps, ...newProps });
 }
+function reconcilePairFields(currentProps, newProps, input) {
+  const pairs = [
+    ["trackNumber", "totalTracks", "track"],
+    ["discNumber", "totalDiscs", "discNumber"]
+  ];
+  for (const [rawKey, totalKey, numericKey] of pairs) {
+    const incoming = newProps[rawKey]?.[0];
+    if (incoming?.includes("/")) {
+      newProps[totalKey] = [];
+      continue;
+    }
+    const numericOnly = input[numericKey] !== void 0 && input[rawKey] === void 0;
+    if (!numericOnly || incoming === void 0) continue;
+    const existing = currentProps[rawKey]?.[0];
+    const slash = existing?.indexOf("/") ?? -1;
+    if (existing !== void 0 && slash !== -1) {
+      newProps[rawKey] = [`${incoming}${existing.slice(slash)}`];
+    }
+  }
+}
 function normalizeTagInput(input) {
   const props = {};
   for (const field of [
@@ -2365,6 +2665,9 @@ function normalizeTagInput(input) {
   if (input.track !== void 0) {
     props.trackNumber = [String(input.track)];
   }
+  if (input.trackNumber !== void 0) {
+    props.trackNumber = Array.isArray(input.trackNumber) ? input.trackNumber : [input.trackNumber];
+  }
   for (const [field, val] of Object.entries(input)) {
     if (BASIC_FIELDS.has(field) || val === void 0) continue;
     if (field === "compilation") {
@@ -2377,6 +2680,12 @@ function normalizeTagInput(input) {
       props[field] = val;
     }
   }
+  for (const [rawField, totalField] of [
+    ["trackNumber", "totalTracks"],
+    ["discNumber", "totalDiscs"]
+  ]) {
+    if (props[rawField]?.[0]?.includes("/")) delete props[totalField];
+  }
   return props;
 }
 var BASIC_PROPERTY_KEYS, BASIC_FIELDS, NUMERIC_FIELDS;
@@ -2384,6 +2693,7 @@ var init_tag_mapping = __esm({
   "src/utils/tag-mapping.ts"() {
     "use strict";
     init_properties();
+    init_mirror_fields();
     BASIC_PROPERTY_KEYS = {
       title: "title",
       artist: "artist",
@@ -2401,7 +2711,8 @@ var init_tag_mapping = __esm({
       "genre",
       "year",
       "date",
-      "track"
+      "track",
+      "trackNumber"
     ]);
     NUMERIC_FIELDS = /* @__PURE__ */ new Set([
       "year",
@@ -2419,7 +2730,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = "1.5.3";
+    VERSION = "1.6.1";
   }
 });
 
@@ -3101,8 +3412,9 @@ var Tags = {
   InvolvedPeople: "involvedPeople",
   Encoding: "encoding"
 };
+var VALID_TAG_NAMES = new Set(Object.values(Tags));
 function isValidTagName(name) {
-  return Object.values(Tags).includes(name);
+  return VALID_TAG_NAMES.has(name);
 }
 function getAllTagNames() {
   return Object.values(Tags);