luogu-renderer 1.0.3 → 1.0.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/luogu-new-renderer.iife.js +1312 -2893
- package/dist/luogu-old-renderer.iife.js +471 -479
- package/package.json +3 -3
- package/render-new.js +5 -7
|
@@ -34,245 +34,6 @@ var LuoguOldRenderer = (() => {
|
|
|
34
34
|
));
|
|
35
35
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
36
36
|
|
|
37
|
-
// node_modules/punycode.js/punycode.js
|
|
38
|
-
var require_punycode = __commonJS({
|
|
39
|
-
"node_modules/punycode.js/punycode.js"(exports, module) {
|
|
40
|
-
"use strict";
|
|
41
|
-
var maxInt = 2147483647;
|
|
42
|
-
var base = 36;
|
|
43
|
-
var tMin = 1;
|
|
44
|
-
var tMax = 26;
|
|
45
|
-
var skew = 38;
|
|
46
|
-
var damp = 700;
|
|
47
|
-
var initialBias = 72;
|
|
48
|
-
var initialN = 128;
|
|
49
|
-
var delimiter = "-";
|
|
50
|
-
var regexPunycode = /^xn--/;
|
|
51
|
-
var regexNonASCII = /[^\0-\x7F]/;
|
|
52
|
-
var regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g;
|
|
53
|
-
var errors = {
|
|
54
|
-
"overflow": "Overflow: input needs wider integers to process",
|
|
55
|
-
"not-basic": "Illegal input >= 0x80 (not a basic code point)",
|
|
56
|
-
"invalid-input": "Invalid input"
|
|
57
|
-
};
|
|
58
|
-
var baseMinusTMin = base - tMin;
|
|
59
|
-
var floor = Math.floor;
|
|
60
|
-
var stringFromCharCode = String.fromCharCode;
|
|
61
|
-
function error(type) {
|
|
62
|
-
throw new RangeError(errors[type]);
|
|
63
|
-
}
|
|
64
|
-
function map(array, callback) {
|
|
65
|
-
const result = [];
|
|
66
|
-
let length = array.length;
|
|
67
|
-
while (length--) {
|
|
68
|
-
result[length] = callback(array[length]);
|
|
69
|
-
}
|
|
70
|
-
return result;
|
|
71
|
-
}
|
|
72
|
-
function mapDomain(domain, callback) {
|
|
73
|
-
const parts = domain.split("@");
|
|
74
|
-
let result = "";
|
|
75
|
-
if (parts.length > 1) {
|
|
76
|
-
result = parts[0] + "@";
|
|
77
|
-
domain = parts[1];
|
|
78
|
-
}
|
|
79
|
-
domain = domain.replace(regexSeparators, ".");
|
|
80
|
-
const labels = domain.split(".");
|
|
81
|
-
const encoded = map(labels, callback).join(".");
|
|
82
|
-
return result + encoded;
|
|
83
|
-
}
|
|
84
|
-
function ucs2decode(string) {
|
|
85
|
-
const output = [];
|
|
86
|
-
let counter = 0;
|
|
87
|
-
const length = string.length;
|
|
88
|
-
while (counter < length) {
|
|
89
|
-
const value = string.charCodeAt(counter++);
|
|
90
|
-
if (value >= 55296 && value <= 56319 && counter < length) {
|
|
91
|
-
const extra = string.charCodeAt(counter++);
|
|
92
|
-
if ((extra & 64512) == 56320) {
|
|
93
|
-
output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
|
|
94
|
-
} else {
|
|
95
|
-
output.push(value);
|
|
96
|
-
counter--;
|
|
97
|
-
}
|
|
98
|
-
} else {
|
|
99
|
-
output.push(value);
|
|
100
|
-
}
|
|
101
|
-
}
|
|
102
|
-
return output;
|
|
103
|
-
}
|
|
104
|
-
var ucs2encode = (codePoints) => String.fromCodePoint(...codePoints);
|
|
105
|
-
var basicToDigit = function(codePoint) {
|
|
106
|
-
if (codePoint >= 48 && codePoint < 58) {
|
|
107
|
-
return 26 + (codePoint - 48);
|
|
108
|
-
}
|
|
109
|
-
if (codePoint >= 65 && codePoint < 91) {
|
|
110
|
-
return codePoint - 65;
|
|
111
|
-
}
|
|
112
|
-
if (codePoint >= 97 && codePoint < 123) {
|
|
113
|
-
return codePoint - 97;
|
|
114
|
-
}
|
|
115
|
-
return base;
|
|
116
|
-
};
|
|
117
|
-
var digitToBasic = function(digit, flag) {
|
|
118
|
-
return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
|
|
119
|
-
};
|
|
120
|
-
var adapt = function(delta, numPoints, firstTime) {
|
|
121
|
-
let k = 0;
|
|
122
|
-
delta = firstTime ? floor(delta / damp) : delta >> 1;
|
|
123
|
-
delta += floor(delta / numPoints);
|
|
124
|
-
for (; delta > baseMinusTMin * tMax >> 1; k += base) {
|
|
125
|
-
delta = floor(delta / baseMinusTMin);
|
|
126
|
-
}
|
|
127
|
-
return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
|
|
128
|
-
};
|
|
129
|
-
var decode2 = function(input) {
|
|
130
|
-
const output = [];
|
|
131
|
-
const inputLength = input.length;
|
|
132
|
-
let i2 = 0;
|
|
133
|
-
let n = initialN;
|
|
134
|
-
let bias = initialBias;
|
|
135
|
-
let basic = input.lastIndexOf(delimiter);
|
|
136
|
-
if (basic < 0) {
|
|
137
|
-
basic = 0;
|
|
138
|
-
}
|
|
139
|
-
for (let j = 0; j < basic; ++j) {
|
|
140
|
-
if (input.charCodeAt(j) >= 128) {
|
|
141
|
-
error("not-basic");
|
|
142
|
-
}
|
|
143
|
-
output.push(input.charCodeAt(j));
|
|
144
|
-
}
|
|
145
|
-
for (let index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {
|
|
146
|
-
const oldi = i2;
|
|
147
|
-
for (let w = 1, k = base; ; k += base) {
|
|
148
|
-
if (index >= inputLength) {
|
|
149
|
-
error("invalid-input");
|
|
150
|
-
}
|
|
151
|
-
const digit = basicToDigit(input.charCodeAt(index++));
|
|
152
|
-
if (digit >= base) {
|
|
153
|
-
error("invalid-input");
|
|
154
|
-
}
|
|
155
|
-
if (digit > floor((maxInt - i2) / w)) {
|
|
156
|
-
error("overflow");
|
|
157
|
-
}
|
|
158
|
-
i2 += digit * w;
|
|
159
|
-
const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
|
|
160
|
-
if (digit < t) {
|
|
161
|
-
break;
|
|
162
|
-
}
|
|
163
|
-
const baseMinusT = base - t;
|
|
164
|
-
if (w > floor(maxInt / baseMinusT)) {
|
|
165
|
-
error("overflow");
|
|
166
|
-
}
|
|
167
|
-
w *= baseMinusT;
|
|
168
|
-
}
|
|
169
|
-
const out = output.length + 1;
|
|
170
|
-
bias = adapt(i2 - oldi, out, oldi == 0);
|
|
171
|
-
if (floor(i2 / out) > maxInt - n) {
|
|
172
|
-
error("overflow");
|
|
173
|
-
}
|
|
174
|
-
n += floor(i2 / out);
|
|
175
|
-
i2 %= out;
|
|
176
|
-
output.splice(i2++, 0, n);
|
|
177
|
-
}
|
|
178
|
-
return String.fromCodePoint(...output);
|
|
179
|
-
};
|
|
180
|
-
var encode2 = function(input) {
|
|
181
|
-
const output = [];
|
|
182
|
-
input = ucs2decode(input);
|
|
183
|
-
const inputLength = input.length;
|
|
184
|
-
let n = initialN;
|
|
185
|
-
let delta = 0;
|
|
186
|
-
let bias = initialBias;
|
|
187
|
-
for (const currentValue of input) {
|
|
188
|
-
if (currentValue < 128) {
|
|
189
|
-
output.push(stringFromCharCode(currentValue));
|
|
190
|
-
}
|
|
191
|
-
}
|
|
192
|
-
const basicLength = output.length;
|
|
193
|
-
let handledCPCount = basicLength;
|
|
194
|
-
if (basicLength) {
|
|
195
|
-
output.push(delimiter);
|
|
196
|
-
}
|
|
197
|
-
while (handledCPCount < inputLength) {
|
|
198
|
-
let m = maxInt;
|
|
199
|
-
for (const currentValue of input) {
|
|
200
|
-
if (currentValue >= n && currentValue < m) {
|
|
201
|
-
m = currentValue;
|
|
202
|
-
}
|
|
203
|
-
}
|
|
204
|
-
const handledCPCountPlusOne = handledCPCount + 1;
|
|
205
|
-
if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
|
|
206
|
-
error("overflow");
|
|
207
|
-
}
|
|
208
|
-
delta += (m - n) * handledCPCountPlusOne;
|
|
209
|
-
n = m;
|
|
210
|
-
for (const currentValue of input) {
|
|
211
|
-
if (currentValue < n && ++delta > maxInt) {
|
|
212
|
-
error("overflow");
|
|
213
|
-
}
|
|
214
|
-
if (currentValue === n) {
|
|
215
|
-
let q = delta;
|
|
216
|
-
for (let k = base; ; k += base) {
|
|
217
|
-
const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
|
|
218
|
-
if (q < t) {
|
|
219
|
-
break;
|
|
220
|
-
}
|
|
221
|
-
const qMinusT = q - t;
|
|
222
|
-
const baseMinusT = base - t;
|
|
223
|
-
output.push(
|
|
224
|
-
stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
|
|
225
|
-
);
|
|
226
|
-
q = floor(qMinusT / baseMinusT);
|
|
227
|
-
}
|
|
228
|
-
output.push(stringFromCharCode(digitToBasic(q, 0)));
|
|
229
|
-
bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
|
|
230
|
-
delta = 0;
|
|
231
|
-
++handledCPCount;
|
|
232
|
-
}
|
|
233
|
-
}
|
|
234
|
-
++delta;
|
|
235
|
-
++n;
|
|
236
|
-
}
|
|
237
|
-
return output.join("");
|
|
238
|
-
};
|
|
239
|
-
var toUnicode = function(input) {
|
|
240
|
-
return mapDomain(input, function(string) {
|
|
241
|
-
return regexPunycode.test(string) ? decode2(string.slice(4).toLowerCase()) : string;
|
|
242
|
-
});
|
|
243
|
-
};
|
|
244
|
-
var toASCII = function(input) {
|
|
245
|
-
return mapDomain(input, function(string) {
|
|
246
|
-
return regexNonASCII.test(string) ? "xn--" + encode2(string) : string;
|
|
247
|
-
});
|
|
248
|
-
};
|
|
249
|
-
var punycode2 = {
|
|
250
|
-
/**
|
|
251
|
-
* A string representing the current Punycode.js version number.
|
|
252
|
-
* @memberOf punycode
|
|
253
|
-
* @type String
|
|
254
|
-
*/
|
|
255
|
-
"version": "2.3.1",
|
|
256
|
-
/**
|
|
257
|
-
* An object of methods to convert from JavaScript's internal character
|
|
258
|
-
* representation (UCS-2) to Unicode code points, and back.
|
|
259
|
-
* @see <https://mathiasbynens.be/notes/javascript-encoding>
|
|
260
|
-
* @memberOf punycode
|
|
261
|
-
* @type Object
|
|
262
|
-
*/
|
|
263
|
-
"ucs2": {
|
|
264
|
-
"decode": ucs2decode,
|
|
265
|
-
"encode": ucs2encode
|
|
266
|
-
},
|
|
267
|
-
"decode": decode2,
|
|
268
|
-
"encode": encode2,
|
|
269
|
-
"toASCII": toASCII,
|
|
270
|
-
"toUnicode": toUnicode
|
|
271
|
-
};
|
|
272
|
-
module.exports = punycode2;
|
|
273
|
-
}
|
|
274
|
-
});
|
|
275
|
-
|
|
276
37
|
// node_modules/katex/dist/katex.js
|
|
277
38
|
var require_katex = __commonJS({
|
|
278
39
|
"node_modules/katex/dist/katex.js"(exports, module) {
|
|
@@ -318,7 +79,7 @@ var LuoguOldRenderer = (() => {
|
|
|
318
79
|
class ParseError2 extends Error {
|
|
319
80
|
// The underlying error message without any context added.
|
|
320
81
|
constructor(message, token) {
|
|
321
|
-
let
|
|
82
|
+
let error2 = "KaTeX parse error: " + message;
|
|
322
83
|
let start;
|
|
323
84
|
let end;
|
|
324
85
|
const loc = token && token.loc;
|
|
@@ -327,9 +88,9 @@ var LuoguOldRenderer = (() => {
|
|
|
327
88
|
start = loc.start;
|
|
328
89
|
end = loc.end;
|
|
329
90
|
if (start === input.length) {
|
|
330
|
-
|
|
91
|
+
error2 += " at end of input: ";
|
|
331
92
|
} else {
|
|
332
|
-
|
|
93
|
+
error2 += " at position " + (start + 1) + ": ";
|
|
333
94
|
}
|
|
334
95
|
const underlined = input.slice(start, end).replace(/[^]/g, "$&\u0332");
|
|
335
96
|
let left;
|
|
@@ -344,9 +105,9 @@ var LuoguOldRenderer = (() => {
|
|
|
344
105
|
} else {
|
|
345
106
|
right = input.slice(end);
|
|
346
107
|
}
|
|
347
|
-
|
|
108
|
+
error2 += left + underlined + right;
|
|
348
109
|
}
|
|
349
|
-
super(
|
|
110
|
+
super(error2);
|
|
350
111
|
this.name = "ParseError";
|
|
351
112
|
this.position = void 0;
|
|
352
113
|
this.length = void 0;
|
|
@@ -584,7 +345,7 @@ var LuoguOldRenderer = (() => {
|
|
|
584
345
|
if (typeof strict === "function") {
|
|
585
346
|
try {
|
|
586
347
|
strict = strict(errorCode, errorMsg, token);
|
|
587
|
-
} catch (
|
|
348
|
+
} catch (error2) {
|
|
588
349
|
strict = "error";
|
|
589
350
|
}
|
|
590
351
|
}
|
|
@@ -1253,7 +1014,7 @@ var LuoguOldRenderer = (() => {
|
|
|
1253
1014
|
"\xEC": "\u0131\u0300"
|
|
1254
1015
|
};
|
|
1255
1016
|
class SymbolNode2 {
|
|
1256
|
-
constructor(text3, height, depth, italic3,
|
|
1017
|
+
constructor(text3, height, depth, italic3, skew2, width, classes, style) {
|
|
1257
1018
|
this.text = void 0;
|
|
1258
1019
|
this.height = void 0;
|
|
1259
1020
|
this.depth = void 0;
|
|
@@ -1267,7 +1028,7 @@ var LuoguOldRenderer = (() => {
|
|
|
1267
1028
|
this.height = height || 0;
|
|
1268
1029
|
this.depth = depth || 0;
|
|
1269
1030
|
this.italic = italic3 || 0;
|
|
1270
|
-
this.skew =
|
|
1031
|
+
this.skew = skew2 || 0;
|
|
1271
1032
|
this.width = width || 0;
|
|
1272
1033
|
this.classes = classes || [];
|
|
1273
1034
|
this.style = style || {};
|
|
@@ -5684,9 +5445,9 @@ var LuoguOldRenderer = (() => {
|
|
|
5684
5445
|
group.children = [...lastGroup.children, ...group.children];
|
|
5685
5446
|
groups.pop();
|
|
5686
5447
|
} else if ((group.type === "msup" || group.type === "msub") && group.children.length >= 1 && (lastGroup.type === "mn" || isNumberPunctuation2(lastGroup))) {
|
|
5687
|
-
const
|
|
5688
|
-
if (
|
|
5689
|
-
|
|
5448
|
+
const base2 = group.children[0];
|
|
5449
|
+
if (base2 instanceof MathNode2 && base2.type === "mn") {
|
|
5450
|
+
base2.children = [...lastGroup.children, ...base2.children];
|
|
5690
5451
|
groups.pop();
|
|
5691
5452
|
}
|
|
5692
5453
|
} else if (lastGroup.type === "mi" && lastGroup.children.length === 1) {
|
|
@@ -6357,25 +6118,25 @@ var LuoguOldRenderer = (() => {
|
|
|
6357
6118
|
}
|
|
6358
6119
|
};
|
|
6359
6120
|
const htmlBuilder3 = (grp, options) => {
|
|
6360
|
-
let
|
|
6121
|
+
let base2;
|
|
6361
6122
|
let group;
|
|
6362
6123
|
let supSubGroup;
|
|
6363
6124
|
if (grp && grp.type === "supsub") {
|
|
6364
6125
|
group = assertNodeType2(grp.base, "accent");
|
|
6365
|
-
|
|
6366
|
-
grp.base =
|
|
6126
|
+
base2 = group.base;
|
|
6127
|
+
grp.base = base2;
|
|
6367
6128
|
supSubGroup = assertSpan2(buildGroup4(grp, options));
|
|
6368
6129
|
grp.base = group;
|
|
6369
6130
|
} else {
|
|
6370
6131
|
group = assertNodeType2(grp, "accent");
|
|
6371
|
-
|
|
6132
|
+
base2 = group.base;
|
|
6372
6133
|
}
|
|
6373
|
-
const body = buildGroup4(
|
|
6374
|
-
const mustShift = group.isShifty && isCharacterBox2(
|
|
6375
|
-
let
|
|
6134
|
+
const body = buildGroup4(base2, options.havingCrampedStyle());
|
|
6135
|
+
const mustShift = group.isShifty && isCharacterBox2(base2);
|
|
6136
|
+
let skew2 = 0;
|
|
6376
6137
|
if (mustShift) {
|
|
6377
6138
|
var _getBaseSymbol$skew, _getBaseSymbol;
|
|
6378
|
-
|
|
6139
|
+
skew2 = (_getBaseSymbol$skew = (_getBaseSymbol = getBaseSymbol2(body)) == null ? void 0 : _getBaseSymbol.skew) != null ? _getBaseSymbol$skew : 0;
|
|
6379
6140
|
}
|
|
6380
6141
|
const accentBelow = group.label === "\\c";
|
|
6381
6142
|
let clearance = accentBelow ? body.height + body.depth : Math.min(body.height, options.fontMetrics().xHeight);
|
|
@@ -6405,7 +6166,7 @@ var LuoguOldRenderer = (() => {
|
|
|
6405
6166
|
accentBody.classes.push("accent-full");
|
|
6406
6167
|
clearance = body.height;
|
|
6407
6168
|
}
|
|
6408
|
-
let left =
|
|
6169
|
+
let left = skew2;
|
|
6409
6170
|
if (!accentFull) {
|
|
6410
6171
|
left -= width / 2;
|
|
6411
6172
|
}
|
|
@@ -6437,9 +6198,9 @@ var LuoguOldRenderer = (() => {
|
|
|
6437
6198
|
type: "elem",
|
|
6438
6199
|
elem: accentBody,
|
|
6439
6200
|
wrapperClasses: ["svg-align"],
|
|
6440
|
-
wrapperStyle:
|
|
6441
|
-
width: "calc(100% - " + makeEm3(2 *
|
|
6442
|
-
marginLeft: makeEm3(2 *
|
|
6201
|
+
wrapperStyle: skew2 > 0 ? {
|
|
6202
|
+
width: "calc(100% - " + makeEm3(2 * skew2) + ")",
|
|
6203
|
+
marginLeft: makeEm3(2 * skew2)
|
|
6443
6204
|
} : void 0
|
|
6444
6205
|
}]
|
|
6445
6206
|
}, options);
|
|
@@ -6468,7 +6229,7 @@ var LuoguOldRenderer = (() => {
|
|
|
6468
6229
|
numArgs: 1
|
|
6469
6230
|
},
|
|
6470
6231
|
handler: (context, args) => {
|
|
6471
|
-
const
|
|
6232
|
+
const base2 = normalizeArgument3(args[0]);
|
|
6472
6233
|
const isStretchy = !NON_STRETCHY_ACCENT_REGEX2.test(context.funcName);
|
|
6473
6234
|
const isShifty = !isStretchy || context.funcName === "\\widehat" || context.funcName === "\\widetilde" || context.funcName === "\\widecheck";
|
|
6474
6235
|
return {
|
|
@@ -6477,7 +6238,7 @@ var LuoguOldRenderer = (() => {
|
|
|
6477
6238
|
label: context.funcName,
|
|
6478
6239
|
isStretchy,
|
|
6479
6240
|
isShifty,
|
|
6480
|
-
base
|
|
6241
|
+
base: base2
|
|
6481
6242
|
};
|
|
6482
6243
|
},
|
|
6483
6244
|
htmlBuilder: htmlBuilder3,
|
|
@@ -6494,7 +6255,7 @@ var LuoguOldRenderer = (() => {
|
|
|
6494
6255
|
argTypes: ["primitive"]
|
|
6495
6256
|
},
|
|
6496
6257
|
handler: (context, args) => {
|
|
6497
|
-
const
|
|
6258
|
+
const base2 = args[0];
|
|
6498
6259
|
let mode = context.parser.mode;
|
|
6499
6260
|
if (mode === "math") {
|
|
6500
6261
|
context.parser.settings.reportNonstrict("mathVsTextAccents", "LaTeX's accent " + context.funcName + " works only in text mode");
|
|
@@ -6506,7 +6267,7 @@ var LuoguOldRenderer = (() => {
|
|
|
6506
6267
|
label: context.funcName,
|
|
6507
6268
|
isStretchy: false,
|
|
6508
6269
|
isShifty: true,
|
|
6509
|
-
base
|
|
6270
|
+
base: base2
|
|
6510
6271
|
};
|
|
6511
6272
|
},
|
|
6512
6273
|
htmlBuilder: htmlBuilder3,
|
|
@@ -6524,12 +6285,12 @@ var LuoguOldRenderer = (() => {
|
|
|
6524
6285
|
parser,
|
|
6525
6286
|
funcName
|
|
6526
6287
|
} = _ref;
|
|
6527
|
-
const
|
|
6288
|
+
const base2 = args[0];
|
|
6528
6289
|
return {
|
|
6529
6290
|
type: "accentUnder",
|
|
6530
6291
|
mode: parser.mode,
|
|
6531
6292
|
label: funcName,
|
|
6532
|
-
base
|
|
6293
|
+
base: base2
|
|
6533
6294
|
};
|
|
6534
6295
|
},
|
|
6535
6296
|
htmlBuilder: (group, options) => {
|
|
@@ -10692,8 +10453,8 @@ var LuoguOldRenderer = (() => {
|
|
|
10692
10453
|
}
|
|
10693
10454
|
});
|
|
10694
10455
|
;
|
|
10695
|
-
const assembleSupSub2 = (
|
|
10696
|
-
|
|
10456
|
+
const assembleSupSub2 = (base2, supGroup, subGroup, options, style, slant, baseShift) => {
|
|
10457
|
+
base2 = makeSpan3([], [base2]);
|
|
10697
10458
|
const subIsSingleCharacter = subGroup && isCharacterBox2(subGroup);
|
|
10698
10459
|
let sub3;
|
|
10699
10460
|
let sup3;
|
|
@@ -10713,7 +10474,7 @@ var LuoguOldRenderer = (() => {
|
|
|
10713
10474
|
}
|
|
10714
10475
|
let finalGroup;
|
|
10715
10476
|
if (sup3 && sub3) {
|
|
10716
|
-
const bottom = options.fontMetrics().bigOpSpacing5 + sub3.elem.height + sub3.elem.depth + sub3.kern +
|
|
10477
|
+
const bottom = options.fontMetrics().bigOpSpacing5 + sub3.elem.height + sub3.elem.depth + sub3.kern + base2.depth + baseShift;
|
|
10717
10478
|
finalGroup = makeVList3({
|
|
10718
10479
|
positionType: "bottom",
|
|
10719
10480
|
positionData: bottom,
|
|
@@ -10729,7 +10490,7 @@ var LuoguOldRenderer = (() => {
|
|
|
10729
10490
|
size: sub3.kern
|
|
10730
10491
|
}, {
|
|
10731
10492
|
type: "elem",
|
|
10732
|
-
elem:
|
|
10493
|
+
elem: base2
|
|
10733
10494
|
}, {
|
|
10734
10495
|
type: "kern",
|
|
10735
10496
|
size: sup3.kern
|
|
@@ -10743,7 +10504,7 @@ var LuoguOldRenderer = (() => {
|
|
|
10743
10504
|
}]
|
|
10744
10505
|
}, options);
|
|
10745
10506
|
} else if (sub3) {
|
|
10746
|
-
const top =
|
|
10507
|
+
const top = base2.height - baseShift;
|
|
10747
10508
|
finalGroup = makeVList3({
|
|
10748
10509
|
positionType: "top",
|
|
10749
10510
|
positionData: top,
|
|
@@ -10759,17 +10520,17 @@ var LuoguOldRenderer = (() => {
|
|
|
10759
10520
|
size: sub3.kern
|
|
10760
10521
|
}, {
|
|
10761
10522
|
type: "elem",
|
|
10762
|
-
elem:
|
|
10523
|
+
elem: base2
|
|
10763
10524
|
}]
|
|
10764
10525
|
}, options);
|
|
10765
10526
|
} else if (sup3) {
|
|
10766
|
-
const bottom =
|
|
10527
|
+
const bottom = base2.depth + baseShift;
|
|
10767
10528
|
finalGroup = makeVList3({
|
|
10768
10529
|
positionType: "bottom",
|
|
10769
10530
|
positionData: bottom,
|
|
10770
10531
|
children: [{
|
|
10771
10532
|
type: "elem",
|
|
10772
|
-
elem:
|
|
10533
|
+
elem: base2
|
|
10773
10534
|
}, {
|
|
10774
10535
|
type: "kern",
|
|
10775
10536
|
size: sup3.kern
|
|
@@ -10783,7 +10544,7 @@ var LuoguOldRenderer = (() => {
|
|
|
10783
10544
|
}]
|
|
10784
10545
|
}, options);
|
|
10785
10546
|
} else {
|
|
10786
|
-
return
|
|
10547
|
+
return base2;
|
|
10787
10548
|
}
|
|
10788
10549
|
const parts = [finalGroup];
|
|
10789
10550
|
if (sub3 && slant !== 0 && !subIsSingleCharacter) {
|
|
@@ -10813,7 +10574,7 @@ var LuoguOldRenderer = (() => {
|
|
|
10813
10574
|
if (style.size === src_Style.DISPLAY.size && group.symbol && !noSuccessor2.has(group.name)) {
|
|
10814
10575
|
large = true;
|
|
10815
10576
|
}
|
|
10816
|
-
let
|
|
10577
|
+
let base2;
|
|
10817
10578
|
let symbolItalic;
|
|
10818
10579
|
if (group.symbol) {
|
|
10819
10580
|
const fontName = large ? "Size2-Regular" : "Size1-Regular";
|
|
@@ -10822,15 +10583,15 @@ var LuoguOldRenderer = (() => {
|
|
|
10822
10583
|
stash = group.name.slice(1);
|
|
10823
10584
|
group.name = stash === "oiint" ? "\\iint" : "\\iiint";
|
|
10824
10585
|
}
|
|
10825
|
-
|
|
10826
|
-
symbolItalic =
|
|
10586
|
+
base2 = makeSymbol3(group.name, fontName, "math", options, ["mop", "op-symbol", large ? "large-op" : "small-op"]);
|
|
10587
|
+
symbolItalic = base2.italic;
|
|
10827
10588
|
if (stash.length > 0) {
|
|
10828
10589
|
const oval = staticSvg3(stash + "Size" + (large ? "2" : "1"), options);
|
|
10829
|
-
|
|
10590
|
+
base2 = makeVList3({
|
|
10830
10591
|
positionType: "individualShift",
|
|
10831
10592
|
children: [{
|
|
10832
10593
|
type: "elem",
|
|
10833
|
-
elem:
|
|
10594
|
+
elem: base2,
|
|
10834
10595
|
shift: 0
|
|
10835
10596
|
}, {
|
|
10836
10597
|
type: "elem",
|
|
@@ -10839,39 +10600,39 @@ var LuoguOldRenderer = (() => {
|
|
|
10839
10600
|
}]
|
|
10840
10601
|
}, options);
|
|
10841
10602
|
group.name = "\\" + stash;
|
|
10842
|
-
|
|
10843
|
-
|
|
10603
|
+
base2.classes.unshift("mop");
|
|
10604
|
+
base2.italic = symbolItalic;
|
|
10844
10605
|
}
|
|
10845
10606
|
} else if (group.body) {
|
|
10846
10607
|
const inner3 = buildExpression4(group.body, options, true);
|
|
10847
10608
|
if (inner3.length === 1 && inner3[0] instanceof SymbolNode2) {
|
|
10848
|
-
|
|
10849
|
-
|
|
10609
|
+
base2 = inner3[0];
|
|
10610
|
+
base2.classes[0] = "mop";
|
|
10850
10611
|
} else {
|
|
10851
|
-
|
|
10612
|
+
base2 = makeSpan3(["mop"], inner3, options);
|
|
10852
10613
|
}
|
|
10853
10614
|
} else {
|
|
10854
10615
|
const output = [];
|
|
10855
10616
|
for (let i2 = 1; i2 < group.name.length; i2++) {
|
|
10856
10617
|
output.push(mathsym3(group.name[i2], group.mode, options));
|
|
10857
10618
|
}
|
|
10858
|
-
|
|
10619
|
+
base2 = makeSpan3(["mop"], output, options);
|
|
10859
10620
|
}
|
|
10860
10621
|
let baseShift = 0;
|
|
10861
10622
|
let slant = 0;
|
|
10862
|
-
if ((
|
|
10623
|
+
if ((base2 instanceof SymbolNode2 || group.name === "\\oiint" || group.name === "\\oiiint") && !group.suppressBaseShift) {
|
|
10863
10624
|
var _base$italic;
|
|
10864
|
-
baseShift = (
|
|
10865
|
-
slant = (_base$italic =
|
|
10625
|
+
baseShift = (base2.height - base2.depth) / 2 - options.fontMetrics().axisHeight;
|
|
10626
|
+
slant = (_base$italic = base2.italic) != null ? _base$italic : 0;
|
|
10866
10627
|
}
|
|
10867
10628
|
if (hasLimits) {
|
|
10868
|
-
return assembleSupSub2(
|
|
10629
|
+
return assembleSupSub2(base2, supGroup, subGroup, options, style, slant, baseShift);
|
|
10869
10630
|
} else {
|
|
10870
10631
|
if (baseShift) {
|
|
10871
|
-
|
|
10872
|
-
|
|
10632
|
+
base2.style.position = "relative";
|
|
10633
|
+
base2.style.top = makeEm3(baseShift);
|
|
10873
10634
|
}
|
|
10874
|
-
return
|
|
10635
|
+
return base2;
|
|
10875
10636
|
}
|
|
10876
10637
|
};
|
|
10877
10638
|
const op_mathmlBuilder = (group, options) => {
|
|
@@ -11055,7 +10816,7 @@ var LuoguOldRenderer = (() => {
|
|
|
11055
10816
|
} else {
|
|
11056
10817
|
group = assertNodeType2(grp, "operatorname");
|
|
11057
10818
|
}
|
|
11058
|
-
let
|
|
10819
|
+
let base2;
|
|
11059
10820
|
if (group.body.length > 0) {
|
|
11060
10821
|
const body = group.body.map((child) => {
|
|
11061
10822
|
const childText = "text" in child ? child.text : void 0;
|
|
@@ -11076,14 +10837,14 @@ var LuoguOldRenderer = (() => {
|
|
|
11076
10837
|
child.text = child.text.replace(/\u2212/, "-").replace(/\u2217/, "*");
|
|
11077
10838
|
}
|
|
11078
10839
|
}
|
|
11079
|
-
|
|
10840
|
+
base2 = makeSpan3(["mop"], expression, options);
|
|
11080
10841
|
} else {
|
|
11081
|
-
|
|
10842
|
+
base2 = makeSpan3(["mop"], [], options);
|
|
11082
10843
|
}
|
|
11083
10844
|
if (hasLimits) {
|
|
11084
|
-
return assembleSupSub2(
|
|
10845
|
+
return assembleSupSub2(base2, supGroup, subGroup, options, options.style, 0, 0);
|
|
11085
10846
|
} else {
|
|
11086
|
-
return
|
|
10847
|
+
return base2;
|
|
11087
10848
|
}
|
|
11088
10849
|
};
|
|
11089
10850
|
const operatorname_mathmlBuilder = (group, options) => {
|
|
@@ -11692,20 +11453,20 @@ var LuoguOldRenderer = (() => {
|
|
|
11692
11453
|
});
|
|
11693
11454
|
;
|
|
11694
11455
|
const htmlBuilderDelegate3 = function(group, options) {
|
|
11695
|
-
const
|
|
11696
|
-
if (!
|
|
11456
|
+
const base2 = group.base;
|
|
11457
|
+
if (!base2) {
|
|
11697
11458
|
return null;
|
|
11698
|
-
} else if (
|
|
11699
|
-
const delegate =
|
|
11459
|
+
} else if (base2.type === "op") {
|
|
11460
|
+
const delegate = base2.limits && (options.style.size === src_Style.DISPLAY.size || base2.alwaysHandleSupSub);
|
|
11700
11461
|
return delegate ? op_htmlBuilder : null;
|
|
11701
|
-
} else if (
|
|
11702
|
-
const delegate =
|
|
11462
|
+
} else if (base2.type === "operatorname") {
|
|
11463
|
+
const delegate = base2.alwaysHandleSupSub && (options.style.size === src_Style.DISPLAY.size || base2.limits);
|
|
11703
11464
|
return delegate ? operatorname_htmlBuilder : null;
|
|
11704
|
-
} else if (
|
|
11705
|
-
return isCharacterBox2(
|
|
11706
|
-
} else if (
|
|
11465
|
+
} else if (base2.type === "accent") {
|
|
11466
|
+
return isCharacterBox2(base2.base) ? htmlBuilder3 : null;
|
|
11467
|
+
} else if (base2.type === "horizBrace") {
|
|
11707
11468
|
const isSup = !group.sub;
|
|
11708
|
-
return isSup ===
|
|
11469
|
+
return isSup === base2.isOver ? horizBrace_htmlBuilder : null;
|
|
11709
11470
|
} else {
|
|
11710
11471
|
return null;
|
|
11711
11472
|
}
|
|
@@ -11722,7 +11483,7 @@ var LuoguOldRenderer = (() => {
|
|
|
11722
11483
|
sup: valueSup,
|
|
11723
11484
|
sub: valueSub
|
|
11724
11485
|
} = group;
|
|
11725
|
-
const
|
|
11486
|
+
const base2 = buildGroup4(valueBase, options);
|
|
11726
11487
|
let supm;
|
|
11727
11488
|
let subm;
|
|
11728
11489
|
const metrics = options.fontMetrics();
|
|
@@ -11733,14 +11494,14 @@ var LuoguOldRenderer = (() => {
|
|
|
11733
11494
|
const newOptions = options.havingStyle(options.style.sup());
|
|
11734
11495
|
supm = buildGroup4(valueSup, newOptions, options);
|
|
11735
11496
|
if (!isCharBox) {
|
|
11736
|
-
supShift =
|
|
11497
|
+
supShift = base2.height - newOptions.fontMetrics().supDrop * newOptions.sizeMultiplier / options.sizeMultiplier;
|
|
11737
11498
|
}
|
|
11738
11499
|
}
|
|
11739
11500
|
if (valueSub) {
|
|
11740
11501
|
const newOptions = options.havingStyle(options.style.sub());
|
|
11741
11502
|
subm = buildGroup4(valueSub, newOptions, options);
|
|
11742
11503
|
if (!isCharBox) {
|
|
11743
|
-
subShift =
|
|
11504
|
+
subShift = base2.depth + newOptions.fontMetrics().subDrop * newOptions.sizeMultiplier / options.sizeMultiplier;
|
|
11744
11505
|
}
|
|
11745
11506
|
}
|
|
11746
11507
|
let minSupShift;
|
|
@@ -11756,9 +11517,9 @@ var LuoguOldRenderer = (() => {
|
|
|
11756
11517
|
let marginLeft = null;
|
|
11757
11518
|
if (subm) {
|
|
11758
11519
|
const isOiint = group.base && group.base.type === "op" && group.base.name && (group.base.name === "\\oiint" || group.base.name === "\\oiiint");
|
|
11759
|
-
if (
|
|
11520
|
+
if (base2 instanceof SymbolNode2 || isOiint) {
|
|
11760
11521
|
var _italic;
|
|
11761
|
-
marginLeft = makeEm3(-((_italic =
|
|
11522
|
+
marginLeft = makeEm3(-((_italic = base2.italic) != null ? _italic : 0));
|
|
11762
11523
|
}
|
|
11763
11524
|
}
|
|
11764
11525
|
let supsub;
|
|
@@ -11818,8 +11579,8 @@ var LuoguOldRenderer = (() => {
|
|
|
11818
11579
|
} else {
|
|
11819
11580
|
throw new Error("supsub must have either sup or sub.");
|
|
11820
11581
|
}
|
|
11821
|
-
const mclass = getTypeOfDomTree3(
|
|
11822
|
-
return makeSpan3([mclass], [
|
|
11582
|
+
const mclass = getTypeOfDomTree3(base2, "right") || "mord";
|
|
11583
|
+
return makeSpan3([mclass], [base2, makeSpan3(["msupsub"], [supsub])], options);
|
|
11823
11584
|
},
|
|
11824
11585
|
mathmlBuilder(group, options) {
|
|
11825
11586
|
let isBrace = false;
|
|
@@ -11846,28 +11607,28 @@ var LuoguOldRenderer = (() => {
|
|
|
11846
11607
|
if (isBrace) {
|
|
11847
11608
|
nodeType = isOver ? "mover" : "munder";
|
|
11848
11609
|
} else if (!group.sub) {
|
|
11849
|
-
const
|
|
11850
|
-
if (
|
|
11610
|
+
const base2 = group.base;
|
|
11611
|
+
if (base2 && base2.type === "op" && base2.limits && (options.style === src_Style.DISPLAY || base2.alwaysHandleSupSub)) {
|
|
11851
11612
|
nodeType = "mover";
|
|
11852
|
-
} else if (
|
|
11613
|
+
} else if (base2 && base2.type === "operatorname" && base2.alwaysHandleSupSub && (base2.limits || options.style === src_Style.DISPLAY)) {
|
|
11853
11614
|
nodeType = "mover";
|
|
11854
11615
|
} else {
|
|
11855
11616
|
nodeType = "msup";
|
|
11856
11617
|
}
|
|
11857
11618
|
} else if (!group.sup) {
|
|
11858
|
-
const
|
|
11859
|
-
if (
|
|
11619
|
+
const base2 = group.base;
|
|
11620
|
+
if (base2 && base2.type === "op" && base2.limits && (options.style === src_Style.DISPLAY || base2.alwaysHandleSupSub)) {
|
|
11860
11621
|
nodeType = "munder";
|
|
11861
|
-
} else if (
|
|
11622
|
+
} else if (base2 && base2.type === "operatorname" && base2.alwaysHandleSupSub && (base2.limits || options.style === src_Style.DISPLAY)) {
|
|
11862
11623
|
nodeType = "munder";
|
|
11863
11624
|
} else {
|
|
11864
11625
|
nodeType = "msub";
|
|
11865
11626
|
}
|
|
11866
11627
|
} else {
|
|
11867
|
-
const
|
|
11868
|
-
if (
|
|
11628
|
+
const base2 = group.base;
|
|
11629
|
+
if (base2 && base2.type === "op" && base2.limits && options.style === src_Style.DISPLAY) {
|
|
11869
11630
|
nodeType = "munderover";
|
|
11870
|
-
} else if (
|
|
11631
|
+
} else if (base2 && base2.type === "operatorname" && base2.alwaysHandleSupSub && (options.style === src_Style.DISPLAY || base2.limits)) {
|
|
11871
11632
|
nodeType = "munderover";
|
|
11872
11633
|
} else {
|
|
11873
11634
|
nodeType = "msubsup";
|
|
@@ -12462,13 +12223,13 @@ var LuoguOldRenderer = (() => {
|
|
|
12462
12223
|
};
|
|
12463
12224
|
defineMacro2("\\char", function(context) {
|
|
12464
12225
|
let token = context.popToken();
|
|
12465
|
-
let
|
|
12226
|
+
let base2;
|
|
12466
12227
|
let number = 0;
|
|
12467
12228
|
if (token.text === "'") {
|
|
12468
|
-
|
|
12229
|
+
base2 = 8;
|
|
12469
12230
|
token = context.popToken();
|
|
12470
12231
|
} else if (token.text === '"') {
|
|
12471
|
-
|
|
12232
|
+
base2 = 16;
|
|
12472
12233
|
token = context.popToken();
|
|
12473
12234
|
} else if (token.text === "`") {
|
|
12474
12235
|
token = context.popToken();
|
|
@@ -12480,16 +12241,16 @@ var LuoguOldRenderer = (() => {
|
|
|
12480
12241
|
number = token.text.charCodeAt(0);
|
|
12481
12242
|
}
|
|
12482
12243
|
} else {
|
|
12483
|
-
|
|
12244
|
+
base2 = 10;
|
|
12484
12245
|
}
|
|
12485
|
-
if (
|
|
12246
|
+
if (base2) {
|
|
12486
12247
|
number = digitToNumber2[token.text];
|
|
12487
|
-
if (number == null || number >=
|
|
12488
|
-
throw new src_ParseError("Invalid base-" +
|
|
12248
|
+
if (number == null || number >= base2) {
|
|
12249
|
+
throw new src_ParseError("Invalid base-" + base2 + " digit " + token.text);
|
|
12489
12250
|
}
|
|
12490
12251
|
let digit;
|
|
12491
|
-
while ((digit = digitToNumber2[context.future().text]) != null && digit <
|
|
12492
|
-
number *=
|
|
12252
|
+
while ((digit = digitToNumber2[context.future().text]) != null && digit < base2) {
|
|
12253
|
+
number *= base2;
|
|
12493
12254
|
number += digit;
|
|
12494
12255
|
context.popToken();
|
|
12495
12256
|
}
|
|
@@ -14155,12 +13916,12 @@ var LuoguOldRenderer = (() => {
|
|
|
14155
13916
|
* Parses a group with optional super/subscripts.
|
|
14156
13917
|
*/
|
|
14157
13918
|
parseAtom(breakOnTokenText) {
|
|
14158
|
-
const
|
|
14159
|
-
if ((
|
|
14160
|
-
return
|
|
13919
|
+
const base2 = this.parseGroup("atom", breakOnTokenText);
|
|
13920
|
+
if ((base2 == null ? void 0 : base2.type) === "internal") {
|
|
13921
|
+
return base2;
|
|
14161
13922
|
}
|
|
14162
13923
|
if (this.mode === "text") {
|
|
14163
|
-
return
|
|
13924
|
+
return base2;
|
|
14164
13925
|
}
|
|
14165
13926
|
let superscript2;
|
|
14166
13927
|
let subscript2;
|
|
@@ -14168,13 +13929,13 @@ var LuoguOldRenderer = (() => {
|
|
|
14168
13929
|
this.consumeSpaces();
|
|
14169
13930
|
const lex = this.fetch();
|
|
14170
13931
|
if (lex.text === "\\limits" || lex.text === "\\nolimits") {
|
|
14171
|
-
if (
|
|
13932
|
+
if (base2 && base2.type === "op") {
|
|
14172
13933
|
const limits = lex.text === "\\limits";
|
|
14173
|
-
|
|
14174
|
-
|
|
14175
|
-
} else if (
|
|
14176
|
-
if (
|
|
14177
|
-
|
|
13934
|
+
base2.limits = limits;
|
|
13935
|
+
base2.alwaysHandleSupSub = true;
|
|
13936
|
+
} else if (base2 && base2.type === "operatorname") {
|
|
13937
|
+
if (base2.alwaysHandleSupSub) {
|
|
13938
|
+
base2.limits = lex.text === "\\limits";
|
|
14178
13939
|
}
|
|
14179
13940
|
} else {
|
|
14180
13941
|
throw new src_ParseError("Limit controls must follow a math operator", lex);
|
|
@@ -14251,12 +14012,12 @@ var LuoguOldRenderer = (() => {
|
|
|
14251
14012
|
return {
|
|
14252
14013
|
type: "supsub",
|
|
14253
14014
|
mode: this.mode,
|
|
14254
|
-
base,
|
|
14015
|
+
base: base2,
|
|
14255
14016
|
sup: superscript2,
|
|
14256
14017
|
sub: subscript2
|
|
14257
14018
|
};
|
|
14258
14019
|
} else {
|
|
14259
|
-
return
|
|
14020
|
+
return base2;
|
|
14260
14021
|
}
|
|
14261
14022
|
}
|
|
14262
14023
|
/**
|
|
@@ -14785,12 +14546,12 @@ var LuoguOldRenderer = (() => {
|
|
|
14785
14546
|
const settings = new Settings2(options);
|
|
14786
14547
|
return src_parseTree(expression, settings);
|
|
14787
14548
|
};
|
|
14788
|
-
const renderError3 = function(
|
|
14789
|
-
if (options.throwOnError || !(
|
|
14790
|
-
throw
|
|
14549
|
+
const renderError3 = function(error2, expression, options) {
|
|
14550
|
+
if (options.throwOnError || !(error2 instanceof src_ParseError)) {
|
|
14551
|
+
throw error2;
|
|
14791
14552
|
}
|
|
14792
14553
|
const node = makeSpan3(["katex-error"], [new SymbolNode2(expression)]);
|
|
14793
|
-
node.setAttribute("title",
|
|
14554
|
+
node.setAttribute("title", error2.toString());
|
|
14794
14555
|
node.setAttribute("style", "color:" + options.errorColor);
|
|
14795
14556
|
return node;
|
|
14796
14557
|
};
|
|
@@ -14799,8 +14560,8 @@ var LuoguOldRenderer = (() => {
|
|
|
14799
14560
|
try {
|
|
14800
14561
|
const tree = src_parseTree(expression, settings);
|
|
14801
14562
|
return buildTree3(tree, expression, settings);
|
|
14802
|
-
} catch (
|
|
14803
|
-
return renderError3(
|
|
14563
|
+
} catch (error2) {
|
|
14564
|
+
return renderError3(error2, expression, settings);
|
|
14804
14565
|
}
|
|
14805
14566
|
};
|
|
14806
14567
|
const renderToHTMLTree3 = function(expression, options) {
|
|
@@ -14808,8 +14569,8 @@ var LuoguOldRenderer = (() => {
|
|
|
14808
14569
|
try {
|
|
14809
14570
|
const tree = src_parseTree(expression, settings);
|
|
14810
14571
|
return buildHTMLTree3(tree, expression, settings);
|
|
14811
|
-
} catch (
|
|
14812
|
-
return renderError3(
|
|
14572
|
+
} catch (error2) {
|
|
14573
|
+
return renderError3(error2, expression, settings);
|
|
14813
14574
|
}
|
|
14814
14575
|
};
|
|
14815
14576
|
const version2 = "0.16.47";
|
|
@@ -16187,7 +15948,7 @@ var LuoguOldRenderer = (() => {
|
|
|
16187
15948
|
return result + escapeHTML(value.substr(processed));
|
|
16188
15949
|
}
|
|
16189
15950
|
var seenDeprecations = {};
|
|
16190
|
-
var
|
|
15951
|
+
var error2 = (message) => {
|
|
16191
15952
|
console.error(message);
|
|
16192
15953
|
};
|
|
16193
15954
|
var warn = (message, ...args) => {
|
|
@@ -16475,7 +16236,7 @@ var LuoguOldRenderer = (() => {
|
|
|
16475
16236
|
}
|
|
16476
16237
|
const language = getLanguage(languageName);
|
|
16477
16238
|
if (!language) {
|
|
16478
|
-
|
|
16239
|
+
error2(LANGUAGE_NOT_FOUND.replace("{}", languageName));
|
|
16479
16240
|
throw new Error('Unknown language: "' + languageName + '"');
|
|
16480
16241
|
}
|
|
16481
16242
|
const md2 = compileLanguage(language, { plugins });
|
|
@@ -16690,11 +16451,11 @@ var LuoguOldRenderer = (() => {
|
|
|
16690
16451
|
try {
|
|
16691
16452
|
lang = languageDefinition(hljs2);
|
|
16692
16453
|
} catch (error$1) {
|
|
16693
|
-
|
|
16454
|
+
error2("Language definition for '{}' could not be registered.".replace("{}", languageName));
|
|
16694
16455
|
if (!SAFE_MODE) {
|
|
16695
16456
|
throw error$1;
|
|
16696
16457
|
} else {
|
|
16697
|
-
|
|
16458
|
+
error2(error$1);
|
|
16698
16459
|
}
|
|
16699
16460
|
lang = PLAINTEXT_LANGUAGE;
|
|
16700
16461
|
}
|
|
@@ -50687,10 +50448,10 @@ var LuoguOldRenderer = (() => {
|
|
|
50687
50448
|
DecodingMode2[DecodingMode2["Attribute"] = 2] = "Attribute";
|
|
50688
50449
|
})(DecodingMode || (DecodingMode = {}));
|
|
50689
50450
|
var EntityDecoder = class {
|
|
50690
|
-
constructor(decodeTree, emitCodePoint,
|
|
50451
|
+
constructor(decodeTree, emitCodePoint, errors2) {
|
|
50691
50452
|
this.decodeTree = decodeTree;
|
|
50692
50453
|
this.emitCodePoint = emitCodePoint;
|
|
50693
|
-
this.errors =
|
|
50454
|
+
this.errors = errors2;
|
|
50694
50455
|
this.state = EntityDecoderState.EntityStart;
|
|
50695
50456
|
this.consumed = 1;
|
|
50696
50457
|
this.result = 0;
|
|
@@ -50764,10 +50525,10 @@ var LuoguOldRenderer = (() => {
|
|
|
50764
50525
|
this.state = EntityDecoderState.NumericDecimal;
|
|
50765
50526
|
return this.stateNumericDecimal(str, offset);
|
|
50766
50527
|
}
|
|
50767
|
-
addToNumericResult(str, start, end,
|
|
50528
|
+
addToNumericResult(str, start, end, base2) {
|
|
50768
50529
|
if (start !== end) {
|
|
50769
50530
|
const digitCount = end - start;
|
|
50770
|
-
this.result = this.result * Math.pow(
|
|
50531
|
+
this.result = this.result * Math.pow(base2, digitCount) + parseInt(str.substr(start, digitCount), base2);
|
|
50771
50532
|
this.consumed += digitCount;
|
|
50772
50533
|
}
|
|
50773
50534
|
}
|
|
@@ -51031,7 +50792,7 @@ var LuoguOldRenderer = (() => {
|
|
|
51031
50792
|
(c, index) => (c.charCodeAt(index) & 64512) === 55296 ? (c.charCodeAt(index) - 55296) * 1024 + c.charCodeAt(index + 1) - 56320 + 65536 : c.charCodeAt(index)
|
|
51032
50793
|
)
|
|
51033
50794
|
);
|
|
51034
|
-
function getEscaper(regex,
|
|
50795
|
+
function getEscaper(regex, map2) {
|
|
51035
50796
|
return function escape4(data) {
|
|
51036
50797
|
let match2;
|
|
51037
50798
|
let lastIdx = 0;
|
|
@@ -51040,7 +50801,7 @@ var LuoguOldRenderer = (() => {
|
|
|
51040
50801
|
if (lastIdx !== match2.index) {
|
|
51041
50802
|
result += data.substring(lastIdx, match2.index);
|
|
51042
50803
|
}
|
|
51043
|
-
result +=
|
|
50804
|
+
result += map2.get(match2[0].charCodeAt(0));
|
|
51044
50805
|
lastIdx = match2.index + 1;
|
|
51045
50806
|
}
|
|
51046
50807
|
return result + data.substring(lastIdx);
|
|
@@ -55095,8 +54856,239 @@ var LuoguOldRenderer = (() => {
|
|
|
55095
54856
|
};
|
|
55096
54857
|
var linkify_it_default = LinkifyIt;
|
|
55097
54858
|
|
|
55098
|
-
// node_modules/
|
|
55099
|
-
var
|
|
54859
|
+
// node_modules/punycode.js/punycode.es6.js
|
|
54860
|
+
var maxInt = 2147483647;
|
|
54861
|
+
var base = 36;
|
|
54862
|
+
var tMin = 1;
|
|
54863
|
+
var tMax = 26;
|
|
54864
|
+
var skew = 38;
|
|
54865
|
+
var damp = 700;
|
|
54866
|
+
var initialBias = 72;
|
|
54867
|
+
var initialN = 128;
|
|
54868
|
+
var delimiter = "-";
|
|
54869
|
+
var regexPunycode = /^xn--/;
|
|
54870
|
+
var regexNonASCII = /[^\0-\x7F]/;
|
|
54871
|
+
var regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g;
|
|
54872
|
+
var errors = {
|
|
54873
|
+
"overflow": "Overflow: input needs wider integers to process",
|
|
54874
|
+
"not-basic": "Illegal input >= 0x80 (not a basic code point)",
|
|
54875
|
+
"invalid-input": "Invalid input"
|
|
54876
|
+
};
|
|
54877
|
+
var baseMinusTMin = base - tMin;
|
|
54878
|
+
var floor = Math.floor;
|
|
54879
|
+
var stringFromCharCode = String.fromCharCode;
|
|
54880
|
+
function error(type) {
|
|
54881
|
+
throw new RangeError(errors[type]);
|
|
54882
|
+
}
|
|
54883
|
+
function map(array, callback) {
|
|
54884
|
+
const result = [];
|
|
54885
|
+
let length = array.length;
|
|
54886
|
+
while (length--) {
|
|
54887
|
+
result[length] = callback(array[length]);
|
|
54888
|
+
}
|
|
54889
|
+
return result;
|
|
54890
|
+
}
|
|
54891
|
+
function mapDomain(domain, callback) {
|
|
54892
|
+
const parts = domain.split("@");
|
|
54893
|
+
let result = "";
|
|
54894
|
+
if (parts.length > 1) {
|
|
54895
|
+
result = parts[0] + "@";
|
|
54896
|
+
domain = parts[1];
|
|
54897
|
+
}
|
|
54898
|
+
domain = domain.replace(regexSeparators, ".");
|
|
54899
|
+
const labels = domain.split(".");
|
|
54900
|
+
const encoded = map(labels, callback).join(".");
|
|
54901
|
+
return result + encoded;
|
|
54902
|
+
}
|
|
54903
|
+
function ucs2decode(string) {
|
|
54904
|
+
const output = [];
|
|
54905
|
+
let counter = 0;
|
|
54906
|
+
const length = string.length;
|
|
54907
|
+
while (counter < length) {
|
|
54908
|
+
const value = string.charCodeAt(counter++);
|
|
54909
|
+
if (value >= 55296 && value <= 56319 && counter < length) {
|
|
54910
|
+
const extra = string.charCodeAt(counter++);
|
|
54911
|
+
if ((extra & 64512) == 56320) {
|
|
54912
|
+
output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
|
|
54913
|
+
} else {
|
|
54914
|
+
output.push(value);
|
|
54915
|
+
counter--;
|
|
54916
|
+
}
|
|
54917
|
+
} else {
|
|
54918
|
+
output.push(value);
|
|
54919
|
+
}
|
|
54920
|
+
}
|
|
54921
|
+
return output;
|
|
54922
|
+
}
|
|
54923
|
+
var ucs2encode = (codePoints) => String.fromCodePoint(...codePoints);
|
|
54924
|
+
var basicToDigit = function(codePoint) {
|
|
54925
|
+
if (codePoint >= 48 && codePoint < 58) {
|
|
54926
|
+
return 26 + (codePoint - 48);
|
|
54927
|
+
}
|
|
54928
|
+
if (codePoint >= 65 && codePoint < 91) {
|
|
54929
|
+
return codePoint - 65;
|
|
54930
|
+
}
|
|
54931
|
+
if (codePoint >= 97 && codePoint < 123) {
|
|
54932
|
+
return codePoint - 97;
|
|
54933
|
+
}
|
|
54934
|
+
return base;
|
|
54935
|
+
};
|
|
54936
|
+
var digitToBasic = function(digit, flag) {
|
|
54937
|
+
return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
|
|
54938
|
+
};
|
|
54939
|
+
var adapt = function(delta, numPoints, firstTime) {
|
|
54940
|
+
let k = 0;
|
|
54941
|
+
delta = firstTime ? floor(delta / damp) : delta >> 1;
|
|
54942
|
+
delta += floor(delta / numPoints);
|
|
54943
|
+
for (; delta > baseMinusTMin * tMax >> 1; k += base) {
|
|
54944
|
+
delta = floor(delta / baseMinusTMin);
|
|
54945
|
+
}
|
|
54946
|
+
return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
|
|
54947
|
+
};
|
|
54948
|
+
var decode2 = function(input) {
|
|
54949
|
+
const output = [];
|
|
54950
|
+
const inputLength = input.length;
|
|
54951
|
+
let i2 = 0;
|
|
54952
|
+
let n = initialN;
|
|
54953
|
+
let bias = initialBias;
|
|
54954
|
+
let basic = input.lastIndexOf(delimiter);
|
|
54955
|
+
if (basic < 0) {
|
|
54956
|
+
basic = 0;
|
|
54957
|
+
}
|
|
54958
|
+
for (let j = 0; j < basic; ++j) {
|
|
54959
|
+
if (input.charCodeAt(j) >= 128) {
|
|
54960
|
+
error("not-basic");
|
|
54961
|
+
}
|
|
54962
|
+
output.push(input.charCodeAt(j));
|
|
54963
|
+
}
|
|
54964
|
+
for (let index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {
|
|
54965
|
+
const oldi = i2;
|
|
54966
|
+
for (let w = 1, k = base; ; k += base) {
|
|
54967
|
+
if (index >= inputLength) {
|
|
54968
|
+
error("invalid-input");
|
|
54969
|
+
}
|
|
54970
|
+
const digit = basicToDigit(input.charCodeAt(index++));
|
|
54971
|
+
if (digit >= base) {
|
|
54972
|
+
error("invalid-input");
|
|
54973
|
+
}
|
|
54974
|
+
if (digit > floor((maxInt - i2) / w)) {
|
|
54975
|
+
error("overflow");
|
|
54976
|
+
}
|
|
54977
|
+
i2 += digit * w;
|
|
54978
|
+
const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
|
|
54979
|
+
if (digit < t) {
|
|
54980
|
+
break;
|
|
54981
|
+
}
|
|
54982
|
+
const baseMinusT = base - t;
|
|
54983
|
+
if (w > floor(maxInt / baseMinusT)) {
|
|
54984
|
+
error("overflow");
|
|
54985
|
+
}
|
|
54986
|
+
w *= baseMinusT;
|
|
54987
|
+
}
|
|
54988
|
+
const out = output.length + 1;
|
|
54989
|
+
bias = adapt(i2 - oldi, out, oldi == 0);
|
|
54990
|
+
if (floor(i2 / out) > maxInt - n) {
|
|
54991
|
+
error("overflow");
|
|
54992
|
+
}
|
|
54993
|
+
n += floor(i2 / out);
|
|
54994
|
+
i2 %= out;
|
|
54995
|
+
output.splice(i2++, 0, n);
|
|
54996
|
+
}
|
|
54997
|
+
return String.fromCodePoint(...output);
|
|
54998
|
+
};
|
|
54999
|
+
var encode2 = function(input) {
|
|
55000
|
+
const output = [];
|
|
55001
|
+
input = ucs2decode(input);
|
|
55002
|
+
const inputLength = input.length;
|
|
55003
|
+
let n = initialN;
|
|
55004
|
+
let delta = 0;
|
|
55005
|
+
let bias = initialBias;
|
|
55006
|
+
for (const currentValue of input) {
|
|
55007
|
+
if (currentValue < 128) {
|
|
55008
|
+
output.push(stringFromCharCode(currentValue));
|
|
55009
|
+
}
|
|
55010
|
+
}
|
|
55011
|
+
const basicLength = output.length;
|
|
55012
|
+
let handledCPCount = basicLength;
|
|
55013
|
+
if (basicLength) {
|
|
55014
|
+
output.push(delimiter);
|
|
55015
|
+
}
|
|
55016
|
+
while (handledCPCount < inputLength) {
|
|
55017
|
+
let m = maxInt;
|
|
55018
|
+
for (const currentValue of input) {
|
|
55019
|
+
if (currentValue >= n && currentValue < m) {
|
|
55020
|
+
m = currentValue;
|
|
55021
|
+
}
|
|
55022
|
+
}
|
|
55023
|
+
const handledCPCountPlusOne = handledCPCount + 1;
|
|
55024
|
+
if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
|
|
55025
|
+
error("overflow");
|
|
55026
|
+
}
|
|
55027
|
+
delta += (m - n) * handledCPCountPlusOne;
|
|
55028
|
+
n = m;
|
|
55029
|
+
for (const currentValue of input) {
|
|
55030
|
+
if (currentValue < n && ++delta > maxInt) {
|
|
55031
|
+
error("overflow");
|
|
55032
|
+
}
|
|
55033
|
+
if (currentValue === n) {
|
|
55034
|
+
let q = delta;
|
|
55035
|
+
for (let k = base; ; k += base) {
|
|
55036
|
+
const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
|
|
55037
|
+
if (q < t) {
|
|
55038
|
+
break;
|
|
55039
|
+
}
|
|
55040
|
+
const qMinusT = q - t;
|
|
55041
|
+
const baseMinusT = base - t;
|
|
55042
|
+
output.push(
|
|
55043
|
+
stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
|
|
55044
|
+
);
|
|
55045
|
+
q = floor(qMinusT / baseMinusT);
|
|
55046
|
+
}
|
|
55047
|
+
output.push(stringFromCharCode(digitToBasic(q, 0)));
|
|
55048
|
+
bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
|
|
55049
|
+
delta = 0;
|
|
55050
|
+
++handledCPCount;
|
|
55051
|
+
}
|
|
55052
|
+
}
|
|
55053
|
+
++delta;
|
|
55054
|
+
++n;
|
|
55055
|
+
}
|
|
55056
|
+
return output.join("");
|
|
55057
|
+
};
|
|
55058
|
+
var toUnicode = function(input) {
|
|
55059
|
+
return mapDomain(input, function(string) {
|
|
55060
|
+
return regexPunycode.test(string) ? decode2(string.slice(4).toLowerCase()) : string;
|
|
55061
|
+
});
|
|
55062
|
+
};
|
|
55063
|
+
var toASCII = function(input) {
|
|
55064
|
+
return mapDomain(input, function(string) {
|
|
55065
|
+
return regexNonASCII.test(string) ? "xn--" + encode2(string) : string;
|
|
55066
|
+
});
|
|
55067
|
+
};
|
|
55068
|
+
var punycode = {
|
|
55069
|
+
/**
|
|
55070
|
+
* A string representing the current Punycode.js version number.
|
|
55071
|
+
* @memberOf punycode
|
|
55072
|
+
* @type String
|
|
55073
|
+
*/
|
|
55074
|
+
"version": "2.3.1",
|
|
55075
|
+
/**
|
|
55076
|
+
* An object of methods to convert from JavaScript's internal character
|
|
55077
|
+
* representation (UCS-2) to Unicode code points, and back.
|
|
55078
|
+
* @see <https://mathiasbynens.be/notes/javascript-encoding>
|
|
55079
|
+
* @memberOf punycode
|
|
55080
|
+
* @type Object
|
|
55081
|
+
*/
|
|
55082
|
+
"ucs2": {
|
|
55083
|
+
"decode": ucs2decode,
|
|
55084
|
+
"encode": ucs2encode
|
|
55085
|
+
},
|
|
55086
|
+
"decode": decode2,
|
|
55087
|
+
"encode": encode2,
|
|
55088
|
+
"toASCII": toASCII,
|
|
55089
|
+
"toUnicode": toUnicode
|
|
55090
|
+
};
|
|
55091
|
+
var punycode_es6_default = punycode;
|
|
55100
55092
|
|
|
55101
55093
|
// node_modules/markdown-it/lib/presets/default.mjs
|
|
55102
55094
|
var default_default = {
|
|
@@ -55290,7 +55282,7 @@ var LuoguOldRenderer = (() => {
|
|
|
55290
55282
|
if (parsed.hostname) {
|
|
55291
55283
|
if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
|
|
55292
55284
|
try {
|
|
55293
|
-
parsed.hostname =
|
|
55285
|
+
parsed.hostname = punycode_es6_default.toASCII(parsed.hostname);
|
|
55294
55286
|
} catch (er) {
|
|
55295
55287
|
}
|
|
55296
55288
|
}
|
|
@@ -55302,7 +55294,7 @@ var LuoguOldRenderer = (() => {
|
|
|
55302
55294
|
if (parsed.hostname) {
|
|
55303
55295
|
if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
|
|
55304
55296
|
try {
|
|
55305
|
-
parsed.hostname =
|
|
55297
|
+
parsed.hostname = punycode_es6_default.toUnicode(parsed.hostname);
|
|
55306
55298
|
} catch (er) {
|
|
55307
55299
|
}
|
|
55308
55300
|
}
|
|
@@ -55536,7 +55528,7 @@ var LuoguOldRenderer = (() => {
|
|
|
55536
55528
|
var ParseError = class _ParseError extends Error {
|
|
55537
55529
|
// The underlying error message without any context added.
|
|
55538
55530
|
constructor(message, token) {
|
|
55539
|
-
var
|
|
55531
|
+
var error2 = "KaTeX parse error: " + message;
|
|
55540
55532
|
var start;
|
|
55541
55533
|
var end;
|
|
55542
55534
|
var loc = token && token.loc;
|
|
@@ -55545,9 +55537,9 @@ var LuoguOldRenderer = (() => {
|
|
|
55545
55537
|
start = loc.start;
|
|
55546
55538
|
end = loc.end;
|
|
55547
55539
|
if (start === input.length) {
|
|
55548
|
-
|
|
55540
|
+
error2 += " at end of input: ";
|
|
55549
55541
|
} else {
|
|
55550
|
-
|
|
55542
|
+
error2 += " at position " + (start + 1) + ": ";
|
|
55551
55543
|
}
|
|
55552
55544
|
var underlined = input.slice(start, end).replace(/[^]/g, "$&\u0332");
|
|
55553
55545
|
var left;
|
|
@@ -55562,9 +55554,9 @@ var LuoguOldRenderer = (() => {
|
|
|
55562
55554
|
} else {
|
|
55563
55555
|
right = input.slice(end);
|
|
55564
55556
|
}
|
|
55565
|
-
|
|
55557
|
+
error2 += left + underlined + right;
|
|
55566
55558
|
}
|
|
55567
|
-
super(
|
|
55559
|
+
super(error2);
|
|
55568
55560
|
this.name = "ParseError";
|
|
55569
55561
|
this.position = void 0;
|
|
55570
55562
|
this.length = void 0;
|
|
@@ -55799,7 +55791,7 @@ var LuoguOldRenderer = (() => {
|
|
|
55799
55791
|
if (typeof strict === "function") {
|
|
55800
55792
|
try {
|
|
55801
55793
|
strict = strict(errorCode, errorMsg, token);
|
|
55802
|
-
} catch (
|
|
55794
|
+
} catch (error2) {
|
|
55803
55795
|
strict = "error";
|
|
55804
55796
|
}
|
|
55805
55797
|
}
|
|
@@ -56462,7 +56454,7 @@ var LuoguOldRenderer = (() => {
|
|
|
56462
56454
|
"\xEC": "\u0131\u0300"
|
|
56463
56455
|
};
|
|
56464
56456
|
var SymbolNode = class {
|
|
56465
|
-
constructor(text3, height, depth, italic2,
|
|
56457
|
+
constructor(text3, height, depth, italic2, skew2, width, classes, style) {
|
|
56466
56458
|
this.text = void 0;
|
|
56467
56459
|
this.height = void 0;
|
|
56468
56460
|
this.depth = void 0;
|
|
@@ -56476,7 +56468,7 @@ var LuoguOldRenderer = (() => {
|
|
|
56476
56468
|
this.height = height || 0;
|
|
56477
56469
|
this.depth = depth || 0;
|
|
56478
56470
|
this.italic = italic2 || 0;
|
|
56479
|
-
this.skew =
|
|
56471
|
+
this.skew = skew2 || 0;
|
|
56480
56472
|
this.width = width || 0;
|
|
56481
56473
|
this.classes = classes || [];
|
|
56482
56474
|
this.style = style || {};
|
|
@@ -60894,9 +60886,9 @@ var LuoguOldRenderer = (() => {
|
|
|
60894
60886
|
_group.children = [...lastGroup.children, ..._group.children];
|
|
60895
60887
|
groups.pop();
|
|
60896
60888
|
} else if ((_group.type === "msup" || _group.type === "msub") && _group.children.length >= 1 && (lastGroup.type === "mn" || isNumberPunctuation(lastGroup))) {
|
|
60897
|
-
var
|
|
60898
|
-
if (
|
|
60899
|
-
|
|
60889
|
+
var base2 = _group.children[0];
|
|
60890
|
+
if (base2 instanceof MathNode && base2.type === "mn") {
|
|
60891
|
+
base2.children = [...lastGroup.children, ...base2.children];
|
|
60900
60892
|
groups.pop();
|
|
60901
60893
|
}
|
|
60902
60894
|
} else if (lastGroup.type === "mi" && lastGroup.children.length === 1) {
|
|
@@ -61556,25 +61548,25 @@ var LuoguOldRenderer = (() => {
|
|
|
61556
61548
|
}
|
|
61557
61549
|
};
|
|
61558
61550
|
var htmlBuilder$a = (grp, options) => {
|
|
61559
|
-
var
|
|
61551
|
+
var base2;
|
|
61560
61552
|
var group;
|
|
61561
61553
|
var supSubGroup;
|
|
61562
61554
|
if (grp && grp.type === "supsub") {
|
|
61563
61555
|
group = assertNodeType(grp.base, "accent");
|
|
61564
|
-
|
|
61565
|
-
grp.base =
|
|
61556
|
+
base2 = group.base;
|
|
61557
|
+
grp.base = base2;
|
|
61566
61558
|
supSubGroup = assertSpan(buildGroup$1(grp, options));
|
|
61567
61559
|
grp.base = group;
|
|
61568
61560
|
} else {
|
|
61569
61561
|
group = assertNodeType(grp, "accent");
|
|
61570
|
-
|
|
61562
|
+
base2 = group.base;
|
|
61571
61563
|
}
|
|
61572
|
-
var body = buildGroup$1(
|
|
61573
|
-
var mustShift = group.isShifty && isCharacterBox(
|
|
61574
|
-
var
|
|
61564
|
+
var body = buildGroup$1(base2, options.havingCrampedStyle());
|
|
61565
|
+
var mustShift = group.isShifty && isCharacterBox(base2);
|
|
61566
|
+
var skew2 = 0;
|
|
61575
61567
|
if (mustShift) {
|
|
61576
61568
|
var _getBaseSymbol$skew, _getBaseSymbol;
|
|
61577
|
-
|
|
61569
|
+
skew2 = (_getBaseSymbol$skew = (_getBaseSymbol = getBaseSymbol(body)) == null ? void 0 : _getBaseSymbol.skew) != null ? _getBaseSymbol$skew : 0;
|
|
61578
61570
|
}
|
|
61579
61571
|
var accentBelow = group.label === "\\c";
|
|
61580
61572
|
var clearance = accentBelow ? body.height + body.depth : Math.min(body.height, options.fontMetrics().xHeight);
|
|
@@ -61604,7 +61596,7 @@ var LuoguOldRenderer = (() => {
|
|
|
61604
61596
|
accentBody.classes.push("accent-full");
|
|
61605
61597
|
clearance = body.height;
|
|
61606
61598
|
}
|
|
61607
|
-
var left =
|
|
61599
|
+
var left = skew2;
|
|
61608
61600
|
if (!accentFull) {
|
|
61609
61601
|
left -= width / 2;
|
|
61610
61602
|
}
|
|
@@ -61636,9 +61628,9 @@ var LuoguOldRenderer = (() => {
|
|
|
61636
61628
|
type: "elem",
|
|
61637
61629
|
elem: accentBody,
|
|
61638
61630
|
wrapperClasses: ["svg-align"],
|
|
61639
|
-
wrapperStyle:
|
|
61640
|
-
width: "calc(100% - " + makeEm(2 *
|
|
61641
|
-
marginLeft: makeEm(2 *
|
|
61631
|
+
wrapperStyle: skew2 > 0 ? {
|
|
61632
|
+
width: "calc(100% - " + makeEm(2 * skew2) + ")",
|
|
61633
|
+
marginLeft: makeEm(2 * skew2)
|
|
61642
61634
|
} : void 0
|
|
61643
61635
|
}]
|
|
61644
61636
|
});
|
|
@@ -61667,7 +61659,7 @@ var LuoguOldRenderer = (() => {
|
|
|
61667
61659
|
numArgs: 1
|
|
61668
61660
|
},
|
|
61669
61661
|
handler: (context, args) => {
|
|
61670
|
-
var
|
|
61662
|
+
var base2 = normalizeArgument(args[0]);
|
|
61671
61663
|
var isStretchy = !NON_STRETCHY_ACCENT_REGEX.test(context.funcName);
|
|
61672
61664
|
var isShifty = !isStretchy || context.funcName === "\\widehat" || context.funcName === "\\widetilde" || context.funcName === "\\widecheck";
|
|
61673
61665
|
return {
|
|
@@ -61676,7 +61668,7 @@ var LuoguOldRenderer = (() => {
|
|
|
61676
61668
|
label: context.funcName,
|
|
61677
61669
|
isStretchy,
|
|
61678
61670
|
isShifty,
|
|
61679
|
-
base
|
|
61671
|
+
base: base2
|
|
61680
61672
|
};
|
|
61681
61673
|
},
|
|
61682
61674
|
htmlBuilder: htmlBuilder$a,
|
|
@@ -61693,7 +61685,7 @@ var LuoguOldRenderer = (() => {
|
|
|
61693
61685
|
argTypes: ["primitive"]
|
|
61694
61686
|
},
|
|
61695
61687
|
handler: (context, args) => {
|
|
61696
|
-
var
|
|
61688
|
+
var base2 = args[0];
|
|
61697
61689
|
var mode = context.parser.mode;
|
|
61698
61690
|
if (mode === "math") {
|
|
61699
61691
|
context.parser.settings.reportNonstrict("mathVsTextAccents", "LaTeX's accent " + context.funcName + " works only in text mode");
|
|
@@ -61705,7 +61697,7 @@ var LuoguOldRenderer = (() => {
|
|
|
61705
61697
|
label: context.funcName,
|
|
61706
61698
|
isStretchy: false,
|
|
61707
61699
|
isShifty: true,
|
|
61708
|
-
base
|
|
61700
|
+
base: base2
|
|
61709
61701
|
};
|
|
61710
61702
|
},
|
|
61711
61703
|
htmlBuilder: htmlBuilder$a,
|
|
@@ -61722,12 +61714,12 @@ var LuoguOldRenderer = (() => {
|
|
|
61722
61714
|
parser,
|
|
61723
61715
|
funcName
|
|
61724
61716
|
} = _ref;
|
|
61725
|
-
var
|
|
61717
|
+
var base2 = args[0];
|
|
61726
61718
|
return {
|
|
61727
61719
|
type: "accentUnder",
|
|
61728
61720
|
mode: parser.mode,
|
|
61729
61721
|
label: funcName,
|
|
61730
|
-
base
|
|
61722
|
+
base: base2
|
|
61731
61723
|
};
|
|
61732
61724
|
},
|
|
61733
61725
|
htmlBuilder: (group, options) => {
|
|
@@ -65855,8 +65847,8 @@ var LuoguOldRenderer = (() => {
|
|
|
65855
65847
|
return buildExpressionRow(body, options);
|
|
65856
65848
|
}
|
|
65857
65849
|
});
|
|
65858
|
-
var assembleSupSub = (
|
|
65859
|
-
|
|
65850
|
+
var assembleSupSub = (base2, supGroup, subGroup, options, style, slant, baseShift) => {
|
|
65851
|
+
base2 = makeSpan([], [base2]);
|
|
65860
65852
|
var subIsSingleCharacter = subGroup && isCharacterBox(subGroup);
|
|
65861
65853
|
var sub2;
|
|
65862
65854
|
var sup2;
|
|
@@ -65876,7 +65868,7 @@ var LuoguOldRenderer = (() => {
|
|
|
65876
65868
|
}
|
|
65877
65869
|
var finalGroup;
|
|
65878
65870
|
if (sup2 && sub2) {
|
|
65879
|
-
var bottom = options.fontMetrics().bigOpSpacing5 + sub2.elem.height + sub2.elem.depth + sub2.kern +
|
|
65871
|
+
var bottom = options.fontMetrics().bigOpSpacing5 + sub2.elem.height + sub2.elem.depth + sub2.kern + base2.depth + baseShift;
|
|
65880
65872
|
finalGroup = makeVList({
|
|
65881
65873
|
positionType: "bottom",
|
|
65882
65874
|
positionData: bottom,
|
|
@@ -65892,7 +65884,7 @@ var LuoguOldRenderer = (() => {
|
|
|
65892
65884
|
size: sub2.kern
|
|
65893
65885
|
}, {
|
|
65894
65886
|
type: "elem",
|
|
65895
|
-
elem:
|
|
65887
|
+
elem: base2
|
|
65896
65888
|
}, {
|
|
65897
65889
|
type: "kern",
|
|
65898
65890
|
size: sup2.kern
|
|
@@ -65906,7 +65898,7 @@ var LuoguOldRenderer = (() => {
|
|
|
65906
65898
|
}]
|
|
65907
65899
|
});
|
|
65908
65900
|
} else if (sub2) {
|
|
65909
|
-
var top =
|
|
65901
|
+
var top = base2.height - baseShift;
|
|
65910
65902
|
finalGroup = makeVList({
|
|
65911
65903
|
positionType: "top",
|
|
65912
65904
|
positionData: top,
|
|
@@ -65922,17 +65914,17 @@ var LuoguOldRenderer = (() => {
|
|
|
65922
65914
|
size: sub2.kern
|
|
65923
65915
|
}, {
|
|
65924
65916
|
type: "elem",
|
|
65925
|
-
elem:
|
|
65917
|
+
elem: base2
|
|
65926
65918
|
}]
|
|
65927
65919
|
});
|
|
65928
65920
|
} else if (sup2) {
|
|
65929
|
-
var _bottom =
|
|
65921
|
+
var _bottom = base2.depth + baseShift;
|
|
65930
65922
|
finalGroup = makeVList({
|
|
65931
65923
|
positionType: "bottom",
|
|
65932
65924
|
positionData: _bottom,
|
|
65933
65925
|
children: [{
|
|
65934
65926
|
type: "elem",
|
|
65935
|
-
elem:
|
|
65927
|
+
elem: base2
|
|
65936
65928
|
}, {
|
|
65937
65929
|
type: "kern",
|
|
65938
65930
|
size: sup2.kern
|
|
@@ -65946,7 +65938,7 @@ var LuoguOldRenderer = (() => {
|
|
|
65946
65938
|
}]
|
|
65947
65939
|
});
|
|
65948
65940
|
} else {
|
|
65949
|
-
return
|
|
65941
|
+
return base2;
|
|
65950
65942
|
}
|
|
65951
65943
|
var parts = [finalGroup];
|
|
65952
65944
|
if (sub2 && slant !== 0 && !subIsSingleCharacter) {
|
|
@@ -65975,7 +65967,7 @@ var LuoguOldRenderer = (() => {
|
|
|
65975
65967
|
if (style.size === Style$1.DISPLAY.size && group.symbol && !noSuccessor.has(group.name)) {
|
|
65976
65968
|
large = true;
|
|
65977
65969
|
}
|
|
65978
|
-
var
|
|
65970
|
+
var base2;
|
|
65979
65971
|
var symbolItalic;
|
|
65980
65972
|
if (group.symbol) {
|
|
65981
65973
|
var fontName = large ? "Size2-Regular" : "Size1-Regular";
|
|
@@ -65984,15 +65976,15 @@ var LuoguOldRenderer = (() => {
|
|
|
65984
65976
|
stash = group.name.slice(1);
|
|
65985
65977
|
group.name = stash === "oiint" ? "\\iint" : "\\iiint";
|
|
65986
65978
|
}
|
|
65987
|
-
|
|
65988
|
-
symbolItalic =
|
|
65979
|
+
base2 = makeSymbol(group.name, fontName, "math", options, ["mop", "op-symbol", large ? "large-op" : "small-op"]);
|
|
65980
|
+
symbolItalic = base2.italic;
|
|
65989
65981
|
if (stash.length > 0) {
|
|
65990
65982
|
var oval = staticSvg(stash + "Size" + (large ? "2" : "1"), options);
|
|
65991
|
-
|
|
65983
|
+
base2 = makeVList({
|
|
65992
65984
|
positionType: "individualShift",
|
|
65993
65985
|
children: [{
|
|
65994
65986
|
type: "elem",
|
|
65995
|
-
elem:
|
|
65987
|
+
elem: base2,
|
|
65996
65988
|
shift: 0
|
|
65997
65989
|
}, {
|
|
65998
65990
|
type: "elem",
|
|
@@ -66001,39 +65993,39 @@ var LuoguOldRenderer = (() => {
|
|
|
66001
65993
|
}]
|
|
66002
65994
|
});
|
|
66003
65995
|
group.name = "\\" + stash;
|
|
66004
|
-
|
|
66005
|
-
|
|
65996
|
+
base2.classes.unshift("mop");
|
|
65997
|
+
base2.italic = symbolItalic;
|
|
66006
65998
|
}
|
|
66007
65999
|
} else if (group.body) {
|
|
66008
66000
|
var inner2 = buildExpression$1(group.body, options, true);
|
|
66009
66001
|
if (inner2.length === 1 && inner2[0] instanceof SymbolNode) {
|
|
66010
|
-
|
|
66011
|
-
|
|
66002
|
+
base2 = inner2[0];
|
|
66003
|
+
base2.classes[0] = "mop";
|
|
66012
66004
|
} else {
|
|
66013
|
-
|
|
66005
|
+
base2 = makeSpan(["mop"], inner2, options);
|
|
66014
66006
|
}
|
|
66015
66007
|
} else {
|
|
66016
66008
|
var output = [];
|
|
66017
66009
|
for (var i2 = 1; i2 < group.name.length; i2++) {
|
|
66018
66010
|
output.push(mathsym(group.name[i2], group.mode, options));
|
|
66019
66011
|
}
|
|
66020
|
-
|
|
66012
|
+
base2 = makeSpan(["mop"], output, options);
|
|
66021
66013
|
}
|
|
66022
66014
|
var baseShift = 0;
|
|
66023
66015
|
var slant = 0;
|
|
66024
|
-
if ((
|
|
66016
|
+
if ((base2 instanceof SymbolNode || group.name === "\\oiint" || group.name === "\\oiiint") && !group.suppressBaseShift) {
|
|
66025
66017
|
var _base$italic;
|
|
66026
|
-
baseShift = (
|
|
66027
|
-
slant = (_base$italic =
|
|
66018
|
+
baseShift = (base2.height - base2.depth) / 2 - options.fontMetrics().axisHeight;
|
|
66019
|
+
slant = (_base$italic = base2.italic) != null ? _base$italic : 0;
|
|
66028
66020
|
}
|
|
66029
66021
|
if (hasLimits) {
|
|
66030
|
-
return assembleSupSub(
|
|
66022
|
+
return assembleSupSub(base2, supGroup, subGroup, options, style, slant, baseShift);
|
|
66031
66023
|
} else {
|
|
66032
66024
|
if (baseShift) {
|
|
66033
|
-
|
|
66034
|
-
|
|
66025
|
+
base2.style.position = "relative";
|
|
66026
|
+
base2.style.top = makeEm(baseShift);
|
|
66035
66027
|
}
|
|
66036
|
-
return
|
|
66028
|
+
return base2;
|
|
66037
66029
|
}
|
|
66038
66030
|
};
|
|
66039
66031
|
var mathmlBuilder$1 = (group, options) => {
|
|
@@ -66216,7 +66208,7 @@ var LuoguOldRenderer = (() => {
|
|
|
66216
66208
|
} else {
|
|
66217
66209
|
group = assertNodeType(grp, "operatorname");
|
|
66218
66210
|
}
|
|
66219
|
-
var
|
|
66211
|
+
var base2;
|
|
66220
66212
|
if (group.body.length > 0) {
|
|
66221
66213
|
var body = group.body.map((child2) => {
|
|
66222
66214
|
var childText = "text" in child2 ? child2.text : void 0;
|
|
@@ -66237,14 +66229,14 @@ var LuoguOldRenderer = (() => {
|
|
|
66237
66229
|
child.text = child.text.replace(/\u2212/, "-").replace(/\u2217/, "*");
|
|
66238
66230
|
}
|
|
66239
66231
|
}
|
|
66240
|
-
|
|
66232
|
+
base2 = makeSpan(["mop"], expression, options);
|
|
66241
66233
|
} else {
|
|
66242
|
-
|
|
66234
|
+
base2 = makeSpan(["mop"], [], options);
|
|
66243
66235
|
}
|
|
66244
66236
|
if (hasLimits) {
|
|
66245
|
-
return assembleSupSub(
|
|
66237
|
+
return assembleSupSub(base2, supGroup, subGroup, options, options.style, 0, 0);
|
|
66246
66238
|
} else {
|
|
66247
|
-
return
|
|
66239
|
+
return base2;
|
|
66248
66240
|
}
|
|
66249
66241
|
};
|
|
66250
66242
|
var mathmlBuilder2 = (group, options) => {
|
|
@@ -66842,20 +66834,20 @@ var LuoguOldRenderer = (() => {
|
|
|
66842
66834
|
}
|
|
66843
66835
|
});
|
|
66844
66836
|
var htmlBuilderDelegate = function htmlBuilderDelegate2(group, options) {
|
|
66845
|
-
var
|
|
66846
|
-
if (!
|
|
66837
|
+
var base2 = group.base;
|
|
66838
|
+
if (!base2) {
|
|
66847
66839
|
return null;
|
|
66848
|
-
} else if (
|
|
66849
|
-
var delegate =
|
|
66840
|
+
} else if (base2.type === "op") {
|
|
66841
|
+
var delegate = base2.limits && (options.style.size === Style$1.DISPLAY.size || base2.alwaysHandleSupSub);
|
|
66850
66842
|
return delegate ? htmlBuilder$2 : null;
|
|
66851
|
-
} else if (
|
|
66852
|
-
var _delegate =
|
|
66843
|
+
} else if (base2.type === "operatorname") {
|
|
66844
|
+
var _delegate = base2.alwaysHandleSupSub && (options.style.size === Style$1.DISPLAY.size || base2.limits);
|
|
66853
66845
|
return _delegate ? htmlBuilder$1 : null;
|
|
66854
|
-
} else if (
|
|
66855
|
-
return isCharacterBox(
|
|
66856
|
-
} else if (
|
|
66846
|
+
} else if (base2.type === "accent") {
|
|
66847
|
+
return isCharacterBox(base2.base) ? htmlBuilder$a : null;
|
|
66848
|
+
} else if (base2.type === "horizBrace") {
|
|
66857
66849
|
var isSup = !group.sub;
|
|
66858
|
-
return isSup ===
|
|
66850
|
+
return isSup === base2.isOver ? htmlBuilder$3 : null;
|
|
66859
66851
|
} else {
|
|
66860
66852
|
return null;
|
|
66861
66853
|
}
|
|
@@ -66872,7 +66864,7 @@ var LuoguOldRenderer = (() => {
|
|
|
66872
66864
|
sup: valueSup,
|
|
66873
66865
|
sub: valueSub
|
|
66874
66866
|
} = group;
|
|
66875
|
-
var
|
|
66867
|
+
var base2 = buildGroup$1(valueBase, options);
|
|
66876
66868
|
var supm;
|
|
66877
66869
|
var subm;
|
|
66878
66870
|
var metrics = options.fontMetrics();
|
|
@@ -66883,14 +66875,14 @@ var LuoguOldRenderer = (() => {
|
|
|
66883
66875
|
var newOptions = options.havingStyle(options.style.sup());
|
|
66884
66876
|
supm = buildGroup$1(valueSup, newOptions, options);
|
|
66885
66877
|
if (!isCharBox) {
|
|
66886
|
-
supShift =
|
|
66878
|
+
supShift = base2.height - newOptions.fontMetrics().supDrop * newOptions.sizeMultiplier / options.sizeMultiplier;
|
|
66887
66879
|
}
|
|
66888
66880
|
}
|
|
66889
66881
|
if (valueSub) {
|
|
66890
66882
|
var _newOptions = options.havingStyle(options.style.sub());
|
|
66891
66883
|
subm = buildGroup$1(valueSub, _newOptions, options);
|
|
66892
66884
|
if (!isCharBox) {
|
|
66893
|
-
subShift =
|
|
66885
|
+
subShift = base2.depth + _newOptions.fontMetrics().subDrop * _newOptions.sizeMultiplier / options.sizeMultiplier;
|
|
66894
66886
|
}
|
|
66895
66887
|
}
|
|
66896
66888
|
var minSupShift;
|
|
@@ -66906,9 +66898,9 @@ var LuoguOldRenderer = (() => {
|
|
|
66906
66898
|
var marginLeft = null;
|
|
66907
66899
|
if (subm) {
|
|
66908
66900
|
var isOiint = group.base && group.base.type === "op" && group.base.name && (group.base.name === "\\oiint" || group.base.name === "\\oiiint");
|
|
66909
|
-
if (
|
|
66901
|
+
if (base2 instanceof SymbolNode || isOiint) {
|
|
66910
66902
|
var _base$italic;
|
|
66911
|
-
marginLeft = makeEm(-((_base$italic =
|
|
66903
|
+
marginLeft = makeEm(-((_base$italic = base2.italic) != null ? _base$italic : 0));
|
|
66912
66904
|
}
|
|
66913
66905
|
}
|
|
66914
66906
|
var supsub;
|
|
@@ -66968,8 +66960,8 @@ var LuoguOldRenderer = (() => {
|
|
|
66968
66960
|
} else {
|
|
66969
66961
|
throw new Error("supsub must have either sup or sub.");
|
|
66970
66962
|
}
|
|
66971
|
-
var mclass = getTypeOfDomTree(
|
|
66972
|
-
return makeSpan([mclass], [
|
|
66963
|
+
var mclass = getTypeOfDomTree(base2, "right") || "mord";
|
|
66964
|
+
return makeSpan([mclass], [base2, makeSpan(["msupsub"], [supsub])], options);
|
|
66973
66965
|
},
|
|
66974
66966
|
mathmlBuilder(group, options) {
|
|
66975
66967
|
var isBrace = false;
|
|
@@ -66996,10 +66988,10 @@ var LuoguOldRenderer = (() => {
|
|
|
66996
66988
|
if (isBrace) {
|
|
66997
66989
|
nodeType = isOver ? "mover" : "munder";
|
|
66998
66990
|
} else if (!group.sub) {
|
|
66999
|
-
var
|
|
67000
|
-
if (
|
|
66991
|
+
var base2 = group.base;
|
|
66992
|
+
if (base2 && base2.type === "op" && base2.limits && (options.style === Style$1.DISPLAY || base2.alwaysHandleSupSub)) {
|
|
67001
66993
|
nodeType = "mover";
|
|
67002
|
-
} else if (
|
|
66994
|
+
} else if (base2 && base2.type === "operatorname" && base2.alwaysHandleSupSub && (base2.limits || options.style === Style$1.DISPLAY)) {
|
|
67003
66995
|
nodeType = "mover";
|
|
67004
66996
|
} else {
|
|
67005
66997
|
nodeType = "msup";
|
|
@@ -67598,13 +67590,13 @@ var LuoguOldRenderer = (() => {
|
|
|
67598
67590
|
};
|
|
67599
67591
|
defineMacro("\\char", function(context) {
|
|
67600
67592
|
var token = context.popToken();
|
|
67601
|
-
var
|
|
67593
|
+
var base2;
|
|
67602
67594
|
var number = 0;
|
|
67603
67595
|
if (token.text === "'") {
|
|
67604
|
-
|
|
67596
|
+
base2 = 8;
|
|
67605
67597
|
token = context.popToken();
|
|
67606
67598
|
} else if (token.text === '"') {
|
|
67607
|
-
|
|
67599
|
+
base2 = 16;
|
|
67608
67600
|
token = context.popToken();
|
|
67609
67601
|
} else if (token.text === "`") {
|
|
67610
67602
|
token = context.popToken();
|
|
@@ -67616,16 +67608,16 @@ var LuoguOldRenderer = (() => {
|
|
|
67616
67608
|
number = token.text.charCodeAt(0);
|
|
67617
67609
|
}
|
|
67618
67610
|
} else {
|
|
67619
|
-
|
|
67611
|
+
base2 = 10;
|
|
67620
67612
|
}
|
|
67621
|
-
if (
|
|
67613
|
+
if (base2) {
|
|
67622
67614
|
number = digitToNumber[token.text];
|
|
67623
|
-
if (number == null || number >=
|
|
67624
|
-
throw new ParseError("Invalid base-" +
|
|
67615
|
+
if (number == null || number >= base2) {
|
|
67616
|
+
throw new ParseError("Invalid base-" + base2 + " digit " + token.text);
|
|
67625
67617
|
}
|
|
67626
67618
|
var digit;
|
|
67627
|
-
while ((digit = digitToNumber[context.future().text]) != null && digit <
|
|
67628
|
-
number *=
|
|
67619
|
+
while ((digit = digitToNumber[context.future().text]) != null && digit < base2) {
|
|
67620
|
+
number *= base2;
|
|
67629
67621
|
number += digit;
|
|
67630
67622
|
context.popToken();
|
|
67631
67623
|
}
|
|
@@ -69288,12 +69280,12 @@ var LuoguOldRenderer = (() => {
|
|
|
69288
69280
|
* Parses a group with optional super/subscripts.
|
|
69289
69281
|
*/
|
|
69290
69282
|
parseAtom(breakOnTokenText) {
|
|
69291
|
-
var
|
|
69292
|
-
if ((
|
|
69293
|
-
return
|
|
69283
|
+
var base2 = this.parseGroup("atom", breakOnTokenText);
|
|
69284
|
+
if ((base2 == null ? void 0 : base2.type) === "internal") {
|
|
69285
|
+
return base2;
|
|
69294
69286
|
}
|
|
69295
69287
|
if (this.mode === "text") {
|
|
69296
|
-
return
|
|
69288
|
+
return base2;
|
|
69297
69289
|
}
|
|
69298
69290
|
var superscript2;
|
|
69299
69291
|
var subscript2;
|
|
@@ -69301,13 +69293,13 @@ var LuoguOldRenderer = (() => {
|
|
|
69301
69293
|
this.consumeSpaces();
|
|
69302
69294
|
var lex = this.fetch();
|
|
69303
69295
|
if (lex.text === "\\limits" || lex.text === "\\nolimits") {
|
|
69304
|
-
if (
|
|
69296
|
+
if (base2 && base2.type === "op") {
|
|
69305
69297
|
var limits = lex.text === "\\limits";
|
|
69306
|
-
|
|
69307
|
-
|
|
69308
|
-
} else if (
|
|
69309
|
-
if (
|
|
69310
|
-
|
|
69298
|
+
base2.limits = limits;
|
|
69299
|
+
base2.alwaysHandleSupSub = true;
|
|
69300
|
+
} else if (base2 && base2.type === "operatorname") {
|
|
69301
|
+
if (base2.alwaysHandleSupSub) {
|
|
69302
|
+
base2.limits = lex.text === "\\limits";
|
|
69311
69303
|
}
|
|
69312
69304
|
} else {
|
|
69313
69305
|
throw new ParseError("Limit controls must follow a math operator", lex);
|
|
@@ -69384,12 +69376,12 @@ var LuoguOldRenderer = (() => {
|
|
|
69384
69376
|
return {
|
|
69385
69377
|
type: "supsub",
|
|
69386
69378
|
mode: this.mode,
|
|
69387
|
-
base,
|
|
69379
|
+
base: base2,
|
|
69388
69380
|
sup: superscript2,
|
|
69389
69381
|
sub: subscript2
|
|
69390
69382
|
};
|
|
69391
69383
|
} else {
|
|
69392
|
-
return
|
|
69384
|
+
return base2;
|
|
69393
69385
|
}
|
|
69394
69386
|
}
|
|
69395
69387
|
/**
|
|
@@ -69915,12 +69907,12 @@ var LuoguOldRenderer = (() => {
|
|
|
69915
69907
|
var settings = new Settings(options);
|
|
69916
69908
|
return parseTree(expression, settings);
|
|
69917
69909
|
};
|
|
69918
|
-
var renderError = function renderError2(
|
|
69919
|
-
if (options.throwOnError || !(
|
|
69920
|
-
throw
|
|
69910
|
+
var renderError = function renderError2(error2, expression, options) {
|
|
69911
|
+
if (options.throwOnError || !(error2 instanceof ParseError)) {
|
|
69912
|
+
throw error2;
|
|
69921
69913
|
}
|
|
69922
69914
|
var node = makeSpan(["katex-error"], [new SymbolNode(expression)]);
|
|
69923
|
-
node.setAttribute("title",
|
|
69915
|
+
node.setAttribute("title", error2.toString());
|
|
69924
69916
|
node.setAttribute("style", "color:" + options.errorColor);
|
|
69925
69917
|
return node;
|
|
69926
69918
|
};
|
|
@@ -69929,8 +69921,8 @@ var LuoguOldRenderer = (() => {
|
|
|
69929
69921
|
try {
|
|
69930
69922
|
var tree = parseTree(expression, settings);
|
|
69931
69923
|
return buildTree(tree, expression, settings);
|
|
69932
|
-
} catch (
|
|
69933
|
-
return renderError(
|
|
69924
|
+
} catch (error2) {
|
|
69925
|
+
return renderError(error2, expression, settings);
|
|
69934
69926
|
}
|
|
69935
69927
|
};
|
|
69936
69928
|
var renderToHTMLTree = function renderToHTMLTree2(expression, options) {
|
|
@@ -69938,8 +69930,8 @@ var LuoguOldRenderer = (() => {
|
|
|
69938
69930
|
try {
|
|
69939
69931
|
var tree = parseTree(expression, settings);
|
|
69940
69932
|
return buildHTMLTree(tree, expression, settings);
|
|
69941
|
-
} catch (
|
|
69942
|
-
return renderError(
|
|
69933
|
+
} catch (error2) {
|
|
69934
|
+
return renderError(error2, expression, settings);
|
|
69943
69935
|
}
|
|
69944
69936
|
};
|
|
69945
69937
|
var version = "0.16.47";
|