@11ty/client 4.0.0-alpha.7 → 4.0.0-alpha.9
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/README.md +1 -1
- package/dist/{eleventy.js → core-fs.js} +12612 -8018
- package/dist/{eleventy.core.js → core-minimal.js} +2356 -1656
- package/dist/formats/{eleventy-liquid.js → liquid.js} +617 -175
- package/dist/formats/{eleventy-markdown.js → markdown.js} +479 -114
- package/dist/formats/{eleventy-nunjucks.js → nunjucks.js} +2321 -2440
- package/dist/plugins/{eleventy-plugin-i18n.js → plugin-i18n.js} +33 -8
- package/package.json +16 -16
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
/*! Eleventy v4.0.0-alpha.
|
|
1
|
+
/*! Eleventy (Build Awesome) v4.0.0-alpha.9 (@11ty/client/md Engine Bundle) */
|
|
2
2
|
var __defProp = Object.defineProperty;
|
|
3
3
|
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
|
|
4
4
|
var __export = (target, all) => {
|
|
@@ -10,6 +10,7 @@ var __export = (target, all) => {
|
|
|
10
10
|
var utils_exports = {};
|
|
11
11
|
__export(utils_exports, {
|
|
12
12
|
arrayReplaceAt: () => arrayReplaceAt,
|
|
13
|
+
asciiTrim: () => asciiTrim,
|
|
13
14
|
assign: () => assign,
|
|
14
15
|
escapeHtml: () => escapeHtml,
|
|
15
16
|
escapeRE: () => escapeRE,
|
|
@@ -17,6 +18,7 @@ __export(utils_exports, {
|
|
|
17
18
|
has: () => has,
|
|
18
19
|
isMdAsciiPunct: () => isMdAsciiPunct,
|
|
19
20
|
isPunctChar: () => isPunctChar,
|
|
21
|
+
isPunctCharCode: () => isPunctCharCode,
|
|
20
22
|
isSpace: () => isSpace,
|
|
21
23
|
isString: () => isString,
|
|
22
24
|
isValidEntityCode: () => isValidEntityCode,
|
|
@@ -862,6 +864,10 @@ function decodeHTML(str, mode = DecodingMode.Legacy) {
|
|
|
862
864
|
return htmlDecoder(str, mode);
|
|
863
865
|
}
|
|
864
866
|
__name(decodeHTML, "decodeHTML");
|
|
867
|
+
function decodeHTMLStrict(str) {
|
|
868
|
+
return htmlDecoder(str, DecodingMode.Strict);
|
|
869
|
+
}
|
|
870
|
+
__name(decodeHTMLStrict, "decodeHTMLStrict");
|
|
865
871
|
|
|
866
872
|
// ../../node_modules/markdown-it/node_modules/entities/lib/esm/generated/encode-html.js
|
|
867
873
|
function restoreDiff(arr) {
|
|
@@ -1105,6 +1111,10 @@ function isPunctChar(ch) {
|
|
|
1105
1111
|
return regex_default4.test(ch) || regex_default5.test(ch);
|
|
1106
1112
|
}
|
|
1107
1113
|
__name(isPunctChar, "isPunctChar");
|
|
1114
|
+
function isPunctCharCode(code2) {
|
|
1115
|
+
return isPunctChar(fromCodePoint2(code2));
|
|
1116
|
+
}
|
|
1117
|
+
__name(isPunctCharCode, "isPunctCharCode");
|
|
1108
1118
|
function isMdAsciiPunct(ch) {
|
|
1109
1119
|
switch (ch) {
|
|
1110
1120
|
case 33:
|
|
@@ -1153,6 +1163,26 @@ function normalizeReference(str) {
|
|
|
1153
1163
|
return str.toLowerCase().toUpperCase();
|
|
1154
1164
|
}
|
|
1155
1165
|
__name(normalizeReference, "normalizeReference");
|
|
1166
|
+
function isAsciiTrimmable(c) {
|
|
1167
|
+
return c === 32 || c === 9 || c === 10 || c === 13;
|
|
1168
|
+
}
|
|
1169
|
+
__name(isAsciiTrimmable, "isAsciiTrimmable");
|
|
1170
|
+
function asciiTrim(str) {
|
|
1171
|
+
let start = 0;
|
|
1172
|
+
for (; start < str.length; start++) {
|
|
1173
|
+
if (!isAsciiTrimmable(str.charCodeAt(start))) {
|
|
1174
|
+
break;
|
|
1175
|
+
}
|
|
1176
|
+
}
|
|
1177
|
+
let end = str.length - 1;
|
|
1178
|
+
for (; end >= start; end--) {
|
|
1179
|
+
if (!isAsciiTrimmable(str.charCodeAt(end))) {
|
|
1180
|
+
break;
|
|
1181
|
+
}
|
|
1182
|
+
}
|
|
1183
|
+
return str.slice(start, end + 1);
|
|
1184
|
+
}
|
|
1185
|
+
__name(asciiTrim, "asciiTrim");
|
|
1156
1186
|
var lib = { mdurl: mdurl_exports, ucmicro: uc_exports };
|
|
1157
1187
|
|
|
1158
1188
|
// ../../node_modules/markdown-it/lib/helpers/index.mjs
|
|
@@ -1922,13 +1952,29 @@ __name(replace, "replace");
|
|
|
1922
1952
|
var QUOTE_TEST_RE = /['"]/;
|
|
1923
1953
|
var QUOTE_RE = /['"]/g;
|
|
1924
1954
|
var APOSTROPHE = "\u2019";
|
|
1925
|
-
function
|
|
1926
|
-
|
|
1955
|
+
function addReplacement(replacements, tokenIdx, pos, ch) {
|
|
1956
|
+
if (!replacements[tokenIdx]) {
|
|
1957
|
+
replacements[tokenIdx] = [];
|
|
1958
|
+
}
|
|
1959
|
+
replacements[tokenIdx].push({ pos, ch });
|
|
1960
|
+
}
|
|
1961
|
+
__name(addReplacement, "addReplacement");
|
|
1962
|
+
function applyReplacements(str, replacements) {
|
|
1963
|
+
let result = "";
|
|
1964
|
+
let lastPos = 0;
|
|
1965
|
+
replacements.sort((a, b) => a.pos - b.pos);
|
|
1966
|
+
for (let i = 0; i < replacements.length; i++) {
|
|
1967
|
+
const replacement = replacements[i];
|
|
1968
|
+
result += str.slice(lastPos, replacement.pos) + replacement.ch;
|
|
1969
|
+
lastPos = replacement.pos + 1;
|
|
1970
|
+
}
|
|
1971
|
+
return result + str.slice(lastPos);
|
|
1927
1972
|
}
|
|
1928
|
-
__name(
|
|
1973
|
+
__name(applyReplacements, "applyReplacements");
|
|
1929
1974
|
function process_inlines(tokens, state) {
|
|
1930
1975
|
let j;
|
|
1931
1976
|
const stack = [];
|
|
1977
|
+
const replacements = {};
|
|
1932
1978
|
for (let i = 0; i < tokens.length; i++) {
|
|
1933
1979
|
const token = tokens[i];
|
|
1934
1980
|
const thisLevel = tokens[i].level;
|
|
@@ -1941,9 +1987,9 @@ function process_inlines(tokens, state) {
|
|
|
1941
1987
|
if (token.type !== "text") {
|
|
1942
1988
|
continue;
|
|
1943
1989
|
}
|
|
1944
|
-
|
|
1990
|
+
const text2 = token.content;
|
|
1945
1991
|
let pos = 0;
|
|
1946
|
-
|
|
1992
|
+
const max = text2.length;
|
|
1947
1993
|
OUTER:
|
|
1948
1994
|
while (pos < max) {
|
|
1949
1995
|
QUOTE_RE.lastIndex = pos;
|
|
@@ -1977,8 +2023,8 @@ function process_inlines(tokens, state) {
|
|
|
1977
2023
|
break;
|
|
1978
2024
|
}
|
|
1979
2025
|
}
|
|
1980
|
-
const isLastPunctChar = isMdAsciiPunct(lastChar) ||
|
|
1981
|
-
const isNextPunctChar = isMdAsciiPunct(nextChar) ||
|
|
2026
|
+
const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctCharCode(lastChar);
|
|
2027
|
+
const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctCharCode(nextChar);
|
|
1982
2028
|
const isLastWhiteSpace = isWhiteSpace(lastChar);
|
|
1983
2029
|
const isNextWhiteSpace = isWhiteSpace(nextChar);
|
|
1984
2030
|
if (isNextWhiteSpace) {
|
|
@@ -2006,7 +2052,7 @@ function process_inlines(tokens, state) {
|
|
|
2006
2052
|
}
|
|
2007
2053
|
if (!canOpen && !canClose) {
|
|
2008
2054
|
if (isSingle) {
|
|
2009
|
-
|
|
2055
|
+
addReplacement(replacements, i, t.index, APOSTROPHE);
|
|
2010
2056
|
}
|
|
2011
2057
|
continue;
|
|
2012
2058
|
}
|
|
@@ -2027,18 +2073,8 @@ function process_inlines(tokens, state) {
|
|
|
2027
2073
|
openQuote = state.md.options.quotes[0];
|
|
2028
2074
|
closeQuote = state.md.options.quotes[1];
|
|
2029
2075
|
}
|
|
2030
|
-
|
|
2031
|
-
|
|
2032
|
-
tokens[item.token].content,
|
|
2033
|
-
item.pos,
|
|
2034
|
-
openQuote
|
|
2035
|
-
);
|
|
2036
|
-
pos += closeQuote.length - 1;
|
|
2037
|
-
if (item.token === i) {
|
|
2038
|
-
pos += openQuote.length - 1;
|
|
2039
|
-
}
|
|
2040
|
-
text2 = token.content;
|
|
2041
|
-
max = text2.length;
|
|
2076
|
+
addReplacement(replacements, i, t.index, closeQuote);
|
|
2077
|
+
addReplacement(replacements, item.token, item.pos, openQuote);
|
|
2042
2078
|
stack.length = j;
|
|
2043
2079
|
continue OUTER;
|
|
2044
2080
|
}
|
|
@@ -2052,10 +2088,13 @@ function process_inlines(tokens, state) {
|
|
|
2052
2088
|
level: thisLevel
|
|
2053
2089
|
});
|
|
2054
2090
|
} else if (canClose && isSingle) {
|
|
2055
|
-
|
|
2091
|
+
addReplacement(replacements, i, t.index, APOSTROPHE);
|
|
2056
2092
|
}
|
|
2057
2093
|
}
|
|
2058
2094
|
}
|
|
2095
|
+
Object.keys(replacements).forEach(function(tokenIdx) {
|
|
2096
|
+
tokens[tokenIdx].content = applyReplacements(tokens[tokenIdx].content, replacements[tokenIdx]);
|
|
2097
|
+
});
|
|
2059
2098
|
}
|
|
2060
2099
|
__name(process_inlines, "process_inlines");
|
|
2061
2100
|
function smartquotes(state) {
|
|
@@ -3262,10 +3301,13 @@ function html_block(state, startLine, endLine, silent) {
|
|
|
3262
3301
|
return HTML_SEQUENCES[i][2];
|
|
3263
3302
|
}
|
|
3264
3303
|
let nextLine = startLine + 1;
|
|
3304
|
+
const endsOnBlankLine = HTML_SEQUENCES[i][1].test("");
|
|
3265
3305
|
if (!HTML_SEQUENCES[i][1].test(lineText)) {
|
|
3266
3306
|
for (; nextLine < endLine; nextLine++) {
|
|
3267
3307
|
if (state.sCount[nextLine] < state.blkIndent) {
|
|
3268
|
-
|
|
3308
|
+
if (endsOnBlankLine || !state.isEmpty(nextLine)) {
|
|
3309
|
+
break;
|
|
3310
|
+
}
|
|
3269
3311
|
}
|
|
3270
3312
|
pos = state.bMarks[nextLine] + state.tShift[nextLine];
|
|
3271
3313
|
max = state.eMarks[nextLine];
|
|
@@ -3319,7 +3361,7 @@ function heading(state, startLine, endLine, silent) {
|
|
|
3319
3361
|
token_o.markup = "########".slice(0, level);
|
|
3320
3362
|
token_o.map = [startLine, state.line];
|
|
3321
3363
|
const token_i = state.push("inline", "", 0);
|
|
3322
|
-
token_i.content = state.src.slice(pos, max)
|
|
3364
|
+
token_i.content = asciiTrim(state.src.slice(pos, max));
|
|
3323
3365
|
token_i.map = [startLine, state.line];
|
|
3324
3366
|
token_i.children = [];
|
|
3325
3367
|
const token_c = state.push("heading_close", "h" + String(level), -1);
|
|
@@ -3373,9 +3415,10 @@ function lheading(state, startLine, endLine) {
|
|
|
3373
3415
|
}
|
|
3374
3416
|
}
|
|
3375
3417
|
if (!level) {
|
|
3418
|
+
state.parentType = oldParentType;
|
|
3376
3419
|
return false;
|
|
3377
3420
|
}
|
|
3378
|
-
const content = state.getLines(startLine, nextLine, state.blkIndent, false)
|
|
3421
|
+
const content = asciiTrim(state.getLines(startLine, nextLine, state.blkIndent, false));
|
|
3379
3422
|
state.line = nextLine + 1;
|
|
3380
3423
|
const token_o = state.push("heading_open", "h" + String(level), 1);
|
|
3381
3424
|
token_o.markup = String.fromCharCode(marker);
|
|
@@ -3415,7 +3458,7 @@ function paragraph(state, startLine, endLine) {
|
|
|
3415
3458
|
break;
|
|
3416
3459
|
}
|
|
3417
3460
|
}
|
|
3418
|
-
const content = state.getLines(startLine, nextLine, state.blkIndent, false)
|
|
3461
|
+
const content = asciiTrim(state.getLines(startLine, nextLine, state.blkIndent, false));
|
|
3419
3462
|
state.line = nextLine;
|
|
3420
3463
|
const token_o = state.push("paragraph_open", "p", 1);
|
|
3421
3464
|
token_o.map = [startLine, state.line];
|
|
@@ -3557,15 +3600,37 @@ StateInline.prototype.push = function(type, tag, nesting) {
|
|
|
3557
3600
|
StateInline.prototype.scanDelims = function(start, canSplitWord) {
|
|
3558
3601
|
const max = this.posMax;
|
|
3559
3602
|
const marker = this.src.charCodeAt(start);
|
|
3560
|
-
|
|
3603
|
+
let lastChar;
|
|
3604
|
+
if (start === 0) {
|
|
3605
|
+
lastChar = 32;
|
|
3606
|
+
} else if (start === 1) {
|
|
3607
|
+
lastChar = this.src.charCodeAt(0);
|
|
3608
|
+
if ((lastChar & 63488) === 55296) {
|
|
3609
|
+
lastChar = 65533;
|
|
3610
|
+
}
|
|
3611
|
+
} else {
|
|
3612
|
+
lastChar = this.src.charCodeAt(start - 1);
|
|
3613
|
+
if ((lastChar & 64512) === 56320) {
|
|
3614
|
+
const highSurr = this.src.charCodeAt(start - 2);
|
|
3615
|
+
lastChar = (highSurr & 64512) === 55296 ? 65536 + (highSurr - 55296 << 10) + (lastChar - 56320) : 65533;
|
|
3616
|
+
} else if ((lastChar & 64512) === 55296) {
|
|
3617
|
+
lastChar = 65533;
|
|
3618
|
+
}
|
|
3619
|
+
}
|
|
3561
3620
|
let pos = start;
|
|
3562
3621
|
while (pos < max && this.src.charCodeAt(pos) === marker) {
|
|
3563
3622
|
pos++;
|
|
3564
3623
|
}
|
|
3565
3624
|
const count = pos - start;
|
|
3566
|
-
|
|
3567
|
-
|
|
3568
|
-
|
|
3625
|
+
let nextChar = pos < max ? this.src.charCodeAt(pos) : 32;
|
|
3626
|
+
if ((nextChar & 64512) === 55296) {
|
|
3627
|
+
const lowSurr = this.src.charCodeAt(pos + 1);
|
|
3628
|
+
nextChar = (lowSurr & 64512) === 56320 ? 65536 + (nextChar - 55296 << 10) + (lowSurr - 56320) : 65533;
|
|
3629
|
+
} else if ((nextChar & 64512) === 56320) {
|
|
3630
|
+
nextChar = 65533;
|
|
3631
|
+
}
|
|
3632
|
+
const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctCharCode(lastChar);
|
|
3633
|
+
const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctCharCode(nextChar);
|
|
3569
3634
|
const isLastWhiteSpace = isWhiteSpace(lastChar);
|
|
3570
3635
|
const isNextWhiteSpace = isWhiteSpace(nextChar);
|
|
3571
3636
|
const left_flanking = !isNextWhiteSpace && (!isNextPunctChar || isLastWhiteSpace || isLastPunctChar);
|
|
@@ -4337,7 +4402,7 @@ function entity(state, silent) {
|
|
|
4337
4402
|
} else {
|
|
4338
4403
|
const match2 = state.src.slice(pos).match(NAMED_RE);
|
|
4339
4404
|
if (match2) {
|
|
4340
|
-
const decoded =
|
|
4405
|
+
const decoded = decodeHTMLStrict(match2[0]);
|
|
4341
4406
|
if (decoded !== match2[0]) {
|
|
4342
4407
|
if (!silent) {
|
|
4343
4408
|
const token = state.push("text_special", "", 0);
|
|
@@ -4704,11 +4769,6 @@ var defaultSchemas = {
|
|
|
4704
4769
|
};
|
|
4705
4770
|
var tlds_2ch_src_re = "a[cdefgilmnoqrstuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrstuvwxyz]|n[acefgilopruz]|om|p[aefghklmnrstwy]|qa|r[eosuw]|s[abcdeghijklmnortuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]";
|
|
4706
4771
|
var tlds_default = "biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|\u0440\u0444".split("|");
|
|
4707
|
-
function resetScanCache(self) {
|
|
4708
|
-
self.__index__ = -1;
|
|
4709
|
-
self.__text_cache__ = "";
|
|
4710
|
-
}
|
|
4711
|
-
__name(resetScanCache, "resetScanCache");
|
|
4712
4772
|
function createValidator(re) {
|
|
4713
4773
|
return function(text2, pos) {
|
|
4714
4774
|
const tail = text2.slice(pos);
|
|
@@ -4739,8 +4799,11 @@ function compile(self) {
|
|
|
4739
4799
|
}
|
|
4740
4800
|
__name(untpl, "untpl");
|
|
4741
4801
|
re.email_fuzzy = RegExp(untpl(re.tpl_email_fuzzy), "i");
|
|
4802
|
+
re.email_fuzzy_global = RegExp(untpl(re.tpl_email_fuzzy), "ig");
|
|
4742
4803
|
re.link_fuzzy = RegExp(untpl(re.tpl_link_fuzzy), "i");
|
|
4804
|
+
re.link_fuzzy_global = RegExp(untpl(re.tpl_link_fuzzy), "ig");
|
|
4743
4805
|
re.link_no_ip_fuzzy = RegExp(untpl(re.tpl_link_no_ip_fuzzy), "i");
|
|
4806
|
+
re.link_no_ip_fuzzy_global = RegExp(untpl(re.tpl_link_no_ip_fuzzy), "ig");
|
|
4744
4807
|
re.host_fuzzy_test = RegExp(untpl(re.tpl_host_fuzzy_test), "i");
|
|
4745
4808
|
const aliases = [];
|
|
4746
4809
|
self.__compiled__ = {};
|
|
@@ -4796,27 +4859,18 @@ function compile(self) {
|
|
|
4796
4859
|
"(" + self.re.schema_test.source + ")|(" + self.re.host_fuzzy_test.source + ")|@",
|
|
4797
4860
|
"i"
|
|
4798
4861
|
);
|
|
4799
|
-
resetScanCache(self);
|
|
4800
4862
|
}
|
|
4801
4863
|
__name(compile, "compile");
|
|
4802
|
-
function Match(
|
|
4803
|
-
const
|
|
4804
|
-
|
|
4805
|
-
|
|
4806
|
-
this.
|
|
4807
|
-
this.
|
|
4808
|
-
this.
|
|
4809
|
-
this.
|
|
4810
|
-
this.text = text2;
|
|
4811
|
-
this.url = text2;
|
|
4864
|
+
function Match(text2, schema, index, lastIndex) {
|
|
4865
|
+
const raw = text2.slice(index, lastIndex);
|
|
4866
|
+
this.schema = schema.toLowerCase();
|
|
4867
|
+
this.index = index;
|
|
4868
|
+
this.lastIndex = lastIndex;
|
|
4869
|
+
this.raw = raw;
|
|
4870
|
+
this.text = raw;
|
|
4871
|
+
this.url = raw;
|
|
4812
4872
|
}
|
|
4813
4873
|
__name(Match, "Match");
|
|
4814
|
-
function createMatch(self, shift) {
|
|
4815
|
-
const match2 = new Match(self, shift);
|
|
4816
|
-
self.__compiled__[match2.schema].normalize(match2, self);
|
|
4817
|
-
return match2;
|
|
4818
|
-
}
|
|
4819
|
-
__name(createMatch, "createMatch");
|
|
4820
4874
|
function LinkifyIt(schemas, options) {
|
|
4821
4875
|
if (!(this instanceof LinkifyIt)) {
|
|
4822
4876
|
return new LinkifyIt(schemas, options);
|
|
@@ -4828,10 +4882,6 @@ function LinkifyIt(schemas, options) {
|
|
|
4828
4882
|
}
|
|
4829
4883
|
}
|
|
4830
4884
|
this.__opts__ = assign2({}, defaultOptions, options);
|
|
4831
|
-
this.__index__ = -1;
|
|
4832
|
-
this.__last_index__ = -1;
|
|
4833
|
-
this.__schema__ = "";
|
|
4834
|
-
this.__text_cache__ = "";
|
|
4835
4885
|
this.__schemas__ = assign2({}, defaultSchemas, schemas);
|
|
4836
4886
|
this.__compiled__ = {};
|
|
4837
4887
|
this.__tlds__ = tlds_default;
|
|
@@ -4850,55 +4900,34 @@ LinkifyIt.prototype.set = /* @__PURE__ */ __name(function set(options) {
|
|
|
4850
4900
|
return this;
|
|
4851
4901
|
}, "set");
|
|
4852
4902
|
LinkifyIt.prototype.test = /* @__PURE__ */ __name(function test(text2) {
|
|
4853
|
-
this.__text_cache__ = text2;
|
|
4854
|
-
this.__index__ = -1;
|
|
4855
4903
|
if (!text2.length) {
|
|
4856
4904
|
return false;
|
|
4857
4905
|
}
|
|
4858
|
-
let m,
|
|
4906
|
+
let m, re;
|
|
4859
4907
|
if (this.re.schema_test.test(text2)) {
|
|
4860
4908
|
re = this.re.schema_search;
|
|
4861
4909
|
re.lastIndex = 0;
|
|
4862
4910
|
while ((m = re.exec(text2)) !== null) {
|
|
4863
|
-
|
|
4864
|
-
|
|
4865
|
-
this.__schema__ = m[2];
|
|
4866
|
-
this.__index__ = m.index + m[1].length;
|
|
4867
|
-
this.__last_index__ = m.index + m[0].length + len;
|
|
4868
|
-
break;
|
|
4911
|
+
if (this.testSchemaAt(text2, m[2], re.lastIndex)) {
|
|
4912
|
+
return true;
|
|
4869
4913
|
}
|
|
4870
4914
|
}
|
|
4871
4915
|
}
|
|
4872
4916
|
if (this.__opts__.fuzzyLink && this.__compiled__["http:"]) {
|
|
4873
|
-
|
|
4874
|
-
|
|
4875
|
-
|
|
4876
|
-
if ((ml = text2.match(this.__opts__.fuzzyIP ? this.re.link_fuzzy : this.re.link_no_ip_fuzzy)) !== null) {
|
|
4877
|
-
shift = ml.index + ml[1].length;
|
|
4878
|
-
if (this.__index__ < 0 || shift < this.__index__) {
|
|
4879
|
-
this.__schema__ = "";
|
|
4880
|
-
this.__index__ = shift;
|
|
4881
|
-
this.__last_index__ = ml.index + ml[0].length;
|
|
4882
|
-
}
|
|
4883
|
-
}
|
|
4917
|
+
if (text2.search(this.re.host_fuzzy_test) >= 0) {
|
|
4918
|
+
if (text2.match(this.__opts__.fuzzyIP ? this.re.link_fuzzy : this.re.link_no_ip_fuzzy) !== null) {
|
|
4919
|
+
return true;
|
|
4884
4920
|
}
|
|
4885
4921
|
}
|
|
4886
4922
|
}
|
|
4887
4923
|
if (this.__opts__.fuzzyEmail && this.__compiled__["mailto:"]) {
|
|
4888
|
-
|
|
4889
|
-
|
|
4890
|
-
|
|
4891
|
-
shift = me.index + me[1].length;
|
|
4892
|
-
next = me.index + me[0].length;
|
|
4893
|
-
if (this.__index__ < 0 || shift < this.__index__ || shift === this.__index__ && next > this.__last_index__) {
|
|
4894
|
-
this.__schema__ = "mailto:";
|
|
4895
|
-
this.__index__ = shift;
|
|
4896
|
-
this.__last_index__ = next;
|
|
4897
|
-
}
|
|
4924
|
+
if (text2.indexOf("@") >= 0) {
|
|
4925
|
+
if (text2.match(this.re.email_fuzzy) !== null) {
|
|
4926
|
+
return true;
|
|
4898
4927
|
}
|
|
4899
4928
|
}
|
|
4900
4929
|
}
|
|
4901
|
-
return
|
|
4930
|
+
return false;
|
|
4902
4931
|
}, "test");
|
|
4903
4932
|
LinkifyIt.prototype.pretest = /* @__PURE__ */ __name(function pretest(text2) {
|
|
4904
4933
|
return this.re.pretest.test(text2);
|
|
@@ -4911,16 +4940,88 @@ LinkifyIt.prototype.testSchemaAt = /* @__PURE__ */ __name(function testSchemaAt(
|
|
|
4911
4940
|
}, "testSchemaAt");
|
|
4912
4941
|
LinkifyIt.prototype.match = /* @__PURE__ */ __name(function match(text2) {
|
|
4913
4942
|
const result = [];
|
|
4914
|
-
|
|
4915
|
-
|
|
4916
|
-
|
|
4917
|
-
|
|
4943
|
+
const type_schemed = [];
|
|
4944
|
+
const type_fuzzy_link = [];
|
|
4945
|
+
const type_fuzzy_email = [];
|
|
4946
|
+
let m, len, re;
|
|
4947
|
+
function choose(a, b) {
|
|
4948
|
+
if (!a) {
|
|
4949
|
+
return b;
|
|
4950
|
+
}
|
|
4951
|
+
if (!b) {
|
|
4952
|
+
return a;
|
|
4953
|
+
}
|
|
4954
|
+
if (a.index !== b.index) {
|
|
4955
|
+
return a.index < b.index ? a : b;
|
|
4956
|
+
}
|
|
4957
|
+
return a.lastIndex >= b.lastIndex ? a : b;
|
|
4918
4958
|
}
|
|
4919
|
-
|
|
4920
|
-
|
|
4921
|
-
|
|
4922
|
-
|
|
4923
|
-
|
|
4959
|
+
__name(choose, "choose");
|
|
4960
|
+
if (!text2.length) {
|
|
4961
|
+
return null;
|
|
4962
|
+
}
|
|
4963
|
+
if (this.re.schema_test.test(text2)) {
|
|
4964
|
+
re = this.re.schema_search;
|
|
4965
|
+
re.lastIndex = 0;
|
|
4966
|
+
while ((m = re.exec(text2)) !== null) {
|
|
4967
|
+
len = this.testSchemaAt(text2, m[2], re.lastIndex);
|
|
4968
|
+
if (len) {
|
|
4969
|
+
type_schemed.push({
|
|
4970
|
+
schema: m[2],
|
|
4971
|
+
index: m.index + m[1].length,
|
|
4972
|
+
lastIndex: m.index + m[0].length + len
|
|
4973
|
+
});
|
|
4974
|
+
}
|
|
4975
|
+
}
|
|
4976
|
+
}
|
|
4977
|
+
if (this.__opts__.fuzzyLink && this.__compiled__["http:"]) {
|
|
4978
|
+
re = this.__opts__.fuzzyIP ? this.re.link_fuzzy_global : this.re.link_no_ip_fuzzy_global;
|
|
4979
|
+
re.lastIndex = 0;
|
|
4980
|
+
while ((m = re.exec(text2)) !== null) {
|
|
4981
|
+
type_fuzzy_link.push({
|
|
4982
|
+
schema: "",
|
|
4983
|
+
index: m.index + m[1].length,
|
|
4984
|
+
lastIndex: m.index + m[0].length
|
|
4985
|
+
});
|
|
4986
|
+
}
|
|
4987
|
+
}
|
|
4988
|
+
if (this.__opts__.fuzzyEmail && this.__compiled__["mailto:"]) {
|
|
4989
|
+
re = this.re.email_fuzzy_global;
|
|
4990
|
+
re.lastIndex = 0;
|
|
4991
|
+
while ((m = re.exec(text2)) !== null) {
|
|
4992
|
+
type_fuzzy_email.push({
|
|
4993
|
+
schema: "mailto:",
|
|
4994
|
+
index: m.index + m[1].length,
|
|
4995
|
+
lastIndex: m.index + m[0].length
|
|
4996
|
+
});
|
|
4997
|
+
}
|
|
4998
|
+
}
|
|
4999
|
+
const indexes = [0, 0, 0];
|
|
5000
|
+
let lastIndex = 0;
|
|
5001
|
+
for (; ; ) {
|
|
5002
|
+
const candidates = [
|
|
5003
|
+
type_schemed[indexes[0]],
|
|
5004
|
+
type_fuzzy_email[indexes[1]],
|
|
5005
|
+
type_fuzzy_link[indexes[2]]
|
|
5006
|
+
];
|
|
5007
|
+
const candidate = choose(choose(candidates[0], candidates[1]), candidates[2]);
|
|
5008
|
+
if (!candidate) {
|
|
5009
|
+
break;
|
|
5010
|
+
}
|
|
5011
|
+
if (candidate === candidates[0]) {
|
|
5012
|
+
indexes[0]++;
|
|
5013
|
+
} else if (candidate === candidates[1]) {
|
|
5014
|
+
indexes[1]++;
|
|
5015
|
+
} else {
|
|
5016
|
+
indexes[2]++;
|
|
5017
|
+
}
|
|
5018
|
+
if (candidate.index < lastIndex) {
|
|
5019
|
+
continue;
|
|
5020
|
+
}
|
|
5021
|
+
const match2 = new Match(text2, candidate.schema, candidate.index, candidate.lastIndex);
|
|
5022
|
+
this.__compiled__[match2.schema].normalize(match2, this);
|
|
5023
|
+
result.push(match2);
|
|
5024
|
+
lastIndex = candidate.lastIndex;
|
|
4924
5025
|
}
|
|
4925
5026
|
if (result.length) {
|
|
4926
5027
|
return result;
|
|
@@ -4928,17 +5029,14 @@ LinkifyIt.prototype.match = /* @__PURE__ */ __name(function match(text2) {
|
|
|
4928
5029
|
return null;
|
|
4929
5030
|
}, "match");
|
|
4930
5031
|
LinkifyIt.prototype.matchAtStart = /* @__PURE__ */ __name(function matchAtStart(text2) {
|
|
4931
|
-
this.__text_cache__ = text2;
|
|
4932
|
-
this.__index__ = -1;
|
|
4933
5032
|
if (!text2.length) return null;
|
|
4934
5033
|
const m = this.re.schema_at_start.exec(text2);
|
|
4935
5034
|
if (!m) return null;
|
|
4936
5035
|
const len = this.testSchemaAt(text2, m[2], m[0].length);
|
|
4937
5036
|
if (!len) return null;
|
|
4938
|
-
|
|
4939
|
-
this.
|
|
4940
|
-
|
|
4941
|
-
return createMatch(this, 0);
|
|
5037
|
+
const match2 = new Match(text2, m[2], m.index + m[1].length, m.index + m[0].length + len);
|
|
5038
|
+
this.__compiled__[match2.schema].normalize(match2, this);
|
|
5039
|
+
return match2;
|
|
4942
5040
|
}, "matchAtStart");
|
|
4943
5041
|
LinkifyIt.prototype.tlds = /* @__PURE__ */ __name(function tlds(list2, keepOld) {
|
|
4944
5042
|
list2 = Array.isArray(list2) ? list2 : [list2];
|
|
@@ -5539,21 +5637,289 @@ MarkdownIt.prototype.renderInline = function(src, env) {
|
|
|
5539
5637
|
};
|
|
5540
5638
|
var lib_default = MarkdownIt;
|
|
5541
5639
|
|
|
5542
|
-
// ../../node_modules
|
|
5543
|
-
function
|
|
5544
|
-
|
|
5640
|
+
// ../../node_modules/obug/dist/core.js
|
|
5641
|
+
function coerce(value) {
|
|
5642
|
+
if (value instanceof Error) return value.stack || value.message;
|
|
5643
|
+
return value;
|
|
5644
|
+
}
|
|
5645
|
+
__name(coerce, "coerce");
|
|
5646
|
+
function selectColor(colors2, namespace) {
|
|
5647
|
+
let hash = 0;
|
|
5648
|
+
for (let i = 0; i < namespace.length; i++) {
|
|
5649
|
+
hash = (hash << 5) - hash + namespace.charCodeAt(i);
|
|
5650
|
+
hash |= 0;
|
|
5651
|
+
}
|
|
5652
|
+
return colors2[Math.abs(hash) % colors2.length];
|
|
5653
|
+
}
|
|
5654
|
+
__name(selectColor, "selectColor");
|
|
5655
|
+
function matchesTemplate(search, template) {
|
|
5656
|
+
let searchIndex = 0;
|
|
5657
|
+
let templateIndex = 0;
|
|
5658
|
+
let starIndex = -1;
|
|
5659
|
+
let matchIndex = 0;
|
|
5660
|
+
while (searchIndex < search.length) if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) if (template[templateIndex] === "*") {
|
|
5661
|
+
starIndex = templateIndex;
|
|
5662
|
+
matchIndex = searchIndex;
|
|
5663
|
+
templateIndex++;
|
|
5664
|
+
} else {
|
|
5665
|
+
searchIndex++;
|
|
5666
|
+
templateIndex++;
|
|
5667
|
+
}
|
|
5668
|
+
else if (starIndex !== -1) {
|
|
5669
|
+
templateIndex = starIndex + 1;
|
|
5670
|
+
matchIndex++;
|
|
5671
|
+
searchIndex = matchIndex;
|
|
5672
|
+
} else return false;
|
|
5673
|
+
while (templateIndex < template.length && template[templateIndex] === "*") templateIndex++;
|
|
5674
|
+
return templateIndex === template.length;
|
|
5675
|
+
}
|
|
5676
|
+
__name(matchesTemplate, "matchesTemplate");
|
|
5677
|
+
function humanize(value) {
|
|
5678
|
+
if (value >= 1e3) return `${(value / 1e3).toFixed(1)}s`;
|
|
5679
|
+
return `${value}ms`;
|
|
5680
|
+
}
|
|
5681
|
+
__name(humanize, "humanize");
|
|
5682
|
+
var globalNamespaces = "";
|
|
5683
|
+
function createDebug(namespace, options) {
|
|
5684
|
+
let prevTime;
|
|
5685
|
+
let enableOverride;
|
|
5686
|
+
let namespacesCache;
|
|
5687
|
+
let enabledCache;
|
|
5688
|
+
const debug2 = /* @__PURE__ */ __name((...args) => {
|
|
5689
|
+
if (!debug2.enabled) return;
|
|
5690
|
+
const curr = Date.now();
|
|
5691
|
+
const diff = curr - (prevTime || curr);
|
|
5692
|
+
prevTime = curr;
|
|
5693
|
+
args[0] = coerce(args[0]);
|
|
5694
|
+
if (typeof args[0] !== "string") args.unshift("%O");
|
|
5695
|
+
let index = 0;
|
|
5696
|
+
args[0] = args[0].replace(/%([a-z%])/gi, (match2, format2) => {
|
|
5697
|
+
if (match2 === "%%") return "%";
|
|
5698
|
+
index++;
|
|
5699
|
+
const formatter = options.formatters[format2];
|
|
5700
|
+
if (typeof formatter === "function") {
|
|
5701
|
+
const value = args[index];
|
|
5702
|
+
match2 = formatter.call(debug2, value);
|
|
5703
|
+
args.splice(index, 1);
|
|
5704
|
+
index--;
|
|
5705
|
+
}
|
|
5706
|
+
return match2;
|
|
5707
|
+
});
|
|
5708
|
+
options.formatArgs.call(debug2, diff, args);
|
|
5709
|
+
debug2.log(...args);
|
|
5710
|
+
}, "debug");
|
|
5711
|
+
debug2.extend = function(namespace2, delimiter2 = ":") {
|
|
5712
|
+
return createDebug(this.namespace + delimiter2 + namespace2, {
|
|
5713
|
+
useColors: this.useColors,
|
|
5714
|
+
color: this.color,
|
|
5715
|
+
formatArgs: this.formatArgs,
|
|
5716
|
+
formatters: this.formatters,
|
|
5717
|
+
inspectOpts: this.inspectOpts,
|
|
5718
|
+
log: this.log,
|
|
5719
|
+
humanize: this.humanize
|
|
5720
|
+
});
|
|
5545
5721
|
};
|
|
5722
|
+
Object.assign(debug2, options);
|
|
5723
|
+
debug2.namespace = namespace;
|
|
5724
|
+
Object.defineProperty(debug2, "enabled", {
|
|
5725
|
+
enumerable: true,
|
|
5726
|
+
configurable: false,
|
|
5727
|
+
get: /* @__PURE__ */ __name(() => {
|
|
5728
|
+
if (enableOverride != null) return enableOverride;
|
|
5729
|
+
if (namespacesCache !== globalNamespaces) {
|
|
5730
|
+
namespacesCache = globalNamespaces;
|
|
5731
|
+
enabledCache = enabled(namespace);
|
|
5732
|
+
}
|
|
5733
|
+
return enabledCache;
|
|
5734
|
+
}, "get"),
|
|
5735
|
+
set: /* @__PURE__ */ __name((v) => {
|
|
5736
|
+
enableOverride = v;
|
|
5737
|
+
}, "set")
|
|
5738
|
+
});
|
|
5739
|
+
return debug2;
|
|
5740
|
+
}
|
|
5741
|
+
__name(createDebug, "createDebug");
|
|
5742
|
+
var names = [];
|
|
5743
|
+
var skips = [];
|
|
5744
|
+
function enable(namespaces2) {
|
|
5745
|
+
globalNamespaces = namespaces2;
|
|
5746
|
+
names = [];
|
|
5747
|
+
skips = [];
|
|
5748
|
+
const split = globalNamespaces.trim().replace(/\s+/g, ",").split(",").filter(Boolean);
|
|
5749
|
+
for (const ns of split) if (ns[0] === "-") skips.push(ns.slice(1));
|
|
5750
|
+
else names.push(ns);
|
|
5751
|
+
}
|
|
5752
|
+
__name(enable, "enable");
|
|
5753
|
+
function enabled(name) {
|
|
5754
|
+
for (const skip of skips) if (matchesTemplate(name, skip)) return false;
|
|
5755
|
+
for (const ns of names) if (matchesTemplate(name, ns)) return true;
|
|
5756
|
+
return false;
|
|
5757
|
+
}
|
|
5758
|
+
__name(enabled, "enabled");
|
|
5759
|
+
|
|
5760
|
+
// ../../node_modules/obug/dist/browser.js
|
|
5761
|
+
var colors = [
|
|
5762
|
+
"#0000CC",
|
|
5763
|
+
"#0000FF",
|
|
5764
|
+
"#0033CC",
|
|
5765
|
+
"#0033FF",
|
|
5766
|
+
"#0066CC",
|
|
5767
|
+
"#0066FF",
|
|
5768
|
+
"#0099CC",
|
|
5769
|
+
"#0099FF",
|
|
5770
|
+
"#00CC00",
|
|
5771
|
+
"#00CC33",
|
|
5772
|
+
"#00CC66",
|
|
5773
|
+
"#00CC99",
|
|
5774
|
+
"#00CCCC",
|
|
5775
|
+
"#00CCFF",
|
|
5776
|
+
"#3300CC",
|
|
5777
|
+
"#3300FF",
|
|
5778
|
+
"#3333CC",
|
|
5779
|
+
"#3333FF",
|
|
5780
|
+
"#3366CC",
|
|
5781
|
+
"#3366FF",
|
|
5782
|
+
"#3399CC",
|
|
5783
|
+
"#3399FF",
|
|
5784
|
+
"#33CC00",
|
|
5785
|
+
"#33CC33",
|
|
5786
|
+
"#33CC66",
|
|
5787
|
+
"#33CC99",
|
|
5788
|
+
"#33CCCC",
|
|
5789
|
+
"#33CCFF",
|
|
5790
|
+
"#6600CC",
|
|
5791
|
+
"#6600FF",
|
|
5792
|
+
"#6633CC",
|
|
5793
|
+
"#6633FF",
|
|
5794
|
+
"#66CC00",
|
|
5795
|
+
"#66CC33",
|
|
5796
|
+
"#9900CC",
|
|
5797
|
+
"#9900FF",
|
|
5798
|
+
"#9933CC",
|
|
5799
|
+
"#9933FF",
|
|
5800
|
+
"#99CC00",
|
|
5801
|
+
"#99CC33",
|
|
5802
|
+
"#CC0000",
|
|
5803
|
+
"#CC0033",
|
|
5804
|
+
"#CC0066",
|
|
5805
|
+
"#CC0099",
|
|
5806
|
+
"#CC00CC",
|
|
5807
|
+
"#CC00FF",
|
|
5808
|
+
"#CC3300",
|
|
5809
|
+
"#CC3333",
|
|
5810
|
+
"#CC3366",
|
|
5811
|
+
"#CC3399",
|
|
5812
|
+
"#CC33CC",
|
|
5813
|
+
"#CC33FF",
|
|
5814
|
+
"#CC6600",
|
|
5815
|
+
"#CC6633",
|
|
5816
|
+
"#CC9900",
|
|
5817
|
+
"#CC9933",
|
|
5818
|
+
"#CCCC00",
|
|
5819
|
+
"#CCCC33",
|
|
5820
|
+
"#FF0000",
|
|
5821
|
+
"#FF0033",
|
|
5822
|
+
"#FF0066",
|
|
5823
|
+
"#FF0099",
|
|
5824
|
+
"#FF00CC",
|
|
5825
|
+
"#FF00FF",
|
|
5826
|
+
"#FF3300",
|
|
5827
|
+
"#FF3333",
|
|
5828
|
+
"#FF3366",
|
|
5829
|
+
"#FF3399",
|
|
5830
|
+
"#FF33CC",
|
|
5831
|
+
"#FF33FF",
|
|
5832
|
+
"#FF6600",
|
|
5833
|
+
"#FF6633",
|
|
5834
|
+
"#FF9900",
|
|
5835
|
+
"#FF9933",
|
|
5836
|
+
"#FFCC00",
|
|
5837
|
+
"#FFCC33"
|
|
5838
|
+
];
|
|
5839
|
+
function formatArgs(diff, args) {
|
|
5840
|
+
const { useColors } = this;
|
|
5841
|
+
args[0] = `${(useColors ? "%c" : "") + this.namespace + (useColors ? " %c" : " ") + args[0] + (useColors ? "%c " : " ")}+${this.humanize(diff)}`;
|
|
5842
|
+
if (!useColors) return;
|
|
5843
|
+
const c = `color: ${this.color}`;
|
|
5844
|
+
args.splice(1, 0, c, "color: inherit");
|
|
5845
|
+
let index = 0;
|
|
5846
|
+
let lastC = 0;
|
|
5847
|
+
args[0].replace(/%[a-z%]/gi, (match2) => {
|
|
5848
|
+
if (match2 === "%%") return;
|
|
5849
|
+
index++;
|
|
5850
|
+
if (match2 === "%c") lastC = index;
|
|
5851
|
+
});
|
|
5852
|
+
args.splice(lastC, 0, c);
|
|
5853
|
+
}
|
|
5854
|
+
__name(formatArgs, "formatArgs");
|
|
5855
|
+
var log = console.debug || console.log || (() => {
|
|
5856
|
+
});
|
|
5857
|
+
var storage = localstorage();
|
|
5858
|
+
var defaultOptions2 = {
|
|
5859
|
+
useColors: true,
|
|
5860
|
+
formatArgs,
|
|
5861
|
+
formatters: {
|
|
5862
|
+
/**
|
|
5863
|
+
* Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
|
|
5864
|
+
*/
|
|
5865
|
+
j(v) {
|
|
5866
|
+
try {
|
|
5867
|
+
return JSON.stringify(v);
|
|
5868
|
+
} catch (error2) {
|
|
5869
|
+
return `[UnexpectedJSONParseError]: ${error2.message}`;
|
|
5870
|
+
}
|
|
5871
|
+
}
|
|
5872
|
+
},
|
|
5873
|
+
inspectOpts: {},
|
|
5874
|
+
humanize,
|
|
5875
|
+
log
|
|
5876
|
+
};
|
|
5877
|
+
function createDebug2(namespace, options) {
|
|
5878
|
+
var _ref;
|
|
5879
|
+
const color = (_ref = options && options.color) !== null && _ref !== void 0 ? _ref : selectColor(colors, namespace);
|
|
5880
|
+
return createDebug(namespace, Object.assign(defaultOptions2, { color }, options));
|
|
5881
|
+
}
|
|
5882
|
+
__name(createDebug2, "createDebug");
|
|
5883
|
+
function localstorage() {
|
|
5884
|
+
try {
|
|
5885
|
+
return localStorage;
|
|
5886
|
+
} catch (_unused) {
|
|
5887
|
+
}
|
|
5888
|
+
}
|
|
5889
|
+
__name(localstorage, "localstorage");
|
|
5890
|
+
function load() {
|
|
5891
|
+
let r;
|
|
5892
|
+
try {
|
|
5893
|
+
r = storage.getItem("debug") || storage.getItem("DEBUG");
|
|
5894
|
+
} catch (_unused2) {
|
|
5895
|
+
}
|
|
5896
|
+
if (!r && typeof process !== "undefined" && "env" in process) r = process.env.DEBUG;
|
|
5897
|
+
return r || "";
|
|
5898
|
+
}
|
|
5899
|
+
__name(load, "load");
|
|
5900
|
+
enable(load());
|
|
5901
|
+
|
|
5902
|
+
// ../../src/Util/IsBuildAwesome.js
|
|
5903
|
+
function isUsingBuildAwesome() {
|
|
5904
|
+
return process?.env?.BUILDAWESOME_PACKAGE === "@awesome.me/buildawesome";
|
|
5905
|
+
}
|
|
5906
|
+
__name(isUsingBuildAwesome, "isUsingBuildAwesome");
|
|
5907
|
+
|
|
5908
|
+
// ../../src/Util/DebugLogUtil.js
|
|
5909
|
+
var PREFIX = isUsingBuildAwesome() ? "BuildAwesome:" : "Eleventy:";
|
|
5910
|
+
function createDebug3(name) {
|
|
5911
|
+
return createDebug2(`${PREFIX}:${name}`);
|
|
5546
5912
|
}
|
|
5547
|
-
__name(
|
|
5913
|
+
__name(createDebug3, "createDebug");
|
|
5548
5914
|
|
|
5549
|
-
// ../../src/Errors/
|
|
5550
|
-
var
|
|
5915
|
+
// ../../src/Errors/BaseError.js
|
|
5916
|
+
var BaseError = class extends Error {
|
|
5551
5917
|
static {
|
|
5552
|
-
__name(this, "
|
|
5918
|
+
__name(this, "BaseError");
|
|
5553
5919
|
}
|
|
5554
5920
|
/**
|
|
5555
5921
|
* @param {string} message - The error message to display.
|
|
5556
|
-
* @param {
|
|
5922
|
+
* @param {Error} [originalError] - The original error caught.
|
|
5557
5923
|
*/
|
|
5558
5924
|
constructor(message, originalError) {
|
|
5559
5925
|
if (originalError) {
|
|
@@ -5570,15 +5936,14 @@ var EleventyBaseError = class extends Error {
|
|
|
5570
5936
|
}
|
|
5571
5937
|
}
|
|
5572
5938
|
};
|
|
5573
|
-
var EleventyBaseError_default = EleventyBaseError;
|
|
5574
5939
|
|
|
5575
5940
|
// ../../src/Engines/TemplateEngine.js
|
|
5576
|
-
var TemplateEngineConfigError = class extends
|
|
5941
|
+
var TemplateEngineConfigError = class extends BaseError {
|
|
5577
5942
|
static {
|
|
5578
5943
|
__name(this, "TemplateEngineConfigError");
|
|
5579
5944
|
}
|
|
5580
5945
|
};
|
|
5581
|
-
var debug =
|
|
5946
|
+
var debug = createDebug3("TemplateEngine");
|
|
5582
5947
|
var AMENDED_INSTANCES = /* @__PURE__ */ new Set();
|
|
5583
5948
|
var TemplateEngine = class {
|
|
5584
5949
|
static {
|