iconfont-preview-cli 1.0.0

package/components/index.mjs

@@ -0,0 +1,1233 @@
+import { defineComponent as J, createVNode as k, computed as pe, ref as N, onMounted as Ae, createElementBlock as Ce, openBlock as me, renderSlot as Ee, unref as ye } from "vue";
+import { ElMessage as Me } from "element-plus";
+function I(t) {
+  return Array.isArray ? Array.isArray(t) : oe(t) === "[object Array]";
+}
+function Fe(t) {
+  if (typeof t == "string")
+    return t;
+  let e = t + "";
+  return e == "0" && 1 / t == -1 / 0 ? "-0" : e;
+}
+function Be(t) {
+  return t == null ? "" : Fe(t);
+}
+function D(t) {
+  return typeof t == "string";
+}
+function ce(t) {
+  return typeof t == "number";
+}
+function De(t) {
+  return t === !0 || t === !1 || Ie(t) && oe(t) == "[object Boolean]";
+}
+function ue(t) {
+  return typeof t == "object";
+}
+function Ie(t) {
+  return ue(t) && t !== null;
+}
+function E(t) {
+  return t != null;
+}
+function W(t) {
+  return !t.trim().length;
+}
+function oe(t) {
+  return t == null ? t === void 0 ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(t);
+}
+const _e = "Incorrect 'index' type", xe = (t) => `Invalid value for key ${t}`, we = (t) => `Pattern length exceeds max of ${t}.`, Se = (t) => `Missing ${t} property in key`, be = (t) => `Property 'weight' in key '${t}' must be a positive integer`, ee = Object.prototype.hasOwnProperty;
+class ve {
+  constructor(e) {
+    this._keys = [], this._keyMap = {};
+    let s = 0;
+    e.forEach((n) => {
+      let r = ae(n);
+      this._keys.push(r), this._keyMap[r.id] = r, s += r.weight;
+    }), this._keys.forEach((n) => {
+      n.weight /= s;
+    });
+  }
+  get(e) {
+    return this._keyMap[e];
+  }
+  keys() {
+    return this._keys;
+  }
+  toJSON() {
+    return JSON.stringify(this._keys);
+  }
+}
+function ae(t) {
+  let e = null, s = null, n = null, r = 1, i = null;
+  if (D(t) || I(t))
+    n = t, e = te(t), s = H(t);
+  else {
+    if (!ee.call(t, "name"))
+      throw new Error(Se("name"));
+    const c = t.name;
+    if (n = c, ee.call(t, "weight") && (r = t.weight, r <= 0))
+      throw new Error(be(c));
+    e = te(c), s = H(c), i = t.getFn;
+  }
+  return { path: e, id: s, weight: r, src: n, getFn: i };
+}
+function te(t) {
+  return I(t) ? t : t.split(".");
+}
+function H(t) {
+  return I(t) ? t.join(".") : t;
+}
+function Re(t, e) {
+  let s = [], n = !1;
+  const r = (i, c, u) => {
+    if (E(i))
+      if (!c[u])
+        s.push(i);
+      else {
+        let o = c[u];
+        const h = i[o];
+        if (!E(h))
+          return;
+        if (u === c.length - 1 && (D(h) || ce(h) || De(h)))
+          s.push(Be(h));
+        else if (I(h)) {
+          n = !0;
+          for (let a = 0, l = h.length; a < l; a += 1)
+            r(h[a], c, u + 1);
+        } else c.length && r(h, c, u + 1);
+      }
+  };
+  return r(t, D(e) ? e.split(".") : e, 0), n ? s : s[0];
+}
+const ke = {
+  // Whether the matches should be included in the result set. When `true`, each record in the result
+  // set will include the indices of the matched characters.
+  // These can consequently be used for highlighting purposes.
+  includeMatches: !1,
+  // When `true`, the matching function will continue to the end of a search pattern even if
+  // a perfect match has already been located in the string.
+  findAllMatches: !1,
+  // Minimum number of characters that must be matched before a result is considered a match
+  minMatchCharLength: 1
+}, Le = {
+  // When `true`, the algorithm continues searching to the end of the input even if a perfect
+  // match is found before the end of the same input.
+  isCaseSensitive: !1,
+  // When `true`, the algorithm will ignore diacritics (accents) in comparisons
+  ignoreDiacritics: !1,
+  // When true, the matching function will continue to the end of a search pattern even if
+  includeScore: !1,
+  // List of properties that will be searched. This also supports nested properties.
+  keys: [],
+  // Whether to sort the result list, by score
+  shouldSort: !0,
+  // Default sort function: sort by ascending score, ascending index
+  sortFn: (t, e) => t.score === e.score ? t.idx < e.idx ? -1 : 1 : t.score < e.score ? -1 : 1
+}, Ne = {
+  // Approximately where in the text is the pattern expected to be found?
+  location: 0,
+  // At what point does the match algorithm give up. A threshold of '0.0' requires a perfect match
+  // (of both letters and location), a threshold of '1.0' would match anything.
+  threshold: 0.6,
+  // Determines how close the match must be to the fuzzy location (specified above).
+  // An exact letter match which is 'distance' characters away from the fuzzy location
+  // would score as a complete mismatch. A distance of '0' requires the match be at
+  // the exact location specified, a threshold of '1000' would require a perfect match
+  // to be within 800 characters of the fuzzy location to be found using a 0.8 threshold.
+  distance: 100
+}, $e = {
+  // When `true`, it enables the use of unix-like search commands
+  useExtendedSearch: !1,
+  // The get function to use when fetching an object's properties.
+  // The default will search nested paths *ie foo.bar.baz*
+  getFn: Re,
+  // When `true`, search will ignore `location` and `distance`, so it won't matter
+  // where in the string the pattern appears.
+  // More info: https://fusejs.io/concepts/scoring-theory.html#fuzziness-score
+  ignoreLocation: !1,
+  // When `true`, the calculation for the relevance score (used for sorting) will
+  // ignore the field-length norm.
+  // More info: https://fusejs.io/concepts/scoring-theory.html#field-length-norm
+  ignoreFieldNorm: !1,
+  // The weight to determine how much field length norm effects scoring.
+  fieldNormWeight: 1
+};
+var f = {
+  ...Le,
+  ...ke,
+  ...Ne,
+  ...$e
+};
+const Oe = /[^ ]+/g;
+function Pe(t = 1, e = 3) {
+  const s = /* @__PURE__ */ new Map(), n = Math.pow(10, e);
+  return {
+    get(r) {
+      const i = r.match(Oe).length;
+      if (s.has(i))
+        return s.get(i);
+      const c = 1 / Math.pow(i, 0.5 * t), u = parseFloat(Math.round(c * n) / n);
+      return s.set(i, u), u;
+    },
+    clear() {
+      s.clear();
+    }
+  };
+}
+class X {
+  constructor({
+    getFn: e = f.getFn,
+    fieldNormWeight: s = f.fieldNormWeight
+  } = {}) {
+    this.norm = Pe(s, 3), this.getFn = e, this.isCreated = !1, this.setIndexRecords();
+  }
+  setSources(e = []) {
+    this.docs = e;
+  }
+  setIndexRecords(e = []) {
+    this.records = e;
+  }
+  setKeys(e = []) {
+    this.keys = e, this._keysMap = {}, e.forEach((s, n) => {
+      this._keysMap[s.id] = n;
+    });
+  }
+  create() {
+    this.isCreated || !this.docs.length || (this.isCreated = !0, D(this.docs[0]) ? this.docs.forEach((e, s) => {
+      this._addString(e, s);
+    }) : this.docs.forEach((e, s) => {
+      this._addObject(e, s);
+    }), this.norm.clear());
+  }
+  // Adds a doc to the end of the index
+  add(e) {
+    const s = this.size();
+    D(e) ? this._addString(e, s) : this._addObject(e, s);
+  }
+  // Removes the doc at the specified index of the index
+  removeAt(e) {
+    this.records.splice(e, 1);
+    for (let s = e, n = this.size(); s < n; s += 1)
+      this.records[s].i -= 1;
+  }
+  getValueForItemAtKeyId(e, s) {
+    return e[this._keysMap[s]];
+  }
+  size() {
+    return this.records.length;
+  }
+  _addString(e, s) {
+    if (!E(e) || W(e))
+      return;
+    let n = {
+      v: e,
+      i: s,
+      n: this.norm.get(e)
+    };
+    this.records.push(n);
+  }
+  _addObject(e, s) {
+    let n = { i: s, $: {} };
+    this.keys.forEach((r, i) => {
+      let c = r.getFn ? r.getFn(e) : this.getFn(e, r.path);
+      if (E(c)) {
+        if (I(c)) {
+          let u = [];
+          const o = [{ nestedArrIndex: -1, value: c }];
+          for (; o.length; ) {
+            const { nestedArrIndex: h, value: a } = o.pop();
+            if (E(a))
+              if (D(a) && !W(a)) {
+                let l = {
+                  v: a,
+                  i: h,
+                  n: this.norm.get(a)
+                };
+                u.push(l);
+              } else I(a) && a.forEach((l, d) => {
+                o.push({
+                  nestedArrIndex: d,
+                  value: l
+                });
+              });
+          }
+          n.$[i] = u;
+        } else if (D(c) && !W(c)) {
+          let u = {
+            v: c,
+            n: this.norm.get(c)
+          };
+          n.$[i] = u;
+        }
+      }
+    }), this.records.push(n);
+  }
+  toJSON() {
+    return {
+      keys: this.keys,
+      records: this.records
+    };
+  }
+}
+function he(t, e, { getFn: s = f.getFn, fieldNormWeight: n = f.fieldNormWeight } = {}) {
+  const r = new X({ getFn: s, fieldNormWeight: n });
+  return r.setKeys(t.map(ae)), r.setSources(e), r.create(), r;
+}
+function Te(t, { getFn: e = f.getFn, fieldNormWeight: s = f.fieldNormWeight } = {}) {
+  const { keys: n, records: r } = t, i = new X({ getFn: e, fieldNormWeight: s });
+  return i.setKeys(n), i.setIndexRecords(r), i;
+}
+function $(t, {
+  errors: e = 0,
+  currentLocation: s = 0,
+  expectedLocation: n = 0,
+  distance: r = f.distance,
+  ignoreLocation: i = f.ignoreLocation
+} = {}) {
+  const c = e / t.length;
+  if (i)
+    return c;
+  const u = Math.abs(n - s);
+  return r ? c + u / r : u ? 1 : c;
+}
+function je(t = [], e = f.minMatchCharLength) {
+  let s = [], n = -1, r = -1, i = 0;
+  for (let c = t.length; i < c; i += 1) {
+    let u = t[i];
+    u && n === -1 ? n = i : !u && n !== -1 && (r = i - 1, r - n + 1 >= e && s.push([n, r]), n = -1);
+  }
+  return t[i - 1] && i - n >= e && s.push([n, i - 1]), s;
+}
+const b = 32;
+function Ke(t, e, s, {
+  location: n = f.location,
+  distance: r = f.distance,
+  threshold: i = f.threshold,
+  findAllMatches: c = f.findAllMatches,
+  minMatchCharLength: u = f.minMatchCharLength,
+  includeMatches: o = f.includeMatches,
+  ignoreLocation: h = f.ignoreLocation
+} = {}) {
+  if (e.length > b)
+    throw new Error(we(b));
+  const a = e.length, l = t.length, d = Math.max(0, Math.min(n, l));
+  let g = i, p = d;
+  const A = u > 1 || o, C = A ? Array(l) : [];
+  let M;
+  for (; (M = t.indexOf(e, p)) > -1; ) {
+    let y = $(e, {
+      currentLocation: M,
+      expectedLocation: d,
+      distance: r,
+      ignoreLocation: h
+    });
+    if (g = Math.min(y, g), p = M + a, A) {
+      let x = 0;
+      for (; x < a; )
+        C[M + x] = 1, x += 1;
+    }
+  }
+  p = -1;
+  let m = [], _ = 1, B = a + l;
+  const T = 1 << a - 1;
+  for (let y = 0; y < a; y += 1) {
+    let x = 0, w = B;
+    for (; x < w; )
+      $(e, {
+        errors: y,
+        currentLocation: d + w,
+        expectedLocation: d,
+        distance: r,
+        ignoreLocation: h
+      }) <= g ? x = w : B = w, w = Math.floor((B - x) / 2 + x);
+    B = w;
+    let Z = Math.max(1, d - w + 1), K = c ? l : Math.min(d + w, l) + a, v = Array(K + 2);
+    v[K + 1] = (1 << y) - 1;
+    for (let F = K; F >= Z; F -= 1) {
+      let L = F - 1, q = s[t.charAt(L)];
+      if (A && (C[L] = +!!q), v[F] = (v[F + 1] << 1 | 1) & q, y && (v[F] |= (m[F + 1] | m[F]) << 1 | 1 | m[F + 1]), v[F] & T && (_ = $(e, {
+        errors: y,
+        currentLocation: L,
+        expectedLocation: d,
+        distance: r,
+        ignoreLocation: h
+      }), _ <= g)) {
+        if (g = _, p = L, p <= d)
+          break;
+        Z = Math.max(1, 2 * d - p);
+      }
+    }
+    if ($(e, {
+      errors: y + 1,
+      currentLocation: d,
+      expectedLocation: d,
+      distance: r,
+      ignoreLocation: h
+    }) > g)
+      break;
+    m = v;
+  }
+  const j = {
+    isMatch: p >= 0,
+    // Count exact matches (those with a score of 0) to be "almost" exact
+    score: Math.max(1e-3, _)
+  };
+  if (A) {
+    const y = je(C, u);
+    y.length ? o && (j.indices = y) : j.isMatch = !1;
+  }
+  return j;
+}
+function We(t) {
+  let e = {};
+  for (let s = 0, n = t.length; s < n; s += 1) {
+    const r = t.charAt(s);
+    e[r] = (e[r] || 0) | 1 << n - s - 1;
+  }
+  return e;
+}
+const O = String.prototype.normalize ? ((t) => t.normalize("NFD").replace(/[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08D3-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C04\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u1885\u1886\u18A9\u1920-\u192B\u1930-\u193B\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ABE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DF9\u1DFB-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F]/g, "")) : ((t) => t);
+class le {
+  constructor(e, {
+    location: s = f.location,
+    threshold: n = f.threshold,
+    distance: r = f.distance,
+    includeMatches: i = f.includeMatches,
+    findAllMatches: c = f.findAllMatches,
+    minMatchCharLength: u = f.minMatchCharLength,
+    isCaseSensitive: o = f.isCaseSensitive,
+    ignoreDiacritics: h = f.ignoreDiacritics,
+    ignoreLocation: a = f.ignoreLocation
+  } = {}) {
+    if (this.options = {
+      location: s,
+      threshold: n,
+      distance: r,
+      includeMatches: i,
+      findAllMatches: c,
+      minMatchCharLength: u,
+      isCaseSensitive: o,
+      ignoreDiacritics: h,
+      ignoreLocation: a
+    }, e = o ? e : e.toLowerCase(), e = h ? O(e) : e, this.pattern = e, this.chunks = [], !this.pattern.length)
+      return;
+    const l = (g, p) => {
+      this.chunks.push({
+        pattern: g,
+        alphabet: We(g),
+        startIndex: p
+      });
+    }, d = this.pattern.length;
+    if (d > b) {
+      let g = 0;
+      const p = d % b, A = d - p;
+      for (; g < A; )
+        l(this.pattern.substr(g, b), g), g += b;
+      if (p) {
+        const C = d - b;
+        l(this.pattern.substr(C), C);
+      }
+    } else
+      l(this.pattern, 0);
+  }
+  searchIn(e) {
+    const { isCaseSensitive: s, ignoreDiacritics: n, includeMatches: r } = this.options;
+    if (e = s ? e : e.toLowerCase(), e = n ? O(e) : e, this.pattern === e) {
+      let A = {
+        isMatch: !0,
+        score: 0
+      };
+      return r && (A.indices = [[0, e.length - 1]]), A;
+    }
+    const {
+      location: i,
+      distance: c,
+      threshold: u,
+      findAllMatches: o,
+      minMatchCharLength: h,
+      ignoreLocation: a
+    } = this.options;
+    let l = [], d = 0, g = !1;
+    this.chunks.forEach(({ pattern: A, alphabet: C, startIndex: M }) => {
+      const { isMatch: m, score: _, indices: B } = Ke(e, A, C, {
+        location: i + M,
+        distance: c,
+        threshold: u,
+        findAllMatches: o,
+        minMatchCharLength: h,
+        includeMatches: r,
+        ignoreLocation: a
+      });
+      m && (g = !0), d += _, m && B && (l = [...l, ...B]);
+    });
+    let p = {
+      isMatch: g,
+      score: g ? d / this.chunks.length : 1
+    };
+    return g && r && (p.indices = l), p;
+  }
+}
+class S {
+  constructor(e) {
+    this.pattern = e;
+  }
+  static isMultiMatch(e) {
+    return se(e, this.multiRegex);
+  }
+  static isSingleMatch(e) {
+    return se(e, this.singleRegex);
+  }
+  search() {
+  }
+}
+function se(t, e) {
+  const s = t.match(e);
+  return s ? s[1] : null;
+}
+class ze extends S {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "exact";
+  }
+  static get multiRegex() {
+    return /^="(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^=(.*)$/;
+  }
+  search(e) {
+    const s = e === this.pattern;
+    return {
+      isMatch: s,
+      score: s ? 0 : 1,
+      indices: [0, this.pattern.length - 1]
+    };
+  }
+}
+class He extends S {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "inverse-exact";
+  }
+  static get multiRegex() {
+    return /^!"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^!(.*)$/;
+  }
+  search(e) {
+    const n = e.indexOf(this.pattern) === -1;
+    return {
+      isMatch: n,
+      score: n ? 0 : 1,
+      indices: [0, e.length - 1]
+    };
+  }
+}
+class Ge extends S {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "prefix-exact";
+  }
+  static get multiRegex() {
+    return /^\^"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^\^(.*)$/;
+  }
+  search(e) {
+    const s = e.startsWith(this.pattern);
+    return {
+      isMatch: s,
+      score: s ? 0 : 1,
+      indices: [0, this.pattern.length - 1]
+    };
+  }
+}
+class Ve extends S {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "inverse-prefix-exact";
+  }
+  static get multiRegex() {
+    return /^!\^"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^!\^(.*)$/;
+  }
+  search(e) {
+    const s = !e.startsWith(this.pattern);
+    return {
+      isMatch: s,
+      score: s ? 0 : 1,
+      indices: [0, e.length - 1]
+    };
+  }
+}
+class Ye extends S {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "suffix-exact";
+  }
+  static get multiRegex() {
+    return /^"(.*)"\$$/;
+  }
+  static get singleRegex() {
+    return /^(.*)\$$/;
+  }
+  search(e) {
+    const s = e.endsWith(this.pattern);
+    return {
+      isMatch: s,
+      score: s ? 0 : 1,
+      indices: [e.length - this.pattern.length, e.length - 1]
+    };
+  }
+}
+class Qe extends S {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "inverse-suffix-exact";
+  }
+  static get multiRegex() {
+    return /^!"(.*)"\$$/;
+  }
+  static get singleRegex() {
+    return /^!(.*)\$$/;
+  }
+  search(e) {
+    const s = !e.endsWith(this.pattern);
+    return {
+      isMatch: s,
+      score: s ? 0 : 1,
+      indices: [0, e.length - 1]
+    };
+  }
+}
+class fe extends S {
+  constructor(e, {
+    location: s = f.location,
+    threshold: n = f.threshold,
+    distance: r = f.distance,
+    includeMatches: i = f.includeMatches,
+    findAllMatches: c = f.findAllMatches,
+    minMatchCharLength: u = f.minMatchCharLength,
+    isCaseSensitive: o = f.isCaseSensitive,
+    ignoreDiacritics: h = f.ignoreDiacritics,
+    ignoreLocation: a = f.ignoreLocation
+  } = {}) {
+    super(e), this._bitapSearch = new le(e, {
+      location: s,
+      threshold: n,
+      distance: r,
+      includeMatches: i,
+      findAllMatches: c,
+      minMatchCharLength: u,
+      isCaseSensitive: o,
+      ignoreDiacritics: h,
+      ignoreLocation: a
+    });
+  }
+  static get type() {
+    return "fuzzy";
+  }
+  static get multiRegex() {
+    return /^"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^(.*)$/;
+  }
+  search(e) {
+    return this._bitapSearch.searchIn(e);
+  }
+}
+class de extends S {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "include";
+  }
+  static get multiRegex() {
+    return /^'"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^'(.*)$/;
+  }
+  search(e) {
+    let s = 0, n;
+    const r = [], i = this.pattern.length;
+    for (; (n = e.indexOf(this.pattern, s)) > -1; )
+      s = n + i, r.push([n, s - 1]);
+    const c = !!r.length;
+    return {
+      isMatch: c,
+      score: c ? 0 : 1,
+      indices: r
+    };
+  }
+}
+const G = [
+  ze,
+  de,
+  Ge,
+  Ve,
+  Qe,
+  Ye,
+  He,
+  fe
+], ne = G.length, Ue = / +(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/, Je = "|";
+function Xe(t, e = {}) {
+  return t.split(Je).map((s) => {
+    let n = s.trim().split(Ue).filter((i) => i && !!i.trim()), r = [];
+    for (let i = 0, c = n.length; i < c; i += 1) {
+      const u = n[i];
+      let o = !1, h = -1;
+      for (; !o && ++h < ne; ) {
+        const a = G[h];
+        let l = a.isMultiMatch(u);
+        l && (r.push(new a(l, e)), o = !0);
+      }
+      if (!o)
+        for (h = -1; ++h < ne; ) {
+          const a = G[h];
+          let l = a.isSingleMatch(u);
+          if (l) {
+            r.push(new a(l, e));
+            break;
+          }
+        }
+    }
+    return r;
+  });
+}
+const Ze = /* @__PURE__ */ new Set([fe.type, de.type]);
+class qe {
+  constructor(e, {
+    isCaseSensitive: s = f.isCaseSensitive,
+    ignoreDiacritics: n = f.ignoreDiacritics,
+    includeMatches: r = f.includeMatches,
+    minMatchCharLength: i = f.minMatchCharLength,
+    ignoreLocation: c = f.ignoreLocation,
+    findAllMatches: u = f.findAllMatches,
+    location: o = f.location,
+    threshold: h = f.threshold,
+    distance: a = f.distance
+  } = {}) {
+    this.query = null, this.options = {
+      isCaseSensitive: s,
+      ignoreDiacritics: n,
+      includeMatches: r,
+      minMatchCharLength: i,
+      findAllMatches: u,
+      ignoreLocation: c,
+      location: o,
+      threshold: h,
+      distance: a
+    }, e = s ? e : e.toLowerCase(), e = n ? O(e) : e, this.pattern = e, this.query = Xe(this.pattern, this.options);
+  }
+  static condition(e, s) {
+    return s.useExtendedSearch;
+  }
+  searchIn(e) {
+    const s = this.query;
+    if (!s)
+      return {
+        isMatch: !1,
+        score: 1
+      };
+    const { includeMatches: n, isCaseSensitive: r, ignoreDiacritics: i } = this.options;
+    e = r ? e : e.toLowerCase(), e = i ? O(e) : e;
+    let c = 0, u = [], o = 0;
+    for (let h = 0, a = s.length; h < a; h += 1) {
+      const l = s[h];
+      u.length = 0, c = 0;
+      for (let d = 0, g = l.length; d < g; d += 1) {
+        const p = l[d], { isMatch: A, indices: C, score: M } = p.search(e);
+        if (A) {
+          if (c += 1, o += M, n) {
+            const m = p.constructor.type;
+            Ze.has(m) ? u = [...u, ...C] : u.push(C);
+          }
+        } else {
+          o = 0, c = 0, u.length = 0;
+          break;
+        }
+      }
+      if (c) {
+        let d = {
+          isMatch: !0,
+          score: o / c
+        };
+        return n && (d.indices = u), d;
+      }
+    }
+    return {
+      isMatch: !1,
+      score: 1
+    };
+  }
+}
+const V = [];
+function et(...t) {
+  V.push(...t);
+}
+function Y(t, e) {
+  for (let s = 0, n = V.length; s < n; s += 1) {
+    let r = V[s];
+    if (r.condition(t, e))
+      return new r(t, e);
+  }
+  return new le(t, e);
+}
+const P = {
+  AND: "$and",
+  OR: "$or"
+}, Q = {
+  PATH: "$path",
+  PATTERN: "$val"
+}, U = (t) => !!(t[P.AND] || t[P.OR]), tt = (t) => !!t[Q.PATH], st = (t) => !I(t) && ue(t) && !U(t), re = (t) => ({
+  [P.AND]: Object.keys(t).map((e) => ({
+    [e]: t[e]
+  }))
+});
+function ge(t, e, { auto: s = !0 } = {}) {
+  const n = (r) => {
+    let i = Object.keys(r);
+    const c = tt(r);
+    if (!c && i.length > 1 && !U(r))
+      return n(re(r));
+    if (st(r)) {
+      const o = c ? r[Q.PATH] : i[0], h = c ? r[Q.PATTERN] : r[o];
+      if (!D(h))
+        throw new Error(xe(o));
+      const a = {
+        keyId: H(o),
+        pattern: h
+      };
+      return s && (a.searcher = Y(h, e)), a;
+    }
+    let u = {
+      children: [],
+      operator: i[0]
+    };
+    return i.forEach((o) => {
+      const h = r[o];
+      I(h) && h.forEach((a) => {
+        u.children.push(n(a));
+      });
+    }), u;
+  };
+  return U(t) || (t = re(t)), n(t);
+}
+function nt(t, { ignoreFieldNorm: e = f.ignoreFieldNorm }) {
+  t.forEach((s) => {
+    let n = 1;
+    s.matches.forEach(({ key: r, norm: i, score: c }) => {
+      const u = r ? r.weight : null;
+      n *= Math.pow(
+        c === 0 && u ? Number.EPSILON : c,
+        (u || 1) * (e ? 1 : i)
+      );
+    }), s.score = n;
+  });
+}
+function rt(t, e) {
+  const s = t.matches;
+  e.matches = [], E(s) && s.forEach((n) => {
+    if (!E(n.indices) || !n.indices.length)
+      return;
+    const { indices: r, value: i } = n;
+    let c = {
+      indices: r,
+      value: i
+    };
+    n.key && (c.key = n.key.src), n.idx > -1 && (c.refIndex = n.idx), e.matches.push(c);
+  });
+}
+function it(t, e) {
+  e.score = t.score;
+}
+function ct(t, e, {
+  includeMatches: s = f.includeMatches,
+  includeScore: n = f.includeScore
+} = {}) {
+  const r = [];
+  return s && r.push(rt), n && r.push(it), t.map((i) => {
+    const { idx: c } = i, u = {
+      item: e[c],
+      refIndex: c
+    };
+    return r.length && r.forEach((o) => {
+      o(i, u);
+    }), u;
+  });
+}
+class R {
+  constructor(e, s = {}, n) {
+    this.options = { ...f, ...s }, this.options.useExtendedSearch, this._keyStore = new ve(this.options.keys), this.setCollection(e, n);
+  }
+  setCollection(e, s) {
+    if (this._docs = e, s && !(s instanceof X))
+      throw new Error(_e);
+    this._myIndex = s || he(this.options.keys, this._docs, {
+      getFn: this.options.getFn,
+      fieldNormWeight: this.options.fieldNormWeight
+    });
+  }
+  add(e) {
+    E(e) && (this._docs.push(e), this._myIndex.add(e));
+  }
+  remove(e = () => !1) {
+    const s = [];
+    for (let n = 0, r = this._docs.length; n < r; n += 1) {
+      const i = this._docs[n];
+      e(i, n) && (this.removeAt(n), n -= 1, r -= 1, s.push(i));
+    }
+    return s;
+  }
+  removeAt(e) {
+    this._docs.splice(e, 1), this._myIndex.removeAt(e);
+  }
+  getIndex() {
+    return this._myIndex;
+  }
+  search(e, { limit: s = -1 } = {}) {
+    const {
+      includeMatches: n,
+      includeScore: r,
+      shouldSort: i,
+      sortFn: c,
+      ignoreFieldNorm: u
+    } = this.options;
+    let o = D(e) ? D(this._docs[0]) ? this._searchStringList(e) : this._searchObjectList(e) : this._searchLogical(e);
+    return nt(o, { ignoreFieldNorm: u }), i && o.sort(c), ce(s) && s > -1 && (o = o.slice(0, s)), ct(o, this._docs, {
+      includeMatches: n,
+      includeScore: r
+    });
+  }
+  _searchStringList(e) {
+    const s = Y(e, this.options), { records: n } = this._myIndex, r = [];
+    return n.forEach(({ v: i, i: c, n: u }) => {
+      if (!E(i))
+        return;
+      const { isMatch: o, score: h, indices: a } = s.searchIn(i);
+      o && r.push({
+        item: i,
+        idx: c,
+        matches: [{ score: h, value: i, norm: u, indices: a }]
+      });
+    }), r;
+  }
+  _searchLogical(e) {
+    const s = ge(e, this.options), n = (u, o, h) => {
+      if (!u.children) {
+        const { keyId: l, searcher: d } = u, g = this._findMatches({
+          key: this._keyStore.get(l),
+          value: this._myIndex.getValueForItemAtKeyId(o, l),
+          searcher: d
+        });
+        return g && g.length ? [
+          {
+            idx: h,
+            item: o,
+            matches: g
+          }
+        ] : [];
+      }
+      const a = [];
+      for (let l = 0, d = u.children.length; l < d; l += 1) {
+        const g = u.children[l], p = n(g, o, h);
+        if (p.length)
+          a.push(...p);
+        else if (u.operator === P.AND)
+          return [];
+      }
+      return a;
+    }, r = this._myIndex.records, i = {}, c = [];
+    return r.forEach(({ $: u, i: o }) => {
+      if (E(u)) {
+        let h = n(s, u, o);
+        h.length && (i[o] || (i[o] = { idx: o, item: u, matches: [] }, c.push(i[o])), h.forEach(({ matches: a }) => {
+          i[o].matches.push(...a);
+        }));
+      }
+    }), c;
+  }
+  _searchObjectList(e) {
+    const s = Y(e, this.options), { keys: n, records: r } = this._myIndex, i = [];
+    return r.forEach(({ $: c, i: u }) => {
+      if (!E(c))
+        return;
+      let o = [];
+      n.forEach((h, a) => {
+        o.push(
+          ...this._findMatches({
+            key: h,
+            value: c[a],
+            searcher: s
+          })
+        );
+      }), o.length && i.push({
+        idx: u,
+        item: c,
+        matches: o
+      });
+    }), i;
+  }
+  _findMatches({ key: e, value: s, searcher: n }) {
+    if (!E(s))
+      return [];
+    let r = [];
+    if (I(s))
+      s.forEach(({ v: i, i: c, n: u }) => {
+        if (!E(i))
+          return;
+        const { isMatch: o, score: h, indices: a } = n.searchIn(i);
+        o && r.push({
+          score: h,
+          key: e,
+          value: i,
+          idx: c,
+          norm: u,
+          indices: a
+        });
+      });
+    else {
+      const { v: i, n: c } = s, { isMatch: u, score: o, indices: h } = n.searchIn(i);
+      u && r.push({ score: o, key: e, value: i, norm: c, indices: h });
+    }
+    return r;
+  }
+}
+R.version = "7.1.0";
+R.createIndex = he;
+R.parseIndex = Te;
+R.config = f;
+R.parseQuery = ge;
+et(qe);
+const ut = /* @__PURE__ */ J({
+  name: "RenderIconClass",
+  props: {
+    iconClass: {
+      type: String,
+      required: !0
+    },
+    highlightChunks: {
+      type: Array,
+      default: () => []
+    }
+  },
+  setup(t) {
+    const e = () => {
+      const {
+        iconClass: s,
+        highlightChunks: n
+      } = t;
+      if (!s || n.length === 0)
+        return s;
+      const r = [];
+      let i = 0;
+      for (const [c, u] of n)
+        c > i && r.push(s.slice(i, c)), r.push(k("span", {
+          class: "highlight"
+        }, [s.slice(c, u + 1)])), i = u + 1;
+      return i < s.length && r.push(s.slice(i)), r;
+    };
+    return () => k("span", {
+      class: "render-icon-class"
+    }, [e()]);
+  }
+});
+function ot(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+/*! clipboard-copy. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+var z, ie;
+function at() {
+  if (ie) return z;
+  ie = 1, z = n;
+  function t() {
+    return new DOMException("The request is not allowed", "NotAllowedError");
+  }
+  async function e(r) {
+    if (!navigator.clipboard)
+      throw t();
+    return navigator.clipboard.writeText(r);
+  }
+  async function s(r) {
+    const i = document.createElement("span");
+    i.textContent = r, i.style.whiteSpace = "pre", i.style.webkitUserSelect = "auto", i.style.userSelect = "all", document.body.appendChild(i);
+    const c = window.getSelection(), u = window.document.createRange();
+    c.removeAllRanges(), u.selectNode(i), c.addRange(u);
+    let o = !1;
+    try {
+      o = window.document.execCommand("copy");
+    } finally {
+      c.removeAllRanges(), window.document.body.removeChild(i);
+    }
+    if (!o) throw t();
+  }
+  async function n(r) {
+    try {
+      await e(r);
+    } catch (i) {
+      try {
+        await s(r);
+      } catch (c) {
+        throw c || i || t();
+      }
+    }
+  }
+  return z;
+}
+var ht = at();
+const lt = /* @__PURE__ */ ot(ht), ft = /* @__PURE__ */ J({
+  name: "RenderIcon",
+  props: {
+    iconInfo: {
+      type: Object,
+      default: ""
+    },
+    iconClass: {
+      type: String,
+      required: !0
+    },
+    copyHandler: Function
+  },
+  setup(t) {
+    const e = async (n) => {
+      if (t.copyHandler) {
+        t.copyHandler(n);
+        return;
+      }
+      let r = "";
+      try {
+        await lt(n), r = "success";
+      } catch {
+        r = "error";
+      }
+      Me({
+        message: `copy ${r} [${n}]`,
+        type: r
+      });
+    }, s = pe(() => t.iconInfo.baseClassName ? `${t.iconInfo.baseClassName} ${t.iconClass}` : t.iconClass);
+    return () => {
+      var n;
+      return k("span", {
+        class: "render-icon",
+        onClick: () => e(s.value)
+      }, [t.iconInfo.renderIcon ? t.iconInfo.renderIcon(s.value) : k("i", {
+        class: [t.iconInfo.baseClassName, t.iconClass]
+      }, null), k(ut, {
+        iconClass: t.iconClass,
+        "highlight-chunks": (n = t.iconInfo.matchesMap) == null ? void 0 : n.get(t.iconClass)
+      }, null)]);
+    };
+  }
+}), dt = {
+  getIconsInfo: {
+    type: Function,
+    required: !0
+  },
+  cssLinkFormat: {
+    type: Function,
+    default: (t) => t
+  }
+}, gt = { class: "render-icon-list" }, mt = /* @__PURE__ */ J({
+  __name: "render-icon-list",
+  props: dt,
+  setup(t, { expose: e }) {
+    const s = t, n = N(), r = N(), i = N([]), c = N([]), u = (a) => {
+      n.value = a, r.value = a, i.value = a.map((l) => l.filePath), c.value = a.map((l) => ({
+        iconInfo: l,
+        fuse: new R(l.classNames, {
+          /**
+           * 搜索结果是否包含匹配的相关性分数，开启后会额外包含一个 score 字段，表示匹配的相似度分数
+           * 0 表示完全匹配
+           * 越接近 1 表示匹配度越低
+           */
+          includeScore: !0,
+          findAllMatches: !0,
+          // 即使字符串中已经找到了完美匹配，匹配函数也会持续到搜索模式的末尾
+          includeMatches: !0,
+          // ✅ 必须开启！用于高亮
+          threshold: 0.3,
+          // 模糊匹配容错度
+          minMatchCharLength: 1,
+          // 长度超过此值的匹配项才会返回
+          shouldSort: !0
+          // 是否按分数对结果列表进行排序
+        })
+      }));
+    }, o = (a) => {
+      const l = document.querySelector("head");
+      if (!l) {
+        console.error("Head element not found");
+        return;
+      }
+      const d = document.createDocumentFragment();
+      a.forEach((g) => {
+        if (!g.filePath) return;
+        const p = s.cssLinkFormat(g.filePath);
+        if (document.querySelector(`link[rel='stylesheet'][href='${p}']`))
+          return;
+        const A = document.createElement("link");
+        A.rel = "stylesheet", A.href = p, d.appendChild(A);
+      }), l.appendChild(d);
+    };
+    return Ae(async () => {
+      var l;
+      const a = await ((l = s.getIconsInfo) == null ? void 0 : l.call(s)) || [];
+      o(a), u(a);
+    }), e({
+      onSearch: (a) => {
+        const l = a.trim();
+        if (!n.value) return;
+        if (!l) {
+          i.value = n.value.map((g) => g.filePath), r.value = n.value;
+          return;
+        }
+        const d = [];
+        c.value.forEach(({ iconInfo: g, fuse: p }) => {
+          const A = p.search(l);
+          if (A.length) {
+            const C = /* @__PURE__ */ new Map(), M = [];
+            A.forEach((m) => {
+              const _ = m.matches || [], B = [];
+              _.forEach((T) => {
+                B.push(...T.indices);
+              }), C.set(m.item, B), M.push(m.item);
+            }), d.push({
+              ...g,
+              matchesMap: C,
+              classNames: M
+            });
+          }
+        }), r.value = d, i.value = d.map((g) => g.filePath);
+      }
+    }), (a, l) => (me(), Ce("div", gt, [
+      Ee(a.$slots, "default", {
+        iconsInfo: r.value,
+        renderIcon: ye(ft)
+      })
+    ]));
+  }
+});
+export {
+  mt as RenderIconList,
+  dt as renderIconListProps
+};