@haoduo-icon/fluent 1.0.0

package/pkg-index.js

@@ -0,0 +1,773 @@
+// node_modules/min-mphash/dist/index.js
+function _define_property(obj, key, value) {
+  if (key in obj)
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  else
+    obj[key] = value;
+  return obj;
+}
+function readVarInt(buffer, offset) {
+  let val = 0;
+  let shift = 0;
+  let bytes = 0;
+  while (true) {
+    const b = buffer[offset + bytes];
+    val |= (127 & b) << shift;
+    bytes++;
+    if ((128 & b) === 0)
+      break;
+    shift += 7;
+  }
+  return {
+    value: val,
+    bytes
+  };
+}
+var CBOR = {
+  encodeInt(val, buffer) {
+    const major = 0;
+    if (val < 24)
+      buffer.push(major | val);
+    else if (val <= 255)
+      buffer.push(24 | major, val);
+    else if (val <= 65535)
+      buffer.push(25 | major, val >> 8, 255 & val);
+    else
+      buffer.push(26 | major, val >>> 24 & 255, val >>> 16 & 255, val >>> 8 & 255, 255 & val);
+  },
+  encodeBytes(bytes, buffer) {
+    const major = 64;
+    const len = bytes.byteLength;
+    if (len < 24)
+      buffer.push(major | len);
+    else if (len <= 255)
+      buffer.push(24 | major, len);
+    else if (len <= 65535)
+      buffer.push(25 | major, len >> 8, 255 & len);
+    else
+      buffer.push(26 | major, len >>> 24 & 255, len >>> 16 & 255, len >>> 8 & 255, 255 & len);
+    for (let i = 0;i < len; i++)
+      buffer.push(bytes[i]);
+  },
+  encodeNull(buffer) {
+    buffer.push(246);
+  },
+  encodeArrayHead(len, buffer) {
+    const major = 128;
+    if (len < 24)
+      buffer.push(major | len);
+  },
+  decode(view, offsetRef) {
+    const byte = view.getUint8(offsetRef.current++);
+    const major = 224 & byte;
+    const additional = 31 & byte;
+    let val = 0;
+    if (additional < 24)
+      val = additional;
+    else if (additional === 24) {
+      val = view.getUint8(offsetRef.current);
+      offsetRef.current += 1;
+    } else if (additional === 25) {
+      val = view.getUint16(offsetRef.current, false);
+      offsetRef.current += 2;
+    } else if (additional === 26) {
+      val = view.getUint32(offsetRef.current, false);
+      offsetRef.current += 4;
+    } else
+      throw new Error("Unsupported CBOR size");
+    if (major === 0)
+      return val;
+    if (major === 64) {
+      const len = val;
+      const buf = new Uint8Array(view.buffer.slice(view.byteOffset + offsetRef.current, view.byteOffset + offsetRef.current + len));
+      offsetRef.current += len;
+      return buf;
+    }
+    if (major === 128) {
+      const len = val;
+      const arr = [];
+      for (let i = 0;i < len; i++)
+        arr.push(CBOR.decode(view, offsetRef));
+      return arr;
+    }
+    if (byte === 246)
+      return null;
+    throw new Error(`Unknown CBOR type: ${byte.toString(16)}`);
+  }
+};
+var INT_TO_MODE = [
+  "none",
+  "4",
+  "8",
+  "16",
+  "32",
+  "2"
+];
+function dictFromCBOR(bin) {
+  const view = new DataView(bin.buffer, bin.byteOffset, bin.byteLength);
+  const offsetRef = {
+    current: 0
+  };
+  const arr = CBOR.decode(view, offsetRef);
+  if (!Array.isArray(arr) || arr.length < 7)
+    throw new Error("Invalid CBOR format");
+  const [n, m, seed0, bucketSizes, seedStream, modeInt, fpRaw, seedZeroBitmap, hashSeed] = arr;
+  const validationMode = INT_TO_MODE[modeInt] || "none";
+  let fingerprints;
+  if (fpRaw && validationMode !== "none") {
+    if (validationMode === "2" || validationMode === "4" || validationMode === "8")
+      fingerprints = fpRaw;
+    else if (validationMode === "16")
+      fingerprints = new Uint16Array(fpRaw.buffer, fpRaw.byteOffset, fpRaw.byteLength / 2);
+    else if (validationMode === "32")
+      fingerprints = new Uint32Array(fpRaw.buffer, fpRaw.byteOffset, fpRaw.byteLength / 4);
+  }
+  return {
+    n,
+    m,
+    seed0,
+    hashSeed: hashSeed || 0,
+    bucketSizes,
+    seedStream,
+    validationMode,
+    fingerprints,
+    seedZeroBitmap: seedZeroBitmap || undefined
+  };
+}
+async function decompressIBinary(data) {
+  const stream = new Blob([
+    data
+  ]).stream().pipeThrough(new DecompressionStream("gzip"));
+  return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+class BitReader {
+  read(bits) {
+    let value = 0;
+    for (let i = 0;i < bits; i++) {
+      if (this.byteOffset >= this.buffer.length)
+        return 0;
+      const bit = this.buffer[this.byteOffset] >> this.bitOffset & 1;
+      value |= bit << i;
+      this.bitOffset++;
+      if (this.bitOffset === 8) {
+        this.byteOffset++;
+        this.bitOffset = 0;
+      }
+    }
+    return value;
+  }
+  constructor(buffer) {
+    _define_property(this, "buffer", undefined);
+    _define_property(this, "byteOffset", 0);
+    _define_property(this, "bitOffset", 0);
+    this.buffer = buffer;
+  }
+}
+function readBitsAt(buffer, bitOffset, bitLength) {
+  let value = 0;
+  let currentBit = bitOffset;
+  for (let i = 0;i < bitLength; i++) {
+    const byteIdx = currentBit >>> 3;
+    const bitIdx = 7 & currentBit;
+    if (byteIdx >= buffer.length)
+      return 0;
+    const bit = buffer[byteIdx] >> bitIdx & 1;
+    value |= bit << i;
+    currentBit++;
+  }
+  return value;
+}
+function MinMPHash_define_property(obj, key, value) {
+  if (key in obj)
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  else
+    obj[key] = value;
+  return obj;
+}
+class MinMPHash {
+  static async fromCompressed(data) {
+    const decompressed = await decompressIBinary(data);
+    return new MinMPHash(decompressed);
+  }
+  hash(input) {
+    if (this.n === 0)
+      return -1;
+    const h1 = murmurHash3_32(input, this.hashSeed);
+    const h2 = murmurHash3_32(input, ~this.hashSeed);
+    const h0 = (scramble(h1, this.seed0) ^ h2) >>> 0;
+    const bIdx = Math.floor(h0 / 4294967296 * this.m);
+    const offset = this.offsets[bIdx];
+    const nextOffset = this.offsets[bIdx + 1];
+    const bucketSize = nextOffset - offset;
+    if (bucketSize === 0)
+      return -1;
+    let resultIdx = 0;
+    if (bucketSize === 1)
+      resultIdx = offset;
+    else {
+      const s = this.seeds[bIdx];
+      const h = (scramble(h1, s) ^ h2) >>> 0;
+      resultIdx = offset + h % bucketSize;
+    }
+    if (this.validationMode !== "none" && this.fingerprints) {
+      const fpHash = murmurHash3_32(input, MinMPHash.FP_SEED);
+      if (this.validationMode === "2") {
+        const expectedFp2 = 3 & fpHash;
+        const byteIdx = resultIdx >>> 2;
+        const shift = (3 & resultIdx) << 1;
+        if ((this.fingerprints[byteIdx] >>> shift & 3) !== expectedFp2)
+          return -1;
+      } else if (this.validationMode === "4") {
+        const expectedFp4 = 15 & fpHash;
+        const byteIdx = resultIdx >>> 1;
+        const storedByte = this.fingerprints[byteIdx];
+        const storedFp4 = (1 & resultIdx) === 0 ? 15 & storedByte : storedByte >>> 4 & 15;
+        if (storedFp4 !== expectedFp4)
+          return -1;
+      } else if (this.validationMode === "8") {
+        if (this.fingerprints[resultIdx] !== (255 & fpHash))
+          return -1;
+      } else if (this.validationMode === "16") {
+        if (this.fingerprints[resultIdx] !== (65535 & fpHash))
+          return -1;
+      } else if (this.fingerprints[resultIdx] !== fpHash >>> 0)
+        return -1;
+    }
+    return resultIdx;
+  }
+  constructor(dict) {
+    MinMPHash_define_property(this, "n", undefined);
+    MinMPHash_define_property(this, "m", undefined);
+    MinMPHash_define_property(this, "seed0", undefined);
+    MinMPHash_define_property(this, "hashSeed", undefined);
+    MinMPHash_define_property(this, "offsets", undefined);
+    MinMPHash_define_property(this, "seeds", undefined);
+    MinMPHash_define_property(this, "validationMode", undefined);
+    MinMPHash_define_property(this, "fingerprints", null);
+    if (dict instanceof Uint8Array)
+      dict = dictFromCBOR(dict);
+    this.n = dict.n;
+    this.m = dict.m;
+    this.seed0 = dict.seed0;
+    this.hashSeed = dict.hashSeed || 0;
+    this.validationMode = dict.validationMode || "none";
+    if (this.n === 0) {
+      this.offsets = new Uint32Array(0);
+      this.seeds = new Int32Array(0);
+      return;
+    }
+    this.offsets = new Uint32Array(this.m + 1);
+    let currentOffset = 0;
+    for (let i = 0;i < this.m; i++) {
+      this.offsets[i] = currentOffset;
+      const byte = dict.bucketSizes[i >>> 1];
+      const len = 1 & i ? byte >>> 4 : 15 & byte;
+      currentOffset += len;
+    }
+    this.offsets[this.m] = currentOffset;
+    this.seeds = new Int32Array(this.m);
+    let ptr = 0;
+    const buf = dict.seedStream;
+    const bitmap = dict.seedZeroBitmap;
+    for (let i = 0;i < this.m; i++) {
+      let isZero = false;
+      if (bitmap) {
+        if ((bitmap[i >>> 3] & 1 << (7 & i)) !== 0)
+          isZero = true;
+      }
+      if (isZero)
+        this.seeds[i] = 0;
+      else {
+        let result = 0;
+        let shift = 0;
+        while (true) {
+          const byte = buf[ptr++];
+          result |= (127 & byte) << shift;
+          if ((128 & byte) === 0)
+            break;
+          shift += 7;
+        }
+        this.seeds[i] = result;
+      }
+    }
+    if (this.validationMode !== "none" && dict.fingerprints) {
+      const raw = dict.fingerprints;
+      if (this.validationMode === "2" || this.validationMode === "4" || this.validationMode === "8")
+        this.fingerprints = raw instanceof Uint8Array ? raw : new Uint8Array(raw);
+      else if (this.validationMode === "16")
+        this.fingerprints = raw instanceof Uint16Array ? raw : new Uint16Array(raw);
+      else
+        this.fingerprints = raw instanceof Uint32Array ? raw : new Uint32Array(raw);
+    }
+  }
+}
+MinMPHash_define_property(MinMPHash, "FP_SEED", 305441741);
+function scramble(k, seed) {
+  k ^= seed;
+  k = Math.imul(k, 2246822507);
+  k ^= k >>> 13;
+  k = Math.imul(k, 3266489909);
+  k ^= k >>> 16;
+  return k >>> 0;
+}
+function murmurHash3_32(key, seed) {
+  let h1 = seed;
+  const c1 = 3432918353;
+  const c2 = 461845907;
+  for (let i = 0;i < key.length; i++) {
+    let k1 = key.charCodeAt(i);
+    k1 = Math.imul(k1, c1);
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = Math.imul(k1, c2);
+    h1 ^= k1;
+    h1 = h1 << 13 | h1 >>> 19;
+    h1 = Math.imul(h1, 5) + 3864292196;
+  }
+  h1 ^= key.length;
+  h1 ^= h1 >>> 16;
+  h1 = Math.imul(h1, 2246822507);
+  h1 ^= h1 >>> 13;
+  h1 = Math.imul(h1, 3266489909);
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+}
+function MinMPLookup_define_property(obj, key, value) {
+  if (key in obj)
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  else
+    obj[key] = value;
+  return obj;
+}
+function deserializeLookupDict(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  let offset = 0;
+  const decoder = new TextDecoder;
+  const readU32 = () => {
+    const val = view.getUint32(offset, false);
+    offset += 4;
+    return val;
+  };
+  const mphLen = readU32();
+  const mmpHashDictBin = data.subarray(offset, offset + mphLen);
+  offset += mphLen;
+  const keysCount = readU32();
+  const keys = [];
+  for (let i = 0;i < keysCount; i++) {
+    const kLen = readU32();
+    const kBytes = data.subarray(offset, offset + kLen);
+    offset += kLen;
+    keys.push(decoder.decode(kBytes));
+  }
+  const sectionLen = readU32();
+  if (sectionLen === 4294967295) {
+    const bitsPerKey = readU32();
+    const dataLen = readU32();
+    const valueToKeyIndexes = data.subarray(offset, offset + dataLen);
+    offset += dataLen;
+    const colMapLen = readU32();
+    let collisionMap;
+    if (colMapLen > 0) {
+      const colBytes = data.subarray(offset, offset + colMapLen);
+      offset += colMapLen;
+      collisionMap = new Map;
+      let cOffset = 0;
+      const { value: count, bytes: b1 } = readVarInt(colBytes, cOffset);
+      cOffset += b1;
+      let prevHash = 0;
+      for (let i = 0;i < count; i++) {
+        const { value: deltaHash, bytes: b2 } = readVarInt(colBytes, cOffset);
+        cOffset += b2;
+        const h = prevHash + deltaHash;
+        prevHash = h;
+        const { value: kCount, bytes: b3 } = readVarInt(colBytes, cOffset);
+        cOffset += b3;
+        const kIndices = [];
+        let prevKey = 0;
+        for (let j = 0;j < kCount; j++) {
+          const { value: deltaKey, bytes: b4 } = readVarInt(colBytes, cOffset);
+          cOffset += b4;
+          const k = prevKey + deltaKey;
+          prevKey = k;
+          kIndices.push(k);
+        }
+        collisionMap.set(h, kIndices);
+      }
+    }
+    return {
+      mmpHashDictBin,
+      keys,
+      valueToKeyIndexes,
+      bitsPerKey,
+      collisionMap
+    };
+  }
+  {
+    const hashBytesLen = sectionLen;
+    const hashBytes = data.subarray(offset, offset + hashBytesLen);
+    offset += hashBytesLen;
+    const keyToHashes = [];
+    let hOffset = 0;
+    for (let i = 0;i < keysCount; i++) {
+      const { value: count, bytes: b1 } = readVarInt(hashBytes, hOffset);
+      hOffset += b1;
+      if (count === 0) {
+        keyToHashes.push(new Uint32Array(0));
+        continue;
+      }
+      const bits = hashBytes[hOffset];
+      hOffset += 1;
+      const totalBits = bits * count;
+      const packedBytesLen = Math.ceil(totalBits / 8);
+      const packedData = hashBytes.subarray(hOffset, hOffset + packedBytesLen);
+      hOffset += packedBytesLen;
+      const br = new BitReader(packedData);
+      const hashes = new Uint32Array(count);
+      let prev = 0;
+      for (let j = 0;j < count; j++) {
+        const delta = br.read(bits);
+        prev += delta;
+        hashes[j] = prev;
+      }
+      keyToHashes.push(hashes);
+    }
+    return {
+      mmpHashDictBin,
+      keys,
+      keyToHashes
+    };
+  }
+}
+
+class MinMPLookup {
+  static async fromCompressed(data) {
+    const decompressed = await decompressIBinary(data);
+    const dict = deserializeLookupDict(decompressed);
+    return new MinMPLookup(dict);
+  }
+  static fromBinary(data) {
+    const dict = deserializeLookupDict(data);
+    return new MinMPLookup(dict);
+  }
+  buildInvertedIndex() {
+    if (!this.dict.keyToHashes)
+      return;
+    const n = this.mph.n;
+    this._invertedIndex = Array.from({
+      length: n
+    }, () => []);
+    for (let i = 0;i < this.dict.keys.length; i++) {
+      const hashes = this.dict.keyToHashes[i];
+      for (let j = 0;j < hashes.length; j++) {
+        const h = hashes[j];
+        if (h < n)
+          this._invertedIndex[h].push(i);
+      }
+    }
+  }
+  query(value) {
+    if (this.dict.valueToKeyIndexes && this.dict.bitsPerKey) {
+      const h = this.mph.hash(value);
+      if (h < 0 || h >= this.mph.n)
+        return null;
+      const keyIdx = readBitsAt(this.dict.valueToKeyIndexes, h * this.dict.bitsPerKey, this.dict.bitsPerKey);
+      if (keyIdx === this.dict.keys.length) {
+        if (this.dict.collisionMap && this.dict.collisionMap.has(h)) {
+          const indices = this.dict.collisionMap.get(h);
+          return indices.length > 0 ? this.dict.keys[indices[0]] : null;
+        }
+        return null;
+      }
+      if (keyIdx >= this.dict.keys.length)
+        return null;
+      return this.dict.keys[keyIdx];
+    }
+    const keys = this.queryAll(value);
+    return keys && keys.length > 0 ? keys[0] : null;
+  }
+  queryAll(value) {
+    if (this.dict.valueToKeyIndexes && this.dict.bitsPerKey) {
+      const h = this.mph.hash(value);
+      if (h < 0 || h >= this.mph.n)
+        return null;
+      const keyIdx = readBitsAt(this.dict.valueToKeyIndexes, h * this.dict.bitsPerKey, this.dict.bitsPerKey);
+      if (keyIdx === this.dict.keys.length) {
+        if (this.dict.collisionMap && this.dict.collisionMap.has(h)) {
+          const indices = this.dict.collisionMap.get(h);
+          return indices.map((i) => this.dict.keys[i]);
+        }
+        return null;
+      }
+      if (keyIdx >= this.dict.keys.length)
+        return null;
+      return [
+        this.dict.keys[keyIdx]
+      ];
+    }
+    const idx = this.mph.hash(value);
+    if (idx < 0 || !this._invertedIndex)
+      return null;
+    if (idx >= this._invertedIndex.length)
+      return null;
+    const keyIndices = this._invertedIndex[idx];
+    if (keyIndices.length === 0)
+      return null;
+    const results = [];
+    for (const keyIdx of keyIndices)
+      results.push(this.dict.keys[keyIdx]);
+    return results.length > 0 ? results : null;
+  }
+  keys() {
+    return this.dict.keys;
+  }
+  constructor(dict) {
+    MinMPLookup_define_property(this, "mph", undefined);
+    MinMPLookup_define_property(this, "dict", undefined);
+    MinMPLookup_define_property(this, "_invertedIndex", null);
+    if (dict instanceof Uint8Array)
+      dict = deserializeLookupDict(dict);
+    this.dict = dict;
+    this.mph = new MinMPHash(dict.mmpHashDictBin);
+    if (dict.keyToHashes)
+      this.buildInvertedIndex();
+  }
+}
+
+// scripts/core.ts
+var GLOBAL_REGISTRY_KEY = "__HD_ICONS_REGISTRY__";
+function getRegistry() {
+  if (typeof window !== "undefined") {
+    if (!window[GLOBAL_REGISTRY_KEY]) {
+      window[GLOBAL_REGISTRY_KEY] = new Map;
+    }
+    return window[GLOBAL_REGISTRY_KEY];
+  } else {
+    if (!globalThis[GLOBAL_REGISTRY_KEY]) {
+      globalThis[GLOBAL_REGISTRY_KEY] = new Map;
+    }
+    return globalThis[GLOBAL_REGISTRY_KEY];
+  }
+}
+function register(pkg, data) {
+  const registry = getRegistry();
+  if (!registry.has(pkg)) {
+    registry.set(pkg, {
+      lookupData: data.lookup,
+      baseUrl: data.baseUrl,
+      chunks: data.chunks
+    });
+    if (typeof window !== "undefined") {
+      window.dispatchEvent(new CustomEvent("hd-icon-registered", { detail: { pkg } }));
+    }
+  }
+}
+
+class HdIcon extends HTMLElement {
+  static get observedAttributes() {
+    return ["icon"];
+  }
+  _use;
+  constructor() {
+    super();
+    this.innerHTML = `<svg width="1em" height="1em" fill="currentColor" style="display: inline-block; vertical-align: middle; overflow: hidden;"><use width="100%" height="100%"></use></svg>`;
+    this._use = this.querySelector("use");
+  }
+  attributeChangedCallback(name, oldValue, newValue) {
+    if (name === "icon" && newValue !== oldValue) {
+      this.render();
+    }
+  }
+  connectedCallback() {
+    this.render();
+    if (typeof window !== "undefined") {
+      window.addEventListener("hd-icon-registered", this.handleRegistration);
+    }
+  }
+  disconnectedCallback() {
+    if (typeof window !== "undefined") {
+      window.removeEventListener("hd-icon-registered", this.handleRegistration);
+    }
+  }
+  handleRegistration = (e) => {
+    const detail = e.detail;
+    const iconKey = this.getAttribute("icon");
+    if (iconKey && iconKey.startsWith(detail.pkg + ":")) {
+      this.render();
+    }
+  };
+  async render() {
+    const iconKey = this.getAttribute("icon");
+    if (!iconKey)
+      return;
+    const [pkg, name] = iconKey.split(":");
+    if (!pkg || !name) {
+      console.warn(`[hd-icon] Invalid icon format: "${iconKey}". Expected "pkg:name".`);
+      return;
+    }
+    const registry = getRegistry().get(pkg);
+    if (!registry) {
+      return;
+    }
+    if (!registry._lookupInstance) {
+      let lookupData = registry.lookupData;
+      if (typeof lookupData === "string") {
+        const binaryString = atob(lookupData);
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0;i < binaryString.length; i++) {
+          bytes[i] = binaryString.charCodeAt(i);
+        }
+        lookupData = bytes;
+        registry.lookupData = lookupData;
+      }
+      registry._lookupInstance = new MinMPLookup(lookupData);
+    }
+    const chunkFile = registry._lookupInstance.query(name);
+    if (!chunkFile) {
+      console.warn(`[hd-icon] Icon "${name}" not found in package "${pkg}".`);
+      return;
+    }
+    const symbolId = `hd-icon-${pkg}-${name}`;
+    let url = chunkFile;
+    if (registry.chunks && registry.chunks[chunkFile]) {
+      url = registry.chunks[chunkFile];
+    } else if (registry.baseUrl) {
+      try {
+        url = new URL(chunkFile, registry.baseUrl).href;
+      } catch (e) {
+        console.warn(`[hd-icon] Failed to resolve icon URL: ${chunkFile} relative to ${registry.baseUrl}`, e);
+      }
+    }
+    this._use.setAttribute("href", `${url}#${symbolId}`);
+  }
+}
+if (typeof customElements !== "undefined" && !customElements.get("hd-icon")) {
+  customElements.define("hd-icon", HdIcon);
+}
+if (typeof window !== "undefined") {
+  window.IconPkg = { register, HdIcon };
+}
+
+// iconpkg/fluent/src-index.ts
+var lookup = "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";
+var chunks = {
+  "fluent-01.svg": new URL("./fluent-01.svg", import.meta.url).href,
+  "fluent-02.svg": new URL("./fluent-02.svg", import.meta.url).href,
+  "fluent-03.svg": new URL("./fluent-03.svg", import.meta.url).href,
+  "fluent-04.svg": new URL("./fluent-04.svg", import.meta.url).href,
+  "fluent-05.svg": new URL("./fluent-05.svg", import.meta.url).href,
+  "fluent-06.svg": new URL("./fluent-06.svg", import.meta.url).href,
+  "fluent-07.svg": new URL("./fluent-07.svg", import.meta.url).href,
+  "fluent-08.svg": new URL("./fluent-08.svg", import.meta.url).href,
+  "fluent-09.svg": new URL("./fluent-09.svg", import.meta.url).href,
+  "fluent-10.svg": new URL("./fluent-10.svg", import.meta.url).href,
+  "fluent-11.svg": new URL("./fluent-11.svg", import.meta.url).href,
+  "fluent-12.svg": new URL("./fluent-12.svg", import.meta.url).href,
+  "fluent-13.svg": new URL("./fluent-13.svg", import.meta.url).href,
+  "fluent-14.svg": new URL("./fluent-14.svg", import.meta.url).href,
+  "fluent-15.svg": new URL("./fluent-15.svg", import.meta.url).href,
+  "fluent-16.svg": new URL("./fluent-16.svg", import.meta.url).href,
+  "fluent-17.svg": new URL("./fluent-17.svg", import.meta.url).href,
+  "fluent-18.svg": new URL("./fluent-18.svg", import.meta.url).href,
+  "fluent-19.svg": new URL("./fluent-19.svg", import.meta.url).href,
+  "fluent-20.svg": new URL("./fluent-20.svg", import.meta.url).href,
+  "fluent-21.svg": new URL("./fluent-21.svg", import.meta.url).href,
+  "fluent-22.svg": new URL("./fluent-22.svg", import.meta.url).href,
+  "fluent-23.svg": new URL("./fluent-23.svg", import.meta.url).href,
+  "fluent-24.svg": new URL("./fluent-24.svg", import.meta.url).href,
+  "fluent-25.svg": new URL("./fluent-25.svg", import.meta.url).href,
+  "fluent-26.svg": new URL("./fluent-26.svg", import.meta.url).href,
+  "fluent-27.svg": new URL("./fluent-27.svg", import.meta.url).href,
+  "fluent-28.svg": new URL("./fluent-28.svg", import.meta.url).href,
+  "fluent-29.svg": new URL("./fluent-29.svg", import.meta.url).href,
+  "fluent-30.svg": new URL("./fluent-30.svg", import.meta.url).href,
+  "fluent-31.svg": new URL("./fluent-31.svg", import.meta.url).href,
+  "fluent-32.svg": new URL("./fluent-32.svg", import.meta.url).href,
+  "fluent-33.svg": new URL("./fluent-33.svg", import.meta.url).href,
+  "fluent-34.svg": new URL("./fluent-34.svg", import.meta.url).href,
+  "fluent-35.svg": new URL("./fluent-35.svg", import.meta.url).href,
+  "fluent-36.svg": new URL("./fluent-36.svg", import.meta.url).href,
+  "fluent-37.svg": new URL("./fluent-37.svg", import.meta.url).href,
+  "fluent-38.svg": new URL("./fluent-38.svg", import.meta.url).href,
+  "fluent-39.svg": new URL("./fluent-39.svg", import.meta.url).href,
+  "fluent-40.svg": new URL("./fluent-40.svg", import.meta.url).href,
+  "fluent-41.svg": new URL("./fluent-41.svg", import.meta.url).href,
+  "fluent-42.svg": new URL("./fluent-42.svg", import.meta.url).href,
+  "fluent-43.svg": new URL("./fluent-43.svg", import.meta.url).href,
+  "fluent-44.svg": new URL("./fluent-44.svg", import.meta.url).href,
+  "fluent-45.svg": new URL("./fluent-45.svg", import.meta.url).href,
+  "fluent-46.svg": new URL("./fluent-46.svg", import.meta.url).href,
+  "fluent-47.svg": new URL("./fluent-47.svg", import.meta.url).href,
+  "fluent-48.svg": new URL("./fluent-48.svg", import.meta.url).href,
+  "fluent-49.svg": new URL("./fluent-49.svg", import.meta.url).href,
+  "fluent-50.svg": new URL("./fluent-50.svg", import.meta.url).href,
+  "fluent-51.svg": new URL("./fluent-51.svg", import.meta.url).href,
+  "fluent-52.svg": new URL("./fluent-52.svg", import.meta.url).href,
+  "fluent-53.svg": new URL("./fluent-53.svg", import.meta.url).href,
+  "fluent-54.svg": new URL("./fluent-54.svg", import.meta.url).href,
+  "fluent-55.svg": new URL("./fluent-55.svg", import.meta.url).href,
+  "fluent-56.svg": new URL("./fluent-56.svg", import.meta.url).href,
+  "fluent-57.svg": new URL("./fluent-57.svg", import.meta.url).href,
+  "fluent-58.svg": new URL("./fluent-58.svg", import.meta.url).href,
+  "fluent-59.svg": new URL("./fluent-59.svg", import.meta.url).href,
+  "fluent-60.svg": new URL("./fluent-60.svg", import.meta.url).href,
+  "fluent-61.svg": new URL("./fluent-61.svg", import.meta.url).href,
+  "fluent-62.svg": new URL("./fluent-62.svg", import.meta.url).href,
+  "fluent-63.svg": new URL("./fluent-63.svg", import.meta.url).href,
+  "fluent-64.svg": new URL("./fluent-64.svg", import.meta.url).href,
+  "fluent-65.svg": new URL("./fluent-65.svg", import.meta.url).href,
+  "fluent-66.svg": new URL("./fluent-66.svg", import.meta.url).href,
+  "fluent-67.svg": new URL("./fluent-67.svg", import.meta.url).href,
+  "fluent-68.svg": new URL("./fluent-68.svg", import.meta.url).href,
+  "fluent-69.svg": new URL("./fluent-69.svg", import.meta.url).href,
+  "fluent-70.svg": new URL("./fluent-70.svg", import.meta.url).href,
+  "fluent-71.svg": new URL("./fluent-71.svg", import.meta.url).href,
+  "fluent-72.svg": new URL("./fluent-72.svg", import.meta.url).href,
+  "fluent-73.svg": new URL("./fluent-73.svg", import.meta.url).href,
+  "fluent-74.svg": new URL("./fluent-74.svg", import.meta.url).href,
+  "fluent-75.svg": new URL("./fluent-75.svg", import.meta.url).href,
+  "fluent-76.svg": new URL("./fluent-76.svg", import.meta.url).href,
+  "fluent-77.svg": new URL("./fluent-77.svg", import.meta.url).href,
+  "fluent-78.svg": new URL("./fluent-78.svg", import.meta.url).href,
+  "fluent-79.svg": new URL("./fluent-79.svg", import.meta.url).href,
+  "fluent-80.svg": new URL("./fluent-80.svg", import.meta.url).href,
+  "fluent-81.svg": new URL("./fluent-81.svg", import.meta.url).href,
+  "fluent-82.svg": new URL("./fluent-82.svg", import.meta.url).href,
+  "fluent-83.svg": new URL("./fluent-83.svg", import.meta.url).href,
+  "fluent-84.svg": new URL("./fluent-84.svg", import.meta.url).href,
+  "fluent-85.svg": new URL("./fluent-85.svg", import.meta.url).href,
+  "fluent-86.svg": new URL("./fluent-86.svg", import.meta.url).href,
+  "fluent-87.svg": new URL("./fluent-87.svg", import.meta.url).href,
+  "fluent-88.svg": new URL("./fluent-88.svg", import.meta.url).href,
+  "fluent-89.svg": new URL("./fluent-89.svg", import.meta.url).href,
+  "fluent-90.svg": new URL("./fluent-90.svg", import.meta.url).href,
+  "fluent-91.svg": new URL("./fluent-91.svg", import.meta.url).href,
+  "fluent-92.svg": new URL("./fluent-92.svg", import.meta.url).href,
+  "fluent-93.svg": new URL("./fluent-93.svg", import.meta.url).href,
+  "fluent-94.svg": new URL("./fluent-94.svg", import.meta.url).href,
+  "fluent-95.svg": new URL("./fluent-95.svg", import.meta.url).href,
+  "fluent-96.svg": new URL("./fluent-96.svg", import.meta.url).href,
+  "fluent-97.svg": new URL("./fluent-97.svg", import.meta.url).href,
+  "fluent-98.svg": new URL("./fluent-98.svg", import.meta.url).href
+};
+register("fluent", {
+  lookup,
+  chunks,
+  baseUrl: import.meta.url
+});
+export {
+  HdIcon
+};