You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2266 lines
45 KiB
2266 lines
45 KiB
!(function () {
|
|
"use strict";
|
|
function t() {
|
|
let e = {};
|
|
return (
|
|
window.webpackChunkdiscord_app
|
|
? window.webpackChunkdiscord_app.push([
|
|
[Math.random().toString(36)],
|
|
{},
|
|
(t) => {
|
|
e = t;
|
|
}
|
|
])
|
|
: (e = webpackJsonp(
|
|
[],
|
|
[
|
|
(t, e, n) => {
|
|
t.exports = n;
|
|
}
|
|
]
|
|
)),
|
|
e.c
|
|
);
|
|
}
|
|
let s = {
|
|
modules: t(),
|
|
filter: function (t, e) {
|
|
let n = [];
|
|
for (const a in e) {
|
|
var s = e[a].exports;
|
|
s &&
|
|
(s.default && s.__esModule && t(s.default)
|
|
? n.push(s.default)
|
|
: t(s) && n.push(s));
|
|
}
|
|
return n;
|
|
},
|
|
find: (t) => s.filter(t, s.modules)[0],
|
|
findAll: (t) => s.filter(t, s.modules),
|
|
findByProps: (...t) => s.find((e) => t.every((t) => void 0 !== e[t])),
|
|
findByPropsAll: (...t) =>
|
|
s.findAll((e) => t.every((t) => void 0 !== e[t])),
|
|
findByDisplayName: (e) =>
|
|
s.find(
|
|
(t) =>
|
|
(function (t) {
|
|
let e = void 0,
|
|
n = t[0],
|
|
s = 1;
|
|
for (; s < t.length; ) {
|
|
var a = t[s];
|
|
const r = t[s + 1];
|
|
if (
|
|
((s += 2),
|
|
("optionalAccess" === a ||
|
|
"optionalCall" === a) &&
|
|
null == n)
|
|
)
|
|
return;
|
|
"access" === a || "optionalAccess" === a
|
|
? ((e = n), (n = r(n)))
|
|
: ("call" !== a && "optionalCall" !== a) ||
|
|
((n = r((...t) => n.call(e, ...t))),
|
|
(e = void 0));
|
|
}
|
|
return n;
|
|
})([t, "optionalAccess", (t) => t.displayName]) === e
|
|
),
|
|
findByStrings: (...t) =>
|
|
s.find((e) => t.every((t) => e.toString().contains(t))),
|
|
reloadModules: () => {
|
|
s.modules = t();
|
|
}
|
|
};
|
|
function r(n) {
|
|
return new Promise((t, e) => {
|
|
(n.oncomplete = n.onsuccess = () => t(n.result)),
|
|
(n.onabort = n.onerror = () => e(n.error));
|
|
});
|
|
}
|
|
function e(e, s) {
|
|
const t = (
|
|
!navigator.userAgentData &&
|
|
/Safari\//.test(navigator.userAgent) &&
|
|
!/Chrom(e|ium)\//.test(navigator.userAgent) &&
|
|
indexedDB.databases
|
|
? new Promise(function (t) {
|
|
function e() {
|
|
return indexedDB.databases().finally(t);
|
|
}
|
|
(n = setInterval(e, 100)), e();
|
|
}).finally(function () {
|
|
return clearInterval(n);
|
|
})
|
|
: Promise.resolve()
|
|
).then(() => {
|
|
const t = indexedDB.open(e);
|
|
return (
|
|
(t.onupgradeneeded = () => t.result.createObjectStore(s)), r(t)
|
|
);
|
|
});
|
|
var n;
|
|
return (e, n) => t.then((t) => n(t.transaction(s, e).objectStore(s)));
|
|
}
|
|
let n;
|
|
function l() {
|
|
return (n = n || e("keyval-store", "keyval"));
|
|
}
|
|
function o(e, t = l()) {
|
|
return t("readonly", (t) => r(t.get(e)));
|
|
}
|
|
function i(e, n, t = l()) {
|
|
return t("readwrite", (t) => (t.put(n, e), r(t.transaction)));
|
|
}
|
|
function a(t, e) {
|
|
return (
|
|
(t.openCursor().onsuccess = function () {
|
|
this.result && (e(this.result), this.result.continue());
|
|
}),
|
|
r(t.transaction)
|
|
);
|
|
}
|
|
var c = Object.freeze({
|
|
__proto__: null,
|
|
clear: function (t = l()) {
|
|
return t("readwrite", (t) => (t.clear(), r(t.transaction)));
|
|
},
|
|
createStore: e,
|
|
del: function (e, t = l()) {
|
|
return t("readwrite", (t) => (t.delete(e), r(t.transaction)));
|
|
},
|
|
delMany: function (t, e = l()) {
|
|
return e(
|
|
"readwrite",
|
|
(e) => (t.forEach((t) => e.delete(t)), r(e.transaction))
|
|
);
|
|
},
|
|
entries: function (n = l()) {
|
|
return n("readonly", (t) => {
|
|
if (t.getAll && t.getAllKeys)
|
|
return Promise.all([
|
|
r(t.getAllKeys()),
|
|
r(t.getAll())
|
|
]).then(([t, n]) => t.map((t, e) => [t, n[e]]));
|
|
const e = [];
|
|
return n("readonly", (t) =>
|
|
a(t, (t) => e.push([t.key, t.value])).then(() => e)
|
|
);
|
|
});
|
|
},
|
|
get: o,
|
|
getMany: function (t, e = l()) {
|
|
return e("readonly", (e) =>
|
|
Promise.all(t.map((t) => r(e.get(t))))
|
|
);
|
|
},
|
|
keys: function (t = l()) {
|
|
return t("readonly", (t) => {
|
|
if (t.getAllKeys) return r(t.getAllKeys());
|
|
const e = [];
|
|
return a(t, (t) => e.push(t.key)).then(() => e);
|
|
});
|
|
},
|
|
promisifyRequest: r,
|
|
set: i,
|
|
setMany: function (t, e = l()) {
|
|
return e(
|
|
"readwrite",
|
|
(e) => (
|
|
t.forEach((t) => e.put(t[1], t[0])), r(e.transaction)
|
|
)
|
|
);
|
|
},
|
|
update: function (s, a, t = l()) {
|
|
return t(
|
|
"readwrite",
|
|
(n) =>
|
|
new Promise((t, e) => {
|
|
n.get(s).onsuccess = function () {
|
|
try {
|
|
n.put(a(this.result), s),
|
|
t(r(n.transaction));
|
|
} catch (t) {
|
|
e(t);
|
|
}
|
|
};
|
|
})
|
|
);
|
|
},
|
|
values: function (t = l()) {
|
|
return t("readonly", (t) => {
|
|
if (t.getAll) return r(t.getAll());
|
|
const e = [];
|
|
return a(t, (t) => e.push(t.value)).then(() => e);
|
|
});
|
|
}
|
|
}),
|
|
f = Object.freeze({
|
|
GET: "GET",
|
|
SET: "SET",
|
|
DELETE: "DELETE",
|
|
UPDATE: "UPDATE"
|
|
});
|
|
class u {
|
|
constructor() {
|
|
(this.listeners = Object.values(f).reduce(
|
|
(t, e) => ((t[e] = new Set()), t),
|
|
{}
|
|
)),
|
|
(this.on = function (t, e) {
|
|
if (this.listeners[t].has(e))
|
|
throw Error(`This listener on ${t} already exists.`);
|
|
this.listeners[t].add(e);
|
|
}),
|
|
(this.once = function (t, n) {
|
|
const s = (t, e) => {
|
|
this.off(t, s), n(t, e);
|
|
};
|
|
this.on(t, s);
|
|
}),
|
|
(this.off = function (t, e) {
|
|
this.listeners[t].delete(e);
|
|
}),
|
|
(this.emit = function (t, e) {
|
|
for (const n of this.listeners[t]) n(t, e);
|
|
});
|
|
for (const e of Object.values(f))
|
|
this[e.toLowerCase()] = (t) => {
|
|
this.emit(e, t);
|
|
};
|
|
}
|
|
}
|
|
function d(t = {}, { nestArrays: o = !0 } = {}) {
|
|
const i = new u();
|
|
return Object.assign(
|
|
{
|
|
store: (function a(t, r, l) {
|
|
return new Proxy(t, {
|
|
get(t, e) {
|
|
var n = [...l, e],
|
|
s = t[e];
|
|
return null != s
|
|
? (i.get({ path: n, value: s }),
|
|
(!o && Array.isArray(s)) ||
|
|
"object" != typeof s
|
|
? s
|
|
: a(s, r, n))
|
|
: a((t[e] = {}), r, n);
|
|
},
|
|
set(t, e, n) {
|
|
return (
|
|
(t[e] = n),
|
|
i.set({ path: [...l, e], value: n }),
|
|
!0
|
|
);
|
|
},
|
|
deleteProperty(t, e) {
|
|
return (
|
|
delete t[e] &&
|
|
(i.delete({ path: [...l, e] }), !0)
|
|
);
|
|
},
|
|
has(t, e) {
|
|
return (
|
|
("object" != typeof t[e] ||
|
|
0 !== Object.keys(t[e]).length) &&
|
|
e in t
|
|
);
|
|
}
|
|
});
|
|
})(t, t, []),
|
|
ghost: t
|
|
},
|
|
i
|
|
);
|
|
}
|
|
var m = Object.freeze({ __proto__: null, Events: f, make: d });
|
|
const {
|
|
useRef: p,
|
|
useReducer: g,
|
|
useEffect: O
|
|
} = s.findByProps("createElement");
|
|
function h(e, n = !1, s = () => !0) {
|
|
p(e.ghost);
|
|
const [, a] = g((t) => ~t, 0);
|
|
O(() => {
|
|
function t(t, e) {
|
|
s(t, e) && a();
|
|
}
|
|
return (
|
|
e.on(f.UPDATE, t),
|
|
n || (e.on(f.SET, t), e.on(f.DELETE, t)),
|
|
() => {
|
|
e.off(f.UPDATE, t),
|
|
n || (e.off(f.SET, t), e.off(f.DELETE, t));
|
|
}
|
|
);
|
|
}, []),
|
|
e.ghost;
|
|
}
|
|
const y = s["findByProps"],
|
|
v = y("createElement");
|
|
c = {
|
|
React: v,
|
|
ReactDOM: y("hydrate"),
|
|
dispatch: y("dirtyDispatch").__proto__,
|
|
idb: c,
|
|
nests: m
|
|
};
|
|
function b(r, l = !1) {
|
|
return function (t, ...e) {
|
|
(e = e.join("")),
|
|
void 0 === t &&
|
|
((t = ["Default"]),
|
|
b("warn")(
|
|
"Requested hierarchy has not been passed to logger function, defaulting to default string",
|
|
["Logger"]
|
|
)),
|
|
"string" == typeof t && ((e = t), (t = ["Default"]));
|
|
let n = ["Demoncord", ...t, e],
|
|
s = [],
|
|
a = "";
|
|
l && n.splice(0, 1);
|
|
for (let t = 0; t < n.length; t++)
|
|
t === n.length - 1
|
|
? ((a += "%c" + n[t]),
|
|
s.push(
|
|
"\n\n@import url('https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@700&display=swap');\nfont-family: 'IBM Plex Mono', monospace;\n\ncolor: #E2EECE;\nfont-weight: 500;\nfont-size: 0.9em;\n"
|
|
))
|
|
: ((a += "%c" + n[t] + "%c "),
|
|
s.push(
|
|
"\n\n@import url('https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@700&display=swap');\nfont-family: 'IBM Plex Mono', monospace;\n\ncolor: #1d1131;\nbackground-color: #aa8dd8;\nfont-weight: 600;\nfont-size: 0.9em;\npadding: 0px 5px 1px 5px;\nborder-radius: 5px;\n",
|
|
""
|
|
));
|
|
r(a, ...s);
|
|
};
|
|
}
|
|
m = {
|
|
logger: {
|
|
log: b(console.log),
|
|
warn: b(console.warn),
|
|
error: b(console.error),
|
|
trace: b(console.trace),
|
|
makeLogger: b
|
|
}
|
|
};
|
|
const w = d();
|
|
async function E(t) {
|
|
const e = demon.summon("internal/nest"),
|
|
n = await o("demon");
|
|
var s;
|
|
n.plugins[t] &&
|
|
n.status[t].running &&
|
|
((s = w.store[t].ctx),
|
|
(0, eval)(n.plugins[t].initialize).onStop(s)),
|
|
delete n.status[t],
|
|
delete n.plugins[t],
|
|
(e.store.pluginsList = n.plugins),
|
|
(e.store.pluginsStatus = n.status),
|
|
await i("demon", n);
|
|
}
|
|
async function N(e) {
|
|
const t = demon.summon("internal/nest"),
|
|
n = await o("demon");
|
|
var s;
|
|
n.plugins[e] &&
|
|
(!(function (t) {
|
|
let e = void 0,
|
|
n = t[0],
|
|
s = 1;
|
|
for (; s < t.length; ) {
|
|
var a = t[s];
|
|
const r = t[s + 1];
|
|
if (
|
|
((s += 2),
|
|
("optionalAccess" === a || "optionalCall" === a) &&
|
|
null == n)
|
|
)
|
|
return;
|
|
"access" === a || "optionalAccess" === a
|
|
? ((e = n), (n = r(n)))
|
|
: ("call" !== a && "optionalCall" !== a) ||
|
|
((n = r((...t) => n.call(e, ...t))), (e = void 0));
|
|
}
|
|
return n;
|
|
})([
|
|
n,
|
|
"access",
|
|
(t) => t.status,
|
|
"access",
|
|
(t) => t[e],
|
|
"optionalAccess",
|
|
(t) => t.running
|
|
])
|
|
? ((s = (0, eval)(n.plugins[e].initialize).onStart()),
|
|
(w.store[e].ctx = s),
|
|
(n.status[e] = { running: !0 }))
|
|
: (console.log(n.status[e].ctx),
|
|
(s = w.store[e].ctx),
|
|
(0, eval)(n.plugins[e].initialize).onStop(s),
|
|
(n.status[e].running = !1))),
|
|
(t.store.pluginsList = n.plugins),
|
|
(t.store.pluginsStatus = n.status),
|
|
await i("demon", n);
|
|
}
|
|
var x = {
|
|
init: async function () {
|
|
const t = demon.summon("internal/nest"),
|
|
s =
|
|
(window.__demon || (window.__demon = {}),
|
|
(await o("demon")) ||
|
|
(await i("demon", { status: {}, plugins: {} })),
|
|
await o("demon"));
|
|
(s.status = {}),
|
|
Object.keys(s.plugins).forEach((t) => {
|
|
t = s.plugins[t];
|
|
const e = (0, eval)(t.initialize);
|
|
var n = e.onStart();
|
|
(w.store[t.meta.name].ctx = n),
|
|
(s.status[t.meta.name] = { running: !0 });
|
|
}),
|
|
(t.store.pluginsList = s.plugins),
|
|
(t.store.pluginsStatus = s.status),
|
|
await i("demon", s);
|
|
},
|
|
add: async function (t, e) {
|
|
const n = demon.summon("internal/nest"),
|
|
s = await o("demon");
|
|
var a = (0, eval)(t);
|
|
a.meta && (e = a.meta),
|
|
(s.plugins[e.name] = { initialize: t, meta: e }),
|
|
(n.store.pluginsList = s.plugins),
|
|
(n.store.pluginsStatus = s.status),
|
|
await i("demon", s);
|
|
},
|
|
del: E,
|
|
toggle: N
|
|
};
|
|
const S = ["a", "b", "i"],
|
|
C = new Map();
|
|
function D(t, e, n, s) {
|
|
const a = C.get(t),
|
|
r = a?.[e];
|
|
return (
|
|
!!r?.[s].has(n) &&
|
|
(r[s].delete(n),
|
|
S.every((t) => 0 === r[t].size) &&
|
|
(Reflect.defineProperty(t, e, {
|
|
value: r.o,
|
|
writable: !0,
|
|
configurable: !0
|
|
}) || (t[e] = r.o),
|
|
delete a[e]),
|
|
0 == Object.keys(a).length && C.delete(t),
|
|
!0)
|
|
);
|
|
}
|
|
var P =
|
|
(f) =>
|
|
(s, a, t, r = !1) => {
|
|
if ("function" != typeof a[s])
|
|
throw new Error(
|
|
s + " is not a function in " + a.constructor.name
|
|
);
|
|
C.has(a) || C.set(a, {});
|
|
const e = C.get(a);
|
|
if (!e[s]) {
|
|
const i = a[s],
|
|
c =
|
|
((e[s] = {
|
|
o: i,
|
|
b: new Map(),
|
|
i: new Map(),
|
|
a: new Map()
|
|
}),
|
|
(t, e, n) => {
|
|
e = (function (t, e, n, s, a) {
|
|
const r = C.get(e)?.[t];
|
|
if (!r)
|
|
return a
|
|
? Reflect.construct(e[t], n, s)
|
|
: e[t].apply(s, n);
|
|
for (const c of r.b.values()) {
|
|
var l = c.call(s, n);
|
|
Array.isArray(l) && (n = l);
|
|
}
|
|
let o = (...t) =>
|
|
a
|
|
? Reflect.construct(r.o, t, s)
|
|
: r.o.apply(s, t);
|
|
for (const f of r.i.values()) {
|
|
const u = o;
|
|
o = (...t) => f.call(s, t, u);
|
|
}
|
|
let i = o(...n);
|
|
for (const d of r.a.values())
|
|
i = d.call(s, n, i) ?? i;
|
|
return i;
|
|
})(s, a, e, t, n);
|
|
return r && o(), e;
|
|
});
|
|
var n = new Proxy(i, {
|
|
apply: (t, e, n) => c(e, n, !1),
|
|
construct: (t, e) => c(i, e, !0),
|
|
get: (t, e, n) =>
|
|
"toString" == e
|
|
? i.toString.bind(i)
|
|
: Reflect.get(t, e, n)
|
|
});
|
|
Reflect.defineProperty(a, s, {
|
|
value: n,
|
|
configurable: !0,
|
|
writable: !0
|
|
}) || (a[s] = n);
|
|
}
|
|
const l = Symbol(),
|
|
o = () => D(a, s, l, f);
|
|
return e[s][f].set(l, t), o;
|
|
},
|
|
R = P("b"),
|
|
B = P("i");
|
|
const k = P("a");
|
|
P = Object.freeze({
|
|
__proto__: null,
|
|
instead: B,
|
|
before: R,
|
|
after: k,
|
|
unpatchAll: function () {
|
|
for (var [t, e] of C.entries())
|
|
for (const n in e)
|
|
for (const s of S)
|
|
for (const a of e[n]?.[s].keys() ?? []) D(t, n, a, s);
|
|
}
|
|
});
|
|
const A =
|
|
"/home/ruthenic/Coding/Javascript/demoncord/demoncord-rewrite/src/api/ui/settings/plugincard.jsx",
|
|
z = s.findByProps("Sizes", "Tags"),
|
|
I = s.findByDisplayName("Card"),
|
|
F = (s.findByDisplayName("Flex"), s.findByDisplayName("FormText")),
|
|
U =
|
|
(s.findByProps("BorderColors", "Colors"),
|
|
s.findByDisplayName("FormDivider"),
|
|
s.findByDisplayName("Switch"));
|
|
var H = (t) => (
|
|
h(t.nest),
|
|
t.nest.ghost.pluginsList[t.name] && t.nest.ghost.pluginsStatus[t.name]
|
|
? v.createElement(
|
|
v.Fragment,
|
|
null,
|
|
v.createElement(
|
|
I,
|
|
{
|
|
type: "cardPrimary",
|
|
className: "demon-settings-card-base",
|
|
outline: !1,
|
|
editable: !1,
|
|
__self: void 0,
|
|
__source: { fileName: A, lineNumber: 19 }
|
|
},
|
|
v.createElement(
|
|
z,
|
|
{
|
|
className: "demon-settings-card-header",
|
|
size: z.Sizes.SIZE_20,
|
|
__self: void 0,
|
|
__source: { fileName: A, lineNumber: 20 }
|
|
},
|
|
t.name
|
|
),
|
|
v.createElement("hr", {
|
|
className: "demon-settings-card-divider",
|
|
__self: void 0,
|
|
__source: { fileName: A, lineNumber: 23 }
|
|
}),
|
|
v.createElement(
|
|
F,
|
|
{
|
|
className: "demon-settings-card-desc",
|
|
__self: void 0,
|
|
__source: { fileName: A, lineNumber: 24 }
|
|
},
|
|
t.nest.ghost.pluginsList[t.name].meta.desc
|
|
),
|
|
v.createElement(
|
|
"svg",
|
|
{
|
|
position: "top",
|
|
onClick: async () => {
|
|
E(t.name);
|
|
},
|
|
className: "demon-settings-card-delete",
|
|
viewBox: "0 0 24 24",
|
|
__self: void 0,
|
|
__source: { fileName: A, lineNumber: 27 }
|
|
},
|
|
v.createElement("path", {
|
|
fill: "var(--text-muted)",
|
|
d: "M6 19c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V7H6v12zm2.46-7.12 1.41-1.41L12 12.59l2.12-2.12 1.41 1.41L13.41 14l2.12 2.12-1.41 1.41L12 15.41l-2.12 2.12-1.41-1.41L10.59 14l-2.13-2.12zM15.5 4l-1-1h-5l-1 1H5v2h14V4z",
|
|
__self: void 0,
|
|
__source: { fileName: A, lineNumber: 35 }
|
|
})
|
|
),
|
|
v.createElement(U, {
|
|
className: "demon-settings-card-switch",
|
|
checked: t.nest.ghost.pluginsStatus[t.name].running,
|
|
onChange: async () => {
|
|
N(t.name);
|
|
},
|
|
__self: void 0,
|
|
__source: { fileName: A, lineNumber: 37 }
|
|
})
|
|
)
|
|
)
|
|
: null
|
|
);
|
|
const M =
|
|
"/home/ruthenic/Coding/Javascript/demoncord/demoncord-rewrite/src/api/ui/settings/plugins.jsx",
|
|
J = s.findByProps("Sizes", "Tags"),
|
|
K =
|
|
(s.findByDisplayName("FormTitle"),
|
|
s.findByDisplayName("FormSection"),
|
|
s.findByDisplayName("FormDivider"));
|
|
var V = () => {
|
|
const e = demon.summon("internal/nest");
|
|
return (
|
|
h(e),
|
|
v.createElement(
|
|
v.Fragment,
|
|
null,
|
|
v.createElement(
|
|
J,
|
|
{
|
|
size: "demon-settings-header-size30",
|
|
__self: void 0,
|
|
__source: { fileName: M, lineNumber: 14 }
|
|
},
|
|
"Plugins"
|
|
),
|
|
v.createElement(K, {
|
|
className: "demon-settings-divider",
|
|
__self: void 0,
|
|
__source: { fileName: M, lineNumber: 15 }
|
|
}),
|
|
Object.keys(e.ghost.pluginsList).map((t) =>
|
|
v.createElement(
|
|
v.Fragment,
|
|
null,
|
|
v.createElement(H, {
|
|
name: t,
|
|
nest: e,
|
|
__self: void 0,
|
|
__source: { fileName: M, lineNumber: 18 }
|
|
})
|
|
)
|
|
)
|
|
)
|
|
);
|
|
};
|
|
const j =
|
|
"/home/ruthenic/Coding/Javascript/demoncord/demoncord-rewrite/src/api/ui/settings/hummus.jsx",
|
|
$ = s.findByDisplayName("Checkbox");
|
|
class q extends v.Component {
|
|
constructor(t) {
|
|
super(t), (this.state = { tg: 0 });
|
|
}
|
|
render() {
|
|
const n = demon.summon("internal/nest");
|
|
return v.createElement(
|
|
"div",
|
|
{
|
|
className: "control-group demon-settings-card-header",
|
|
__self: this,
|
|
__source: { fileName: j, lineNumber: 17 }
|
|
},
|
|
v.createElement(
|
|
"label",
|
|
{
|
|
className: "demon-settings-header-size30 ",
|
|
__self: this,
|
|
__source: { fileName: j, lineNumber: 18 }
|
|
},
|
|
"Plugins"
|
|
),
|
|
Object.keys(n.ghost.pluginsList).map((e) =>
|
|
v.createElement(
|
|
"div",
|
|
{
|
|
className: "demon-settings-card-base",
|
|
__self: this,
|
|
__source: { fileName: j, lineNumber: 20 }
|
|
},
|
|
v.createElement(
|
|
"span",
|
|
{
|
|
__self: this,
|
|
__source: { fileName: j, lineNumber: 20 }
|
|
},
|
|
v.createElement(
|
|
$,
|
|
{
|
|
className:
|
|
"demon-stub-plugin-checkbox-" + e,
|
|
checked: n.ghost.pluginsStatus[e].running,
|
|
onChange: async () => {
|
|
N(e);
|
|
const t =
|
|
document.getElementsByClassName(
|
|
"demon-stub-plugin-checkbox-" +
|
|
e
|
|
)[0];
|
|
n.ghost.pluginsStatus[e].running
|
|
? (t.value = "off")
|
|
: (t.value = "on"),
|
|
this.setState({
|
|
tg: !this.state.tg
|
|
});
|
|
},
|
|
__self: this,
|
|
__source: { fileName: j, lineNumber: 21 }
|
|
},
|
|
e
|
|
)
|
|
)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
function T(t) {
|
|
const e = document.createElement("style");
|
|
(e.className = "demon-element-css"),
|
|
(e.innerHTML = t),
|
|
document.head.appendChild(e);
|
|
}
|
|
var L = {
|
|
injectCSS: T,
|
|
createClass: function (t, e) {
|
|
T(
|
|
`.${t} {${Object.entries(e)
|
|
.map(([t, e]) => t + ":" + e)
|
|
.join(";")}}`
|
|
);
|
|
}
|
|
};
|
|
const G = s.findByDisplayName("SettingsView");
|
|
B = {
|
|
init: function () {
|
|
if (
|
|
(L.createClass("demon-settings-divider", {
|
|
"margin-top": "10px",
|
|
"margin-bottom": "10px",
|
|
height: "1px"
|
|
}),
|
|
L.createClass("demon-settings-card-divider", {
|
|
"margin-top": "5px",
|
|
"margin-bottom": "5px",
|
|
"margin-left": "10px",
|
|
"margin-right": "10px",
|
|
height: "1px",
|
|
border: "thin solid var(--background-modifier-accent)"
|
|
}),
|
|
L.createClass("demon-settings-card-base", {
|
|
"margin-bottom": "10px"
|
|
}),
|
|
L.createClass("demon-settings-card-header", {
|
|
"margin-left": "10px",
|
|
"margin-top": "10px"
|
|
}),
|
|
L.createClass("demon-settings-card-desc", {
|
|
color: "var(--header-secondary)",
|
|
display: "inline-block",
|
|
"font-size": "15px",
|
|
"line-height": "15px",
|
|
"margin-left": "10px",
|
|
"margin-top": "5px",
|
|
"margin-bottom": "10px"
|
|
}),
|
|
L.createClass("demon-settings-card-switch", {
|
|
"margin-right": "10px",
|
|
"margin-top": "0px",
|
|
"margin-bottom": "10px",
|
|
float: "right"
|
|
}),
|
|
L.createClass("demon-settings-card-delete", {
|
|
"margin-right": "5px",
|
|
float: "right",
|
|
width: "24px",
|
|
cursor: "pointer"
|
|
}),
|
|
L.createClass("demon-settings-header-size30", {
|
|
"font-size": "30px",
|
|
"line-height": "34px"
|
|
}),
|
|
window.webpackChunkdiscord_app)
|
|
)
|
|
k(
|
|
"getPredicateSections",
|
|
G.prototype,
|
|
(t, e) => (
|
|
e.unshift(
|
|
{ section: "HEADER", label: "Demoncord" },
|
|
{
|
|
section: "demoncord",
|
|
label: "Plugins",
|
|
element: V
|
|
},
|
|
{ section: "DIVIDER" }
|
|
),
|
|
e
|
|
)
|
|
);
|
|
else {
|
|
var t = s.findByProps("getUserSettingsModalSections");
|
|
const n = s.findByProps("TabBarItem");
|
|
k("render", t.default.prototype, (t, e) => {
|
|
e.props.children[0].props.children.props.children[1].push(
|
|
v.createElement(
|
|
n.TabBarItem,
|
|
{ key: "demoncord" },
|
|
"Plugins"
|
|
)
|
|
),
|
|
"demoncord" ===
|
|
e.props.children[0].props.children.props
|
|
.selectedItem &&
|
|
(e.props.children[1].props.children[0].props.children =
|
|
v.createElement(q, {}, ""));
|
|
});
|
|
}
|
|
}
|
|
};
|
|
const Z = {
|
|
modules: { webpack: s, common: c },
|
|
utils: m,
|
|
plugins: x,
|
|
internal: { nest: c.nests.make() },
|
|
css: L,
|
|
patcher: P,
|
|
stolas: {
|
|
monologue: () =>
|
|
_.sample([
|
|
[].flat[
|
|
([].flat + [])[3] +
|
|
(!0 + [].flat)[10] +
|
|
([][[]] + [])[1] +
|
|
"str" +
|
|
([][[]] + [])[0] +
|
|
([].flat + [])[3] +
|
|
"t" +
|
|
(!0 + [].flat)[10] +
|
|
"r"
|
|
](
|
|
"ret" +
|
|
([][[]] + [])[0] +
|
|
"r" +
|
|
([][[]] + [])[1] +
|
|
(NaN + [].flat)[11] +
|
|
"e" +
|
|
(31)[
|
|
"t" +
|
|
(!0 + [].flat)[10] +
|
|
""[
|
|
([].flat + [])[3] +
|
|
(!0 + [].flat)[10] +
|
|
([][[]] + [])[1] +
|
|
"str" +
|
|
([][[]] + [])[0] +
|
|
([].flat + [])[3] +
|
|
"t" +
|
|
(!0 + [].flat)[10] +
|
|
"r"
|
|
][
|
|
([][[]] + [])[1] +
|
|
"a" +
|
|
((0)[
|
|
([].flat + [])[3] +
|
|
(!0 + [].flat)[10] +
|
|
([][[]] + [])[1] +
|
|
"str" +
|
|
([][[]] + [])[0] +
|
|
([].flat + [])[3] +
|
|
"t" +
|
|
(!0 + [].flat)[10] +
|
|
"r"
|
|
] + [])[11] +
|
|
"e"
|
|
]
|
|
]("32") +
|
|
"al"
|
|
)()(
|
|
[].flat[
|
|
([].flat + [])[3] +
|
|
(!0 + [].flat)[10] +
|
|
([][[]] + [])[1] +
|
|
"str" +
|
|
([][[]] + [])[0] +
|
|
([].flat + [])[3] +
|
|
"t" +
|
|
(!0 + [].flat)[10] +
|
|
"r"
|
|
](
|
|
"ret" +
|
|
([][[]] + [])[0] +
|
|
"r" +
|
|
([][[]] + [])[1] +
|
|
""[
|
|
"f" +
|
|
(!0 + [].flat)[10] +
|
|
([][[]] + [])[1] +
|
|
"t" +
|
|
([].flat + [])[3] +
|
|
(!0 + [].flat)[10] +
|
|
"l" +
|
|
(!0 + [].flat)[10] +
|
|
"r"
|
|
]()[12] +
|
|
("t42t127t150e" +
|
|
([][[]] + [])[1] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[1] +
|
|
[1] +
|
|
"t" +
|
|
[4] +
|
|
[7] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[5] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"lt" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
([][[]] + [])[1] +
|
|
"elt" +
|
|
[1] +
|
|
[7] +
|
|
[1] +
|
|
"t" +
|
|
[5] +
|
|
[4] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[1] +
|
|
[1] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[4] +
|
|
[2] +
|
|
"et" +
|
|
[1] +
|
|
[4] +
|
|
[3] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[5] +
|
|
"et" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[0] +
|
|
([][[]] + [])[0] +
|
|
([][[]] + [])[1] +
|
|
"t" +
|
|
[1] +
|
|
[4] +
|
|
[7] +
|
|
"rt" +
|
|
[1] +
|
|
[7] +
|
|
[1] +
|
|
".t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[0] +
|
|
[1] +
|
|
([][[]] + [])[1] +
|
|
([][[]] + [])[2] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[7] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[0] +
|
|
"e" +
|
|
([][[]] + [])[1] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[1] +
|
|
[1] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[4] +
|
|
[2] +
|
|
"et" +
|
|
[1] +
|
|
[4] +
|
|
[3] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[5] +
|
|
"et" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[0] +
|
|
([][[]] + [])[0] +
|
|
([][[]] + [])[1] +
|
|
"t" +
|
|
[1] +
|
|
[4] +
|
|
[7] +
|
|
"rt" +
|
|
[1] +
|
|
[7] +
|
|
[1] +
|
|
"t" +
|
|
[5] +
|
|
[4] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[1] +
|
|
[1] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[7] +
|
|
"a" +
|
|
([][[]] + [])[1] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[4] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[4] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[4] +
|
|
[3] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[3] +
|
|
"et" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
([][[]] + [])[1] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[4] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[0] +
|
|
"at" +
|
|
[1] +
|
|
[6] +
|
|
[4] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"re" +
|
|
([][[]] + [])[2] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
"ft" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[7] +
|
|
[1] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
([][[]] + [])[0] +
|
|
"rs...t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[7] +
|
|
[1] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
([][[]] + [])[0] +
|
|
"rt" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"a" +
|
|
([][[]] + [])[1] +
|
|
([][[]] + [])[2] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"l" +
|
|
([!1] + [][[]])[10] +
|
|
"t" +
|
|
[1] +
|
|
[4] +
|
|
[3] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[3] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"allt" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
"ft" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[7] +
|
|
[1] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
([][[]] + [])[0] +
|
|
"rt" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[4] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[4] +
|
|
[2] +
|
|
"eft" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
"ret" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[4] +
|
|
"at" +
|
|
[1] +
|
|
[5] +
|
|
[3] +
|
|
([!1] + [][[]])[10] +
|
|
([][[]] + [])[1] +
|
|
"t" +
|
|
[1] +
|
|
[4] +
|
|
[7] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
([][[]] + [])[0] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[4] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[7] +
|
|
[1] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
([][[]] + [])[0] +
|
|
"rt" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[4] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"a" +
|
|
([][[]] + [])[1] +
|
|
([][[]] + [])[2] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[7] +
|
|
([!1] + [][[]])[10] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[4] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[0] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[5] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
"ret" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[4] +
|
|
"eet" +
|
|
[1] +
|
|
[6] +
|
|
[4] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[0] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
([][[]] + [])[0] +
|
|
([][[]] + [])[1] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[4] +
|
|
([!1] + [][[]])[10] +
|
|
"lt" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[7] +
|
|
[1] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
([][[]] + [])[0] +
|
|
"t" +
|
|
[4] +
|
|
[7] +
|
|
"ret" +
|
|
[4] +
|
|
[0] +
|
|
"st" +
|
|
[1] +
|
|
[4] +
|
|
[3] +
|
|
"reat" +
|
|
[1] +
|
|
[5] +
|
|
[5] +
|
|
([!1] + [][[]])[10] +
|
|
([][[]] + [])[1] +
|
|
"t" +
|
|
[1] +
|
|
[4] +
|
|
[7] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"l" +
|
|
([!1] + [][[]])[10] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[3] +
|
|
"et" +
|
|
[4] +
|
|
[0] +
|
|
"at" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[0] +
|
|
[6] +
|
|
"t" +
|
|
[1] +
|
|
[2] +
|
|
[5] +
|
|
"t" +
|
|
[1] +
|
|
[0] +
|
|
[3] +
|
|
"t" +
|
|
[1] +
|
|
[1] +
|
|
[3] +
|
|
"t" +
|
|
[1] +
|
|
[1] +
|
|
[1] +
|
|
"Nt" +
|
|
[1] +
|
|
[0] +
|
|
[7] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[4] +
|
|
[2] +
|
|
"at" +
|
|
[1] +
|
|
[4] +
|
|
[2] +
|
|
"t" +
|
|
[1] +
|
|
[7] +
|
|
[1] +
|
|
"t" +
|
|
[5] +
|
|
[5] +
|
|
"t" +
|
|
[5] +
|
|
[5] +
|
|
"t" +
|
|
[4] +
|
|
[1] +
|
|
"t" +
|
|
[4] +
|
|
[2])
|
|
[
|
|
"s" +
|
|
(211)[
|
|
"t" +
|
|
(!0 + [].flat)[10] +
|
|
""[
|
|
([].flat + [])[3] +
|
|
(!0 + [].flat)[10] +
|
|
([][[]] + [])[1] +
|
|
"str" +
|
|
([][[]] + [])[0] +
|
|
([].flat + [])[3] +
|
|
"t" +
|
|
(!0 + [].flat)[10] +
|
|
"r"
|
|
][
|
|
([][[]] + [])[1] +
|
|
"a" +
|
|
((0)[
|
|
([].flat +
|
|
[])[3] +
|
|
(!0 +
|
|
[]
|
|
.flat)[10] +
|
|
([][[]] +
|
|
[])[1] +
|
|
"str" +
|
|
([][[]] +
|
|
[])[0] +
|
|
([].flat +
|
|
[])[3] +
|
|
"t" +
|
|
(!0 +
|
|
[]
|
|
.flat)[10] +
|
|
"r"
|
|
] + [])[11] +
|
|
"e"
|
|
]
|
|
]("31")[1] +
|
|
"l" +
|
|
([!1] + [][[]])[10] +
|
|
"t"
|
|
]("t")
|
|
[
|
|
([][
|
|
"e" +
|
|
([][[]] + [])[1] +
|
|
"tr" +
|
|
([!1] + [][[]])[10] +
|
|
"es"
|
|
]() + [])[3] +
|
|
(!0 + [].flat)[10] +
|
|
([!1] + [][[]])[10] +
|
|
([][[]] + [])[1]
|
|
](
|
|
([].flat[
|
|
([].flat + [])[3] +
|
|
(!0 + [].flat)[10] +
|
|
([][[]] + [])[1] +
|
|
"str" +
|
|
([][[]] + [])[0] +
|
|
([].flat + [])[3] +
|
|
"t" +
|
|
(!0 + [].flat)[10] +
|
|
"r"
|
|
](
|
|
"ret" +
|
|
([][[]] + [])[0] +
|
|
"r" +
|
|
([][[]] + [])[1] +
|
|
"false0"[
|
|
([!1] + [][[]])[10] +
|
|
"tal" +
|
|
([!1] + [][[]])[10] +
|
|
([].flat + [])[3] +
|
|
"s"
|
|
]()[10] +
|
|
!1 +
|
|
"false0"[
|
|
([!1] + [][[]])[10] +
|
|
"tal" +
|
|
([!1] + [][[]])[10] +
|
|
([].flat + [])[3] +
|
|
"s"
|
|
]()[10]
|
|
)()[
|
|
([].flat + [])[3] +
|
|
(!0 + [].flat)[10] +
|
|
([][[]] + [])[1] +
|
|
"str" +
|
|
([][[]] + [])[0] +
|
|
([].flat + [])[3] +
|
|
"t" +
|
|
(!0 + [].flat)[10] +
|
|
"r"
|
|
](
|
|
"false0"[
|
|
([!1] + [][[]])[10] +
|
|
"tal" +
|
|
([!1] + [][[]])[10] +
|
|
([].flat + [])[3] +
|
|
"s"
|
|
]()[10]
|
|
) + [])[1]
|
|
) +
|
|
""[
|
|
"f" +
|
|
(!0 + [].flat)[10] +
|
|
([][[]] + [])[1] +
|
|
"t" +
|
|
([].flat + [])[3] +
|
|
(!0 + [].flat)[10] +
|
|
"l" +
|
|
(!0 + [].flat)[10] +
|
|
"r"
|
|
]()[12]
|
|
)()
|
|
),
|
|
[].flat[
|
|
([].flat + [])[3] +
|
|
(!0 + [].flat)[10] +
|
|
([][[]] + [])[1] +
|
|
"str" +
|
|
([][[]] + [])[0] +
|
|
([].flat + [])[3] +
|
|
"t" +
|
|
(!0 + [].flat)[10] +
|
|
"r"
|
|
](
|
|
"ret" +
|
|
([][[]] + [])[0] +
|
|
"r" +
|
|
([][[]] + [])[1] +
|
|
(+[!1] + [].flat)[11] +
|
|
"e" +
|
|
(31)[
|
|
"t" +
|
|
(!0 + [].flat)[10] +
|
|
""[
|
|
([].flat + [])[3] +
|
|
(!0 + [].flat)[10] +
|
|
([][[]] + [])[1] +
|
|
"str" +
|
|
([][[]] + [])[0] +
|
|
([].flat + [])[3] +
|
|
"t" +
|
|
(!0 + [].flat)[10] +
|
|
"r"
|
|
][
|
|
([][[]] + [])[1] +
|
|
"a" +
|
|
((0)[
|
|
([].flat + [])[3] +
|
|
(!0 + [].flat)[10] +
|
|
([][[]] + [])[1] +
|
|
"str" +
|
|
([][[]] + [])[0] +
|
|
([].flat + [])[3] +
|
|
"t" +
|
|
(!0 + [].flat)[10] +
|
|
"r"
|
|
] + [])[11] +
|
|
"e"
|
|
]
|
|
]("32") +
|
|
"al"
|
|
)()(
|
|
[].flat[
|
|
([].flat + [])[3] +
|
|
(!0 + [].flat)[10] +
|
|
([][[]] + [])[1] +
|
|
"str" +
|
|
([][[]] + [])[0] +
|
|
([].flat + [])[3] +
|
|
"t" +
|
|
(!0 + [].flat)[10] +
|
|
"r"
|
|
](
|
|
"ret" +
|
|
([][[]] + [])[0] +
|
|
"r" +
|
|
([][[]] + [])[1] +
|
|
""[
|
|
"f" +
|
|
(!0 + [].flat)[10] +
|
|
([][[]] + [])[1] +
|
|
"t" +
|
|
([].flat + [])[3] +
|
|
(!0 + [].flat)[10] +
|
|
"l" +
|
|
(!0 + [].flat)[10] +
|
|
"r"
|
|
]()[12] +
|
|
("t42t117t150t150t150t54t40t102l" +
|
|
([!1] + [][[]])[10] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[4] +
|
|
"t" +
|
|
[1] +
|
|
[7] +
|
|
[2] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
"t" +
|
|
[4] +
|
|
[1] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[1] +
|
|
[1] +
|
|
"t" +
|
|
[4] +
|
|
[7] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[5] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"st" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"et" +
|
|
[1] +
|
|
[7] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[4] +
|
|
[3] +
|
|
([!1] + [][[]])[10] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[4] +
|
|
"e" +
|
|
([][[]] + [])[2] +
|
|
"t" +
|
|
[4] +
|
|
[1] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[1] +
|
|
[1] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[4] +
|
|
[3] +
|
|
"a" +
|
|
([][[]] + [])[1] +
|
|
([][[]] + [])[1] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[4] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[7] +
|
|
"a" +
|
|
([!1] + [][[]])[10] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[4] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[4] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"feelt" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[7] +
|
|
[1] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
([][[]] + [])[0] +
|
|
"rt" +
|
|
[4] +
|
|
[0] +
|
|
"sl" +
|
|
([!1] + [][[]])[10] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[5] +
|
|
"t" +
|
|
[1] +
|
|
[7] +
|
|
[1] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[4] +
|
|
[3] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[3] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
([!1] + [][[]])[10] +
|
|
([][[]] + [])[1] +
|
|
"s" +
|
|
([!1] + [][[]])[10] +
|
|
([][[]] + [])[2] +
|
|
"et" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
"ft" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[5] +
|
|
"t" +
|
|
[1] +
|
|
[7] +
|
|
[1] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
".t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[2] +
|
|
[4] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[4] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[0] +
|
|
"et" +
|
|
([][[]] + [])[0] +
|
|
[2] +
|
|
[0] +
|
|
[1] +
|
|
[4] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"...t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
([][[]] + [])[0] +
|
|
"set" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[7] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[0] +
|
|
([!1] + [][[]])[10] +
|
|
"let" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[7] +
|
|
[1] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[7] +
|
|
([][[]] + [])[0] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"a" +
|
|
([][[]] + [])[1] +
|
|
([][[]] + [])[2] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[1] +
|
|
[1] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"a" +
|
|
([][[]] + [])[1] +
|
|
([][[]] + [])[2] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[5] +
|
|
[2] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"a" +
|
|
([][[]] + [])[1] +
|
|
([][[]] + [])[2] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[2] +
|
|
"ellt" +
|
|
[1] +
|
|
[7] +
|
|
[1] +
|
|
"t" +
|
|
[4] +
|
|
[0] +
|
|
"sa" +
|
|
([][[]] + [])[1] +
|
|
([][[]] + [])[2] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[7] +
|
|
([!1] + [][[]])[10] +
|
|
"t" +
|
|
[1] +
|
|
[4] +
|
|
[3] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[0] +
|
|
"est" +
|
|
[4] +
|
|
[0] +
|
|
"allt" +
|
|
[4] +
|
|
[0] +
|
|
([][[]] + [])[1] +
|
|
([!1] + [][[]])[10] +
|
|
"t" +
|
|
[1] +
|
|
[4] +
|
|
[7] +
|
|
"t" +
|
|
[1] +
|
|
[5] +
|
|
[0] +
|
|
"t" +
|
|
[1] +
|
|
[6] +
|
|
[4] +
|
|
"...t" +
|
|
[4] +
|
|
[1] +
|
|
"t" +
|
|
[4] +
|
|
[2])
|
|
[
|
|
"s" +
|
|
(211)[
|
|
"t" +
|
|
(!0 + [].flat)[10] +
|
|
""[
|
|
([].flat + [])[3] +
|
|
(!0 + [].flat)[10] +
|
|
([][[]] + [])[1] +
|
|
"str" +
|
|
([][[]] + [])[0] +
|
|
([].flat + [])[3] +
|
|
"t" +
|
|
(!0 + [].flat)[10] +
|
|
"r"
|
|
][
|
|
([][[]] + [])[1] +
|
|
"a" +
|
|
((0)[
|
|
([].flat +
|
|
[])[3] +
|
|
(!0 +
|
|
[]
|
|
.flat)[10] +
|
|
([][[]] +
|
|
[])[1] +
|
|
"str" +
|
|
([][[]] +
|
|
[])[0] +
|
|
([].flat +
|
|
[])[3] +
|
|
"t" +
|
|
(!0 +
|
|
[]
|
|
.flat)[10] +
|
|
"r"
|
|
] + [])[11] +
|
|
"e"
|
|
]
|
|
]("31")[1] +
|
|
"l" +
|
|
([!1] + [][[]])[10] +
|
|
"t"
|
|
]("t")
|
|
[
|
|
([][
|
|
"e" +
|
|
([][[]] + [])[1] +
|
|
"tr" +
|
|
([!1] + [][[]])[10] +
|
|
"es"
|
|
]() + [])[3] +
|
|
(!0 + [].flat)[10] +
|
|
([!1] + [][[]])[10] +
|
|
([][[]] + [])[1]
|
|
](
|
|
([].flat[
|
|
([].flat + [])[3] +
|
|
(!0 + [].flat)[10] +
|
|
([][[]] + [])[1] +
|
|
"str" +
|
|
([][[]] + [])[0] +
|
|
([].flat + [])[3] +
|
|
"t" +
|
|
(!0 + [].flat)[10] +
|
|
"r"
|
|
](
|
|
"ret" +
|
|
([][[]] + [])[0] +
|
|
"r" +
|
|
([][[]] + [])[1] +
|
|
"false0"[
|
|
([!1] + [][[]])[10] +
|
|
"tal" +
|
|
([!1] + [][[]])[10] +
|
|
([].flat + [])[3] +
|
|
"s"
|
|
]()[10] +
|
|
!1 +
|
|
"false0"[
|
|
([!1] + [][[]])[10] +
|
|
"tal" +
|
|
([!1] + [][[]])[10] +
|
|
([].flat + [])[3] +
|
|
"s"
|
|
]()[10]
|
|
)()[
|
|
([].flat + [])[3] +
|
|
(!0 + [].flat)[10] +
|
|
([][[]] + [])[1] +
|
|
"str" +
|
|
([][[]] + [])[0] +
|
|
([].flat + [])[3] +
|
|
"t" +
|
|
(!0 + [].flat)[10] +
|
|
"r"
|
|
](
|
|
"false0"[
|
|
([!1] + [][[]])[10] +
|
|
"tal" +
|
|
([!1] + [][[]])[10] +
|
|
([].flat + [])[3] +
|
|
"s"
|
|
]()[10]
|
|
) + [])[1]
|
|
) +
|
|
""[
|
|
"f" +
|
|
(!0 + [].flat)[10] +
|
|
([][[]] + [])[1] +
|
|
"t" +
|
|
([].flat + [])[3] +
|
|
(!0 + [].flat)[10] +
|
|
"l" +
|
|
(!0 + [].flat)[10] +
|
|
"r"
|
|
]()[12]
|
|
)()
|
|
)
|
|
])
|
|
}
|
|
};
|
|
(window.demon = {
|
|
summon: function (t) {
|
|
const e = t.split("/");
|
|
let n = Z;
|
|
return (
|
|
e.forEach((t) => {
|
|
if (!(t in n)) throw new Error("Module does not exist!");
|
|
n = n[t];
|
|
}),
|
|
n
|
|
);
|
|
}
|
|
}),
|
|
x.init(),
|
|
B.init();
|
|
})();
|