1804 lines
72 KiB
JavaScript
1804 lines
72 KiB
JavaScript
/*
|
|
* Extracted from browser-delivered Turbopack chunk: 836d2aeda096d319.fb0a464622.js
|
|
* Module id: 968336
|
|
* For reading/searching only; this factory depends on the original Turbopack runtime.
|
|
*/
|
|
|
|
const moduleFactory = (t) => {
|
|
"use strict";
|
|
let e;
|
|
var i,
|
|
n = t.i(462214),
|
|
o = t.i(358379);
|
|
let r = Object.freeze({ left: 0, top: 0, width: 16, height: 16 }),
|
|
s = Object.freeze({ rotate: 0, vFlip: !1, hFlip: !1 }),
|
|
a = Object.freeze({ ...r, ...s }),
|
|
l = Object.freeze({ ...a, body: "", hidden: !1 });
|
|
function c(t, e) {
|
|
let i,
|
|
n,
|
|
o =
|
|
((i = {}),
|
|
!t.hFlip != !e.hFlip && (i.hFlip = !0),
|
|
!t.vFlip != !e.vFlip && (i.vFlip = !0),
|
|
(n = ((t.rotate || 0) + (e.rotate || 0)) % 4) && (i.rotate = n),
|
|
i);
|
|
for (let i in l)
|
|
i in s
|
|
? i in t && !(i in o) && (o[i] = s[i])
|
|
: i in e
|
|
? (o[i] = e[i])
|
|
: i in t && (o[i] = t[i]);
|
|
return o;
|
|
}
|
|
function u(t, e) {
|
|
let i,
|
|
n,
|
|
o,
|
|
r = [];
|
|
if ("object" != typeof t || "object" != typeof t.icons) return r;
|
|
t.not_found instanceof Array &&
|
|
t.not_found.forEach((t) => {
|
|
e(t, null), r.push(t);
|
|
});
|
|
let s =
|
|
((i = t.icons),
|
|
(n = t.aliases || Object.create(null)),
|
|
(o = Object.create(null)),
|
|
Object.keys(i)
|
|
.concat(Object.keys(n))
|
|
.forEach(function t(e) {
|
|
if (i[e]) return (o[e] = []);
|
|
if (!(e in o)) {
|
|
o[e] = null;
|
|
let i = n[e] && n[e].parent,
|
|
r = i && t(i);
|
|
r && (o[e] = [i].concat(r));
|
|
}
|
|
return o[e];
|
|
}),
|
|
o);
|
|
for (let i in s) {
|
|
let n = s[i];
|
|
n &&
|
|
(e(
|
|
i,
|
|
(function (t, e, i) {
|
|
let n = t.icons,
|
|
o = t.aliases || Object.create(null),
|
|
r = {};
|
|
function s(t) {
|
|
r = c(n[t] || o[t], r);
|
|
}
|
|
return s(e), i.forEach(s), c(t, r);
|
|
})(t, i, n),
|
|
),
|
|
r.push(i));
|
|
}
|
|
return r;
|
|
}
|
|
let h = { provider: "", aliases: {}, not_found: {}, ...r };
|
|
function d(t, e) {
|
|
for (let i in e) if (i in t && typeof t[i] != typeof e[i]) return !1;
|
|
return !0;
|
|
}
|
|
function p(t) {
|
|
if (
|
|
"object" != typeof t ||
|
|
null === t ||
|
|
"string" != typeof t.prefix ||
|
|
!t.icons ||
|
|
"object" != typeof t.icons ||
|
|
!d(t, h)
|
|
)
|
|
return null;
|
|
let e = t.icons;
|
|
for (let t in e) {
|
|
let i = e[t];
|
|
if (!t || "string" != typeof i.body || !d(i, l)) return null;
|
|
}
|
|
let i = t.aliases || Object.create(null);
|
|
for (let t in i) {
|
|
let n = i[t],
|
|
o = n.parent;
|
|
if (!t || "string" != typeof o || (!e[o] && !i[o]) || !d(n, l))
|
|
return null;
|
|
}
|
|
return t;
|
|
}
|
|
let m = Object.create(null);
|
|
function f(t, e) {
|
|
let i = m[t] || (m[t] = Object.create(null));
|
|
return (
|
|
i[e] ||
|
|
(i[e] = {
|
|
provider: t,
|
|
prefix: e,
|
|
icons: Object.create(null),
|
|
missing: new Set(),
|
|
})
|
|
);
|
|
}
|
|
function g(t, e) {
|
|
return p(e)
|
|
? u(e, (e, i) => {
|
|
i ? (t.icons[e] = i) : t.missing.add(e);
|
|
})
|
|
: [];
|
|
}
|
|
let v = /^[a-z0-9]+(-[a-z0-9]+)*$/,
|
|
y = (t, e, i, n = "") => {
|
|
let o = t.split(":");
|
|
if ("@" === t.slice(0, 1)) {
|
|
if (o.length < 2 || o.length > 3) return null;
|
|
n = o.shift().slice(1);
|
|
}
|
|
if (o.length > 3 || !o.length) return null;
|
|
if (o.length > 1) {
|
|
let t = o.pop(),
|
|
i = o.pop(),
|
|
r = { provider: o.length > 0 ? o[0] : n, prefix: i, name: t };
|
|
return e && !b(r) ? null : r;
|
|
}
|
|
let r = o[0],
|
|
s = r.split("-");
|
|
if (s.length > 1) {
|
|
let t = { provider: n, prefix: s.shift(), name: s.join("-") };
|
|
return e && !b(t) ? null : t;
|
|
}
|
|
if (i && "" === n) {
|
|
let t = { provider: n, prefix: "", name: r };
|
|
return e && !b(t, i) ? null : t;
|
|
}
|
|
return null;
|
|
},
|
|
b = (t, e) => !!t && !!(((e && "" === t.prefix) || t.prefix) && t.name),
|
|
I = !1;
|
|
function x(t) {
|
|
return "boolean" == typeof t && (I = t), I;
|
|
}
|
|
function w(t) {
|
|
let e = "string" == typeof t ? y(t, !0, I) : t;
|
|
if (e) {
|
|
let t = f(e.provider, e.prefix),
|
|
i = e.name;
|
|
return t.icons[i] || (t.missing.has(i) ? null : void 0);
|
|
}
|
|
}
|
|
function S(t, e) {
|
|
if ("object" != typeof t) return !1;
|
|
if (
|
|
("string" != typeof e && (e = t.provider || ""), I && !e && !t.prefix)
|
|
) {
|
|
let e = !1;
|
|
return (
|
|
p(t) &&
|
|
((t.prefix = ""),
|
|
u(t, (t, i) => {
|
|
(function (t, e) {
|
|
let i = y(t, !0, I);
|
|
if (!i) return !1;
|
|
let n = f(i.provider, i.prefix);
|
|
if (!e) return n.missing.add(i.name), !0;
|
|
var o = i.name;
|
|
try {
|
|
if ("string" == typeof e.body)
|
|
return (n.icons[o] = { ...e }), !0;
|
|
} catch (t) {}
|
|
return !1;
|
|
})(t, i) && (e = !0);
|
|
})),
|
|
e
|
|
);
|
|
}
|
|
let i = t.prefix;
|
|
return !!b({ prefix: i, name: "a" }) && !!g(f(e, i), t);
|
|
}
|
|
let T = Object.freeze({ width: null, height: null }),
|
|
P = Object.freeze({ ...T, ...s }),
|
|
k = /(-?[0-9.]*[0-9]+[0-9.]*)/g,
|
|
A = /^-?[0-9.]*[0-9]+[0-9.]*$/g;
|
|
function C(t, e, i) {
|
|
if (1 === e) return t;
|
|
if (((i = i || 100), "number" == typeof t))
|
|
return Math.ceil(t * e * i) / i;
|
|
if ("string" != typeof t) return t;
|
|
let n = t.split(k);
|
|
if (null === n || !n.length) return t;
|
|
let o = [],
|
|
r = n.shift(),
|
|
s = A.test(r);
|
|
for (;;) {
|
|
if (s) {
|
|
let t = parseFloat(r);
|
|
isNaN(t) ? o.push(r) : o.push(Math.ceil(t * e * i) / i);
|
|
} else o.push(r);
|
|
if (void 0 === (r = n.shift())) return o.join("");
|
|
s = !s;
|
|
}
|
|
}
|
|
let E = /\sid="(\S+)"/g,
|
|
L =
|
|
"IconifyId" +
|
|
Date.now().toString(16) +
|
|
((0x1000000 * Math.random()) | 0).toString(16),
|
|
M = 0,
|
|
R = Object.create(null);
|
|
function D(t) {
|
|
return R[t] || R[""];
|
|
}
|
|
function V(t) {
|
|
let e;
|
|
if ("string" == typeof t.resources) e = [t.resources];
|
|
else if (!((e = t.resources) instanceof Array) || !e.length) return null;
|
|
return {
|
|
resources: e,
|
|
path: t.path || "/",
|
|
maxURL: t.maxURL || 500,
|
|
rotate: t.rotate || 750,
|
|
timeout: t.timeout || 5e3,
|
|
random: !0 === t.random,
|
|
index: t.index || 0,
|
|
dataAfterTimeout: !1 !== t.dataAfterTimeout,
|
|
};
|
|
}
|
|
let F = Object.create(null),
|
|
j = ["https://api.simplesvg.com", "https://api.unisvg.com"],
|
|
N = [];
|
|
for (; j.length > 0; )
|
|
1 === j.length || Math.random() > 0.5
|
|
? N.push(j.shift())
|
|
: N.push(j.pop());
|
|
F[""] = V({ resources: ["https://api.iconify.design"].concat(N) });
|
|
let B = (() => {
|
|
let t;
|
|
try {
|
|
if (((t = fetch), "function" == typeof t)) return t;
|
|
} catch (t) {}
|
|
})();
|
|
function O(t, e) {
|
|
t.forEach((t) => {
|
|
let i = t.loaderCallbacks;
|
|
i && (t.loaderCallbacks = i.filter((t) => t.id !== e));
|
|
});
|
|
}
|
|
let U = 0,
|
|
H = {
|
|
resources: [],
|
|
index: 0,
|
|
timeout: 2e3,
|
|
rotate: 750,
|
|
random: !1,
|
|
dataAfterTimeout: !1,
|
|
};
|
|
function z(t) {
|
|
let e = { ...H, ...t },
|
|
i = [];
|
|
function n() {
|
|
i = i.filter((t) => "pending" === t().status);
|
|
}
|
|
return {
|
|
query: function (t, o, r) {
|
|
let s = (function (t, e, i, n) {
|
|
let o,
|
|
r,
|
|
s = t.resources.length,
|
|
a = t.random ? Math.floor(Math.random() * s) : t.index;
|
|
if (t.random) {
|
|
let e = t.resources.slice(0);
|
|
for (o = []; e.length > 1; ) {
|
|
let t = Math.floor(Math.random() * e.length);
|
|
o.push(e[t]), (e = e.slice(0, t).concat(e.slice(t + 1)));
|
|
}
|
|
o = o.concat(e);
|
|
} else o = t.resources.slice(a).concat(t.resources.slice(0, a));
|
|
let l = Date.now(),
|
|
c = "pending",
|
|
u = 0,
|
|
h = null,
|
|
d = [],
|
|
p = [];
|
|
function m() {
|
|
h && (clearTimeout(h), (h = null));
|
|
}
|
|
function f() {
|
|
"pending" === c && (c = "aborted"),
|
|
m(),
|
|
d.forEach((t) => {
|
|
"pending" === t.status && (t.status = "aborted");
|
|
}),
|
|
(d = []);
|
|
}
|
|
function g(t, e) {
|
|
e && (p = []), "function" == typeof t && p.push(t);
|
|
}
|
|
function v() {
|
|
(c = "failed"),
|
|
p.forEach((t) => {
|
|
t(void 0, r);
|
|
});
|
|
}
|
|
function y() {
|
|
d.forEach((t) => {
|
|
"pending" === t.status && (t.status = "aborted");
|
|
}),
|
|
(d = []);
|
|
}
|
|
return (
|
|
"function" == typeof n && p.push(n),
|
|
setTimeout(function n() {
|
|
if ("pending" !== c) return;
|
|
m();
|
|
let s = o.shift();
|
|
if (void 0 === s) {
|
|
if (d.length) {
|
|
h = setTimeout(() => {
|
|
m(), "pending" === c && (y(), v());
|
|
}, t.timeout);
|
|
return;
|
|
}
|
|
v();
|
|
return;
|
|
}
|
|
let a = {
|
|
status: "pending",
|
|
resource: s,
|
|
callback: (e, i) => {
|
|
!(function (e, i, s) {
|
|
let a = "success" !== i;
|
|
switch (((d = d.filter((t) => t !== e)), c)) {
|
|
case "pending":
|
|
break;
|
|
case "failed":
|
|
if (a || !t.dataAfterTimeout) return;
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
if ("abort" === i) {
|
|
(r = s), v();
|
|
return;
|
|
}
|
|
if (a) {
|
|
(r = s), d.length || (o.length ? n() : v());
|
|
return;
|
|
}
|
|
if ((m(), y(), !t.random)) {
|
|
let i = t.resources.indexOf(e.resource);
|
|
-1 !== i && i !== t.index && (t.index = i);
|
|
}
|
|
(c = "completed"),
|
|
p.forEach((t) => {
|
|
t(s);
|
|
});
|
|
})(a, e, i);
|
|
},
|
|
};
|
|
d.push(a),
|
|
u++,
|
|
(h = setTimeout(n, t.rotate)),
|
|
i(s, e, a.callback);
|
|
}),
|
|
function () {
|
|
return {
|
|
startTime: l,
|
|
payload: e,
|
|
status: c,
|
|
queriesSent: u,
|
|
queriesPending: d.length,
|
|
subscribe: g,
|
|
abort: f,
|
|
};
|
|
}
|
|
);
|
|
})(e, t, o, (t, e) => {
|
|
n(), r && r(t, e);
|
|
});
|
|
return i.push(s), s;
|
|
},
|
|
find: function (t) {
|
|
return i.find((e) => t(e)) || null;
|
|
},
|
|
setIndex: (t) => {
|
|
e.index = t;
|
|
},
|
|
getIndex: () => e.index,
|
|
cleanup: n,
|
|
};
|
|
}
|
|
let W = Object.create(null);
|
|
function $() {}
|
|
function G(t, e, i) {
|
|
function n() {
|
|
let i = t.pendingIcons;
|
|
e.forEach((e) => {
|
|
i && i.delete(e), t.icons[e] || t.missing.add(e);
|
|
});
|
|
}
|
|
if (i && "object" == typeof i)
|
|
try {
|
|
if (!g(t, i).length) return void n();
|
|
} catch (t) {
|
|
console.error(t);
|
|
}
|
|
n(),
|
|
t.iconsLoaderFlag ||
|
|
((t.iconsLoaderFlag = !0),
|
|
setTimeout(() => {
|
|
(t.iconsLoaderFlag = !1),
|
|
t.pendingCallbacksFlag ||
|
|
((t.pendingCallbacksFlag = !0),
|
|
setTimeout(() => {
|
|
t.pendingCallbacksFlag = !1;
|
|
let e = t.loaderCallbacks ? t.loaderCallbacks.slice(0) : [];
|
|
if (!e.length) return;
|
|
let i = !1,
|
|
n = t.provider,
|
|
o = t.prefix;
|
|
e.forEach((e) => {
|
|
let r = e.icons,
|
|
s = r.pending.length;
|
|
(r.pending = r.pending.filter((e) => {
|
|
if (e.prefix !== o) return !0;
|
|
let s = e.name;
|
|
if (t.icons[s])
|
|
r.loaded.push({ provider: n, prefix: o, name: s });
|
|
else {
|
|
if (!t.missing.has(s)) return (i = !0), !0;
|
|
r.missing.push({ provider: n, prefix: o, name: s });
|
|
}
|
|
return !1;
|
|
})),
|
|
r.pending.length !== s &&
|
|
(i || O([t], e.id),
|
|
e.callback(
|
|
r.loaded.slice(0),
|
|
r.missing.slice(0),
|
|
r.pending.slice(0),
|
|
e.abort,
|
|
));
|
|
});
|
|
}));
|
|
}));
|
|
}
|
|
function X(t, e) {
|
|
t instanceof Promise
|
|
? t
|
|
.then((t) => {
|
|
e(t);
|
|
})
|
|
.catch(() => {
|
|
e(null);
|
|
})
|
|
: e(t);
|
|
}
|
|
let Y = /[\s,]+/,
|
|
q = { ...P, inline: !1 },
|
|
K = {
|
|
xmlns: "http://www.w3.org/2000/svg",
|
|
xmlnsXlink: "http://www.w3.org/1999/xlink",
|
|
"aria-hidden": !0,
|
|
role: "img",
|
|
},
|
|
_ = { display: "inline-block" },
|
|
Z = { backgroundColor: "currentColor" },
|
|
Q = { backgroundColor: "transparent" },
|
|
J = { Image: "var(--svg)", Repeat: "no-repeat", Size: "100% 100%" },
|
|
tt = { WebkitMask: Z, mask: Z, background: Q };
|
|
for (let t in tt) {
|
|
let e = tt[t];
|
|
for (let i in J) e[t + i] = J[i];
|
|
}
|
|
let te = { ...q, inline: !0 };
|
|
function ti(t) {
|
|
return t + (t.match(/^[-0-9.]+$/) ? "px" : "");
|
|
}
|
|
if (
|
|
(x(!0),
|
|
(i = {
|
|
prepare: (t, e, i) => {
|
|
let n = [],
|
|
o = (function (t, e) {
|
|
let i,
|
|
n = F[t];
|
|
if (!n) return 0;
|
|
if (n.maxURL) {
|
|
let t = 0;
|
|
n.resources.forEach((e) => {
|
|
t = Math.max(t, e.length);
|
|
}),
|
|
(i =
|
|
n.maxURL - t - n.path.length - (e + ".json?icons=").length);
|
|
} else i = 0;
|
|
return i;
|
|
})(t, e),
|
|
r = "icons",
|
|
s = { type: r, provider: t, prefix: e, icons: [] },
|
|
a = 0;
|
|
return (
|
|
i.forEach((i, l) => {
|
|
(a += i.length + 1) >= o &&
|
|
l > 0 &&
|
|
(n.push(s),
|
|
(s = { type: r, provider: t, prefix: e, icons: [] }),
|
|
(a = i.length)),
|
|
s.icons.push(i);
|
|
}),
|
|
n.push(s),
|
|
n
|
|
);
|
|
},
|
|
send: (t, e, i) => {
|
|
if (!B) return void i("abort", 424);
|
|
let n = (function (t) {
|
|
if ("string" == typeof t) {
|
|
let e = F[t];
|
|
if (e) return e.path;
|
|
}
|
|
return "/";
|
|
})(e.provider);
|
|
switch (e.type) {
|
|
case "icons":
|
|
n +=
|
|
e.prefix +
|
|
".json?" +
|
|
new URLSearchParams({ icons: e.icons.join(",") }).toString();
|
|
break;
|
|
case "custom": {
|
|
let t = e.uri;
|
|
n += "/" === t.slice(0, 1) ? t.slice(1) : t;
|
|
break;
|
|
}
|
|
default:
|
|
i("abort", 400);
|
|
return;
|
|
}
|
|
let o = 503;
|
|
B(t + n)
|
|
.then((t) => {
|
|
let e = t.status;
|
|
return 200 !== e
|
|
? void setTimeout(() => {
|
|
i(404 === e ? "abort" : "next", e);
|
|
})
|
|
: ((o = 501), t.json());
|
|
})
|
|
.then((t) => {
|
|
"object" != typeof t || null === t
|
|
? setTimeout(() => {
|
|
404 === t ? i("abort", t) : i("next", o);
|
|
})
|
|
: setTimeout(() => {
|
|
i("success", t);
|
|
});
|
|
})
|
|
.catch(() => {
|
|
i("next", o);
|
|
});
|
|
},
|
|
}),
|
|
(R[""] = i),
|
|
"u" > typeof document && "u" > typeof window)
|
|
) {
|
|
let t = window;
|
|
if (void 0 !== t.IconifyPreload) {
|
|
let e = t.IconifyPreload,
|
|
i = "Invalid IconifyPreload syntax.";
|
|
"object" == typeof e &&
|
|
null !== e &&
|
|
(e instanceof Array ? e : [e]).forEach((t) => {
|
|
try {
|
|
("object" != typeof t ||
|
|
null === t ||
|
|
t instanceof Array ||
|
|
"object" != typeof t.icons ||
|
|
"string" != typeof t.prefix ||
|
|
!S(t)) &&
|
|
console.error(i);
|
|
} catch (t) {
|
|
console.error(i);
|
|
}
|
|
});
|
|
}
|
|
if (void 0 !== t.IconifyProviders) {
|
|
let e = t.IconifyProviders;
|
|
if ("object" == typeof e && null !== e)
|
|
for (let t in e) {
|
|
let i = "IconifyProviders[" + t + "] is invalid.";
|
|
try {
|
|
let n = e[t];
|
|
if ("object" != typeof n || !n || void 0 === n.resources)
|
|
continue;
|
|
!(function (t, e) {
|
|
let i = V(e);
|
|
return null !== i && ((F[t] = i), !0);
|
|
})(t, n) && console.error(i);
|
|
} catch (t) {
|
|
console.error(i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function tn(t) {
|
|
let [i, n] = (0, o.useState)(!!t.ssr),
|
|
[r, s] = (0, o.useState)({}),
|
|
[l, c] = (0, o.useState)(
|
|
(function (e) {
|
|
if (e) {
|
|
let e = t.icon;
|
|
if ("object" == typeof e) return { name: "", data: e };
|
|
let i = w(e);
|
|
if (i) return { name: e, data: i };
|
|
}
|
|
return { name: "" };
|
|
})(!!t.ssr),
|
|
);
|
|
function u() {
|
|
let t = r.callback;
|
|
t && (t(), s({}));
|
|
}
|
|
function h(t) {
|
|
if (JSON.stringify(l) !== JSON.stringify(t)) return u(), c(t), !0;
|
|
}
|
|
(0, o.useEffect)(() => (n(!0), u), []),
|
|
(0, o.useEffect)(() => {
|
|
i &&
|
|
(function e() {
|
|
var i;
|
|
let n = t.icon;
|
|
if ("object" == typeof n) return void h({ name: "", data: n });
|
|
let o = w(n);
|
|
h({ name: n, data: o }) &&
|
|
(void 0 === o
|
|
? s({
|
|
callback: ((t, e) => {
|
|
var i;
|
|
let n,
|
|
o,
|
|
r,
|
|
s,
|
|
a,
|
|
l =
|
|
((i = (function (t, e = !0, i = !1) {
|
|
let n = [];
|
|
return (
|
|
t.forEach((t) => {
|
|
let o = "string" == typeof t ? y(t, e, i) : t;
|
|
o && n.push(o);
|
|
}),
|
|
n
|
|
);
|
|
})(t, !0, x())),
|
|
(r = { loaded: [], missing: [], pending: [] }),
|
|
(s = Object.create(null)),
|
|
i.sort((t, e) =>
|
|
t.provider !== e.provider
|
|
? t.provider.localeCompare(e.provider)
|
|
: t.prefix !== e.prefix
|
|
? t.prefix.localeCompare(e.prefix)
|
|
: t.name.localeCompare(e.name),
|
|
),
|
|
(a = { provider: "", prefix: "", name: "" }),
|
|
i.forEach((t) => {
|
|
if (
|
|
a.name === t.name &&
|
|
a.prefix === t.prefix &&
|
|
a.provider === t.provider
|
|
)
|
|
return;
|
|
a = t;
|
|
let e = t.provider,
|
|
i = t.prefix,
|
|
n = t.name,
|
|
o = s[e] || (s[e] = Object.create(null)),
|
|
l = o[i] || (o[i] = f(e, i));
|
|
(n in l.icons
|
|
? r.loaded
|
|
: "" === i || l.missing.has(n)
|
|
? r.missing
|
|
: r.pending
|
|
).push({ provider: e, prefix: i, name: n });
|
|
}),
|
|
r);
|
|
if (!l.pending.length) {
|
|
let t = !0;
|
|
return (
|
|
e &&
|
|
setTimeout(() => {
|
|
t && e(l.loaded, l.missing, l.pending, $);
|
|
}),
|
|
() => {
|
|
t = !1;
|
|
}
|
|
);
|
|
}
|
|
let c = Object.create(null),
|
|
u = [];
|
|
return (
|
|
l.pending.forEach((t) => {
|
|
let { provider: e, prefix: i } = t;
|
|
if (i === o && e === n) return;
|
|
(n = e), (o = i), u.push(f(e, i));
|
|
let r = c[e] || (c[e] = Object.create(null));
|
|
r[i] || (r[i] = []);
|
|
}),
|
|
l.pending.forEach((t) => {
|
|
let { provider: e, prefix: i, name: n } = t,
|
|
o = f(e, i),
|
|
r =
|
|
o.pendingIcons || (o.pendingIcons = new Set());
|
|
r.has(n) || (r.add(n), c[e][i].push(n));
|
|
}),
|
|
u.forEach((t) => {
|
|
let e = c[t.provider][t.prefix];
|
|
e.length &&
|
|
(t.iconsToLoad
|
|
? (t.iconsToLoad = t.iconsToLoad
|
|
.concat(e)
|
|
.sort())
|
|
: (t.iconsToLoad = e),
|
|
t.iconsQueueFlag ||
|
|
((t.iconsQueueFlag = !0),
|
|
setTimeout(() => {
|
|
let e, i;
|
|
t.iconsQueueFlag = !1;
|
|
let { provider: n, prefix: o } = t,
|
|
r = t.iconsToLoad;
|
|
if ((delete t.iconsToLoad, !r || !r.length))
|
|
return;
|
|
let s = t.loadIcon;
|
|
if (t.loadIcons && (r.length > 1 || !s))
|
|
return void X(t.loadIcons(r, o, n), (e) => {
|
|
G(t, r, e);
|
|
});
|
|
if (s)
|
|
return void r.forEach((e) => {
|
|
X(s(e, o, n), (i) => {
|
|
let n = i
|
|
? { prefix: o, icons: { [e]: i } }
|
|
: null;
|
|
G(t, [e], n);
|
|
});
|
|
});
|
|
let { valid: a, invalid: l } =
|
|
((e = []),
|
|
(i = []),
|
|
r.forEach((t) => {
|
|
(t.match(v) ? e : i).push(t);
|
|
}),
|
|
{ valid: e, invalid: i });
|
|
if ((l.length && G(t, l, null), !a.length))
|
|
return;
|
|
let c = o.match(v) ? D(n) : null;
|
|
c
|
|
? c.prepare(n, o, a).forEach((e) => {
|
|
!(function (t, e, i) {
|
|
let n, o;
|
|
if ("string" == typeof t) {
|
|
let e = D(t);
|
|
if (!e) return i(void 0, 424);
|
|
o = e.send;
|
|
let r = (function (t) {
|
|
if (!W[t]) {
|
|
let e = F[t];
|
|
if (!e) return;
|
|
let i = z(e);
|
|
W[t] = {
|
|
config: e,
|
|
redundancy: i,
|
|
};
|
|
}
|
|
return W[t];
|
|
})(t);
|
|
r && (n = r.redundancy);
|
|
} else {
|
|
let e = V(t);
|
|
if (e) {
|
|
n = z(e);
|
|
let i = D(
|
|
t.resources
|
|
? t.resources[0]
|
|
: "",
|
|
);
|
|
i && (o = i.send);
|
|
}
|
|
}
|
|
n && o
|
|
? n.query(e, o, i)().abort
|
|
: i(void 0, 424);
|
|
})(n, e, (i) => {
|
|
G(t, e.icons, i);
|
|
});
|
|
})
|
|
: G(t, a, null);
|
|
})));
|
|
}),
|
|
e
|
|
? (function (t, e, i) {
|
|
let n = U++,
|
|
o = O.bind(null, i, n);
|
|
if (!e.pending.length) return o;
|
|
let r = {
|
|
id: n,
|
|
icons: e,
|
|
callback: t,
|
|
abort: o,
|
|
};
|
|
return (
|
|
i.forEach((t) => {
|
|
(
|
|
t.loaderCallbacks ||
|
|
(t.loaderCallbacks = [])
|
|
).push(r);
|
|
}),
|
|
o
|
|
);
|
|
})(e, l, u)
|
|
: $
|
|
);
|
|
})([n], e),
|
|
})
|
|
: o && (null == (i = t.onLoad) || i.call(t, n)));
|
|
})();
|
|
}, [t.icon, i]);
|
|
let { name: d, data: p } = l;
|
|
return p
|
|
? ((t, i, n) => {
|
|
var r;
|
|
let s,
|
|
l,
|
|
c,
|
|
u,
|
|
h,
|
|
d,
|
|
p,
|
|
m,
|
|
f,
|
|
g,
|
|
v,
|
|
b,
|
|
I,
|
|
x = i.inline ? te : q,
|
|
w = (function (t, e) {
|
|
let i = { ...t };
|
|
for (let t in e) {
|
|
let n = e[t],
|
|
o = typeof n;
|
|
t in T
|
|
? (null === n ||
|
|
(n && ("string" === o || "number" === o))) &&
|
|
(i[t] = n)
|
|
: o === typeof i[t] && (i[t] = "rotate" === t ? n % 4 : n);
|
|
}
|
|
return i;
|
|
})(x, i),
|
|
S = i.mode || "svg",
|
|
k = {},
|
|
A = i.style || {},
|
|
R = { ...("svg" === S ? K : {}) };
|
|
if (n) {
|
|
let t = y(n, !1, !0);
|
|
if (t) {
|
|
let e = ["iconify"];
|
|
for (let i of ["provider", "prefix"])
|
|
t[i] && e.push("iconify--" + t[i]);
|
|
R.className = e.join(" ");
|
|
}
|
|
}
|
|
for (let t in i) {
|
|
let e = i[t];
|
|
if (void 0 !== e)
|
|
switch (t) {
|
|
case "icon":
|
|
case "style":
|
|
case "children":
|
|
case "onLoad":
|
|
case "mode":
|
|
case "ssr":
|
|
case "fallback":
|
|
break;
|
|
case "_ref":
|
|
R.ref = e;
|
|
break;
|
|
case "className":
|
|
R[t] = (R[t] ? R[t] + " " : "") + e;
|
|
break;
|
|
case "inline":
|
|
case "hFlip":
|
|
case "vFlip":
|
|
w[t] = !0 === e || "true" === e || 1 === e;
|
|
break;
|
|
case "flip":
|
|
"string" == typeof e &&
|
|
(function (t, e) {
|
|
e.split(Y).forEach((e) => {
|
|
switch (e.trim()) {
|
|
case "horizontal":
|
|
t.hFlip = !0;
|
|
break;
|
|
case "vertical":
|
|
t.vFlip = !0;
|
|
}
|
|
});
|
|
})(w, e);
|
|
break;
|
|
case "color":
|
|
k.color = e;
|
|
break;
|
|
case "rotate":
|
|
"string" == typeof e
|
|
? (w[t] = (function (t, e = 0) {
|
|
let i = t.replace(/^-?[0-9.]*/, "");
|
|
function n(t) {
|
|
for (; t < 0; ) t += 4;
|
|
return t % 4;
|
|
}
|
|
if ("" === i) {
|
|
let e = parseInt(t);
|
|
return isNaN(e) ? 0 : n(e);
|
|
}
|
|
if (i !== t) {
|
|
let e = 0;
|
|
switch (i) {
|
|
case "%":
|
|
e = 25;
|
|
break;
|
|
case "deg":
|
|
e = 90;
|
|
}
|
|
if (e) {
|
|
let o = parseFloat(
|
|
t.slice(0, t.length - i.length),
|
|
);
|
|
return isNaN(o)
|
|
? 0
|
|
: (o /= e) % 1 == 0
|
|
? n(o)
|
|
: 0;
|
|
}
|
|
}
|
|
return e;
|
|
})(e))
|
|
: "number" == typeof e && (w[t] = e);
|
|
break;
|
|
case "ariaHidden":
|
|
case "aria-hidden":
|
|
!0 !== e && "true" !== e && delete R["aria-hidden"];
|
|
break;
|
|
default:
|
|
void 0 === x[t] && (R[t] = e);
|
|
}
|
|
}
|
|
let D =
|
|
((c = { ...a, ...t }),
|
|
(u = { ...P, ...w }),
|
|
(h = {
|
|
left: c.left,
|
|
top: c.top,
|
|
width: c.width,
|
|
height: c.height,
|
|
}),
|
|
(d = c.body),
|
|
[c, u].forEach((t) => {
|
|
var e, i, n, o;
|
|
let r,
|
|
s,
|
|
a = [],
|
|
l = t.hFlip,
|
|
c = t.vFlip,
|
|
u = t.rotate;
|
|
switch (
|
|
(l
|
|
? c
|
|
? (u += 2)
|
|
: (a.push(
|
|
"translate(" +
|
|
(h.width + h.left).toString() +
|
|
" " +
|
|
(0 - h.top).toString() +
|
|
")",
|
|
),
|
|
a.push("scale(-1 1)"),
|
|
(h.top = h.left = 0))
|
|
: c &&
|
|
(a.push(
|
|
"translate(" +
|
|
(0 - h.left).toString() +
|
|
" " +
|
|
(h.height + h.top).toString() +
|
|
")",
|
|
),
|
|
a.push("scale(1 -1)"),
|
|
(h.top = h.left = 0)),
|
|
u < 0 && (u -= 4 * Math.floor(u / 4)),
|
|
(u %= 4))
|
|
) {
|
|
case 1:
|
|
a.unshift(
|
|
"rotate(90 " +
|
|
(r = h.height / 2 + h.top).toString() +
|
|
" " +
|
|
r.toString() +
|
|
")",
|
|
);
|
|
break;
|
|
case 2:
|
|
a.unshift(
|
|
"rotate(180 " +
|
|
(h.width / 2 + h.left).toString() +
|
|
" " +
|
|
(h.height / 2 + h.top).toString() +
|
|
")",
|
|
);
|
|
break;
|
|
case 3:
|
|
a.unshift(
|
|
"rotate(-90 " +
|
|
(r = h.width / 2 + h.left).toString() +
|
|
" " +
|
|
r.toString() +
|
|
")",
|
|
);
|
|
}
|
|
u % 2 == 1 &&
|
|
(h.left !== h.top &&
|
|
((r = h.left), (h.left = h.top), (h.top = r)),
|
|
h.width !== h.height &&
|
|
((r = h.width), (h.width = h.height), (h.height = r))),
|
|
a.length &&
|
|
((e = d),
|
|
(i = '<g transform="' + a.join(" ") + '">'),
|
|
(n = (s = (function (t, e = "defs") {
|
|
let i = "",
|
|
n = t.indexOf("<" + e);
|
|
for (; n >= 0; ) {
|
|
let o = t.indexOf(">", n),
|
|
r = t.indexOf("</" + e);
|
|
if (-1 === o || -1 === r) break;
|
|
let s = t.indexOf(">", r);
|
|
if (-1 === s) break;
|
|
(i += t.slice(o + 1, r).trim()),
|
|
(t = t.slice(0, n).trim() + t.slice(s + 1));
|
|
}
|
|
return { defs: i, content: t };
|
|
})(e)).defs),
|
|
(o = i + s.content + "</g>"),
|
|
(d = n ? "<defs>" + n + "</defs>" + o : o));
|
|
}),
|
|
(p = u.width),
|
|
(m = u.height),
|
|
(f = h.width),
|
|
(g = h.height),
|
|
null === p
|
|
? (s = C(
|
|
(l = null === m ? "1em" : "auto" === m ? g : m),
|
|
f / g,
|
|
))
|
|
: ((s = "auto" === p ? f : p),
|
|
(l = null === m ? C(s, g / f) : "auto" === m ? g : m)),
|
|
(v = {}),
|
|
(b = (t, e) => {
|
|
"unset" !== e &&
|
|
"undefined" !== e &&
|
|
"none" !== e &&
|
|
(v[t] = e.toString());
|
|
})("width", s),
|
|
b("height", l),
|
|
(v.viewBox = (I = [h.left, h.top, f, g]).join(" ")),
|
|
{ attributes: v, viewBox: I, body: d }),
|
|
V = D.attributes;
|
|
if ((w.inline && (k.verticalAlign = "-0.125em"), "svg" === S)) {
|
|
(R.style = { ...k, ...A }), Object.assign(R, V);
|
|
let t = 0,
|
|
n = i.id;
|
|
return (
|
|
"string" == typeof n && (n = n.replace(/-/g, "_")),
|
|
(R.dangerouslySetInnerHTML = {
|
|
__html:
|
|
((r = (function (t, e = L) {
|
|
let i,
|
|
n = [];
|
|
for (; (i = E.exec(t)); ) n.push(i[1]);
|
|
if (!n.length) return t;
|
|
let o =
|
|
"suffix" +
|
|
((0x1000000 * Math.random()) | Date.now()).toString(16);
|
|
return (
|
|
n.forEach((i) => {
|
|
let n =
|
|
"function" == typeof e
|
|
? e(i)
|
|
: e + (M++).toString(),
|
|
r = i.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
|
t = t.replace(
|
|
RegExp('([#;"])(' + r + ')([")]|\\.[a-z])', "g"),
|
|
"$1" + n + o + "$3",
|
|
);
|
|
}),
|
|
(t = t.replace(RegExp(o, "g"), ""))
|
|
);
|
|
})(D.body, n ? () => n + "ID" + t++ : "iconifyReact")),
|
|
void 0 === e &&
|
|
(function () {
|
|
try {
|
|
e = window.trustedTypes.createPolicy("iconify", {
|
|
createHTML: (t) => t,
|
|
});
|
|
} catch (t) {
|
|
e = null;
|
|
}
|
|
})(),
|
|
e ? e.createHTML(r) : r),
|
|
}),
|
|
(0, o.createElement)("svg", R)
|
|
);
|
|
}
|
|
let { body: F, width: j, height: N } = t,
|
|
B =
|
|
"mask" === S ||
|
|
("bg" !== S && -1 !== F.indexOf("currentColor")),
|
|
O = (function (t, e) {
|
|
let i =
|
|
-1 === t.indexOf("xlink:")
|
|
? ""
|
|
: ' xmlns:xlink="http://www.w3.org/1999/xlink"';
|
|
for (let t in e) i += " " + t + '="' + e[t] + '"';
|
|
return (
|
|
'<svg xmlns="http://www.w3.org/2000/svg"' +
|
|
i +
|
|
">" +
|
|
t +
|
|
"</svg>"
|
|
);
|
|
})(F, { ...V, width: j + "", height: N + "" });
|
|
return (
|
|
(R.style = {
|
|
...k,
|
|
"--svg":
|
|
'url("data:image/svg+xml,' +
|
|
O.replace(/"/g, "'")
|
|
.replace(/%/g, "%25")
|
|
.replace(/#/g, "%23")
|
|
.replace(/</g, "%3C")
|
|
.replace(/>/g, "%3E")
|
|
.replace(/\s+/g, " ") +
|
|
'")',
|
|
width: ti(V.width),
|
|
height: ti(V.height),
|
|
..._,
|
|
...(B ? Z : Q),
|
|
...A,
|
|
}),
|
|
(0, o.createElement)("span", R)
|
|
);
|
|
})({ ...a, ...p }, t, d)
|
|
: t.children
|
|
? t.children
|
|
: t.fallback
|
|
? t.fallback
|
|
: (0, o.createElement)("span", {});
|
|
}
|
|
let to = (0, o.forwardRef)((t, e) => tn({ ...t, _ref: e }));
|
|
(0, o.forwardRef)((t, e) => tn({ inline: !0, ...t, _ref: e })),
|
|
t.s(["Icon", () => to, "addCollection", () => S], 968336),
|
|
fetch("/icons/libtv.json")
|
|
.then((t) => t.json())
|
|
.then((t) => S(t))
|
|
.catch((t) =>
|
|
console.warn("[Icons] Failed to load libtv icon collection:", t),
|
|
);
|
|
let tr = ({
|
|
icon: t,
|
|
className: e,
|
|
style: i,
|
|
width: o,
|
|
height: r,
|
|
color: s,
|
|
isLoading: a,
|
|
}) => {
|
|
let l = `pointer-events-none ${e || ""}`;
|
|
return a
|
|
? (0, n.jsx)(to, {
|
|
className: `animate-spin ${l}`,
|
|
color: s,
|
|
height: r,
|
|
icon: "libtv:loading",
|
|
style: i,
|
|
width: o,
|
|
})
|
|
: (0, n.jsx)(to, {
|
|
className: l,
|
|
color: s,
|
|
height: r,
|
|
icon: t,
|
|
style: i,
|
|
width: o,
|
|
});
|
|
},
|
|
ts = (t, e) => {
|
|
let i = ({
|
|
className: t,
|
|
style: i,
|
|
width: o,
|
|
height: r,
|
|
color: s,
|
|
isLoading: a,
|
|
}) =>
|
|
(0, n.jsx)(tr, {
|
|
className: t,
|
|
color: s,
|
|
height: r,
|
|
icon: e,
|
|
isLoading: a,
|
|
style: i,
|
|
width: o,
|
|
});
|
|
return (i.displayName = t), i;
|
|
},
|
|
ta = {
|
|
"3d": ts("3dIcon", "libtv:3d"),
|
|
"3dAdd": ts("3dAddIcon", "libtv:3d-add"),
|
|
"3dAddS": ts("3dAddSIcon", "libtv:3d-add-s"),
|
|
Add: ts("AddIcon", "libtv:add"),
|
|
AddImg: ts("AddImgIcon", "libtv:add-img"),
|
|
AddVideoL: ts("AddVideoLIcon", "libtv:add-video-l"),
|
|
AdderN: ts("AdderNIcon", "libtv:adder-n"),
|
|
Adjustments: ts("AdjustmentsIcon", "libtv:adjustments"),
|
|
AgentFrame: ts("AgentFrameIcon", "libtv:agent-frame"),
|
|
All: ts("AllIcon", "libtv:all"),
|
|
AllAdjust: ts("AllAdjustIcon", "libtv:all-adjust"),
|
|
Analyze: ts("AnalyzeIcon", "libtv:analyze"),
|
|
AnchorEditor: ts("AnchorEditorIcon", "libtv:anchor-editor"),
|
|
Angle: ts("AngleIcon", "libtv:angle"),
|
|
Annotate: ts("AnnotateIcon", "libtv:annotate"),
|
|
Applications: ts("ApplicationsIcon", "libtv:applications"),
|
|
ArchitecturalDesign: ts(
|
|
"ArchitecturalDesignIcon",
|
|
"libtv:architectural-design",
|
|
),
|
|
Arrow: ts("ArrowIcon", "libtv:arrow"),
|
|
ArrowDownLeft: ts("ArrowDownLeftIcon", "libtv:arrow-down-left"),
|
|
ArrowDownRight: ts("ArrowDownRightIcon", "libtv:arrow-down-right"),
|
|
ArrowUpRight: ts("ArrowUpRightIcon", "libtv:arrow-up-right"),
|
|
ArrowshapeleftN: ts("ArrowshapeleftNIcon", "libtv:arrowshapeleft-n"),
|
|
ArrowshaperightN: ts("ArrowshaperightNIcon", "libtv:arrowshaperight-n"),
|
|
Artboard: ts("ArtboardIcon", "libtv:artboard"),
|
|
ArtboardF: ts("ArtboardFIcon", "libtv:artboard-f"),
|
|
AssestN: ts("AssestNIcon", "libtv:assest-n"),
|
|
AtSign: ts("AtSignIcon", "libtv:at-sign"),
|
|
Audio: ts("AudioIcon", "libtv:audio"),
|
|
AudioDisc: ts("AudioDiscIcon", "libtv:audio-disc"),
|
|
AudioNone: ts("AudioNoneIcon", "libtv:none-audio"),
|
|
AudioPlayPending: ts(
|
|
"AudioPlayPendingIcon",
|
|
"libtv:audio-play-pending",
|
|
),
|
|
AudioPlayPlaying: ts(
|
|
"AudioPlayPlayingIcon",
|
|
"libtv:audio-play-playing",
|
|
),
|
|
AudioFile: ts("AudioFileIcon", "libtv:audio-file"),
|
|
AudioLines: ts("AudioLinesIcon", "libtv:audio-lines"),
|
|
AudioVideo: ts("AudioVideoIcon", "libtv:audio-video"),
|
|
AudioWave: ts("AudioWaveIcon", "libtv:audio-wave"),
|
|
AutoHeight: ts("AutoHeightIcon", "libtv:auto-height"),
|
|
AutoWidth: ts("AutoWidthIcon", "libtv:auto-width"),
|
|
Back: ts("BackIcon", "libtv:back"),
|
|
Banana: ts("BananaIcon", "libtv:banana"),
|
|
BatchExport: ts("BatchExportIcon", "libtv:batch-export"),
|
|
Binoculars: ts("BinocularsIcon", "libtv:binoculars"),
|
|
BlendingToolsN: ts("BlendingToolsNIcon", "libtv:blending-tools-n"),
|
|
Blur: ts("BlurIcon", "libtv:blur"),
|
|
Bold: ts("BoldIcon", "libtv:bold"),
|
|
Branding: ts("BrandingIcon", "libtv:branding"),
|
|
BulkDownload: ts("BulkDownloadIcon", "libtv:bulkdownload"),
|
|
BroadPicture: ts("BroadPictureIcon", "libtv:broad-picture"),
|
|
Brush: ts("BrushIcon", "libtv:brush"),
|
|
BrushBold: ts("BrushBoldIcon", "libtv:brush-bold"),
|
|
BrushN: ts("BrushNIcon", "libtv:brush-n"),
|
|
Camera: ts("CameraIcon", "libtv:camera"),
|
|
CameraControl: ts("CameraControlIcon", "libtv:camera-control"),
|
|
CharThreeView: ts("CharThreeViewIcon", "libtv:char-three-view"),
|
|
CharacterDesign: ts("CharacterDesignIcon", "libtv:character-design"),
|
|
ChatshapeN: ts("ChatshapeNIcon", "libtv:chatshape-n"),
|
|
Check: ts("CheckIcon", "libtv:check"),
|
|
CheckL: ts("CheckLIcon", "libtv:check-l"),
|
|
CircleF: ts("CircleFIcon", "libtv:circle-f"),
|
|
Clear: ts("ClearIcon", "libtv:clear"),
|
|
ClickCollapse: ts("ClickCollapseIcon", "libtv:click-collapse"),
|
|
ClickExpand: ts("ClickExpandIcon", "libtv:click-expand"),
|
|
Clock: ts("ClockIcon", "libtv:clock"),
|
|
Clone: ts("CloneIcon", "libtv:clone"),
|
|
Close: ts("CloseIcon", "libtv:close"),
|
|
Color: ts("ColorIcon", "libtv:color"),
|
|
CommentN: ts("CommentNIcon", "libtv:comment-n"),
|
|
Comparison: ts("ComparisonIcon", "libtv:comparison"),
|
|
Computing: ts("ComputingIcon", "libtv:computing"),
|
|
ComputingN: ts("ComputingNIcon", "libtv:computing-n"),
|
|
Copy: ts("CopyIcon", "libtv:copy"),
|
|
CopyLink: ts("CopyLinkIcon", "libtv:copy-link"),
|
|
Corner: ts("CornerIcon", "libtv:corner"),
|
|
CreateDialogue: ts("CreateDialogueIcon", "libtv:create-dialogue"),
|
|
CustomSize: ts("CustomSizeIcon", "libtv:custom-size"),
|
|
Cut: ts("CutIcon", "libtv:cut"),
|
|
DeepThink: ts("DeepThinkIcon", "libtv:deep-think"),
|
|
DeepmindL: ts("DeepmindLIcon", "libtv:deepmind-l"),
|
|
DeleteAccount: ts("DeleteAccountIcon", "libtv:delete-account"),
|
|
DesignTools: ts("DesignToolsIcon", "libtv:design-tools"),
|
|
Discord: ts("DiscordIcon", "libtv:discord"),
|
|
DiscordN: ts("DiscordNIcon", "libtv:discord-n"),
|
|
Discount: ts("DiscountIcon", "libtv:discount"),
|
|
DocumentN: ts("DocumentNIcon", "libtv:document-n"),
|
|
DownL: ts("DownLIcon", "libtv:down-l"),
|
|
DownS: ts("DownSIcon", "libtv:down-s"),
|
|
Download: ts("DownloadIcon", "libtv:download"),
|
|
Drag: ts("DragIcon", "libtv:drag"),
|
|
ECommerce: ts("ECommerceIcon", "libtv:e-commerce"),
|
|
EditHistory: ts("EditHistoryIcon", "libtv:edit-history"),
|
|
Editt: ts("EdittIcon", "libtv:editt"),
|
|
EnhancePrompt: ts("EnhancePromptIcon", "libtv:enhance-prompt"),
|
|
Enterprise: ts("EnterpriseIcon", "libtv:enterprise"),
|
|
EnterpriseN: ts("EnterpriseNIcon", "libtv:enterprise-n"),
|
|
Eraser: ts("EraserIcon", "libtv:eraser"),
|
|
Expand: ts("ExpandIcon", "libtv:expand"),
|
|
ExpandLeft: ts("ExpandLeftIcon", "libtv:expand-left"),
|
|
ExternalDoc: ts("ExternalDocIcon", "libtv:external-doc"),
|
|
Eye: ts("EyeIcon", "libtv:eye"),
|
|
EyeClosed: ts("EyeClosedIcon", "libtv:eye-closed"),
|
|
FileInput: ts("FileInputIcon", "libtv:file-input"),
|
|
FileSearch: ts("FileSearchIcon", "libtv:file-search"),
|
|
FirstFrameS: ts("FirstFrameSIcon", "libtv:first-frame-s"),
|
|
FlipHorizontal: ts("FlipHorizontalIcon", "libtv:flip-horizontal"),
|
|
Float: ts("FloatIcon", "libtv:float"),
|
|
Focus: ts("FocusIcon", "libtv:focus"),
|
|
Folder: ts("FolderIcon", "libtv:folder"),
|
|
FontN: ts("FontNIcon", "libtv:font-n"),
|
|
Fontsl: ts("FontslIcon", "libtv:fontsl"),
|
|
Fontsm: ts("FontsmIcon", "libtv:fontsm"),
|
|
Fontss: ts("FontssIcon", "libtv:fontss"),
|
|
Forward: ts("ForwardIcon", "libtv:forward"),
|
|
Fps: ts("FpsIcon", "libtv:fps"),
|
|
FrameN: ts("FrameNIcon", "libtv:frame-n"),
|
|
ClipFullscreen: ts("ClipFullscreenIcon", "libtv:clip-fullscreen"),
|
|
ClipTimelineSnap: ts(
|
|
"ClipTimelineSnapIcon",
|
|
"libtv:clip-timeline-snap",
|
|
),
|
|
ClipTimelineSplit: ts(
|
|
"ClipTimelineSplitIcon",
|
|
"libtv:clip-timeline-split",
|
|
),
|
|
ClipTimelineTrimLeft: ts(
|
|
"ClipTimelineTrimLeftIcon",
|
|
"libtv:clip-timeline-trim-left",
|
|
),
|
|
ClipTimelineTrimRight: ts(
|
|
"ClipTimelineTrimRightIcon",
|
|
"libtv:clip-timeline-trim-right",
|
|
),
|
|
Fullscreen: ts("FullscreenIcon", "libtv:fullscreen"),
|
|
Generate: ts("GenerateIcon", "libtv:generate"),
|
|
GitFork: ts("GitForkIcon", "libtv:git-fork"),
|
|
GitForkN: ts("GitForkNIcon", "libtv:git-fork-n"),
|
|
Globe: ts("GlobeIcon", "libtv:globe"),
|
|
GlobeN: ts("GlobeNIcon", "libtv:globe-n"),
|
|
GoLiblib: ts("GoLiblibIcon", "libtv:go-liblib"),
|
|
Grid3x3: ts("Grid3x3Icon", "libtv:grid-3x3"),
|
|
GridPercent: ts("GridPercentIcon", "libtv:grid-percent"),
|
|
GridSplit: ts("GridSplitIcon", "libtv:grid-split"),
|
|
Group: ts("GroupIcon", "libtv:group"),
|
|
HandN: ts("HandNIcon", "libtv:hand-n"),
|
|
Hd: ts("HdIcon", "libtv:hd"),
|
|
Heading1: ts("Heading1Icon", "libtv:heading-1"),
|
|
Heading2: ts("Heading2Icon", "libtv:heading-2"),
|
|
Heading3: ts("Heading3Icon", "libtv:heading-3"),
|
|
HeartF: ts("HeartFIcon", "libtv:heart-f"),
|
|
HeartL: ts("HeartLIcon", "libtv:heart-l"),
|
|
Help: ts("HelpIcon", "libtv:help"),
|
|
HelpBoxN: ts("HelpBoxNIcon", "libtv:help-box-n"),
|
|
HelpCircleN: ts("HelpCircleNIcon", "libtv:help-circle-n"),
|
|
HelpF: ts("HelpFIcon", "libtv:help-f"),
|
|
HistoryN: ts("HistoryNIcon", "libtv:history-n"),
|
|
Home: ts("HomeIcon", "libtv:home"),
|
|
HomeN: ts("HomeNIcon", "libtv:home-n"),
|
|
Identify: ts("IdentifyIcon", "libtv:identify"),
|
|
Illustration: ts("IllustrationIcon", "libtv:illustration"),
|
|
Image: ts("ImageIcon", "libtv:image"),
|
|
ImageGeneration: ts("ImageGenerationIcon", "libtv:image-generation"),
|
|
ImageGenerationC: ts(
|
|
"ImageGenerationCIcon",
|
|
"libtv:image-generation-c",
|
|
),
|
|
ImageGeneratorN: ts("ImageGeneratorNIcon", "libtv:image-generator-n"),
|
|
ImagePlaceholder: ts("ImagePlaceholderIcon", "libtv:image-placeholder"),
|
|
ImageProcessing: ts("ImageProcessingIcon", "libtv:image-processing"),
|
|
ImageS: ts("ImageSIcon", "libtv:image-s"),
|
|
Imagepromt: ts("ImagepromtIcon", "libtv:imagepromt"),
|
|
Imageset: ts("ImagesetIcon", "libtv:imageset"),
|
|
ImagesetF: ts("ImagesetFIcon", "libtv:imageset-f"),
|
|
ImportedVideo: ts("ImportedVideoIcon", "libtv:imported-video"),
|
|
InfoL: ts("InfoLIcon", "libtv:info-l"),
|
|
InfoN: ts("InfoNIcon", "libtv:info-n"),
|
|
InfoSurface: ts("InfoSurfaceIcon", "libtv:info-surface"),
|
|
Inspiration: ts("InspirationIcon", "libtv:inspiration"),
|
|
InvitationCode: ts("InvitationCodeIcon", "libtv:invitation-code"),
|
|
InvitationN: ts("InvitationNIcon", "libtv:invitation-n"),
|
|
Invite: ts("InviteIcon", "libtv:invite"),
|
|
InviteGift: ts("InviteGiftIcon", "libtv:invite-gift"),
|
|
Italic: ts("ItalicIcon", "libtv:italic"),
|
|
LanguageN: ts("LanguageNIcon", "libtv:language-n"),
|
|
LayerAdder: ts("LayerAdderIcon", "libtv:layer-adder"),
|
|
LayerFilter: ts("LayerFilterIcon", "libtv:layer-filter"),
|
|
LayerN: ts("LayerNIcon", "libtv:layer-n"),
|
|
LayersF: ts("LayersFIcon", "libtv:layers-f"),
|
|
LayoutFree: ts("LayoutFreeIcon", "libtv:layout-free"),
|
|
LayoutGrid: ts("LayoutGridIcon", "libtv:layout-grid"),
|
|
LayoutList: ts("LayoutListIcon", "libtv:layout-list"),
|
|
LayoutN: ts("LayoutNIcon", "libtv:layout-n"),
|
|
LayoutPanelTop: ts("LayoutPanelTopIcon", "libtv:layout-panel-top"),
|
|
Left: ts("LeftIcon", "libtv:left"),
|
|
LeftS: ts("LeftSIcon", "libtv:left-s"),
|
|
Lightning: ts("LightningIcon", "libtv:lightning"),
|
|
LightningF: ts("LightningFIcon", "libtv:lightning-f"),
|
|
LikeF: ts("LikeFIcon", "libtv:like-f"),
|
|
LikeL: ts("LikeLIcon", "libtv:like-l"),
|
|
LinkedN: ts("LinkedNIcon", "libtv:linked-n"),
|
|
List: ts("ListIcon", "libtv:list"),
|
|
ListDetail: ts("ListDetailIcon", "libtv:list-detail"),
|
|
ListOrdered: ts("ListOrderedIcon", "libtv:list-ordered"),
|
|
Loading: ts("LoadingIcon", "libtv:loading"),
|
|
LocalAdjust: ts("LocalAdjustIcon", "libtv:local-adjust"),
|
|
LocalSelection: ts("LocalSelectionIcon", "libtv:local-selection"),
|
|
LocateHistory: ts("LocateHistoryIcon", "libtv:locate-history"),
|
|
Lock: ts("LockIcon", "libtv:lock"),
|
|
KeyRound: ts("KeyRoundIcon", "libtv:key-round"),
|
|
LogoL: ts("LogoLIcon", "libtv:logo-l"),
|
|
Lora: ts("LoraIcon", "libtv:lora"),
|
|
MagicWand: ts("MagicWandIcon", "libtv:magic-wand"),
|
|
MailN: ts("MailNIcon", "libtv:mail-n"),
|
|
MapPinned: ts("MapPinnedIcon", "libtv:map-pinned"),
|
|
Mark: ts("MarkIcon", "libtv:mark"),
|
|
MarkF: ts("MarkFIcon", "libtv:mark-f"),
|
|
Markpen: ts("MarkpenIcon", "libtv:markpen"),
|
|
Mask: ts("MaskIcon", "libtv:mask"),
|
|
Merge: ts("MergeIcon", "libtv:merge"),
|
|
MessageClock: ts("MessageClockIcon", "libtv:message-clock"),
|
|
MessageComment: ts("MessageCommentIcon", "libtv:message-comment"),
|
|
MidjourneyS: ts("MidjourneySIcon", "libtv:midjourney-s"),
|
|
Minimize: ts("MinimizeIcon", "libtv:minimize"),
|
|
Minimum: ts("MinimumIcon", "libtv:minimum"),
|
|
Minus: ts("MinusIcon", "libtv:minus"),
|
|
Mirror: ts("MirrorIcon", "libtv:mirror"),
|
|
Mock: ts("MockIcon", "libtv:mock"),
|
|
MoodboardTools: ts("MoodboardToolsIcon", "libtv:moodboard-tools"),
|
|
More: ts("MoreIcon", "libtv:more"),
|
|
MoreLike: ts("MoreLikeIcon", "libtv:more-like"),
|
|
MouseN: ts("MouseNIcon", "libtv:mouse-n"),
|
|
MousePointerClick: ts(
|
|
"MousePointerClickIcon",
|
|
"libtv:mouse-pointer-click",
|
|
),
|
|
NewProject: ts("NewProjectIcon", "libtv:new-project"),
|
|
NextStep: ts("NextStepIcon", "libtv:next-step"),
|
|
NineGridPreset: ts("NineGridPresetIcon", "libtv:nine-grid-preset"),
|
|
Notification: ts("NotificationIcon", "libtv:notification"),
|
|
NotificationN: ts("NotificationNIcon", "libtv:notification-n"),
|
|
OffAudio: ts("OffAudioIcon", "libtv:off-audio"),
|
|
OrderDetail: ts("OrderDetailIcon", "libtv:order-detail"),
|
|
Other: ts("OtherIcon", "libtv:other"),
|
|
OtherN: ts("OtherNIcon", "libtv:other-n"),
|
|
Paint: ts("PaintIcon", "libtv:paint"),
|
|
Palette: ts("PaletteIcon", "libtv:palette"),
|
|
PanelRight: ts("PanelRightIcon", "libtv:panel-right"),
|
|
Paperclip: ts("PaperclipIcon", "libtv:paperclip"),
|
|
Params: ts("ParamsIcon", "libtv:params"),
|
|
PauseF: ts("PauseFIcon", "libtv:pause-f"),
|
|
PauseL: ts("PauseLIcon", "libtv:pause-l"),
|
|
Payment: ts("PaymentIcon", "libtv:payment"),
|
|
Pen: ts("PenIcon", "libtv:pen"),
|
|
PenEdit: ts("PenEditIcon", "libtv:pen-edit"),
|
|
PenLine: ts("PenLineIcon", "libtv:pen-line"),
|
|
PenN: ts("PenNIcon", "libtv:pen-n"),
|
|
PenPaper: ts("PenPaperIcon", "libtv:pen-paper"),
|
|
Pencil: ts("PencilIcon", "libtv:pencil"),
|
|
Personal: ts("PersonalIcon", "libtv:personal"),
|
|
PersonalCircleN: ts("PersonalCircleNIcon", "libtv:personal-circle-n"),
|
|
PersonalSettings: ts("PersonalSettingsIcon", "libtv:personal-settings"),
|
|
PerspnalN: ts("PerspnalNIcon", "libtv:perspnal-n"),
|
|
PicVideo: ts("PicVideoIcon", "libtv:pic-video"),
|
|
PictureInPictureF: ts(
|
|
"PictureInPictureFIcon",
|
|
"libtv:picture-in-picture-f",
|
|
),
|
|
PictureInPictureL: ts(
|
|
"PictureInPictureLIcon",
|
|
"libtv:picture-in-picture-l",
|
|
),
|
|
PictureLoss: ts("PictureLossIcon", "libtv:picture-loss"),
|
|
Pilcrow: ts("PilcrowIcon", "libtv:pilcrow"),
|
|
Pin: ts("PinIcon", "libtv:pin"),
|
|
PinOff: ts("PinOffIcon", "libtv:pin-off"),
|
|
Play: ts("PlayIcon", "libtv:play"),
|
|
PlayEnd: ts("PlayEndIcon", "libtv:play-end"),
|
|
PlayLine: ts("PlayLineIcon", "libtv:play-line"),
|
|
PlusL: ts("PlusLIcon", "libtv:plus-l"),
|
|
PlusS: ts("PlusSIcon", "libtv:plus-s"),
|
|
PolygonN: ts("PolygonNIcon", "libtv:polygon-n"),
|
|
PositionCanvas: ts("PositionCanvasIcon", "libtv:position-canvas"),
|
|
Poster: ts("PosterIcon", "libtv:poster"),
|
|
PreviewCollapse: ts("PreviewCollapseIcon", "libtv:preview-collapse"),
|
|
PreviewExpand: ts("PreviewExpandIcon", "libtv:preview-expand"),
|
|
Ppt: ts("PptIcon", "libtv:ppt"),
|
|
PrivacyN: ts("PrivacyNIcon", "libtv:privacy-n"),
|
|
ProductDesign: ts("ProductDesignIcon", "libtv:product-design"),
|
|
Profile: ts("ProfileIcon", "libtv:profile"),
|
|
Quit: ts("QuitIcon", "libtv:quit"),
|
|
QuitN: ts("QuitNIcon", "libtv:quit-n"),
|
|
Radius: ts("RadiusIcon", "libtv:radius"),
|
|
RadiusSingle: ts("RadiusSingleIcon", "libtv:radius-single"),
|
|
Rasterize: ts("RasterizeIcon", "libtv:rasterize"),
|
|
RectangleN: ts("RectangleNIcon", "libtv:rectangle-n"),
|
|
Redo: ts("RedoIcon", "libtv:redo"),
|
|
Refresh: ts("RefreshIcon", "libtv:refresh"),
|
|
RefreshN: ts("RefreshNIcon", "libtv:refresh-n"),
|
|
Regenerate: ts("RegenerateIcon", "libtv:regenerate"),
|
|
Relight: ts("RelightIcon", "libtv:relight"),
|
|
Repaint: ts("RepaintIcon", "libtv:repaint"),
|
|
RemoveBg: ts("RemoveBgIcon", "libtv:remove-bg"),
|
|
Repeat: ts("RepeatIcon", "libtv:repeat"),
|
|
Restore: ts("RestoreIcon", "libtv:restore"),
|
|
RiceEar: ts("RiceEarIcon", "libtv:rice-ear"),
|
|
Right: ts("RightIcon", "libtv:right"),
|
|
RightS: ts("RightSIcon", "libtv:right-s"),
|
|
Rocket: ts("RocketIcon", "libtv:rocket"),
|
|
RocketN: ts("RocketNIcon", "libtv:rocket-n"),
|
|
RoleF: ts("RoleFIcon", "libtv:role-f"),
|
|
Rotate: ts("RotateIcon", "libtv:rotate"),
|
|
Rotate3d: ts("Rotate3dIcon", "libtv:rotate-3d"),
|
|
RotateImage: ts("RotateImageIcon", "libtv:rotate-image"),
|
|
RoundN: ts("RoundNIcon", "libtv:round-n"),
|
|
RowSpace: ts("RowSpaceIcon", "libtv:row-space"),
|
|
Save: ts("SaveIcon", "libtv:save"),
|
|
Search: ts("SearchIcon", "libtv:search"),
|
|
SearchC: ts("SearchCIcon", "libtv:search-c"),
|
|
SecondEdit: ts("SecondEditIcon", "libtv:second-edit"),
|
|
SeedreamS: ts("SeedreamSIcon", "libtv:seedream-s"),
|
|
Send: ts("SendIcon", "libtv:send"),
|
|
SendCanvas: ts("SendCanvasIcon", "libtv:send-canvas"),
|
|
SendChat: ts("SendChatIcon", "libtv:send-chat"),
|
|
Sendtoleft: ts("SendtoleftIcon", "libtv:sendtoleft"),
|
|
SetUp: ts("SetUpIcon", "libtv:set-up"),
|
|
Share: ts("ShareIcon", "libtv:share"),
|
|
ShieldCheck: ts("ShieldCheckIcon", "libtv:shield-check"),
|
|
Shortcut: ts("ShortcutIcon", "libtv:shortcut"),
|
|
ShortcutN: ts("ShortcutNIcon", "libtv:shortcut-n"),
|
|
Shrink: ts("ShrinkIcon", "libtv:shrink"),
|
|
SidebarRight: ts("SidebarRightIcon", "libtv:sidebar-right"),
|
|
Skill: ts("SkillIcon", "libtv:skill"),
|
|
SmartCanvas: ts("SmartCanvasIcon", "libtv:smart-canvas"),
|
|
SmartSelection: ts("SmartSelectionIcon", "libtv:smart-selection"),
|
|
SmartSelectionF: ts("SmartSelectionFIcon", "libtv:smart-selection-f"),
|
|
SmartSplit: ts("SmartSplitIcon", "libtv:smart-split"),
|
|
Smartphone: ts("SmartphoneIcon", "libtv:smartphone"),
|
|
SmartphoneN: ts("SmartphoneNIcon", "libtv:smartphone-n"),
|
|
Snow: ts("SnowIcon", "libtv:snow"),
|
|
Sort: ts("SortIcon", "libtv:sort"),
|
|
SparkleF: ts("SparkleFIcon", "libtv:sparkle-f"),
|
|
SparklePlus: ts("SparklePlusIcon", "libtv:sparkle-plus"),
|
|
Split: ts("SplitIcon", "libtv:split"),
|
|
SquareDashed: ts("SquareDashedIcon", "libtv:square-dashed"),
|
|
SquarePlay: ts("SquarePlayIcon", "libtv:square-play"),
|
|
SquareScissors: ts("SquareScissorsIcon", "libtv:square-scissors"),
|
|
Sun: ts("SunIcon", "libtv:sun"),
|
|
StarF: ts("StarFIcon", "libtv:star-f"),
|
|
StarL: ts("StarLIcon", "libtv:star-l"),
|
|
StarN: ts("StarNIcon", "libtv:star-n"),
|
|
StartF: ts("StartFIcon", "libtv:start-f"),
|
|
StartL: ts("StartLIcon", "libtv:start-l"),
|
|
Stamp: ts("StampIcon", "libtv:stamp"),
|
|
Step: ts("StepIcon", "libtv:step"),
|
|
StoryboardAi: ts("StoryboardAiIcon", "libtv:storyboard-ai"),
|
|
Straw: ts("StrawIcon", "libtv:straw"),
|
|
Strikethrough: ts("StrikethroughIcon", "libtv:strikethrough"),
|
|
StrokeWidth: ts("StrokeWidthIcon", "libtv:stroke-width"),
|
|
Style: ts("StyleIcon", "libtv:style"),
|
|
Sublock: ts("SublockIcon", "libtv:sublock"),
|
|
Suggestion: ts("SuggestionIcon", "libtv:suggestion"),
|
|
Svg: ts("SvgIcon", "libtv:svg"),
|
|
Swap: ts("SwapIcon", "libtv:swap"),
|
|
Switch: ts("SwitchIcon", "libtv:switch"),
|
|
Target: ts("TargetIcon", "libtv:target"),
|
|
Team: ts("TeamIcon", "libtv:team"),
|
|
TeamCreated: ts("TeamCreatedIcon", "libtv:team-created"),
|
|
TempleteN: ts("TempleteNIcon", "libtv:templete-n"),
|
|
Terms: ts("TermsIcon", "libtv:terms"),
|
|
TermsS: ts("TermsSIcon", "libtv:terms-s"),
|
|
TextAlignCenter: ts("TextAlignCenterIcon", "libtv:text-align-center"),
|
|
TextAlignLeft: ts("TextAlignLeftIcon", "libtv:text-align-left"),
|
|
TextAlignRight: ts("TextAlignRightIcon", "libtv:text-align-right"),
|
|
TextFile: ts("TextFileIcon", "libtv:text-file"),
|
|
TextFill: ts("TextFillIcon", "libtv:text-fill"),
|
|
TextImages: ts("TextImagesIcon", "libtv:text-images"),
|
|
TextN: ts("TextNIcon", "libtv:text-n"),
|
|
TextSpace: ts("TextSpaceIcon", "libtv:text-space"),
|
|
TextStorke: ts("TextStorkeIcon", "libtv:text-storke"),
|
|
Textchange: ts("TextchangeIcon", "libtv:textchange"),
|
|
Think: ts("ThinkIcon", "libtv:think"),
|
|
ThumbnailAudio: ts("ThumbnailAudioIcon", "libtv:thumbnail-audio"),
|
|
ThumbsDown: ts("ThumbsDownIcon", "libtv:thumbs-down"),
|
|
ThumbsDownF: ts("ThumbsDownFIcon", "libtv:thumbs-down-f"),
|
|
ThumbsUp: ts("ThumbsUpIcon", "libtv:thumbs-up"),
|
|
ThumbsUpF: ts("ThumbsUpFIcon", "libtv:thumbs-up-f"),
|
|
Tool: ts("ToolIcon", "libtv:tool"),
|
|
ToolboxN: ts("ToolboxNIcon", "libtv:toolbox-n"),
|
|
Translate: ts("TranslateIcon", "libtv:translate"),
|
|
Trash: ts("TrashIcon", "libtv:trash"),
|
|
TuiteN: ts("TuiteNIcon", "libtv:tuite-n"),
|
|
UesStyle: ts("UesStyleIcon", "libtv:ues-style"),
|
|
UiLayout: ts("UiLayoutIcon", "libtv:ui-layout"),
|
|
Underline: ts("UnderlineIcon", "libtv:underline"),
|
|
Undo: ts("UndoIcon", "libtv:undo"),
|
|
Ungroup: ts("UngroupIcon", "libtv:ungroup"),
|
|
Unlimited: ts("UnlimitedIcon", "libtv:unlimited"),
|
|
Unlock: ts("UnlockIcon", "libtv:unlock"),
|
|
UpArrow: ts("UpArrowIcon", "libtv:up-arrow"),
|
|
UpDownArrows: ts("UpDownArrowsIcon", "libtv:up-down-arrows"),
|
|
UpL: ts("UpLIcon", "libtv:up-l"),
|
|
UpS: ts("UpSIcon", "libtv:up-s"),
|
|
Upload: ts("UploadIcon", "libtv:upload"),
|
|
UploadImageN: ts("UploadImageNIcon", "libtv:upload-image-n"),
|
|
UploadImg: ts("UploadImgIcon", "libtv:upload-img"),
|
|
UploadVideoL: ts("UploadVideoLIcon", "libtv:upload-video-l"),
|
|
UploadVideoN: ts("UploadVideoNIcon", "libtv:upload-video-n"),
|
|
UsageBox: ts("UsageBoxIcon", "libtv:usage-box"),
|
|
Vector: ts("VectorIcon", "libtv:vector"),
|
|
VectorL: ts("VectorLIcon", "libtv:vector-l"),
|
|
Vertical: ts("VerticalIcon", "libtv:vertical"),
|
|
VideoAdd: ts("VideoAddIcon", "libtv:video-add"),
|
|
VideoAddS: ts("VideoAddSIcon", "libtv:video-add-s"),
|
|
VideoBox: ts("VideoBoxIcon", "libtv:video-box"),
|
|
VideoExtend: ts("VideoExtendIcon", "libtv:video-extend"),
|
|
VideoGen: ts("VideoGenIcon", "libtv:video-gen"),
|
|
VideoGeneratorN: ts("VideoGeneratorNIcon", "libtv:video-generator-n"),
|
|
VideoLoss: ts("VideoLossIcon", "libtv:video-loss"),
|
|
View: ts("ViewIcon", "libtv:view"),
|
|
WarnF: ts("WarnFIcon", "libtv:warn-f"),
|
|
WarnL: ts("WarnLIcon", "libtv:warn-l"),
|
|
Zoom: ts("ZoomIcon", "libtv:zoom"),
|
|
ZoomOut: ts("ZoomOutIcon", "libtv:zoom-out"),
|
|
gift: ts("GiftIcon", "libtv:gift"),
|
|
MemberStore: ts("MemberStoreIcon", "libtv:member-store"),
|
|
chatBubbleError: ts("ChatBubbleErrorIcon", "tdesign:chat-bubble-error"),
|
|
chatBubbleHelp: ts("ChatBubbleHelpIcon", "tdesign:chat-bubble-help"),
|
|
infoCircle: ts("InfoCircleIcon", "tdesign:info-circle"),
|
|
closeCircle: ts("CloseCircleIcon", "tdesign:close-circle"),
|
|
close: ts("CloseIcon", "libtv:close"),
|
|
checkCircle: ts("CheckCircleIcon", "tdesign:check-circle"),
|
|
check: ts("CheckIcon", "libtv:check"),
|
|
playCircleFilled: ts(
|
|
"PlayCircleFilledIcon",
|
|
"tdesign:play-circle-filled",
|
|
),
|
|
play: ts("PlayIcon", "libtv:play"),
|
|
audioNone: ts("AudioNoneIcon", "libtv:none-audio"),
|
|
audioPlayPending: ts(
|
|
"AudioPlayPendingIcon",
|
|
"libtv:audio-play-pending",
|
|
),
|
|
audioPlayPlaying: ts(
|
|
"AudioPlayPlayingIcon",
|
|
"libtv:audio-play-playing",
|
|
),
|
|
chevronUp: ts("ChevronUpIcon", "libtv:up-s"),
|
|
chevronDown: ts("ChevronDownIcon", "libtv:down-s"),
|
|
chevronRight: ts("ChevronRightIcon", "libtv:right-s"),
|
|
chevronLeft: ts("ChevronLeftIcon", "libtv:left-s"),
|
|
arrowRightUp: ts("ArrowRightUpIcon", "tdesign:arrow-right-up"),
|
|
arrowRight: ts("ArrowRightIcon", "tdesign:arrow-right"),
|
|
arrowLeft: ts("ArrowLeftIcon", "tdesign:arrow-left"),
|
|
crookedSmile: ts("CrookedSmileIcon", "tdesign:crooked-smile"),
|
|
menu: ts("MenuIcon", "tdesign:view-list"),
|
|
mapNavigation: ts("MapNavigationIcon", "tdesign:map-navigation"),
|
|
animation: ts("AnimationIcon", "tdesign:animation"),
|
|
rocket: ts("RocketIcon", "libtv:rocket"),
|
|
vipModel: ts("VipModelIcon", "libtv:vip-model"),
|
|
twitterX: ts("TwitterXIcon", "fa6-brands:square-x-twitter"),
|
|
twitterXLine: ts("TwitterXLineIcon", "ri:twitter-x-line"),
|
|
discord: ts("DiscordIcon", "bxl:discord-alt"),
|
|
linkedin: ts("LinkedinIcon", "bxl:linkedin"),
|
|
youtube: ts("YoutubeIcon", "bxl:youtube"),
|
|
instagram: ts("InstagramIcon", "bxl:instagram"),
|
|
tiktok: ts("TiktokIcon", "bxl:tiktok"),
|
|
apple: ts("AppleIcon", "bxl:apple"),
|
|
tablerHelp: ts("TablerHelpIcon", "libtv:help"),
|
|
home: ts("HomeIcon", "libtv:home"),
|
|
folder: ts("FolderIcon", "libtv:folder"),
|
|
plus: ts("PlusIcon", "libtv:plus-s"),
|
|
loader2: ts("Loader2Icon", "libtv:loading"),
|
|
lucideChevronDown: ts("LucideChevronDownIcon", "libtv:down-s"),
|
|
lucidePlay: ts("LucidePlayIcon", "libtv:play"),
|
|
lucideCheck: ts("LucideCheckIcon", "libtv:check"),
|
|
image: ts("ImageIcon", "libtv:image"),
|
|
camera: ts("CameraIcon", "libtv:camera"),
|
|
layers: ts("LayersIcon", "libtv:layers-f"),
|
|
sparkles: ts("SparklesIcon", "libtv:sparkle-f"),
|
|
expand: ts("ExpandIcon", "libtv:expand"),
|
|
pilcrow: ts("PilcrowIcon", "libtv:pilcrow"),
|
|
list: ts("ListIcon", "libtv:list"),
|
|
listOrdered: ts("ListOrderedIcon", "libtv:list-ordered"),
|
|
minus: ts("MinusIcon", "libtv:minus"),
|
|
copy: ts("CopyIcon", "libtv:copy"),
|
|
upload: ts("UploadIcon", "libtv:upload"),
|
|
gallerySelect: ts("GallerySelectIcon", "libtv:gallery-select"),
|
|
layoutGrid: ts("LayoutGridIcon", "libtv:layout-grid"),
|
|
x: ts("XIcon", "libtv:close"),
|
|
search: ts("SearchIcon", "libtv:search"),
|
|
heart: ts("HeartIcon", "libtv:heart-l"),
|
|
helpCircle: ts("HelpCircleIcon", "libtv:help-circle-n"),
|
|
ungroup: ts("UngroupIcon", "libtv:ungroup"),
|
|
trash2: ts("Trash2Icon", "libtv:trash"),
|
|
download: ts("DownloadIcon", "libtv:download"),
|
|
palette: ts("PaletteIcon", "libtv:palette"),
|
|
ellipsis: ts("EllipsisIcon", "libtv:more"),
|
|
pencil: ts("PencilIcon", "libtv:pencil"),
|
|
group: ts("GroupIcon", "libtv:group"),
|
|
eye: ts("EyeIcon", "libtv:eye"),
|
|
eyeOff: ts("EyeOffIcon", "libtv:eye-closed"),
|
|
contact: ts("ContactIcon", "libtv:contact"),
|
|
user: ts("UserIcon", "libtv:perspnal-n"),
|
|
lucidePause: ts("LucidePauseIcon", "libtv:pause-l"),
|
|
video: ts("VideoIcon", "libtv:video-box"),
|
|
grid2x2: ts("Grid2x2Icon", "libtv:grid-2x2"),
|
|
alignJustify: ts("AlignJustifyIcon", "libtv:text-align-center"),
|
|
scan: ts("ScanIcon", "libtv:radius"),
|
|
maximize2: ts("Maximize2Icon", "libtv:broad-picture"),
|
|
scissors: ts("ScissorsIcon", "lucide:scissors"),
|
|
magnet: ts("MagnetIcon", "lucide:magnet"),
|
|
canvasNavSave: ts("CanvasNavSaveIcon", "libtv:canvas-save"),
|
|
imageOff: ts("ImageOffIcon", "libtv:picture-loss"),
|
|
zap: ts("ZapIcon", "libtv:lightning-f"),
|
|
inbox: ts("InboxIcon", "libtv:file-input"),
|
|
music: ts("MusicIcon", "libtv:audio"),
|
|
film: ts("FilmIcon", "libtv:imported-video"),
|
|
crosshair: ts("CrosshairIcon", "libtv:target"),
|
|
mic: ts("MicIcon", "libtv:audio"),
|
|
wandSparkles: ts("WandSparklesIcon", "libtv:magic-wand"),
|
|
externalLink: ts("ExternalLinkIcon", "libtv:share"),
|
|
mousePointer2: ts("MousePointer2Icon", "libtv:mouse-n"),
|
|
workflow: ts("WorkflowIcon", "libtv:blending-tools-n"),
|
|
box: ts("BoxIcon", "libtv:usage-box"),
|
|
history: ts("HistoryIcon", "libtv:history-n"),
|
|
table2: ts("Table2Icon", "lucide:table-2"),
|
|
barChart2: ts("BarChart2Icon", "lucide:bar-chart-2"),
|
|
moreHorizontal: ts("MoreHorizontalIcon", "libtv:more"),
|
|
columns3: ts("Columns3Icon", "lucide:columns-3"),
|
|
filter: ts("FilterIcon", "libtv:layer-filter"),
|
|
arrowUpDown: ts("ArrowUpDownIcon", "libtv:up-down-arrows"),
|
|
brain: ts("BrainIcon", "libtv:deep-think"),
|
|
chartBar: ts("ChartBarIcon", "lucide:chart-bar"),
|
|
pieChart: ts("PieChartIcon", "lucide:pie-chart"),
|
|
lineChart: ts("LineChartIcon", "lucide:trending-up"),
|
|
arrowUp: ts("ArrowUpIcon", "libtv:up-arrow"),
|
|
arrowDown: ts("ArrowDownIcon", "libtv:down-l"),
|
|
chevronsUpDown: ts("ChevronsUpDownIcon", "lucide:chevrons-up-down"),
|
|
settings2: ts("Settings2Icon", "lucide:settings-2"),
|
|
textIcon: ts("TextIcon", "lucide:text"),
|
|
hash: ts("HashIcon", "lucide:hash"),
|
|
link2: ts("Link2Icon", "lucide:link-2"),
|
|
calendarDays: ts("CalendarDaysIcon", "lucide:calendar-days"),
|
|
circleDot: ts("CircleDotIcon", "lucide:circle-dot"),
|
|
listChecks: ts("ListChecksIcon", "lucide:list-checks"),
|
|
circleAlert: ts("CircleAlertIcon", "lucide:circle-alert"),
|
|
triangleAlert: ts("TriangleAlertIcon", "lucide:triangle-alert"),
|
|
lucideClock: ts("LucideClockIcon", "lucide:clock"),
|
|
circleCheck: ts("CircleCheckIcon", "lucide:circle-check"),
|
|
lucideSquare: ts("LucideSquareIcon", "lucide:square"),
|
|
LogOut: ts("LogOutIcon", "lucide:log-out"),
|
|
chatToolbarBox: ts("ChatToolbarBoxIcon", "lucide:box"),
|
|
chatToolbarBookOpen: ts("ChatToolbarBookOpenIcon", "lucide:book-open"),
|
|
};
|
|
t.s(["IconifyIcon", 0, to, "Icons", 0, ta], 41671);
|
|
};
|
|
|
|
export default moduleFactory;
|