446 lines
16 KiB
JavaScript
446 lines
16 KiB
JavaScript
/*
|
|
* Extracted from browser-delivered Turbopack chunk: 939e07c76f4b30f0.294c1bf0d6.js
|
|
* Module id: 308894
|
|
* For reading/searching only; this factory depends on the original Turbopack runtime.
|
|
*/
|
|
|
|
const moduleFactory = (e, t, i) => {
|
|
var r = (function (e) {
|
|
var t = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i,
|
|
i = 0,
|
|
r = {},
|
|
a = {
|
|
manual: e.Prism && e.Prism.manual,
|
|
disableWorkerMessageHandler:
|
|
e.Prism && e.Prism.disableWorkerMessageHandler,
|
|
util: {
|
|
encode: function e(t) {
|
|
return t instanceof n
|
|
? new n(t.type, e(t.content), t.alias)
|
|
: Array.isArray(t)
|
|
? t.map(e)
|
|
: t
|
|
.replace(/&/g, "&")
|
|
.replace(/</g, "<")
|
|
.replace(/\u00a0/g, " ");
|
|
},
|
|
type: function (e) {
|
|
return Object.prototype.toString.call(e).slice(8, -1);
|
|
},
|
|
objId: function (e) {
|
|
return (
|
|
e.__id || Object.defineProperty(e, "__id", { value: ++i }),
|
|
e.__id
|
|
);
|
|
},
|
|
clone: function e(t, i) {
|
|
var r, n;
|
|
switch (((i = i || {}), a.util.type(t))) {
|
|
case "Object":
|
|
if (i[(n = a.util.objId(t))]) return i[n];
|
|
for (var A in ((r = {}), (i[n] = r), t))
|
|
t.hasOwnProperty(A) && (r[A] = e(t[A], i));
|
|
return r;
|
|
case "Array":
|
|
if (i[(n = a.util.objId(t))]) return i[n];
|
|
return (
|
|
(r = []),
|
|
(i[n] = r),
|
|
t.forEach(function (t, a) {
|
|
r[a] = e(t, i);
|
|
}),
|
|
r
|
|
);
|
|
default:
|
|
return t;
|
|
}
|
|
},
|
|
getLanguage: function (e) {
|
|
for (; e; ) {
|
|
var i = t.exec(e.className);
|
|
if (i) return i[1].toLowerCase();
|
|
e = e.parentElement;
|
|
}
|
|
return "none";
|
|
},
|
|
setLanguage: function (e, i) {
|
|
(e.className = e.className.replace(RegExp(t, "gi"), "")),
|
|
e.classList.add("language-" + i);
|
|
},
|
|
currentScript: function () {
|
|
if ("u" < typeof document) return null;
|
|
if ("currentScript" in document) return document.currentScript;
|
|
try {
|
|
throw Error();
|
|
} catch (r) {
|
|
var e = (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(r.stack) ||
|
|
[])[1];
|
|
if (e) {
|
|
var t = document.getElementsByTagName("script");
|
|
for (var i in t) if (t[i].src == e) return t[i];
|
|
}
|
|
return null;
|
|
}
|
|
},
|
|
isActive: function (e, t, i) {
|
|
for (var r = "no-" + t; e; ) {
|
|
var a = e.classList;
|
|
if (a.contains(t)) return !0;
|
|
if (a.contains(r)) return !1;
|
|
e = e.parentElement;
|
|
}
|
|
return !!i;
|
|
},
|
|
},
|
|
languages: {
|
|
plain: r,
|
|
plaintext: r,
|
|
text: r,
|
|
txt: r,
|
|
extend: function (e, t) {
|
|
var i = a.util.clone(a.languages[e]);
|
|
for (var r in t) i[r] = t[r];
|
|
return i;
|
|
},
|
|
insertBefore: function (e, t, i, r) {
|
|
var n = (r = r || a.languages)[e],
|
|
A = {};
|
|
for (var s in n)
|
|
if (n.hasOwnProperty(s)) {
|
|
if (s == t)
|
|
for (var o in i) i.hasOwnProperty(o) && (A[o] = i[o]);
|
|
i.hasOwnProperty(s) || (A[s] = n[s]);
|
|
}
|
|
var l = r[e];
|
|
return (
|
|
(r[e] = A),
|
|
a.languages.DFS(a.languages, function (t, i) {
|
|
i === l && t != e && (this[t] = A);
|
|
}),
|
|
A
|
|
);
|
|
},
|
|
DFS: function e(t, i, r, n) {
|
|
n = n || {};
|
|
var A = a.util.objId;
|
|
for (var s in t)
|
|
if (t.hasOwnProperty(s)) {
|
|
i.call(t, s, t[s], r || s);
|
|
var o = t[s],
|
|
l = a.util.type(o);
|
|
"Object" !== l || n[A(o)]
|
|
? "Array" !== l ||
|
|
n[A(o)] ||
|
|
((n[A(o)] = !0), e(o, i, s, n))
|
|
: ((n[A(o)] = !0), e(o, i, null, n));
|
|
}
|
|
},
|
|
},
|
|
plugins: {},
|
|
highlightAll: function (e, t) {
|
|
a.highlightAllUnder(document, e, t);
|
|
},
|
|
highlightAllUnder: function (e, t, i) {
|
|
var r = {
|
|
callback: i,
|
|
container: e,
|
|
selector:
|
|
'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code',
|
|
};
|
|
a.hooks.run("before-highlightall", r),
|
|
(r.elements = Array.prototype.slice.apply(
|
|
r.container.querySelectorAll(r.selector),
|
|
)),
|
|
a.hooks.run("before-all-elements-highlight", r);
|
|
for (var n, A = 0; (n = r.elements[A++]); )
|
|
a.highlightElement(n, !0 === t, r.callback);
|
|
},
|
|
highlightElement: function (t, i, r) {
|
|
var n = a.util.getLanguage(t),
|
|
A = a.languages[n];
|
|
a.util.setLanguage(t, n);
|
|
var s = t.parentElement;
|
|
s && "pre" === s.nodeName.toLowerCase() && a.util.setLanguage(s, n);
|
|
var o = t.textContent,
|
|
l = { element: t, language: n, grammar: A, code: o };
|
|
function c(e) {
|
|
(l.highlightedCode = e),
|
|
a.hooks.run("before-insert", l),
|
|
(l.element.innerHTML = l.highlightedCode),
|
|
a.hooks.run("after-highlight", l),
|
|
a.hooks.run("complete", l),
|
|
r && r.call(l.element);
|
|
}
|
|
if (
|
|
(a.hooks.run("before-sanity-check", l),
|
|
(s = l.element.parentElement) &&
|
|
"pre" === s.nodeName.toLowerCase() &&
|
|
!s.hasAttribute("tabindex") &&
|
|
s.setAttribute("tabindex", "0"),
|
|
!l.code)
|
|
) {
|
|
a.hooks.run("complete", l), r && r.call(l.element);
|
|
return;
|
|
}
|
|
if ((a.hooks.run("before-highlight", l), !l.grammar))
|
|
return void c(a.util.encode(l.code));
|
|
if (i && e.Worker) {
|
|
var d = new Worker(a.filename);
|
|
(d.onmessage = function (e) {
|
|
c(e.data);
|
|
}),
|
|
d.postMessage(
|
|
JSON.stringify({
|
|
language: l.language,
|
|
code: l.code,
|
|
immediateClose: !0,
|
|
}),
|
|
);
|
|
} else c(a.highlight(l.code, l.grammar, l.language));
|
|
},
|
|
highlight: function (e, t, i) {
|
|
var r = { code: e, grammar: t, language: i };
|
|
if ((a.hooks.run("before-tokenize", r), !r.grammar))
|
|
throw Error('The language "' + r.language + '" has no grammar.');
|
|
return (
|
|
(r.tokens = a.tokenize(r.code, r.grammar)),
|
|
a.hooks.run("after-tokenize", r),
|
|
n.stringify(a.util.encode(r.tokens), r.language)
|
|
);
|
|
},
|
|
tokenize: function (e, t) {
|
|
var i = t.rest;
|
|
if (i) {
|
|
for (var r in i) t[r] = i[r];
|
|
delete t.rest;
|
|
}
|
|
var l = new s();
|
|
return (
|
|
o(l, l.head, e),
|
|
(function e(t, i, r, s, l, c) {
|
|
for (var d in r)
|
|
if (r.hasOwnProperty(d) && r[d]) {
|
|
var u = r[d];
|
|
u = Array.isArray(u) ? u : [u];
|
|
for (var g = 0; g < u.length; ++g) {
|
|
if (c && c.cause == d + "," + g) return;
|
|
var p = u[g],
|
|
h = p.inside,
|
|
m = !!p.lookbehind,
|
|
I = !!p.greedy,
|
|
f = p.alias;
|
|
if (I && !p.pattern.global) {
|
|
var C = p.pattern.toString().match(/[imsuy]*$/)[0];
|
|
p.pattern = RegExp(p.pattern.source, C + "g");
|
|
}
|
|
for (
|
|
var E = p.pattern || p, B = s.next, b = l;
|
|
B !== i.tail && (!c || !(b >= c.reach));
|
|
b += B.value.length, B = B.next
|
|
) {
|
|
var y,
|
|
w = B.value;
|
|
if (i.length > t.length) return;
|
|
if (!(w instanceof n)) {
|
|
var Q = 1;
|
|
if (I) {
|
|
if (!(y = A(E, b, t, m)) || y.index >= t.length)
|
|
break;
|
|
var S = y.index,
|
|
k = y.index + y[0].length,
|
|
v = b;
|
|
for (v += B.value.length; S >= v; )
|
|
v += (B = B.next).value.length;
|
|
if (
|
|
((v -= B.value.length),
|
|
(b = v),
|
|
B.value instanceof n)
|
|
)
|
|
continue;
|
|
for (
|
|
var x = B;
|
|
x !== i.tail &&
|
|
(v < k || "string" == typeof x.value);
|
|
x = x.next
|
|
)
|
|
Q++, (v += x.value.length);
|
|
Q--, (w = t.slice(b, v)), (y.index -= b);
|
|
} else if (!(y = A(E, 0, w, m))) continue;
|
|
var S = y.index,
|
|
D = y[0],
|
|
T = w.slice(0, S),
|
|
N = w.slice(S + D.length),
|
|
R = b + w.length;
|
|
c && R > c.reach && (c.reach = R);
|
|
var M = B.prev;
|
|
if (
|
|
(T && ((M = o(i, M, T)), (b += T.length)),
|
|
(function (e, t, i) {
|
|
for (
|
|
var r = t.next, a = 0;
|
|
a < i && r !== e.tail;
|
|
a++
|
|
)
|
|
r = r.next;
|
|
(t.next = r), (r.prev = t), (e.length -= a);
|
|
})(i, M, Q),
|
|
(B = o(
|
|
i,
|
|
M,
|
|
new n(d, h ? a.tokenize(D, h) : D, f, D),
|
|
)),
|
|
N && o(i, B, N),
|
|
Q > 1)
|
|
) {
|
|
var P = { cause: d + "," + g, reach: R };
|
|
e(t, i, r, B.prev, b, P),
|
|
c && P.reach > c.reach && (c.reach = P.reach);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
})(e, l, t, l.head, 0),
|
|
(function (e) {
|
|
for (var t = [], i = e.head.next; i !== e.tail; )
|
|
t.push(i.value), (i = i.next);
|
|
return t;
|
|
})(l)
|
|
);
|
|
},
|
|
hooks: {
|
|
all: {},
|
|
add: function (e, t) {
|
|
var i = a.hooks.all;
|
|
(i[e] = i[e] || []), i[e].push(t);
|
|
},
|
|
run: function (e, t) {
|
|
var i = a.hooks.all[e];
|
|
if (i && i.length) for (var r, n = 0; (r = i[n++]); ) r(t);
|
|
},
|
|
},
|
|
Token: n,
|
|
};
|
|
function n(e, t, i, r) {
|
|
(this.type = e),
|
|
(this.content = t),
|
|
(this.alias = i),
|
|
(this.length = 0 | (r || "").length);
|
|
}
|
|
function A(e, t, i, r) {
|
|
e.lastIndex = t;
|
|
var a = e.exec(i);
|
|
if (a && r && a[1]) {
|
|
var n = a[1].length;
|
|
(a.index += n), (a[0] = a[0].slice(n));
|
|
}
|
|
return a;
|
|
}
|
|
function s() {
|
|
var e = { value: null, prev: null, next: null },
|
|
t = { value: null, prev: e, next: null };
|
|
(e.next = t), (this.head = e), (this.tail = t), (this.length = 0);
|
|
}
|
|
function o(e, t, i) {
|
|
var r = t.next,
|
|
a = { value: i, prev: t, next: r };
|
|
return (t.next = a), (r.prev = a), e.length++, a;
|
|
}
|
|
if (
|
|
((e.Prism = a),
|
|
(n.stringify = function e(t, i) {
|
|
if ("string" == typeof t) return t;
|
|
if (Array.isArray(t)) {
|
|
var r = "";
|
|
return (
|
|
t.forEach(function (t) {
|
|
r += e(t, i);
|
|
}),
|
|
r
|
|
);
|
|
}
|
|
var n = {
|
|
type: t.type,
|
|
content: e(t.content, i),
|
|
tag: "span",
|
|
classes: ["token", t.type],
|
|
attributes: {},
|
|
language: i,
|
|
},
|
|
A = t.alias;
|
|
A &&
|
|
(Array.isArray(A)
|
|
? Array.prototype.push.apply(n.classes, A)
|
|
: n.classes.push(A)),
|
|
a.hooks.run("wrap", n);
|
|
var s = "";
|
|
for (var o in n.attributes)
|
|
s +=
|
|
" " +
|
|
o +
|
|
'="' +
|
|
(n.attributes[o] || "").replace(/"/g, """) +
|
|
'"';
|
|
return (
|
|
"<" +
|
|
n.tag +
|
|
' class="' +
|
|
n.classes.join(" ") +
|
|
'"' +
|
|
s +
|
|
">" +
|
|
n.content +
|
|
"</" +
|
|
n.tag +
|
|
">"
|
|
);
|
|
}),
|
|
!e.document)
|
|
)
|
|
return (
|
|
e.addEventListener &&
|
|
(a.disableWorkerMessageHandler ||
|
|
e.addEventListener(
|
|
"message",
|
|
function (t) {
|
|
var i = JSON.parse(t.data),
|
|
r = i.language,
|
|
n = i.code,
|
|
A = i.immediateClose;
|
|
e.postMessage(a.highlight(n, a.languages[r], r)),
|
|
A && e.close();
|
|
},
|
|
!1,
|
|
)),
|
|
a
|
|
);
|
|
var l = a.util.currentScript();
|
|
function c() {
|
|
a.manual || a.highlightAll();
|
|
}
|
|
if (
|
|
(l &&
|
|
((a.filename = l.src),
|
|
l.hasAttribute("data-manual") && (a.manual = !0)),
|
|
!a.manual)
|
|
) {
|
|
var d = document.readyState;
|
|
"loading" === d || ("interactive" === d && l && l.defer)
|
|
? document.addEventListener("DOMContentLoaded", c)
|
|
: window.requestAnimationFrame
|
|
? window.requestAnimationFrame(c)
|
|
: window.setTimeout(c, 16);
|
|
}
|
|
return a;
|
|
})(
|
|
"u" > typeof window
|
|
? window
|
|
: "u" > typeof WorkerGlobalScope && self instanceof WorkerGlobalScope
|
|
? self
|
|
: {},
|
|
);
|
|
t.exports && (t.exports = r), (e.g.Prism = r);
|
|
};
|
|
|
|
export default moduleFactory;
|