@unmail/react 0.1.1 → 0.1.2
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/index.d.ts +0 -2
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +505 -569
- package/dist/index.js.map +1 -0
- package/package.json +4 -9
- package/dist/index.d.mts +0 -5120
- package/dist/index.d.mts.map +0 -1
- package/dist/index.mjs +0 -20861
- package/dist/index.mjs.map +0 -1
- /package/dist/{chunk-z5eko27R.mjs → chunk-Bp6m_JJh.js} +0 -0
package/dist/index.js
CHANGED
|
@@ -1,54 +1,15 @@
|
|
|
1
|
-
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
});
|
|
14
|
-
return target;
|
|
15
|
-
};
|
|
16
|
-
var __copyProps = (to, from, except, desc) => {
|
|
17
|
-
if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
|
|
18
|
-
key = keys[i];
|
|
19
|
-
if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
|
|
20
|
-
get: ((k) => from[k]).bind(null, key),
|
|
21
|
-
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
|
|
22
|
-
});
|
|
23
|
-
}
|
|
24
|
-
return to;
|
|
25
|
-
};
|
|
26
|
-
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
|
|
27
|
-
value: mod,
|
|
28
|
-
enumerable: true
|
|
29
|
-
}) : target, mod));
|
|
30
|
-
|
|
31
|
-
//#endregion
|
|
32
|
-
let react = require("react");
|
|
33
|
-
react = __toESM(react);
|
|
34
|
-
let react_jsx_runtime = require("react/jsx-runtime");
|
|
35
|
-
react_jsx_runtime = __toESM(react_jsx_runtime);
|
|
36
|
-
let prismjs = require("prismjs");
|
|
37
|
-
prismjs = __toESM(prismjs);
|
|
38
|
-
let marked = require("marked");
|
|
39
|
-
marked = __toESM(marked);
|
|
40
|
-
let html_to_text = require("html-to-text");
|
|
41
|
-
html_to_text = __toESM(html_to_text);
|
|
42
|
-
let prettier_standalone = require("prettier/standalone");
|
|
43
|
-
prettier_standalone = __toESM(prettier_standalone);
|
|
44
|
-
let prettier_plugins_html = require("prettier/plugins/html");
|
|
45
|
-
prettier_plugins_html = __toESM(prettier_plugins_html);
|
|
46
|
-
let node_stream = require("node:stream");
|
|
47
|
-
node_stream = __toESM(node_stream);
|
|
48
|
-
let css_tree = require("css-tree");
|
|
49
|
-
css_tree = __toESM(css_tree);
|
|
50
|
-
let tailwindcss = require("tailwindcss");
|
|
51
|
-
tailwindcss = __toESM(tailwindcss);
|
|
1
|
+
import { t as __export } from "./chunk-Bp6m_JJh.js";
|
|
2
|
+
import * as React$1 from "react";
|
|
3
|
+
import React, { Suspense } from "react";
|
|
4
|
+
import { Fragment, jsx, jsxs } from "react/jsx-runtime";
|
|
5
|
+
import * as PrismImport from "prismjs";
|
|
6
|
+
import { Renderer, marked } from "marked";
|
|
7
|
+
import { convert } from "html-to-text";
|
|
8
|
+
import * as prettier from "prettier/standalone";
|
|
9
|
+
import * as prettierHtml from "prettier/plugins/html";
|
|
10
|
+
import { Writable } from "node:stream";
|
|
11
|
+
import { List, clone, find, generate, parse, string, walk } from "css-tree";
|
|
12
|
+
import { compile } from "tailwindcss";
|
|
52
13
|
|
|
53
14
|
//#region src/components/body.tsx
|
|
54
15
|
const marginProperties = [
|
|
@@ -64,24 +25,24 @@ const marginProperties = [
|
|
|
64
25
|
"marginInlineStart",
|
|
65
26
|
"marginInlineEnd"
|
|
66
27
|
];
|
|
67
|
-
const Body =
|
|
28
|
+
const Body = React$1.forwardRef(({ children, style,...props }, ref) => {
|
|
68
29
|
const bodyStyle = {
|
|
69
30
|
background: style?.background,
|
|
70
31
|
backgroundColor: style?.backgroundColor
|
|
71
32
|
};
|
|
72
33
|
if (style) for (const property of marginProperties) bodyStyle[property] = style[property] !== void 0 ? 0 : void 0;
|
|
73
|
-
return /* @__PURE__ */
|
|
34
|
+
return /* @__PURE__ */ jsx("body", {
|
|
74
35
|
...props,
|
|
75
36
|
style: bodyStyle,
|
|
76
37
|
ref,
|
|
77
|
-
children: /* @__PURE__ */
|
|
38
|
+
children: /* @__PURE__ */ jsx("table", {
|
|
78
39
|
border: 0,
|
|
79
40
|
width: "100%",
|
|
80
41
|
cellPadding: "0",
|
|
81
42
|
cellSpacing: "0",
|
|
82
43
|
role: "presentation",
|
|
83
44
|
align: "center",
|
|
84
|
-
children: /* @__PURE__ */
|
|
45
|
+
children: /* @__PURE__ */ jsx("tbody", { children: /* @__PURE__ */ jsx("tr", { children: /* @__PURE__ */ jsx("td", {
|
|
85
46
|
style,
|
|
86
47
|
children
|
|
87
48
|
}) }) })
|
|
@@ -189,12 +150,12 @@ function computeFontWidthAndSpaceCount(expectedWidth) {
|
|
|
189
150
|
while (computeRequiredFontWidth() > maxFontWidth) smallestSpaceCount++;
|
|
190
151
|
return [computeRequiredFontWidth(), smallestSpaceCount];
|
|
191
152
|
}
|
|
192
|
-
const Button =
|
|
153
|
+
const Button = React$1.forwardRef(({ children, style, target = "_blank",...props }, ref) => {
|
|
193
154
|
const { paddingTop, paddingRight, paddingBottom, paddingLeft } = parsePadding(style ?? {});
|
|
194
155
|
const textRaise = pxToPt((paddingTop ?? 0) + (paddingBottom ?? 0));
|
|
195
156
|
const [plFontWidth, plSpaceCount] = computeFontWidthAndSpaceCount(paddingLeft ?? 0);
|
|
196
157
|
const [prFontWidth, prSpaceCount] = computeFontWidthAndSpaceCount(paddingRight ?? 0);
|
|
197
|
-
return /* @__PURE__ */
|
|
158
|
+
return /* @__PURE__ */ jsxs("a", {
|
|
198
159
|
...props,
|
|
199
160
|
ref,
|
|
200
161
|
style: {
|
|
@@ -211,8 +172,8 @@ const Button = react.forwardRef(({ children, style, target = "_blank",...props }
|
|
|
211
172
|
},
|
|
212
173
|
target,
|
|
213
174
|
children: [
|
|
214
|
-
/* @__PURE__ */
|
|
215
|
-
/* @__PURE__ */
|
|
175
|
+
/* @__PURE__ */ jsx("span", { dangerouslySetInnerHTML: { __html: `<!--[if mso]><i style="mso-font-width:${plFontWidth * 100}%;mso-text-raise:${textRaise}" hidden>${" ".repeat(plSpaceCount)}</i><![endif]-->` } }),
|
|
176
|
+
/* @__PURE__ */ jsx("span", {
|
|
216
177
|
style: {
|
|
217
178
|
maxWidth: "100%",
|
|
218
179
|
display: "inline-block",
|
|
@@ -222,7 +183,7 @@ const Button = react.forwardRef(({ children, style, target = "_blank",...props }
|
|
|
222
183
|
},
|
|
223
184
|
children
|
|
224
185
|
}),
|
|
225
|
-
/* @__PURE__ */
|
|
186
|
+
/* @__PURE__ */ jsx("span", { dangerouslySetInnerHTML: { __html: `<!--[if mso]><i style="mso-font-width:${prFontWidth * 100}%" hidden>${" ".repeat(prSpaceCount)}​</i><![endif]-->` } })
|
|
226
187
|
]
|
|
227
188
|
});
|
|
228
189
|
});
|
|
@@ -230,8 +191,8 @@ Button.displayName = "Button";
|
|
|
230
191
|
|
|
231
192
|
//#endregion
|
|
232
193
|
//#region src/components/prism.ts
|
|
233
|
-
const Prism =
|
|
234
|
-
Prism.languages.markup = {
|
|
194
|
+
const Prism$1 = PrismImport.default ?? PrismImport;
|
|
195
|
+
Prism$1.languages.markup = {
|
|
235
196
|
comment: {
|
|
236
197
|
pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
|
|
237
198
|
greedy: !0
|
|
@@ -296,19 +257,19 @@ Prism.languages.markup = {
|
|
|
296
257
|
pattern: /&[\da-z]{1,8};/i,
|
|
297
258
|
alias: "named-entity"
|
|
298
259
|
}, /&#x?[\da-f]{1,8};/i]
|
|
299
|
-
}, Prism.languages.markup.tag.inside["attr-value"].inside.entity = Prism.languages.markup.entity, Prism.languages.markup.doctype.inside["internal-subset"].inside = Prism.languages.markup, Prism.hooks.add("wrap", function(e) {
|
|
260
|
+
}, Prism$1.languages.markup.tag.inside["attr-value"].inside.entity = Prism$1.languages.markup.entity, Prism$1.languages.markup.doctype.inside["internal-subset"].inside = Prism$1.languages.markup, Prism$1.hooks.add("wrap", function(e) {
|
|
300
261
|
"entity" === e.type && (e.attributes.title = e.content.replace(/&/, "&"));
|
|
301
|
-
}), Object.defineProperty(Prism.languages.markup.tag, "addInlined", { value: function(e, t) {
|
|
262
|
+
}), Object.defineProperty(Prism$1.languages.markup.tag, "addInlined", { value: function(e, t) {
|
|
302
263
|
var n = {}, n = (n["language-" + t] = {
|
|
303
264
|
pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
|
|
304
265
|
lookbehind: !0,
|
|
305
|
-
inside: Prism.languages[t]
|
|
266
|
+
inside: Prism$1.languages[t]
|
|
306
267
|
}, n.cdata = /^<!\[CDATA\[|\]\]>$/i, { "included-cdata": {
|
|
307
268
|
pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
|
|
308
269
|
inside: n
|
|
309
270
|
} }), t = (n["language-" + t] = {
|
|
310
271
|
pattern: /[\s\S]+/,
|
|
311
|
-
inside: Prism.languages[t]
|
|
272
|
+
inside: Prism$1.languages[t]
|
|
312
273
|
}, {});
|
|
313
274
|
t[e] = {
|
|
314
275
|
pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function() {
|
|
@@ -317,9 +278,9 @@ Prism.languages.markup = {
|
|
|
317
278
|
lookbehind: !0,
|
|
318
279
|
greedy: !0,
|
|
319
280
|
inside: n
|
|
320
|
-
}, Prism.languages.insertBefore("markup", "cdata", t);
|
|
321
|
-
} }), Object.defineProperty(Prism.languages.markup.tag, "addAttribute", { value: function(e, t) {
|
|
322
|
-
Prism.languages.markup.tag.inside["special-attr"].push({
|
|
281
|
+
}, Prism$1.languages.insertBefore("markup", "cdata", t);
|
|
282
|
+
} }), Object.defineProperty(Prism$1.languages.markup.tag, "addAttribute", { value: function(e, t) {
|
|
283
|
+
Prism$1.languages.markup.tag.inside["special-attr"].push({
|
|
323
284
|
pattern: RegExp(/(^|["'\s])/.source + "(?:" + e + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source, "i"),
|
|
324
285
|
lookbehind: !0,
|
|
325
286
|
inside: {
|
|
@@ -331,7 +292,7 @@ Prism.languages.markup = {
|
|
|
331
292
|
pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
|
|
332
293
|
lookbehind: !0,
|
|
333
294
|
alias: [t, "language-" + t],
|
|
334
|
-
inside: Prism.languages[t]
|
|
295
|
+
inside: Prism$1.languages[t]
|
|
335
296
|
},
|
|
336
297
|
punctuation: [{
|
|
337
298
|
pattern: /^=/,
|
|
@@ -341,7 +302,7 @@ Prism.languages.markup = {
|
|
|
341
302
|
}
|
|
342
303
|
}
|
|
343
304
|
});
|
|
344
|
-
} }), Prism.languages.html = Prism.languages.markup, Prism.languages.mathml = Prism.languages.markup, Prism.languages.svg = Prism.languages.markup, Prism.languages.xml = Prism.languages.extend("markup", {}), Prism.languages.ssml = Prism.languages.xml, Prism.languages.atom = Prism.languages.xml, Prism.languages.rss = Prism.languages.xml, (function(e) {
|
|
305
|
+
} }), Prism$1.languages.html = Prism$1.languages.markup, Prism$1.languages.mathml = Prism$1.languages.markup, Prism$1.languages.svg = Prism$1.languages.markup, Prism$1.languages.xml = Prism$1.languages.extend("markup", {}), Prism$1.languages.ssml = Prism$1.languages.xml, Prism$1.languages.atom = Prism$1.languages.xml, Prism$1.languages.rss = Prism$1.languages.xml, (function(e) {
|
|
345
306
|
var t = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/, t = (e.languages.css = {
|
|
346
307
|
comment: /\/\*[\s\S]*?\*\//,
|
|
347
308
|
atrule: {
|
|
@@ -391,7 +352,7 @@ Prism.languages.markup = {
|
|
|
391
352
|
punctuation: /[(){};:,]/
|
|
392
353
|
}, e.languages.css.atrule.inside.rest = e.languages.css, e.languages.markup);
|
|
393
354
|
t && (t.tag.addInlined("style", "css"), t.tag.addAttribute("style", "css"));
|
|
394
|
-
})(Prism), Prism.languages.clike = {
|
|
355
|
+
})(Prism$1), Prism$1.languages.clike = {
|
|
395
356
|
comment: [{
|
|
396
357
|
pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
|
|
397
358
|
lookbehind: !0,
|
|
@@ -492,8 +453,8 @@ Prism.languages.markup = {
|
|
|
492
453
|
alias: "keyword"
|
|
493
454
|
}
|
|
494
455
|
};
|
|
495
|
-
})(Prism), Prism.languages.javascript = Prism.languages.extend("clike", {
|
|
496
|
-
"class-name": [Prism.languages.clike["class-name"], {
|
|
456
|
+
})(Prism$1), Prism$1.languages.javascript = Prism$1.languages.extend("clike", {
|
|
457
|
+
"class-name": [Prism$1.languages.clike["class-name"], {
|
|
497
458
|
pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
|
|
498
459
|
lookbehind: !0
|
|
499
460
|
}],
|
|
@@ -510,7 +471,7 @@ Prism.languages.markup = {
|
|
|
510
471
|
lookbehind: !0
|
|
511
472
|
},
|
|
512
473
|
operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
|
|
513
|
-
}), Prism.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/, Prism.languages.insertBefore("javascript", "keyword", {
|
|
474
|
+
}), Prism$1.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/, Prism$1.languages.insertBefore("javascript", "keyword", {
|
|
514
475
|
regex: {
|
|
515
476
|
pattern: RegExp(/((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source + /\//.source + "(?:" + /(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/.source + "|" + /(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/.source + ")" + /(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source),
|
|
516
477
|
lookbehind: !0,
|
|
@@ -520,7 +481,7 @@ Prism.languages.markup = {
|
|
|
520
481
|
pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
|
|
521
482
|
lookbehind: !0,
|
|
522
483
|
alias: "language-regex",
|
|
523
|
-
inside: Prism.languages.regex
|
|
484
|
+
inside: Prism$1.languages.regex
|
|
524
485
|
},
|
|
525
486
|
"regex-delimiter": /^\/|\/$/,
|
|
526
487
|
"regex-flags": /^[a-z]+$/
|
|
@@ -534,26 +495,26 @@ Prism.languages.markup = {
|
|
|
534
495
|
{
|
|
535
496
|
pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
|
|
536
497
|
lookbehind: !0,
|
|
537
|
-
inside: Prism.languages.javascript
|
|
498
|
+
inside: Prism$1.languages.javascript
|
|
538
499
|
},
|
|
539
500
|
{
|
|
540
501
|
pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
|
|
541
502
|
lookbehind: !0,
|
|
542
|
-
inside: Prism.languages.javascript
|
|
503
|
+
inside: Prism$1.languages.javascript
|
|
543
504
|
},
|
|
544
505
|
{
|
|
545
506
|
pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
|
|
546
507
|
lookbehind: !0,
|
|
547
|
-
inside: Prism.languages.javascript
|
|
508
|
+
inside: Prism$1.languages.javascript
|
|
548
509
|
},
|
|
549
510
|
{
|
|
550
511
|
pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,
|
|
551
512
|
lookbehind: !0,
|
|
552
|
-
inside: Prism.languages.javascript
|
|
513
|
+
inside: Prism$1.languages.javascript
|
|
553
514
|
}
|
|
554
515
|
],
|
|
555
516
|
constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
|
|
556
|
-
}), Prism.languages.insertBefore("javascript", "string", {
|
|
517
|
+
}), Prism$1.languages.insertBefore("javascript", "string", {
|
|
557
518
|
hashbang: {
|
|
558
519
|
pattern: /^#!.*/,
|
|
559
520
|
greedy: !0,
|
|
@@ -575,7 +536,7 @@ Prism.languages.markup = {
|
|
|
575
536
|
pattern: /^\$\{|\}$/,
|
|
576
537
|
alias: "punctuation"
|
|
577
538
|
},
|
|
578
|
-
rest: Prism.languages.javascript
|
|
539
|
+
rest: Prism$1.languages.javascript
|
|
579
540
|
}
|
|
580
541
|
},
|
|
581
542
|
string: /[\s\S]+/
|
|
@@ -587,11 +548,11 @@ Prism.languages.markup = {
|
|
|
587
548
|
greedy: !0,
|
|
588
549
|
alias: "property"
|
|
589
550
|
}
|
|
590
|
-
}), Prism.languages.insertBefore("javascript", "operator", { "literal-property": {
|
|
551
|
+
}), Prism$1.languages.insertBefore("javascript", "operator", { "literal-property": {
|
|
591
552
|
pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
|
|
592
553
|
lookbehind: !0,
|
|
593
554
|
alias: "property"
|
|
594
|
-
} }), Prism.languages.markup && (Prism.languages.markup.tag.addInlined("script", "javascript"), Prism.languages.markup.tag.addAttribute(/on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source, "javascript")), Prism.languages.js = Prism.languages.javascript, Prism.languages.abap = {
|
|
555
|
+
} }), Prism$1.languages.markup && (Prism$1.languages.markup.tag.addInlined("script", "javascript"), Prism$1.languages.markup.tag.addAttribute(/on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source, "javascript")), Prism$1.languages.js = Prism$1.languages.javascript, Prism$1.languages.abap = {
|
|
595
556
|
comment: /^\*.*/m,
|
|
596
557
|
string: /(`|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
|
|
597
558
|
"string-template": {
|
|
@@ -629,7 +590,7 @@ Prism.languages.markup = {
|
|
|
629
590
|
punctuation: /[,.:()]/
|
|
630
591
|
}, (function() {
|
|
631
592
|
var e = "(?:ALPHA|BIT|CHAR|CR|CRLF|CTL|DIGIT|DQUOTE|HEXDIG|HTAB|LF|LWSP|OCTET|SP|VCHAR|WSP)";
|
|
632
|
-
Prism.languages.abnf = {
|
|
593
|
+
Prism$1.languages.abnf = {
|
|
633
594
|
comment: /;.*/,
|
|
634
595
|
string: {
|
|
635
596
|
pattern: /(?:%[is])?"[^"\n\r]*"/,
|
|
@@ -669,14 +630,14 @@ Prism.languages.markup = {
|
|
|
669
630
|
operator: /=\/?|\//,
|
|
670
631
|
punctuation: /[()\[\]]/
|
|
671
632
|
};
|
|
672
|
-
})(), Prism.languages.actionscript = Prism.languages.extend("javascript", {
|
|
633
|
+
})(), Prism$1.languages.actionscript = Prism$1.languages.extend("javascript", {
|
|
673
634
|
keyword: /\b(?:as|break|case|catch|class|const|default|delete|do|dynamic|each|else|extends|final|finally|for|function|get|if|implements|import|in|include|instanceof|interface|internal|is|namespace|native|new|null|override|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|use|var|void|while|with)\b/,
|
|
674
635
|
operator: /\+\+|--|(?:[+\-*\/%^]|&&?|\|\|?|<<?|>>?>?|[!=]=?)=?|[~?@]/
|
|
675
|
-
}), Prism.languages.actionscript["class-name"].alias = "function", delete Prism.languages.actionscript.parameter, delete Prism.languages.actionscript["literal-property"], Prism.languages.markup && Prism.languages.insertBefore("actionscript", "string", { xml: {
|
|
636
|
+
}), Prism$1.languages.actionscript["class-name"].alias = "function", delete Prism$1.languages.actionscript.parameter, delete Prism$1.languages.actionscript["literal-property"], Prism$1.languages.markup && Prism$1.languages.insertBefore("actionscript", "string", { xml: {
|
|
676
637
|
pattern: /(^|[^.])<\/?\w+(?:\s+[^\s>\/=]+=("|')(?:\\[\s\S]|(?!\2)[^\\])*\2)*\s*\/?>/,
|
|
677
638
|
lookbehind: !0,
|
|
678
|
-
inside: Prism.languages.markup
|
|
679
|
-
} }), Prism.languages.ada = {
|
|
639
|
+
inside: Prism$1.languages.markup
|
|
640
|
+
} }), Prism$1.languages.ada = {
|
|
680
641
|
comment: /--.*/,
|
|
681
642
|
string: /"(?:""|[^"\r\f\n])*"/,
|
|
682
643
|
number: [{ pattern: /\b\d(?:_?\d)*#[\dA-F](?:_?[\dA-F])*(?:\.[\dA-F](?:_?[\dA-F])*)?#(?:E[+-]?\d(?:_?\d)*)?/i }, { pattern: /\b\d(?:_?\d)*(?:\.\d(?:_?\d)*)?(?:E[+-]?\d(?:_?\d)*)?\b/i }],
|
|
@@ -690,7 +651,7 @@ Prism.languages.markup = {
|
|
|
690
651
|
punctuation: /\.\.?|[,;():]/,
|
|
691
652
|
char: /'.'/,
|
|
692
653
|
variable: /\b[a-z](?:\w)*\b/i
|
|
693
|
-
}, Prism.languages.agda = {
|
|
654
|
+
}, Prism$1.languages.agda = {
|
|
694
655
|
comment: /\{-[\s\S]*?(?:-\}|$)|--.*/,
|
|
695
656
|
string: {
|
|
696
657
|
pattern: /"(?:\\(?:\r\n|[\s\S])|[^\\\r\n"])*"/,
|
|
@@ -710,7 +671,7 @@ Prism.languages.markup = {
|
|
|
710
671
|
lookbehind: !0
|
|
711
672
|
},
|
|
712
673
|
keyword: /\b(?:Set|abstract|constructor|data|eta-equality|field|forall|hiding|import|in|inductive|infix|infixl|infixr|instance|let|macro|module|mutual|no-eta-equality|open|overlap|pattern|postulate|primitive|private|public|quote|quoteContext|quoteGoal|quoteTerm|record|renaming|rewrite|syntax|tactic|unquote|unquoteDecl|unquoteDef|using|variable|where|with)\b/
|
|
713
|
-
}, Prism.languages.al = {
|
|
674
|
+
}, Prism$1.languages.al = {
|
|
714
675
|
comment: /\/\/.*|\/\*[\s\S]*?\*\//,
|
|
715
676
|
string: {
|
|
716
677
|
pattern: /'(?:''|[^'\r\n])*'(?!')|"(?:""|[^"\r\n])*"(?!")/,
|
|
@@ -727,7 +688,7 @@ Prism.languages.markup = {
|
|
|
727
688
|
"class-name": /\b(?:automation|biginteger|bigtext|blob|boolean|byte|char|clienttype|code|completiontriggererrorlevel|connectiontype|database|dataclassification|datascope|date|dateformula|datetime|decimal|defaultlayout|dialog|dictionary|dotnetassembly|dotnettypedeclaration|duration|errorinfo|errortype|executioncontext|executionmode|fieldclass|fieldref|fieldtype|file|filterpagebuilder|guid|httpclient|httpcontent|httpheaders|httprequestmessage|httpresponsemessage|instream|integer|joker|jsonarray|jsonobject|jsontoken|jsonvalue|keyref|list|moduledependencyinfo|moduleinfo|none|notification|notificationscope|objecttype|option|outstream|pageresult|record|recordid|recordref|reportformat|securityfilter|sessionsettings|tableconnectiontype|tablefilter|testaction|testfield|testfilterfield|testpage|testpermissions|testrequestpage|text|textbuilder|textconst|textencoding|time|transactionmodel|transactiontype|variant|verbosity|version|view|views|webserviceactioncontext|webserviceactionresultcode|xmlattribute|xmlattributecollection|xmlcdata|xmlcomment|xmldeclaration|xmldocument|xmldocumenttype|xmlelement|xmlnamespacemanager|xmlnametable|xmlnode|xmlnodelist|xmlprocessinginstruction|xmlreadoptions|xmltext|xmlwriteoptions)\b/i,
|
|
728
689
|
operator: /\.\.|:[=:]|[-+*/]=?|<>|[<>]=?|=|\b(?:and|div|mod|not|or|xor)\b/i,
|
|
729
690
|
punctuation: /[()\[\]{}:.;,]/
|
|
730
|
-
}, Prism.languages.antlr4 = {
|
|
691
|
+
}, Prism$1.languages.antlr4 = {
|
|
731
692
|
comment: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
|
|
732
693
|
string: {
|
|
733
694
|
pattern: /'(?:\\.|[^\\'\r\n])*'/,
|
|
@@ -785,7 +746,7 @@ Prism.languages.markup = {
|
|
|
785
746
|
constant: /\b[A-Z][A-Z_]*\b/,
|
|
786
747
|
operator: /\.\.|->|[|~]|[*+?]\??/,
|
|
787
748
|
punctuation: /[;:()=]/
|
|
788
|
-
}, Prism.languages.g4 = Prism.languages.antlr4, Prism.languages.apacheconf = {
|
|
749
|
+
}, Prism$1.languages.g4 = Prism$1.languages.antlr4, Prism$1.languages.apacheconf = {
|
|
789
750
|
comment: /#.*/,
|
|
790
751
|
"directive-inline": {
|
|
791
752
|
pattern: /(^[\t ]*)\b(?:AcceptFilter|AcceptPathInfo|AccessFileName|Action|Add(?:Alt|AltByEncoding|AltByType|Charset|DefaultCharset|Description|Encoding|Handler|Icon|IconByEncoding|IconByType|InputFilter|Language|ModuleInfo|OutputFilter|OutputFilterByType|Type)|Alias|AliasMatch|Allow(?:CONNECT|EncodedSlashes|Methods|Override|OverrideList)?|Anonymous(?:_LogEmail|_MustGiveEmail|_NoUserID|_VerifyEmail)?|AsyncRequestWorkerFactor|Auth(?:BasicAuthoritative|BasicFake|BasicProvider|BasicUseDigestAlgorithm|DBDUserPWQuery|DBDUserRealmQuery|DBMGroupFile|DBMType|DBMUserFile|Digest(?:Algorithm|Domain|NonceLifetime|Provider|Qop|ShmemSize)|Form(?:Authoritative|Body|DisableNoStore|FakeBasicAuth|Location|LoginRequiredLocation|LoginSuccessLocation|LogoutLocation|Method|Mimetype|Password|Provider|SitePassphrase|Size|Username)|GroupFile|LDAP(?:AuthorizePrefix|BindAuthoritative|BindDN|BindPassword|CharsetConfig|CompareAsUser|CompareDNOnServer|DereferenceAliases|GroupAttribute|GroupAttributeIsDN|InitialBindAsUser|InitialBindPattern|MaxSubGroupDepth|RemoteUserAttribute|RemoteUserIsDN|SearchAsUser|SubGroupAttribute|SubGroupClass|Url)|Merging|Name|nCache(?:Context|Enable|ProvideFor|SOCache|Timeout)|nzFcgiCheckAuthnProvider|nzFcgiDefineProvider|Type|UserFile|zDBDLoginToReferer|zDBDQuery|zDBDRedirectQuery|zDBMType|zSendForbiddenOnFailure)|BalancerGrowth|BalancerInherit|BalancerMember|BalancerPersist|BrowserMatch|BrowserMatchNoCase|BufferedLogs|BufferSize|Cache(?:DefaultExpire|DetailHeader|DirLength|DirLevels|Disable|Enable|File|Header|IgnoreCacheControl|IgnoreHeaders|IgnoreNoLastMod|IgnoreQueryString|IgnoreURLSessionIdentifiers|KeyBaseURL|LastModifiedFactor|Lock|LockMaxAge|LockPath|MaxExpire|MaxFileSize|MinExpire|MinFileSize|NegotiatedDocs|QuickHandler|ReadSize|ReadTime|Root|Socache(?:MaxSize|MaxTime|MinTime|ReadSize|ReadTime)?|StaleOnError|StoreExpired|StoreNoStore|StorePrivate)|CGIDScriptTimeout|CGIMapExtension|CharsetDefault|CharsetOptions|CharsetSourceEnc|CheckCaseOnly|CheckSpelling|ChrootDir|ContentDigest|CookieDomain|CookieExpires|CookieName|CookieStyle|CookieTracking|CoreDumpDirectory|CustomLog|Dav|DavDepthInfinity|DavGenericLockDB|DavLockDB|DavMinTimeout|DBDExptime|DBDInitSQL|DBDKeep|DBDMax|DBDMin|DBDParams|DBDPersist|DBDPrepareSQL|DBDriver|DefaultIcon|DefaultLanguage|DefaultRuntimeDir|DefaultType|Define|Deflate(?:BufferSize|CompressionLevel|FilterNote|InflateLimitRequestBody|InflateRatio(?:Burst|Limit)|MemLevel|WindowSize)|Deny|DirectoryCheckHandler|DirectoryIndex|DirectoryIndexRedirect|DirectorySlash|DocumentRoot|DTracePrivileges|DumpIOInput|DumpIOOutput|EnableExceptionHook|EnableMMAP|EnableSendfile|Error|ErrorDocument|ErrorLog|ErrorLogFormat|Example|ExpiresActive|ExpiresByType|ExpiresDefault|ExtendedStatus|ExtFilterDefine|ExtFilterOptions|FallbackResource|FileETag|FilterChain|FilterDeclare|FilterProtocol|FilterProvider|FilterTrace|ForceLanguagePriority|ForceType|ForensicLog|GprofDir|GracefulShutdownTimeout|Group|Header|HeaderName|Heartbeat(?:Address|Listen|MaxServers|Storage)|HostnameLookups|IdentityCheck|IdentityCheckTimeout|ImapBase|ImapDefault|ImapMenu|Include|IncludeOptional|Index(?:HeadInsert|Ignore|IgnoreReset|Options|OrderDefault|StyleSheet)|InputSed|ISAPI(?:AppendLogToErrors|AppendLogToQuery|CacheFile|FakeAsync|LogNotSupported|ReadAheadBuffer)|KeepAlive|KeepAliveTimeout|KeptBodySize|LanguagePriority|LDAP(?:CacheEntries|CacheTTL|ConnectionPoolTTL|ConnectionTimeout|LibraryDebug|OpCacheEntries|OpCacheTTL|ReferralHopLimit|Referrals|Retries|RetryDelay|SharedCacheFile|SharedCacheSize|Timeout|TrustedClientCert|TrustedGlobalCert|TrustedMode|VerifyServerCert)|Limit(?:InternalRecursion|Request(?:Body|Fields|FieldSize|Line)|XMLRequestBody)|Listen|ListenBackLog|LoadFile|LoadModule|LogFormat|LogLevel|LogMessage|LuaAuthzProvider|LuaCodeCache|Lua(?:Hook(?:AccessChecker|AuthChecker|CheckUserID|Fixups|InsertFilter|Log|MapToStorage|TranslateName|TypeChecker)|Inherit|InputFilter|MapHandler|OutputFilter|PackageCPath|PackagePath|QuickHandler|Root|Scope)|Max(?:ConnectionsPerChild|KeepAliveRequests|MemFree|RangeOverlaps|RangeReversals|Ranges|RequestWorkers|SpareServers|SpareThreads|Threads)|MergeTrailers|MetaDir|MetaFiles|MetaSuffix|MimeMagicFile|MinSpareServers|MinSpareThreads|MMapFile|ModemStandard|ModMimeUsePathInfo|MultiviewsMatch|Mutex|NameVirtualHost|NoProxy|NWSSLTrustedCerts|NWSSLUpgradeable|Options|Order|OutputSed|PassEnv|PidFile|PrivilegesMode|Protocol|ProtocolEcho|Proxy(?:AddHeaders|BadHeader|Block|Domain|ErrorOverride|ExpressDBMFile|ExpressDBMType|ExpressEnable|FtpDirCharset|FtpEscapeWildcards|FtpListOnWildcard|HTML(?:BufSize|CharsetOut|DocType|Enable|Events|Extended|Fixups|Interp|Links|Meta|StripComments|URLMap)|IOBufferSize|MaxForwards|Pass(?:Inherit|InterpolateEnv|Match|Reverse|ReverseCookieDomain|ReverseCookiePath)?|PreserveHost|ReceiveBufferSize|Remote|RemoteMatch|Requests|SCGIInternalRedirect|SCGISendfile|Set|SourceAddress|Status|Timeout|Via)|ReadmeName|ReceiveBufferSize|Redirect|RedirectMatch|RedirectPermanent|RedirectTemp|ReflectorHeader|RemoteIP(?:Header|InternalProxy|InternalProxyList|ProxiesHeader|TrustedProxy|TrustedProxyList)|RemoveCharset|RemoveEncoding|RemoveHandler|RemoveInputFilter|RemoveLanguage|RemoveOutputFilter|RemoveType|RequestHeader|RequestReadTimeout|Require|Rewrite(?:Base|Cond|Engine|Map|Options|Rule)|RLimitCPU|RLimitMEM|RLimitNPROC|Satisfy|ScoreBoardFile|Script(?:Alias|AliasMatch|InterpreterSource|Log|LogBuffer|LogLength|Sock)?|SecureListen|SeeRequestTail|SendBufferSize|Server(?:Admin|Alias|Limit|Name|Path|Root|Signature|Tokens)|Session(?:Cookie(?:Name|Name2|Remove)|Crypto(?:Cipher|Driver|Passphrase|PassphraseFile)|DBD(?:CookieName|CookieName2|CookieRemove|DeleteLabel|InsertLabel|PerUser|SelectLabel|UpdateLabel)|Env|Exclude|Header|Include|MaxAge)?|SetEnv|SetEnvIf|SetEnvIfExpr|SetEnvIfNoCase|SetHandler|SetInputFilter|SetOutputFilter|SSIEndTag|SSIErrorMsg|SSIETag|SSILastModified|SSILegacyExprParser|SSIStartTag|SSITimeFormat|SSIUndefinedEcho|SSL(?:CACertificateFile|CACertificatePath|CADNRequestFile|CADNRequestPath|CARevocationCheck|CARevocationFile|CARevocationPath|CertificateChainFile|CertificateFile|CertificateKeyFile|CipherSuite|Compression|CryptoDevice|Engine|FIPS|HonorCipherOrder|InsecureRenegotiation|OCSP(?:DefaultResponder|Enable|OverrideResponder|ResponderTimeout|ResponseMaxAge|ResponseTimeSkew|UseRequestNonce)|OpenSSLConfCmd|Options|PassPhraseDialog|Protocol|Proxy(?:CACertificateFile|CACertificatePath|CARevocation(?:Check|File|Path)|CheckPeer(?:CN|Expire|Name)|CipherSuite|Engine|MachineCertificate(?:ChainFile|File|Path)|Protocol|Verify|VerifyDepth)|RandomSeed|RenegBufferSize|Require|RequireSSL|Session(?:Cache|CacheTimeout|TicketKeyFile|Tickets)|SRPUnknownUserSeed|SRPVerifierFile|Stapling(?:Cache|ErrorCacheTimeout|FakeTryLater|ForceURL|ResponderTimeout|ResponseMaxAge|ResponseTimeSkew|ReturnResponderErrors|StandardCacheTimeout)|StrictSNIVHostCheck|UserName|UseStapling|VerifyClient|VerifyDepth)|StartServers|StartThreads|Substitute|Suexec|SuexecUserGroup|ThreadLimit|ThreadsPerChild|ThreadStackSize|TimeOut|TraceEnable|TransferLog|TypesConfig|UnDefine|UndefMacro|UnsetEnv|Use|UseCanonicalName|UseCanonicalPhysicalPort|User|UserDir|VHostCGIMode|VHostCGIPrivs|VHostGroup|VHostPrivs|VHostSecure|VHostUser|Virtual(?:DocumentRoot|ScriptAlias)(?:IP)?|WatchdogInterval|XBitHack|xml2EncAlias|xml2EncDefault|xml2StartParse)\b/im,
|
|
@@ -825,7 +786,7 @@ Prism.languages.markup = {
|
|
|
825
786
|
},
|
|
826
787
|
variable: /[$%]\{?(?:\w\.?[-+:]?)+\}?/,
|
|
827
788
|
regex: /\^?.*\$|\^.*\$?/
|
|
828
|
-
}, Prism.languages.sql = {
|
|
789
|
+
}, Prism$1.languages.sql = {
|
|
829
790
|
comment: {
|
|
830
791
|
pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,
|
|
831
792
|
lookbehind: !0
|
|
@@ -906,7 +867,7 @@ Prism.languages.markup = {
|
|
|
906
867
|
operator: /[!=](?:==?)?|\?\.?|&&|\|\||--|\+\+|[-+*/^&|]=?|:|<<?=?|>{1,3}=?/,
|
|
907
868
|
punctuation: /[()\[\]{};,.]/
|
|
908
869
|
};
|
|
909
|
-
})(Prism), Prism.languages.apl = {
|
|
870
|
+
})(Prism$1), Prism$1.languages.apl = {
|
|
910
871
|
comment: /(?:⍝|#[! ]).*$/m,
|
|
911
872
|
string: {
|
|
912
873
|
pattern: /'(?:[^'\r\n]|'')*'/,
|
|
@@ -937,7 +898,7 @@ Prism.languages.markup = {
|
|
|
937
898
|
pattern: /[{}⍺⍵⍶⍹∇⍫:]/,
|
|
938
899
|
alias: "builtin"
|
|
939
900
|
}
|
|
940
|
-
}, Prism.languages.applescript = {
|
|
901
|
+
}, Prism$1.languages.applescript = {
|
|
941
902
|
comment: [
|
|
942
903
|
/\(\*(?:\(\*(?:[^*]|\*(?!\)))*\*\)|(?!\(\*)[\s\S])*?\*\)/,
|
|
943
904
|
/--.+/,
|
|
@@ -949,7 +910,7 @@ Prism.languages.markup = {
|
|
|
949
910
|
keyword: /\b(?:about|above|after|against|apart from|around|aside from|at|back|before|beginning|behind|below|beneath|beside|between|but|by|considering|continue|copy|does|eighth|else|end|equal|error|every|exit|false|fifth|first|for|fourth|from|front|get|given|global|if|ignoring|in|instead of|into|is|it|its|last|local|me|middle|my|ninth|of|on|onto|out of|over|prop|property|put|repeat|return|returning|second|set|seventh|since|sixth|some|tell|tenth|that|the|then|third|through|thru|timeout|times|to|transaction|true|try|until|where|while|whose|with|without)\b/,
|
|
950
911
|
"class-name": /\b(?:POSIX file|RGB color|alias|application|boolean|centimeters|centimetres|class|constant|cubic centimeters|cubic centimetres|cubic feet|cubic inches|cubic meters|cubic metres|cubic yards|date|degrees Celsius|degrees Fahrenheit|degrees Kelvin|feet|file|gallons|grams|inches|integer|kilograms|kilometers|kilometres|list|liters|litres|meters|metres|miles|number|ounces|pounds|quarts|real|record|reference|script|square feet|square kilometers|square kilometres|square meters|square metres|square miles|square yards|text|yards)\b/,
|
|
951
912
|
punctuation: /[{}():,¬«»《》]/
|
|
952
|
-
}, Prism.languages.aql = {
|
|
913
|
+
}, Prism$1.languages.aql = {
|
|
953
914
|
comment: /\/\/.*|\/\*[\s\S]*?\*\//,
|
|
954
915
|
property: {
|
|
955
916
|
pattern: /([{,]\s*)(?:(?!\d)\w+|(["'´`])(?:(?!\2)[^\\\r\n]|\\.)*\2)(?=\s*:)/,
|
|
@@ -994,7 +955,7 @@ Prism.languages.markup = {
|
|
|
994
955
|
],
|
|
995
956
|
operator: /\*{2,}|[=!]~|[!=<>]=?|&&|\|\||[-+*/%]/,
|
|
996
957
|
punctuation: /::|[?.:,;()[\]{}]/
|
|
997
|
-
}, Prism.languages.c = Prism.languages.extend("clike", {
|
|
958
|
+
}, Prism$1.languages.c = Prism$1.languages.extend("clike", {
|
|
998
959
|
comment: {
|
|
999
960
|
pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
|
|
1000
961
|
greedy: !0
|
|
@@ -1011,10 +972,10 @@ Prism.languages.markup = {
|
|
|
1011
972
|
function: /\b[a-z_]\w*(?=\s*\()/i,
|
|
1012
973
|
number: /(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i,
|
|
1013
974
|
operator: />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/
|
|
1014
|
-
}), Prism.languages.insertBefore("c", "string", { char: {
|
|
975
|
+
}), Prism$1.languages.insertBefore("c", "string", { char: {
|
|
1015
976
|
pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/,
|
|
1016
977
|
greedy: !0
|
|
1017
|
-
} }), Prism.languages.insertBefore("c", "string", { macro: {
|
|
978
|
+
} }), Prism$1.languages.insertBefore("c", "string", { macro: {
|
|
1018
979
|
pattern: /(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im,
|
|
1019
980
|
lookbehind: !0,
|
|
1020
981
|
greedy: !0,
|
|
@@ -1023,9 +984,9 @@ Prism.languages.markup = {
|
|
|
1023
984
|
string: [{
|
|
1024
985
|
pattern: /^(#\s*include\s*)<[^>]+>/,
|
|
1025
986
|
lookbehind: !0
|
|
1026
|
-
}, Prism.languages.c.string],
|
|
1027
|
-
char: Prism.languages.c.char,
|
|
1028
|
-
comment: Prism.languages.c.comment,
|
|
987
|
+
}, Prism$1.languages.c.string],
|
|
988
|
+
char: Prism$1.languages.c.char,
|
|
989
|
+
comment: Prism$1.languages.c.comment,
|
|
1029
990
|
"macro-name": [{
|
|
1030
991
|
pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
|
|
1031
992
|
lookbehind: !0
|
|
@@ -1043,10 +1004,10 @@ Prism.languages.markup = {
|
|
|
1043
1004
|
punctuation: /##|\\(?=[\r\n])/,
|
|
1044
1005
|
expression: {
|
|
1045
1006
|
pattern: /\S[\s\S]*/,
|
|
1046
|
-
inside: Prism.languages.c
|
|
1007
|
+
inside: Prism$1.languages.c
|
|
1047
1008
|
}
|
|
1048
1009
|
}
|
|
1049
|
-
} }), Prism.languages.insertBefore("c", "function", { constant: /\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/ }), delete Prism.languages.c.boolean, (function(e) {
|
|
1010
|
+
} }), Prism$1.languages.insertBefore("c", "function", { constant: /\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/ }), delete Prism$1.languages.c.boolean, (function(e) {
|
|
1050
1011
|
var t = /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/, n = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(/<keyword>/g, function() {
|
|
1051
1012
|
return t.source;
|
|
1052
1013
|
});
|
|
@@ -1106,11 +1067,11 @@ Prism.languages.markup = {
|
|
|
1106
1067
|
greedy: !0,
|
|
1107
1068
|
inside: e.languages.extend("cpp", {})
|
|
1108
1069
|
} }), e.languages.insertBefore("inside", "double-colon", { "class-name": /\b[a-z_]\w*\b(?!\s*::)/i }, e.languages.cpp["base-clause"]);
|
|
1109
|
-
})(Prism), Prism.languages.arduino = Prism.languages.extend("cpp", {
|
|
1070
|
+
})(Prism$1), Prism$1.languages.arduino = Prism$1.languages.extend("cpp", {
|
|
1110
1071
|
keyword: /\b(?:String|array|bool|boolean|break|byte|case|catch|continue|default|do|double|else|finally|for|function|goto|if|in|instanceof|int|integer|long|loop|new|null|return|setup|string|switch|throw|try|void|while|word)\b/,
|
|
1111
1072
|
constant: /\b(?:ANALOG_MESSAGE|DEFAULT|DIGITAL_MESSAGE|EXTERNAL|FIRMATA_STRING|HIGH|INPUT|INPUT_PULLUP|INTERNAL|INTERNAL1V1|INTERNAL2V56|LED_BUILTIN|LOW|OUTPUT|REPORT_ANALOG|REPORT_DIGITAL|SET_PIN_MODE|SYSEX_START|SYSTEM_RESET)\b/,
|
|
1112
1073
|
builtin: /\b(?:Audio|BSSID|Bridge|Client|Console|EEPROM|Esplora|EsploraTFT|Ethernet|EthernetClient|EthernetServer|EthernetUDP|File|FileIO|FileSystem|Firmata|GPRS|GSM|GSMBand|GSMClient|GSMModem|GSMPIN|GSMScanner|GSMServer|GSMVoiceCall|GSM_SMS|HttpClient|IPAddress|IRread|Keyboard|KeyboardController|LiquidCrystal|LiquidCrystal_I2C|Mailbox|Mouse|MouseController|PImage|Process|RSSI|RobotControl|RobotMotor|SD|SPI|SSID|Scheduler|Serial|Server|Servo|SoftwareSerial|Stepper|Stream|TFT|Task|USBHost|WiFi|WiFiClient|WiFiServer|WiFiUDP|Wire|YunClient|YunServer|abs|addParameter|analogRead|analogReadResolution|analogReference|analogWrite|analogWriteResolution|answerCall|attach|attachGPRS|attachInterrupt|attached|autoscroll|available|background|beep|begin|beginPacket|beginSD|beginSMS|beginSpeaker|beginTFT|beginTransmission|beginWrite|bit|bitClear|bitRead|bitSet|bitWrite|blink|blinkVersion|buffer|changePIN|checkPIN|checkPUK|checkReg|circle|cityNameRead|cityNameWrite|clear|clearScreen|click|close|compassRead|config|connect|connected|constrain|cos|countryNameRead|countryNameWrite|createChar|cursor|debugPrint|delay|delayMicroseconds|detach|detachInterrupt|digitalRead|digitalWrite|disconnect|display|displayLogos|drawBMP|drawCompass|encryptionType|end|endPacket|endSMS|endTransmission|endWrite|exists|exitValue|fill|find|findUntil|flush|gatewayIP|get|getAsynchronously|getBand|getButton|getCurrentCarrier|getIMEI|getKey|getModifiers|getOemKey|getPINUsed|getResult|getSignalStrength|getSocket|getVoiceCallStatus|getXChange|getYChange|hangCall|height|highByte|home|image|interrupts|isActionDone|isDirectory|isListening|isPIN|isPressed|isValid|keyPressed|keyReleased|keyboardRead|knobRead|leftToRight|line|lineFollowConfig|listen|listenOnLocalhost|loadImage|localIP|lowByte|macAddress|maintain|map|max|messageAvailable|micros|millis|min|mkdir|motorsStop|motorsWrite|mouseDragged|mouseMoved|mousePressed|mouseReleased|move|noAutoscroll|noBlink|noBuffer|noCursor|noDisplay|noFill|noInterrupts|noListenOnLocalhost|noStroke|noTone|onReceive|onRequest|open|openNextFile|overflow|parseCommand|parseFloat|parseInt|parsePacket|pauseMode|peek|pinMode|playFile|playMelody|point|pointTo|position|pow|prepare|press|print|printFirmwareVersion|printVersion|println|process|processInput|pulseIn|put|random|randomSeed|read|readAccelerometer|readBlue|readButton|readBytes|readBytesUntil|readGreen|readJoystickButton|readJoystickSwitch|readJoystickX|readJoystickY|readLightSensor|readMessage|readMicrophone|readNetworks|readRed|readSlider|readString|readStringUntil|readTemperature|ready|rect|release|releaseAll|remoteIP|remoteNumber|remotePort|remove|requestFrom|retrieveCallingNumber|rewindDirectory|rightToLeft|rmdir|robotNameRead|robotNameWrite|run|runAsynchronously|runShellCommand|runShellCommandAsynchronously|running|scanNetworks|scrollDisplayLeft|scrollDisplayRight|seek|sendAnalog|sendDigitalPortPair|sendDigitalPorts|sendString|sendSysex|serialEvent|setBand|setBitOrder|setClockDivider|setCursor|setDNS|setDataMode|setFirmwareVersion|setMode|setPINUsed|setSpeed|setTextSize|setTimeout|shiftIn|shiftOut|shutdown|sin|size|sqrt|startLoop|step|stop|stroke|subnetMask|switchPIN|tan|tempoWrite|text|tone|transfer|tuneWrite|turn|updateIR|userNameRead|userNameWrite|voiceCall|waitContinue|width|write|writeBlue|writeGreen|writeJSON|writeMessage|writeMicroseconds|writeRGB|writeRed|yield)\b/
|
|
1113
|
-
}), Prism.languages.ino = Prism.languages.arduino, Prism.languages.arff = {
|
|
1074
|
+
}), Prism$1.languages.ino = Prism$1.languages.arduino, Prism$1.languages.arff = {
|
|
1114
1075
|
comment: /%.*/,
|
|
1115
1076
|
string: {
|
|
1116
1077
|
pattern: /(["'])(?:\\.|(?!\1)[^\\\r\n])*\1/,
|
|
@@ -1119,7 +1080,7 @@ Prism.languages.markup = {
|
|
|
1119
1080
|
keyword: /@(?:attribute|data|end|relation)\b/i,
|
|
1120
1081
|
number: /\b\d+(?:\.\d+)?\b/,
|
|
1121
1082
|
punctuation: /[{},]/
|
|
1122
|
-
}, Prism.languages.armasm = {
|
|
1083
|
+
}, Prism$1.languages.armasm = {
|
|
1123
1084
|
comment: {
|
|
1124
1085
|
pattern: /;.*/,
|
|
1125
1086
|
greedy: !0
|
|
@@ -1159,7 +1120,7 @@ Prism.languages.markup = {
|
|
|
1159
1120
|
},
|
|
1160
1121
|
operator: /<>|<<|>>|&&|\|\||[=!<>/]=?|[+\-*%#?&|^]|:[A-Z]+:/,
|
|
1161
1122
|
punctuation: /[()[\],]/
|
|
1162
|
-
}, Prism.languages["arm-asm"] = Prism.languages.armasm, (function(e) {
|
|
1123
|
+
}, Prism$1.languages["arm-asm"] = Prism$1.languages.armasm, (function(e) {
|
|
1163
1124
|
for (var t = "\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_CURRENT_DESKTOP|XDG_DATA_DIRS|XDG_GREETER_DATA_DIR|XDG_MENU_PREFIX|XDG_RUNTIME_DIR|XDG_SEAT|XDG_SEAT_PATH|XDG_SESSION_DESKTOP|XDG_SESSION_ID|XDG_SESSION_PATH|XDG_SESSION_TYPE|XDG_VTNR|XMODIFIERS)\\b", n = {
|
|
1164
1125
|
pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
|
|
1165
1126
|
lookbehind: !0,
|
|
@@ -1329,7 +1290,7 @@ Prism.languages.markup = {
|
|
|
1329
1290
|
"number"
|
|
1330
1291
|
]), i = a.variable[1].inside, o = 0; o < r.length; o++) i[r[o]] = e.languages.bash[r[o]];
|
|
1331
1292
|
e.languages.sh = e.languages.bash, e.languages.shell = e.languages.bash;
|
|
1332
|
-
})(Prism), (function(e) {
|
|
1293
|
+
})(Prism$1), (function(e) {
|
|
1333
1294
|
var t = /[*&][^\s[\]{},]+/, n = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/, a = "(?:" + n.source + "(?:[ ]+" + t.source + ")?|" + t.source + "(?:[ ]+" + n.source + ")?)", r = /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(/<PLAIN>/g, function() {
|
|
1334
1295
|
return /[^\s\x00-\x08\x0e-\x1f,[\]{}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]/.source;
|
|
1335
1296
|
}), i = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
|
|
@@ -1394,7 +1355,7 @@ Prism.languages.markup = {
|
|
|
1394
1355
|
important: t,
|
|
1395
1356
|
punctuation: /---|[:[\]{}\-,|>?]|\.\.\./
|
|
1396
1357
|
}, e.languages.yml = e.languages.yaml;
|
|
1397
|
-
})(Prism), (function(s) {
|
|
1358
|
+
})(Prism$1), (function(s) {
|
|
1398
1359
|
var t = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
|
|
1399
1360
|
function e(e$1) {
|
|
1400
1361
|
return e$1 = e$1.replace(/<inner>/g, function() {
|
|
@@ -1624,7 +1585,7 @@ Prism.languages.markup = {
|
|
|
1624
1585
|
quot: "\""
|
|
1625
1586
|
}, c = String.fromCodePoint || String.fromCharCode;
|
|
1626
1587
|
s.languages.md = s.languages.markdown;
|
|
1627
|
-
})(Prism), (function(n) {
|
|
1588
|
+
})(Prism$1), (function(n) {
|
|
1628
1589
|
function e(e$1, t) {
|
|
1629
1590
|
return {
|
|
1630
1591
|
pattern: RegExp(/\{!/.source + "(?:" + (t || e$1) + ")" + /$[\s\S]*\}/.source, "m"),
|
|
@@ -1699,7 +1660,7 @@ Prism.languages.markup = {
|
|
|
1699
1660
|
symbol: { pattern: /<:|-:|ø|@|#|\+|\||\*|\$|---|-|%|\/|\.\.|\^|~|=|<|>|\\/ },
|
|
1700
1661
|
boolean: { pattern: /\b(?:false|maybe|true)\b/ }
|
|
1701
1662
|
}, n.languages.art = n.languages.arturo;
|
|
1702
|
-
})(Prism), (function(e) {
|
|
1663
|
+
})(Prism$1), (function(e) {
|
|
1703
1664
|
var t = {
|
|
1704
1665
|
pattern: /(^[ \t]*)\[(?!\[)(?:(["'$`])(?:(?!\2)[^\\]|\\.)*\2|\[(?:[^\[\]\\]|\\.)*\]|[^\[\]\\"'$`]|\\.)*\]/m,
|
|
1705
1666
|
lookbehind: !0,
|
|
@@ -1853,7 +1814,7 @@ Prism.languages.markup = {
|
|
|
1853
1814
|
t.inside.interpreted.inside.rest = n("macro inline replacement entity"), r["passthrough-block"].inside.rest = n("macro"), r["literal-block"].inside.rest = n("callout"), r.table.inside.rest = n("comment-block passthrough-block literal-block other-block list-punctuation indented-block comment title attribute-entry attributes hr page-break admonition list-label callout macro inline replacement entity line-continuation"), r["other-block"].inside.rest = n("table list-punctuation indented-block comment attribute-entry attributes hr page-break admonition list-label macro inline replacement entity line-continuation"), r.title.inside.rest = n("macro inline replacement entity"), e.hooks.add("wrap", function(e$1) {
|
|
1854
1815
|
"entity" === e$1.type && (e$1.attributes.title = e$1.content.replace(/&/, "&"));
|
|
1855
1816
|
}), e.languages.adoc = e.languages.asciidoc;
|
|
1856
|
-
})(Prism), (function(n) {
|
|
1817
|
+
})(Prism$1), (function(n) {
|
|
1857
1818
|
function a(e$1, n$1) {
|
|
1858
1819
|
return e$1.replace(/<<(\d+)>>/g, function(e$2, t$1) {
|
|
1859
1820
|
return "(?:" + n$1[+t$1] + ")";
|
|
@@ -2077,7 +2038,7 @@ Prism.languages.markup = {
|
|
|
2077
2038
|
greedy: !0
|
|
2078
2039
|
}
|
|
2079
2040
|
}), n.languages.dotnet = n.languages.cs = n.languages.csharp;
|
|
2080
|
-
})(Prism), Prism.languages.aspnet = Prism.languages.extend("markup", {
|
|
2041
|
+
})(Prism$1), Prism$1.languages.aspnet = Prism$1.languages.extend("markup", {
|
|
2081
2042
|
"page-directive": {
|
|
2082
2043
|
pattern: /<%\s*@.*%>/,
|
|
2083
2044
|
alias: "tag",
|
|
@@ -2086,7 +2047,7 @@ Prism.languages.markup = {
|
|
|
2086
2047
|
pattern: /<%\s*@\s*(?:Assembly|Control|Implements|Import|Master(?:Type)?|OutputCache|Page|PreviousPageType|Reference|Register)?|%>/i,
|
|
2087
2048
|
alias: "tag"
|
|
2088
2049
|
},
|
|
2089
|
-
rest: Prism.languages.markup.tag.inside
|
|
2050
|
+
rest: Prism$1.languages.markup.tag.inside
|
|
2090
2051
|
}
|
|
2091
2052
|
},
|
|
2092
2053
|
directive: {
|
|
@@ -2097,18 +2058,18 @@ Prism.languages.markup = {
|
|
|
2097
2058
|
pattern: /<%\s*?[$=%#:]{0,2}|%>/,
|
|
2098
2059
|
alias: "tag"
|
|
2099
2060
|
},
|
|
2100
|
-
rest: Prism.languages.csharp
|
|
2061
|
+
rest: Prism$1.languages.csharp
|
|
2101
2062
|
}
|
|
2102
2063
|
}
|
|
2103
|
-
}), Prism.languages.aspnet.tag.pattern = /<(?!%)\/?[^\s>\/]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/, Prism.languages.insertBefore("inside", "punctuation", { directive: Prism.languages.aspnet.directive }, Prism.languages.aspnet.tag.inside["attr-value"]), Prism.languages.insertBefore("aspnet", "comment", { "asp-comment": {
|
|
2064
|
+
}), Prism$1.languages.aspnet.tag.pattern = /<(?!%)\/?[^\s>\/]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/, Prism$1.languages.insertBefore("inside", "punctuation", { directive: Prism$1.languages.aspnet.directive }, Prism$1.languages.aspnet.tag.inside["attr-value"]), Prism$1.languages.insertBefore("aspnet", "comment", { "asp-comment": {
|
|
2104
2065
|
pattern: /<%--[\s\S]*?--%>/,
|
|
2105
2066
|
alias: ["asp", "comment"]
|
|
2106
|
-
} }), Prism.languages.insertBefore("aspnet", Prism.languages.javascript ? "script" : "tag", { "asp-script": {
|
|
2067
|
+
} }), Prism$1.languages.insertBefore("aspnet", Prism$1.languages.javascript ? "script" : "tag", { "asp-script": {
|
|
2107
2068
|
pattern: /(<script(?=.*runat=['"]?server\b)[^>]*>)[\s\S]*?(?=<\/script>)/i,
|
|
2108
2069
|
lookbehind: !0,
|
|
2109
2070
|
alias: ["asp", "script"],
|
|
2110
|
-
inside: Prism.languages.csharp || {}
|
|
2111
|
-
} }), Prism.languages.asm6502 = {
|
|
2071
|
+
inside: Prism$1.languages.csharp || {}
|
|
2072
|
+
} }), Prism$1.languages.asm6502 = {
|
|
2112
2073
|
comment: /;.*/,
|
|
2113
2074
|
directive: {
|
|
2114
2075
|
pattern: /\.\w+(?= )/,
|
|
@@ -2136,7 +2097,7 @@ Prism.languages.markup = {
|
|
|
2136
2097
|
alias: "variable"
|
|
2137
2098
|
},
|
|
2138
2099
|
punctuation: /[(),:]/
|
|
2139
|
-
}, Prism.languages.asmatmel = {
|
|
2100
|
+
}, Prism$1.languages.asmatmel = {
|
|
2140
2101
|
comment: {
|
|
2141
2102
|
pattern: /;.*/,
|
|
2142
2103
|
greedy: !0
|
|
@@ -2176,7 +2137,7 @@ Prism.languages.markup = {
|
|
|
2176
2137
|
},
|
|
2177
2138
|
operator: />>=?|<<=?|&[&=]?|\|[\|=]?|[-+*/%^!=<>?]=?/,
|
|
2178
2139
|
punctuation: /[(),:]/
|
|
2179
|
-
}, Prism.languages.autohotkey = {
|
|
2140
|
+
}, Prism$1.languages.autohotkey = {
|
|
2180
2141
|
comment: [{
|
|
2181
2142
|
pattern: /(^|\s);.*/,
|
|
2182
2143
|
lookbehind: !0
|
|
@@ -2208,7 +2169,7 @@ Prism.languages.markup = {
|
|
|
2208
2169
|
keyword: /\b(?:Abort|AboveNormal|Add|ahk_class|ahk_exe|ahk_group|ahk_id|ahk_pid|All|Alnum|Alpha|AltSubmit|AltTab|AltTabAndMenu|AltTabMenu|AltTabMenuDismiss|AlwaysOnTop|AutoSize|Background|BackgroundTrans|BelowNormal|between|BitAnd|BitNot|BitOr|BitShiftLeft|BitShiftRight|BitXOr|Bold|Border|Button|ByRef|Catch|Checkbox|Checked|CheckedGray|Choose|ChooseString|Close|Color|ComboBox|Contains|ControlList|Count|Date|DateTime|Days|DDL|Default|DeleteAll|Delimiter|Deref|Destroy|Digit|Disable|Disabled|DropDownList|Edit|Eject|Else|Enable|Enabled|Error|Exist|Expand|ExStyle|FileSystem|Finally|First|Flash|Float|FloatFast|Focus|Font|for|global|Grid|Group|GroupBox|GuiClose|GuiContextMenu|GuiDropFiles|GuiEscape|GuiSize|Hdr|Hidden|Hide|High|HKCC|HKCR|HKCU|HKEY_CLASSES_ROOT|HKEY_CURRENT_CONFIG|HKEY_CURRENT_USER|HKEY_LOCAL_MACHINE|HKEY_USERS|HKLM|HKU|Hours|HScroll|Icon|IconSmall|ID|IDLast|If|IfEqual|IfExist|IfGreater|IfGreaterOrEqual|IfInString|IfLess|IfLessOrEqual|IfMsgBox|IfNotEqual|IfNotExist|IfNotInString|IfWinActive|IfWinExist|IfWinNotActive|IfWinNotExist|Ignore|ImageList|in|Integer|IntegerFast|Interrupt|is|italic|Join|Label|LastFound|LastFoundExist|Limit|Lines|List|ListBox|ListView|local|Lock|Logoff|Low|Lower|Lowercase|MainWindow|Margin|Maximize|MaximizeBox|MaxSize|Minimize|MinimizeBox|MinMax|MinSize|Minutes|MonthCal|Mouse|Move|Multi|NA|No|NoActivate|NoDefault|NoHide|NoIcon|NoMainWindow|norm|Normal|NoSort|NoSortHdr|NoStandard|Not|NoTab|NoTimers|Number|Off|Ok|On|OwnDialogs|Owner|Parse|Password|Picture|Pixel|Pos|Pow|Priority|ProcessName|Radio|Range|Read|ReadOnly|Realtime|Redraw|Region|REG_BINARY|REG_DWORD|REG_EXPAND_SZ|REG_MULTI_SZ|REG_SZ|Relative|Rename|Report|Resize|Restore|Retry|RGB|Screen|Seconds|Section|Serial|SetLabel|ShiftAltTab|Show|Single|Slider|SortDesc|Standard|static|Status|StatusBar|StatusCD|strike|Style|Submit|SysMenu|Tab2|TabStop|Text|Theme|Throw|Tile|ToggleCheck|ToggleEnable|ToolWindow|Top|Topmost|TransColor|Transparent|Tray|TreeView|Try|TryAgain|Type|UnCheck|underline|Unicode|Unlock|Until|UpDown|Upper|Uppercase|UseErrorLevel|Vis|VisFirst|Visible|VScroll|Wait|WaitClose|WantCtrlA|WantF2|WantReturn|While|Wrap|Xdigit|xm|xp|xs|Yes|ym|yp|ys)\b/i,
|
|
2209
2170
|
function: /[^(); \t,\n+*\-=?>:\\\/<&%\[\]]+(?=\()/,
|
|
2210
2171
|
punctuation: /[{}[\]():,]/
|
|
2211
|
-
}, Prism.languages.autoit = {
|
|
2172
|
+
}, Prism$1.languages.autoit = {
|
|
2212
2173
|
comment: [/;.*/, {
|
|
2213
2174
|
pattern: /(^[\t ]*)#(?:comments-start|cs)[\s\S]*?^[ \t]*#(?:ce|comments-end)/m,
|
|
2214
2175
|
lookbehind: !0
|
|
@@ -2345,7 +2306,7 @@ Prism.languages.markup = {
|
|
|
2345
2306
|
operator: /\+\+?|[!=<>]=?|&&|\|\||[?:*/%-]/,
|
|
2346
2307
|
punctuation: /[{}\[\]();,.]/
|
|
2347
2308
|
}, e.languages.avs = e.languages.avisynth;
|
|
2348
|
-
})(Prism), Prism.languages["avro-idl"] = {
|
|
2309
|
+
})(Prism$1), Prism$1.languages["avro-idl"] = {
|
|
2349
2310
|
comment: {
|
|
2350
2311
|
pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
|
|
2351
2312
|
greedy: !0
|
|
@@ -2382,7 +2343,7 @@ Prism.languages.markup = {
|
|
|
2382
2343
|
}, /-?\b(?:Infinity|NaN)\b/],
|
|
2383
2344
|
operator: /=/,
|
|
2384
2345
|
punctuation: /[()\[\]{}<>.:,;-]/
|
|
2385
|
-
}, Prism.languages.avdl = Prism.languages["avro-idl"], Prism.languages.awk = {
|
|
2346
|
+
}, Prism$1.languages.avdl = Prism$1.languages["avro-idl"], Prism$1.languages.awk = {
|
|
2386
2347
|
hashbang: {
|
|
2387
2348
|
pattern: /^#!.*/,
|
|
2388
2349
|
greedy: !0,
|
|
@@ -2408,7 +2369,7 @@ Prism.languages.markup = {
|
|
|
2408
2369
|
number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0x[a-fA-F0-9]+)\b/,
|
|
2409
2370
|
operator: /--|\+\+|!?~|>&|>>|<<|(?:\*\*|[<>!=+\-*/%^])=?|&&|\|[|&]|[?:]/,
|
|
2410
2371
|
punctuation: /[()[\]{},;]/
|
|
2411
|
-
}, Prism.languages.gawk = Prism.languages.awk, Prism.languages.basic = {
|
|
2372
|
+
}, Prism$1.languages.gawk = Prism$1.languages.awk, Prism$1.languages.basic = {
|
|
2412
2373
|
comment: {
|
|
2413
2374
|
pattern: /(?:!|REM\b).+/i,
|
|
2414
2375
|
inside: { keyword: /^REM/i }
|
|
@@ -2428,7 +2389,7 @@ Prism.languages.markup = {
|
|
|
2428
2389
|
alias: "attr-name",
|
|
2429
2390
|
inside: { punctuation: /:/ }
|
|
2430
2391
|
}, n = /"(?:[\\"]"|[^"])*"(?!")/, a = /(?:\b|-)\d+\b/;
|
|
2431
|
-
Prism.languages.batch = {
|
|
2392
|
+
Prism$1.languages.batch = {
|
|
2432
2393
|
comment: [/^::.*/m, {
|
|
2433
2394
|
pattern: /((?:^|[&(])[ \t]*)rem\b(?:[^^&)\r\n]|\^(?:\r\n|[\s\S]))*/im,
|
|
2434
2395
|
lookbehind: !0
|
|
@@ -2501,7 +2462,7 @@ Prism.languages.markup = {
|
|
|
2501
2462
|
operator: /[&@]/,
|
|
2502
2463
|
punctuation: /[()']/
|
|
2503
2464
|
};
|
|
2504
|
-
})(), Prism.languages.bbcode = { tag: {
|
|
2465
|
+
})(), Prism$1.languages.bbcode = { tag: {
|
|
2505
2466
|
pattern: /\[\/?[^\s=\]]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'"\]=]+))?(?:\s+[^\s=\]]+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'"\]=]+))*\s*\]/,
|
|
2506
2467
|
inside: {
|
|
2507
2468
|
tag: {
|
|
@@ -2518,7 +2479,7 @@ Prism.languages.markup = {
|
|
|
2518
2479
|
punctuation: /\]/,
|
|
2519
2480
|
"attr-name": /[^\s=\]]+/
|
|
2520
2481
|
}
|
|
2521
|
-
} }, Prism.languages.shortcode = Prism.languages.bbcode, Prism.languages.bbj = {
|
|
2482
|
+
} }, Prism$1.languages.shortcode = Prism$1.languages.bbcode, Prism$1.languages.bbj = {
|
|
2522
2483
|
comment: {
|
|
2523
2484
|
pattern: /(^|[^\\:])rem\s+.*/i,
|
|
2524
2485
|
lookbehind: !0,
|
|
@@ -2534,7 +2495,7 @@ Prism.languages.markup = {
|
|
|
2534
2495
|
boolean: /\b(?:BBjAPI\.TRUE|BBjAPI\.FALSE)\b/i,
|
|
2535
2496
|
operator: /<[=>]?|>=?|[+\-*\/^=&]|\b(?:and|not|or|xor)\b/i,
|
|
2536
2497
|
punctuation: /[.,;:()]/
|
|
2537
|
-
}, Prism.languages.bicep = {
|
|
2498
|
+
}, Prism$1.languages.bicep = {
|
|
2538
2499
|
comment: [{
|
|
2539
2500
|
pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
|
|
2540
2501
|
lookbehind: !0,
|
|
@@ -2590,7 +2551,7 @@ Prism.languages.markup = {
|
|
|
2590
2551
|
number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
|
|
2591
2552
|
operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/,
|
|
2592
2553
|
punctuation: /[{}[\];(),.:]/
|
|
2593
|
-
}, Prism.languages.bicep["interpolated-string"].inside.interpolation.inside.expression.inside = Prism.languages.bicep, Prism.languages.birb = Prism.languages.extend("clike", {
|
|
2554
|
+
}, Prism$1.languages.bicep["interpolated-string"].inside.interpolation.inside.expression.inside = Prism$1.languages.bicep, Prism$1.languages.birb = Prism$1.languages.extend("clike", {
|
|
2594
2555
|
string: {
|
|
2595
2556
|
pattern: /r?("|')(?:\\.|(?!\1)[^\\])*\1/,
|
|
2596
2557
|
greedy: !0
|
|
@@ -2599,11 +2560,11 @@ Prism.languages.markup = {
|
|
|
2599
2560
|
keyword: /\b(?:assert|break|case|class|const|default|else|enum|final|follows|for|grab|if|nest|new|next|noSeeb|return|static|switch|throw|var|void|while)\b/,
|
|
2600
2561
|
operator: /\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?|:/,
|
|
2601
2562
|
variable: /\b[a-z_]\w*\b/
|
|
2602
|
-
}), Prism.languages.insertBefore("birb", "function", { metadata: {
|
|
2563
|
+
}), Prism$1.languages.insertBefore("birb", "function", { metadata: {
|
|
2603
2564
|
pattern: /<\w+>/,
|
|
2604
2565
|
greedy: !0,
|
|
2605
2566
|
alias: "symbol"
|
|
2606
|
-
} }), Prism.languages.bison = Prism.languages.extend("c", {}), Prism.languages.insertBefore("bison", "comment", { bison: {
|
|
2567
|
+
} }), Prism$1.languages.bison = Prism$1.languages.extend("c", {}), Prism$1.languages.insertBefore("bison", "comment", { bison: {
|
|
2607
2568
|
pattern: /^(?:[^%]|%(?!%))*%%[\s\S]*?%%/,
|
|
2608
2569
|
inside: {
|
|
2609
2570
|
c: {
|
|
@@ -2618,11 +2579,11 @@ Prism.languages.markup = {
|
|
|
2618
2579
|
alias: "variable",
|
|
2619
2580
|
inside: { punctuation: /<|>/ }
|
|
2620
2581
|
},
|
|
2621
|
-
rest: Prism.languages.c
|
|
2582
|
+
rest: Prism$1.languages.c
|
|
2622
2583
|
}
|
|
2623
2584
|
},
|
|
2624
|
-
comment: Prism.languages.c.comment,
|
|
2625
|
-
string: Prism.languages.c.string,
|
|
2585
|
+
comment: Prism$1.languages.c.comment,
|
|
2586
|
+
string: Prism$1.languages.c.string,
|
|
2626
2587
|
property: /\S+(?=:)/,
|
|
2627
2588
|
keyword: /%\w+/,
|
|
2628
2589
|
number: {
|
|
@@ -2631,7 +2592,7 @@ Prism.languages.markup = {
|
|
|
2631
2592
|
},
|
|
2632
2593
|
punctuation: /%[%?]|[|:;\[\]<>]/
|
|
2633
2594
|
}
|
|
2634
|
-
} }), Prism.languages.bnf = {
|
|
2595
|
+
} }), Prism$1.languages.bnf = {
|
|
2635
2596
|
string: { pattern: /"[^\r\n"]*"|'[^\r\n']*'/ },
|
|
2636
2597
|
definition: {
|
|
2637
2598
|
pattern: /<[^<>\r\n\t]+>(?=\s*::=)/,
|
|
@@ -2643,7 +2604,7 @@ Prism.languages.markup = {
|
|
|
2643
2604
|
inside: { punctuation: /^<|>$/ }
|
|
2644
2605
|
},
|
|
2645
2606
|
operator: /::=|[|()[\]{}*+?]|\.{3}/
|
|
2646
|
-
}, Prism.languages.rbnf = Prism.languages.bnf, Prism.languages.bqn = {
|
|
2607
|
+
}, Prism$1.languages.rbnf = Prism$1.languages.bnf, Prism$1.languages.bqn = {
|
|
2647
2608
|
shebang: {
|
|
2648
2609
|
pattern: /^#![ \t]*\/.*/,
|
|
2649
2610
|
alias: "important",
|
|
@@ -2705,7 +2666,7 @@ Prism.languages.markup = {
|
|
|
2705
2666
|
alias: "operator"
|
|
2706
2667
|
},
|
|
2707
2668
|
punctuation: /[←⇐↩(){}⟨⟩[\]‿·⋄,.;:?]/
|
|
2708
|
-
}, Prism.languages.brainfuck = {
|
|
2669
|
+
}, Prism$1.languages.brainfuck = {
|
|
2709
2670
|
pointer: {
|
|
2710
2671
|
pattern: /<|>/,
|
|
2711
2672
|
alias: "keyword"
|
|
@@ -2724,7 +2685,7 @@ Prism.languages.markup = {
|
|
|
2724
2685
|
},
|
|
2725
2686
|
operator: /[.,]/,
|
|
2726
2687
|
comment: /\S+/
|
|
2727
|
-
}, Prism.languages.brightscript = {
|
|
2688
|
+
}, Prism$1.languages.brightscript = {
|
|
2728
2689
|
comment: /(?:\brem|').*/i,
|
|
2729
2690
|
"directive-statement": {
|
|
2730
2691
|
pattern: /(^[\t ]*)#(?:const|else(?:[\t ]+if)?|end[\t ]+if|error|if).*/im,
|
|
@@ -2765,7 +2726,7 @@ Prism.languages.markup = {
|
|
|
2765
2726
|
operator: /--|\+\+|>>=?|<<=?|<>|[-+*/\\<>]=?|[:^=?]|\b(?:and|mod|not|or)\b/i,
|
|
2766
2727
|
punctuation: /[.,;()[\]{}]/,
|
|
2767
2728
|
constant: /\b(?:LINE_NUM)\b/i
|
|
2768
|
-
}, Prism.languages.brightscript["directive-statement"].inside.expression.inside = Prism.languages.brightscript, Prism.languages.bro = {
|
|
2729
|
+
}, Prism$1.languages.brightscript["directive-statement"].inside.expression.inside = Prism$1.languages.brightscript, Prism$1.languages.bro = {
|
|
2769
2730
|
comment: {
|
|
2770
2731
|
pattern: /(^|[^\\$])#.*/,
|
|
2771
2732
|
lookbehind: !0,
|
|
@@ -2789,7 +2750,7 @@ Prism.languages.markup = {
|
|
|
2789
2750
|
operator: /--?|\+\+?|!=?=?|<=?|>=?|==?=?|&&|\|\|?|\?|\*|\/|~|\^|%/,
|
|
2790
2751
|
number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
|
|
2791
2752
|
punctuation: /[{}[\];(),.:]/
|
|
2792
|
-
}, Prism.languages.bsl = {
|
|
2753
|
+
}, Prism$1.languages.bsl = {
|
|
2793
2754
|
comment: /\/\/.*/,
|
|
2794
2755
|
string: [{
|
|
2795
2756
|
pattern: /"(?:[^"]|"")*"(?!")/,
|
|
@@ -2823,7 +2784,7 @@ Prism.languages.markup = {
|
|
|
2823
2784
|
greedy: !0,
|
|
2824
2785
|
alias: "important"
|
|
2825
2786
|
}]
|
|
2826
|
-
}, Prism.languages.oscript = Prism.languages.bsl, Prism.languages.cfscript = Prism.languages.extend("clike", {
|
|
2787
|
+
}, Prism$1.languages.oscript = Prism$1.languages.bsl, Prism$1.languages.cfscript = Prism$1.languages.extend("clike", {
|
|
2827
2788
|
comment: [{
|
|
2828
2789
|
pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
|
|
2829
2790
|
lookbehind: !0,
|
|
@@ -2846,10 +2807,10 @@ Prism.languages.markup = {
|
|
|
2846
2807
|
pattern: /\b(?:any|array|binary|boolean|date|guid|numeric|query|string|struct|uuid|void|xml)\b/,
|
|
2847
2808
|
alias: "builtin"
|
|
2848
2809
|
}
|
|
2849
|
-
}), Prism.languages.insertBefore("cfscript", "keyword", { "function-variable": {
|
|
2810
|
+
}), Prism$1.languages.insertBefore("cfscript", "keyword", { "function-variable": {
|
|
2850
2811
|
pattern: /[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
|
|
2851
2812
|
alias: "function"
|
|
2852
|
-
} }), delete Prism.languages.cfscript["class-name"], Prism.languages.cfc = Prism.languages.cfscript, Prism.languages.chaiscript = Prism.languages.extend("clike", {
|
|
2813
|
+
} }), delete Prism$1.languages.cfscript["class-name"], Prism$1.languages.cfc = Prism$1.languages.cfscript, Prism$1.languages.chaiscript = Prism$1.languages.extend("clike", {
|
|
2853
2814
|
string: {
|
|
2854
2815
|
pattern: /(^|[^\\])'(?:[^'\\]|\\[\s\S])*'/,
|
|
2855
2816
|
lookbehind: !0,
|
|
@@ -2863,13 +2824,13 @@ Prism.languages.markup = {
|
|
|
2863
2824
|
lookbehind: !0
|
|
2864
2825
|
}],
|
|
2865
2826
|
keyword: /\b(?:attr|auto|break|case|catch|class|continue|def|default|else|finally|for|fun|global|if|return|switch|this|try|var|while)\b/,
|
|
2866
|
-
number: [Prism.languages.cpp.number, /\b(?:Infinity|NaN)\b/],
|
|
2827
|
+
number: [Prism$1.languages.cpp.number, /\b(?:Infinity|NaN)\b/],
|
|
2867
2828
|
operator: />>=?|<<=?|\|\||&&|:[:=]?|--|\+\+|[=!<>+\-*/%|&^]=?|[?~]|`[^`\r\n]{1,4}`/
|
|
2868
|
-
}), Prism.languages.insertBefore("chaiscript", "operator", { "parameter-type": {
|
|
2829
|
+
}), Prism$1.languages.insertBefore("chaiscript", "operator", { "parameter-type": {
|
|
2869
2830
|
pattern: /([,(]\s*)\w+(?=\s+\w)/,
|
|
2870
2831
|
lookbehind: !0,
|
|
2871
2832
|
alias: "class-name"
|
|
2872
|
-
} }), Prism.languages.insertBefore("chaiscript", "string", { "string-interpolation": {
|
|
2833
|
+
} }), Prism$1.languages.insertBefore("chaiscript", "string", { "string-interpolation": {
|
|
2873
2834
|
pattern: /(^|[^\\])"(?:[^"$\\]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*"/,
|
|
2874
2835
|
lookbehind: !0,
|
|
2875
2836
|
greedy: !0,
|
|
@@ -2881,7 +2842,7 @@ Prism.languages.markup = {
|
|
|
2881
2842
|
"interpolation-expression": {
|
|
2882
2843
|
pattern: /(^\$\{)[\s\S]+(?=\}$)/,
|
|
2883
2844
|
lookbehind: !0,
|
|
2884
|
-
inside: Prism.languages.chaiscript
|
|
2845
|
+
inside: Prism$1.languages.chaiscript
|
|
2885
2846
|
},
|
|
2886
2847
|
"interpolation-punctuation": {
|
|
2887
2848
|
pattern: /^\$\{|\}$/,
|
|
@@ -2891,7 +2852,7 @@ Prism.languages.markup = {
|
|
|
2891
2852
|
},
|
|
2892
2853
|
string: /[\s\S]+/
|
|
2893
2854
|
}
|
|
2894
|
-
} }), Prism.languages.cil = {
|
|
2855
|
+
} }), Prism$1.languages.cil = {
|
|
2895
2856
|
comment: /\/\/.*/,
|
|
2896
2857
|
string: {
|
|
2897
2858
|
pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
|
|
@@ -2908,13 +2869,13 @@ Prism.languages.markup = {
|
|
|
2908
2869
|
boolean: /\b(?:false|true)\b/,
|
|
2909
2870
|
number: /\b-?(?:0x[0-9a-f]+|\d+)(?:\.[0-9a-f]+)?\b/i,
|
|
2910
2871
|
punctuation: /[{}[\];(),:=]|IL_[0-9A-Za-z]+/
|
|
2911
|
-
}, Prism.languages.cilkc = Prism.languages.insertBefore("c", "function", { "parallel-keyword": {
|
|
2872
|
+
}, Prism$1.languages.cilkc = Prism$1.languages.insertBefore("c", "function", { "parallel-keyword": {
|
|
2912
2873
|
pattern: /\bcilk_(?:for|reducer|s(?:cope|pawn|ync))\b/,
|
|
2913
2874
|
alias: "keyword"
|
|
2914
|
-
} }), Prism.languages["cilk-c"] = Prism.languages.cilkc, Prism.languages.cilkcpp = Prism.languages.insertBefore("cpp", "function", { "parallel-keyword": {
|
|
2875
|
+
} }), Prism$1.languages["cilk-c"] = Prism$1.languages.cilkc, Prism$1.languages.cilkcpp = Prism$1.languages.insertBefore("cpp", "function", { "parallel-keyword": {
|
|
2915
2876
|
pattern: /\bcilk_(?:for|reducer|s(?:cope|pawn|ync))\b/,
|
|
2916
2877
|
alias: "keyword"
|
|
2917
|
-
} }), Prism.languages["cilk-cpp"] = Prism.languages.cilkcpp, Prism.languages.cilk = Prism.languages.cilkcpp, Prism.languages.clojure = {
|
|
2878
|
+
} }), Prism$1.languages["cilk-cpp"] = Prism$1.languages.cilkcpp, Prism$1.languages.cilk = Prism$1.languages.cilkcpp, Prism$1.languages.clojure = {
|
|
2918
2879
|
comment: {
|
|
2919
2880
|
pattern: /;.*/,
|
|
2920
2881
|
greedy: !0
|
|
@@ -2943,7 +2904,7 @@ Prism.languages.markup = {
|
|
|
2943
2904
|
},
|
|
2944
2905
|
operator: /[#@^`~]/,
|
|
2945
2906
|
punctuation: /[{}\[\](),]/
|
|
2946
|
-
}, Prism.languages.cmake = {
|
|
2907
|
+
}, Prism$1.languages.cmake = {
|
|
2947
2908
|
comment: /#.*/,
|
|
2948
2909
|
string: {
|
|
2949
2910
|
pattern: /"(?:[^\\"]|\\.)*"/,
|
|
@@ -2969,7 +2930,7 @@ Prism.languages.markup = {
|
|
|
2969
2930
|
number: /\b\d+(?:\.\d+)*\b/,
|
|
2970
2931
|
function: /\b[a-z_]\w*(?=\s*\()\b/i,
|
|
2971
2932
|
punctuation: /[()>}]|\$[<{]/
|
|
2972
|
-
}, Prism.languages.cobol = {
|
|
2933
|
+
}, Prism$1.languages.cobol = {
|
|
2973
2934
|
comment: {
|
|
2974
2935
|
pattern: /\*>.*|(^[ \t]*)\*.*/m,
|
|
2975
2936
|
lookbehind: !0,
|
|
@@ -3072,7 +3033,7 @@ Prism.languages.markup = {
|
|
|
3072
3033
|
inside: { interpolation: n }
|
|
3073
3034
|
}]
|
|
3074
3035
|
}), e.languages.insertBefore("coffeescript", "keyword", { property: /(?!\d)\w+(?=\s*:(?!:))/ }), delete e.languages.coffeescript["template-string"], e.languages.coffee = e.languages.coffeescript;
|
|
3075
|
-
})(Prism), Prism.languages.concurnas = {
|
|
3036
|
+
})(Prism$1), Prism$1.languages.concurnas = {
|
|
3076
3037
|
comment: {
|
|
3077
3038
|
pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\/\/.*)/,
|
|
3078
3039
|
lookbehind: !0,
|
|
@@ -3103,7 +3064,7 @@ Prism.languages.markup = {
|
|
|
3103
3064
|
pattern: /@(?:\w+:)?(?:\w+|\[[^\]]+\])?/,
|
|
3104
3065
|
alias: "builtin"
|
|
3105
3066
|
}
|
|
3106
|
-
}, Prism.languages.insertBefore("concurnas", "langext", {
|
|
3067
|
+
}, Prism$1.languages.insertBefore("concurnas", "langext", {
|
|
3107
3068
|
"regex-literal": {
|
|
3108
3069
|
pattern: /\br("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
|
|
3109
3070
|
greedy: !0,
|
|
@@ -3111,7 +3072,7 @@ Prism.languages.markup = {
|
|
|
3111
3072
|
interpolation: {
|
|
3112
3073
|
pattern: /((?:^|[^\\])(?:\\{2})*)\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
|
|
3113
3074
|
lookbehind: !0,
|
|
3114
|
-
inside: Prism.languages.concurnas
|
|
3075
|
+
inside: Prism$1.languages.concurnas
|
|
3115
3076
|
},
|
|
3116
3077
|
regex: /[\s\S]+/
|
|
3117
3078
|
}
|
|
@@ -3123,16 +3084,16 @@ Prism.languages.markup = {
|
|
|
3123
3084
|
interpolation: {
|
|
3124
3085
|
pattern: /((?:^|[^\\])(?:\\{2})*)\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
|
|
3125
3086
|
lookbehind: !0,
|
|
3126
|
-
inside: Prism.languages.concurnas
|
|
3087
|
+
inside: Prism$1.languages.concurnas
|
|
3127
3088
|
},
|
|
3128
3089
|
string: /[\s\S]+/
|
|
3129
3090
|
}
|
|
3130
3091
|
}
|
|
3131
|
-
}), Prism.languages.conc = Prism.languages.concurnas, (function() {
|
|
3092
|
+
}), Prism$1.languages.conc = Prism$1.languages.concurnas, (function() {
|
|
3132
3093
|
function e(e$1) {
|
|
3133
3094
|
return RegExp(/([ \t])/.source + "(?:" + e$1 + ")" + /(?=[\s;]|$)/.source, "i");
|
|
3134
3095
|
}
|
|
3135
|
-
Prism.languages.csp = {
|
|
3096
|
+
Prism$1.languages.csp = {
|
|
3136
3097
|
directive: {
|
|
3137
3098
|
pattern: /(^|[\s;])(?:base-uri|block-all-mixed-content|(?:child|connect|default|font|frame|img|manifest|media|object|prefetch|script|style|worker)-src|disown-opener|form-action|frame-(?:ancestors|options)|input-protection(?:-(?:clip|selectors))?|navigate-to|plugin-types|policy-uri|referrer|reflected-xss|report-(?:to|uri)|require-sri-for|sandbox|(?:script|style)-src-(?:attr|elem)|upgrade-insecure-requests)(?=[\s;]|$)/i,
|
|
3138
3099
|
lookbehind: !0,
|
|
@@ -3287,7 +3248,7 @@ Prism.languages.markup = {
|
|
|
3287
3248
|
}
|
|
3288
3249
|
}
|
|
3289
3250
|
};
|
|
3290
|
-
})(Prism), (function(e) {
|
|
3251
|
+
})(Prism$1), (function(e) {
|
|
3291
3252
|
for (var t = /\(\*(?:[^(*]|\((?!\*)|\*(?!\))|<self>)*\*\)/.source, n = 0; n < 2; n++) t = t.replace(/<self>/g, function() {
|
|
3292
3253
|
return t;
|
|
3293
3254
|
});
|
|
@@ -3325,7 +3286,7 @@ Prism.languages.markup = {
|
|
|
3325
3286
|
operator: /\/\\|\\\/|\.{2,3}|:{1,2}=|\*\*|[-=]>|<(?:->?|[+:=>]|<:)|>(?:=|->)|\|[-|]?|[-!%&*+/<=>?@^~']/,
|
|
3326
3287
|
punctuation: /\.\(|`\(|@\{|`\{|\{\||\[=|:>|[:.,;(){}\[\]]/
|
|
3327
3288
|
};
|
|
3328
|
-
})(Prism), (function(e) {
|
|
3289
|
+
})(Prism$1), (function(e) {
|
|
3329
3290
|
e.languages.ruby = e.languages.extend("clike", {
|
|
3330
3291
|
comment: {
|
|
3331
3292
|
pattern: /#.*|^=begin\s[\s\S]*?^=end/m,
|
|
@@ -3476,7 +3437,7 @@ Prism.languages.markup = {
|
|
|
3476
3437
|
builtin: /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/,
|
|
3477
3438
|
constant: /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/
|
|
3478
3439
|
}), e.languages.rb = e.languages.ruby;
|
|
3479
|
-
})(Prism), (function(e) {
|
|
3440
|
+
})(Prism$1), (function(e) {
|
|
3480
3441
|
e.languages.crystal = e.languages.extend("ruby", {
|
|
3481
3442
|
keyword: [/\b(?:__DIR__|__END_LINE__|__FILE__|__LINE__|abstract|alias|annotation|as|asm|begin|break|case|class|def|do|else|elsif|end|ensure|enum|extend|for|fun|if|ifdef|include|instance_sizeof|lib|macro|module|next|of|out|pointerof|private|protected|ptr|require|rescue|return|select|self|sizeof|struct|super|then|type|typeof|undef|uninitialized|union|unless|until|when|while|with|yield)\b/, {
|
|
3482
3443
|
pattern: /(\.\s*)(?:is_a|responds_to)\?/,
|
|
@@ -3523,7 +3484,7 @@ Prism.languages.markup = {
|
|
|
3523
3484
|
greedy: !0
|
|
3524
3485
|
}
|
|
3525
3486
|
});
|
|
3526
|
-
})(Prism), (function(e) {
|
|
3487
|
+
})(Prism$1), (function(e) {
|
|
3527
3488
|
var t = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/, t = (e.languages.css.selector = {
|
|
3528
3489
|
pattern: e.languages.css.selector.pattern,
|
|
3529
3490
|
lookbehind: !0,
|
|
@@ -3607,7 +3568,7 @@ Prism.languages.markup = {
|
|
|
3607
3568
|
unit: t,
|
|
3608
3569
|
number: n
|
|
3609
3570
|
});
|
|
3610
|
-
})(Prism), Prism.languages.csv = {
|
|
3571
|
+
})(Prism$1), Prism$1.languages.csv = {
|
|
3611
3572
|
value: /[^\r\n,"]+|"(?:[^"]|"")*"(?!")/,
|
|
3612
3573
|
punctuation: /,/
|
|
3613
3574
|
}, (function(e) {
|
|
@@ -3668,7 +3629,7 @@ Prism.languages.markup = {
|
|
|
3668
3629
|
operator: /\.{3}|_\|_|&&?|\|\|?|[=!]~|[<>=!]=?|[+\-*/?]/,
|
|
3669
3630
|
punctuation: /[()[\]{},.:]/
|
|
3670
3631
|
}, e.languages.cue["string-literal"].inside.interpolation.inside.expression.inside = e.languages.cue;
|
|
3671
|
-
})(Prism), Prism.languages.cypher = {
|
|
3632
|
+
})(Prism$1), Prism$1.languages.cypher = {
|
|
3672
3633
|
comment: /\/\/.*/,
|
|
3673
3634
|
string: {
|
|
3674
3635
|
pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/,
|
|
@@ -3696,7 +3657,7 @@ Prism.languages.markup = {
|
|
|
3696
3657
|
number: /\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/,
|
|
3697
3658
|
operator: /:|<--?|--?>?|<>|=~?|[<>]=?|[+*/%^|]|\.\.\.?/,
|
|
3698
3659
|
punctuation: /[()[\]{},;.]/
|
|
3699
|
-
}, Prism.languages.d = Prism.languages.extend("clike", {
|
|
3660
|
+
}, Prism$1.languages.d = Prism$1.languages.extend("clike", {
|
|
3700
3661
|
comment: [{
|
|
3701
3662
|
pattern: /^\s*#!.+/,
|
|
3702
3663
|
greedy: !0
|
|
@@ -3729,7 +3690,7 @@ Prism.languages.markup = {
|
|
|
3729
3690
|
lookbehind: !0
|
|
3730
3691
|
}],
|
|
3731
3692
|
operator: /\|[|=]?|&[&=]?|\+[+=]?|-[-=]?|\.?\.\.|=[>=]?|!(?:i[ns]\b|<>?=?|>=?|=)?|\bi[ns]\b|(?:<[<>]?|>>?>?|\^\^|[*\/%^~])=?/
|
|
3732
|
-
}), Prism.languages.insertBefore("d", "string", { char: /'(?:\\(?:\W|\w+)|[^\\])'/ }), Prism.languages.insertBefore("d", "keyword", { property: /\B@\w*/ }), Prism.languages.insertBefore("d", "function", { register: {
|
|
3693
|
+
}), Prism$1.languages.insertBefore("d", "string", { char: /'(?:\\(?:\W|\w+)|[^\\])'/ }), Prism$1.languages.insertBefore("d", "keyword", { property: /\B@\w*/ }), Prism$1.languages.insertBefore("d", "function", { register: {
|
|
3733
3694
|
pattern: /\b(?:[ABCD][LHX]|E?(?:BP|DI|SI|SP)|[BS]PL|[ECSDGF]S|CR[0234]|[DS]IL|DR[012367]|E[ABCD]X|X?MM[0-7]|R(?:1[0-5]|[89])[BWD]?|R[ABCD]X|R[BS]P|R[DS]I|TR[3-7]|XMM(?:1[0-5]|[89])|YMM(?:1[0-5]|\d))\b|\bST(?:\([0-7]\)|\b)/,
|
|
3734
3695
|
alias: "variable"
|
|
3735
3696
|
} }), (function(e) {
|
|
@@ -3781,7 +3742,7 @@ Prism.languages.markup = {
|
|
|
3781
3742
|
operator: /[?&|]/
|
|
3782
3743
|
}
|
|
3783
3744
|
} });
|
|
3784
|
-
})(Prism), Prism.languages.dataweave = {
|
|
3745
|
+
})(Prism$1), Prism$1.languages.dataweave = {
|
|
3785
3746
|
url: /\b[A-Za-z]+:\/\/[\w/:.?=&-]+|\burn:[\w:.?=&-]+/,
|
|
3786
3747
|
property: {
|
|
3787
3748
|
pattern: /(?:\b\w+#)?(?:"(?:\\.|[^\\"\r\n])*"|\b\w+)(?=\s*[:@])/,
|
|
@@ -3815,7 +3776,7 @@ Prism.languages.markup = {
|
|
|
3815
3776
|
punctuation: /[{}[\];(),.:@]/,
|
|
3816
3777
|
operator: /<<|>>|->|[<>~=]=?|!=|--?-?|\+\+?|!|\?/,
|
|
3817
3778
|
boolean: /\b(?:false|true)\b/
|
|
3818
|
-
}, Prism.languages.dax = {
|
|
3779
|
+
}, Prism$1.languages.dax = {
|
|
3819
3780
|
comment: {
|
|
3820
3781
|
pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/).*)/,
|
|
3821
3782
|
lookbehind: !0
|
|
@@ -3841,7 +3802,7 @@ Prism.languages.markup = {
|
|
|
3841
3802
|
number: /\b\d+(?:\.\d*)?|\B\.\d+\b/,
|
|
3842
3803
|
operator: /:=|[-+*\/=^]|&&?|\|\||<(?:=>?|<|>)?|>[>=]?|\b(?:IN|NOT)\b/i,
|
|
3843
3804
|
punctuation: /[;\[\](){}`,.]/
|
|
3844
|
-
}, Prism.languages.dhall = {
|
|
3805
|
+
}, Prism$1.languages.dhall = {
|
|
3845
3806
|
comment: /--.*|\{-(?:[^-{]|-(?!\})|\{(?!-)|\{-(?:[^-{]|-(?!\})|\{(?!-))*-\})*-\}/,
|
|
3846
3807
|
string: {
|
|
3847
3808
|
pattern: /"(?:[^"\\]|\\.)*"|''(?:[^']|'(?!')|'''|''\$\{)*''(?!'|\$)/,
|
|
@@ -3891,7 +3852,7 @@ Prism.languages.markup = {
|
|
|
3891
3852
|
operator: /\/\\|\/\/\\\\|&&|\|\||===|[!=]=|\/\/|->|\+\+|::|[+*#@=:?<>|\\\u2227\u2a53\u2261\u2afd\u03bb\u2192]/,
|
|
3892
3853
|
punctuation: /\.\.|[{}\[\](),./]/,
|
|
3893
3854
|
"class-name": /\b[A-Z]\w*\b/
|
|
3894
|
-
}, Prism.languages.dhall.string.inside.interpolation.inside.expression.inside = Prism.languages.dhall, (function(a) {
|
|
3855
|
+
}, Prism$1.languages.dhall.string.inside.interpolation.inside.expression.inside = Prism$1.languages.dhall, (function(a) {
|
|
3895
3856
|
a.languages.diff = { coord: [
|
|
3896
3857
|
/^(?:\*{3}|-{3}|\+{3}).*$/m,
|
|
3897
3858
|
/^@@.*@@$/m,
|
|
@@ -3922,7 +3883,7 @@ Prism.languages.markup = {
|
|
|
3922
3883
|
}
|
|
3923
3884
|
};
|
|
3924
3885
|
}), Object.defineProperty(a.languages.diff, "PREFIXES", { value: r });
|
|
3925
|
-
})(Prism), (function(m) {
|
|
3886
|
+
})(Prism$1), (function(m) {
|
|
3926
3887
|
function g(e, t) {
|
|
3927
3888
|
return "___" + e.toUpperCase() + t + "___";
|
|
3928
3889
|
}
|
|
@@ -3946,7 +3907,7 @@ Prism.languages.markup = {
|
|
|
3946
3907
|
})(d.tokens));
|
|
3947
3908
|
} }
|
|
3948
3909
|
});
|
|
3949
|
-
})(Prism), (function(e) {
|
|
3910
|
+
})(Prism$1), (function(e) {
|
|
3950
3911
|
e.languages.django = {
|
|
3951
3912
|
comment: /^\{#[\s\S]*?#\}$/,
|
|
3952
3913
|
tag: {
|
|
@@ -3990,7 +3951,7 @@ Prism.languages.markup = {
|
|
|
3990
3951
|
}), e.hooks.add("after-tokenize", function(e$1) {
|
|
3991
3952
|
n.tokenizePlaceholders(e$1, "jinja2");
|
|
3992
3953
|
});
|
|
3993
|
-
})(Prism), Prism.languages["dns-zone-file"] = {
|
|
3954
|
+
})(Prism$1), Prism$1.languages["dns-zone-file"] = {
|
|
3994
3955
|
comment: /;.*/,
|
|
3995
3956
|
string: {
|
|
3996
3957
|
pattern: /"(?:\\.|[^"\\\r\n])*"/,
|
|
@@ -4015,7 +3976,7 @@ Prism.languages.markup = {
|
|
|
4015
3976
|
alias: "keyword"
|
|
4016
3977
|
},
|
|
4017
3978
|
punctuation: /[()]/
|
|
4018
|
-
}, Prism.languages["dns-zone"] = Prism.languages["dns-zone-file"], (function(e) {
|
|
3979
|
+
}, Prism$1.languages["dns-zone"] = Prism$1.languages["dns-zone-file"], (function(e) {
|
|
4019
3980
|
var t = /\\[\r\n](?:\s|\\[\r\n]|#.*(?!.))*(?![\s#]|\\[\r\n])/.source, n = /(?:[ \t]+(?![ \t])(?:<SP_BS>)?|<SP_BS>)/.source.replace(/<SP_BS>/g, function() {
|
|
4020
3981
|
return t;
|
|
4021
3982
|
}), a = /"(?:[^"\\\r\n]|\\(?:\r\n|[\s\S]))*"|'(?:[^'\\\r\n]|\\(?:\r\n|[\s\S]))*'/.source, r = /--[\w-]+=(?:<STR>|(?!["'])(?:[^\s\\]|\\.)+)/.source.replace(/<STR>/g, function() {
|
|
@@ -4087,7 +4048,7 @@ Prism.languages.markup = {
|
|
|
4087
4048
|
},
|
|
4088
4049
|
comment: o
|
|
4089
4050
|
}, e.languages.dockerfile = e.languages.docker;
|
|
4090
|
-
})(Prism), (function(e) {
|
|
4051
|
+
})(Prism$1), (function(e) {
|
|
4091
4052
|
var n = "(?:" + [
|
|
4092
4053
|
/[a-zA-Z_\x80-\uFFFF][\w\x80-\uFFFF]*/.source,
|
|
4093
4054
|
/-?(?:\.\d+|\d+(?:\.\d*)?)/.source,
|
|
@@ -4147,7 +4108,7 @@ Prism.languages.markup = {
|
|
|
4147
4108
|
operator: /[=:]|-[->]/,
|
|
4148
4109
|
punctuation: /[\[\]{};,]/
|
|
4149
4110
|
}, e.languages.gv = e.languages.dot;
|
|
4150
|
-
})(Prism), Prism.languages.ebnf = {
|
|
4111
|
+
})(Prism$1), Prism$1.languages.ebnf = {
|
|
4151
4112
|
comment: /\(\*[\s\S]*?\*\)/,
|
|
4152
4113
|
string: {
|
|
4153
4114
|
pattern: /"[^"\r\n]*"|'[^'\r\n]*'/,
|
|
@@ -4166,7 +4127,7 @@ Prism.languages.markup = {
|
|
|
4166
4127
|
rule: /\b[a-z]\w*(?:[ \t]+[a-z]\w*)*\b/i,
|
|
4167
4128
|
punctuation: /\([:/]|[:/]\)|[.,;()[\]{}]/,
|
|
4168
4129
|
operator: /[-=|*/!]/
|
|
4169
|
-
}, Prism.languages.editorconfig = {
|
|
4130
|
+
}, Prism$1.languages.editorconfig = {
|
|
4170
4131
|
comment: /[;#].*/,
|
|
4171
4132
|
section: {
|
|
4172
4133
|
pattern: /(^[ \t]*)\[.+\]/m,
|
|
@@ -4188,7 +4149,7 @@ Prism.languages.markup = {
|
|
|
4188
4149
|
alias: "attr-value",
|
|
4189
4150
|
inside: { punctuation: /^=/ }
|
|
4190
4151
|
}
|
|
4191
|
-
}, Prism.languages.eiffel = {
|
|
4152
|
+
}, Prism$1.languages.eiffel = {
|
|
4192
4153
|
comment: /--.*/,
|
|
4193
4154
|
string: [
|
|
4194
4155
|
{
|
|
@@ -4227,7 +4188,7 @@ Prism.languages.markup = {
|
|
|
4227
4188
|
}), t.hooks.add("after-tokenize", function(e) {
|
|
4228
4189
|
t.languages["markup-templating"].tokenizePlaceholders(e, "ejs");
|
|
4229
4190
|
}), t.languages.eta = t.languages.ejs;
|
|
4230
|
-
})(Prism), Prism.languages.elixir = {
|
|
4191
|
+
})(Prism$1), Prism$1.languages.elixir = {
|
|
4231
4192
|
doc: {
|
|
4232
4193
|
pattern: /@(?:doc|moduledoc)\s+(?:("""|''')[\s\S]*?\1|("|')(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2)/,
|
|
4233
4194
|
inside: {
|
|
@@ -4295,7 +4256,7 @@ Prism.languages.markup = {
|
|
|
4295
4256
|
}
|
|
4296
4257
|
],
|
|
4297
4258
|
punctuation: /<<|>>|[.,%\[\]{}()]/
|
|
4298
|
-
}, Prism.languages.elixir.string.forEach(function(e) {
|
|
4259
|
+
}, Prism$1.languages.elixir.string.forEach(function(e) {
|
|
4299
4260
|
e.inside = { interpolation: {
|
|
4300
4261
|
pattern: /#\{[^}]+\}/,
|
|
4301
4262
|
inside: {
|
|
@@ -4303,10 +4264,10 @@ Prism.languages.markup = {
|
|
|
4303
4264
|
pattern: /^#\{|\}$/,
|
|
4304
4265
|
alias: "punctuation"
|
|
4305
4266
|
},
|
|
4306
|
-
rest: Prism.languages.elixir
|
|
4267
|
+
rest: Prism$1.languages.elixir
|
|
4307
4268
|
}
|
|
4308
4269
|
} };
|
|
4309
|
-
}), Prism.languages.elm = {
|
|
4270
|
+
}), Prism$1.languages.elm = {
|
|
4310
4271
|
comment: /--.*|\{-[\s\S]*?-\}/,
|
|
4311
4272
|
char: {
|
|
4312
4273
|
pattern: /'(?:[^\\'\r\n]|\\(?:[abfnrtv\\']|\d+|x[0-9a-fA-F]+|u\{[0-9a-fA-F]+\}))'/,
|
|
@@ -4331,7 +4292,7 @@ Prism.languages.markup = {
|
|
|
4331
4292
|
hvariable: /\b(?:[A-Z]\w*\.)*[a-z]\w*\b/,
|
|
4332
4293
|
constant: /\b(?:[A-Z]\w*\.)*[A-Z]\w*\b/,
|
|
4333
4294
|
punctuation: /[{}[\]|(),.:]/
|
|
4334
|
-
}, Prism.languages.lua = {
|
|
4295
|
+
}, Prism$1.languages.lua = {
|
|
4335
4296
|
comment: /^#!.+|--(?:\[(=*)\[[\s\S]*?\]\1\]|.*)/m,
|
|
4336
4297
|
string: {
|
|
4337
4298
|
pattern: /(["'])(?:(?!\1)[^\\\r\n]|\\z(?:\r\n|\s)|\\(?:\r\n|[^z]))*\1|\[(=*)\[[\s\S]*?\]\2\]/,
|
|
@@ -4360,7 +4321,7 @@ Prism.languages.markup = {
|
|
|
4360
4321
|
}), t.hooks.add("after-tokenize", function(e) {
|
|
4361
4322
|
t.languages["markup-templating"].tokenizePlaceholders(e, "etlua");
|
|
4362
4323
|
});
|
|
4363
|
-
})(Prism), (function(t) {
|
|
4324
|
+
})(Prism$1), (function(t) {
|
|
4364
4325
|
t.languages.erb = {
|
|
4365
4326
|
delimiter: {
|
|
4366
4327
|
pattern: /^(\s*)<%=?|%>(?=\s*$)/,
|
|
@@ -4377,7 +4338,7 @@ Prism.languages.markup = {
|
|
|
4377
4338
|
}), t.hooks.add("after-tokenize", function(e) {
|
|
4378
4339
|
t.languages["markup-templating"].tokenizePlaceholders(e, "erb");
|
|
4379
4340
|
});
|
|
4380
|
-
})(Prism), Prism.languages.erlang = {
|
|
4341
|
+
})(Prism$1), Prism$1.languages.erlang = {
|
|
4381
4342
|
comment: /%.+/,
|
|
4382
4343
|
string: {
|
|
4383
4344
|
pattern: /"(?:\\.|[^\\"\r\n])*"/,
|
|
@@ -4416,7 +4377,7 @@ Prism.languages.markup = {
|
|
|
4416
4377
|
],
|
|
4417
4378
|
atom: /\b[a-z][\w@]*/,
|
|
4418
4379
|
punctuation: /[()[\]{}:;,.#|]|<<|>>/
|
|
4419
|
-
}, Prism.languages["excel-formula"] = {
|
|
4380
|
+
}, Prism$1.languages["excel-formula"] = {
|
|
4420
4381
|
comment: {
|
|
4421
4382
|
pattern: /(\bN\(\s*)"(?:[^"]|"")*"(?=\s*\))/i,
|
|
4422
4383
|
lookbehind: !0,
|
|
@@ -4466,7 +4427,7 @@ Prism.languages.markup = {
|
|
|
4466
4427
|
boolean: /\b(?:FALSE|TRUE)\b/i,
|
|
4467
4428
|
operator: /[-+*/^%=&,]|<[=>]?|>=?/,
|
|
4468
4429
|
punctuation: /[[\]();{}|]/
|
|
4469
|
-
}, Prism.languages.xlsx = Prism.languages.xls = Prism.languages["excel-formula"], Prism.languages.fsharp = Prism.languages.extend("clike", {
|
|
4430
|
+
}, Prism$1.languages.xlsx = Prism$1.languages.xls = Prism$1.languages["excel-formula"], Prism$1.languages.fsharp = Prism$1.languages.extend("clike", {
|
|
4470
4431
|
comment: [{
|
|
4471
4432
|
pattern: /(^|[^\\])\(\*(?!\))[\s\S]*?\*\)/,
|
|
4472
4433
|
lookbehind: !0,
|
|
@@ -4496,7 +4457,7 @@ Prism.languages.markup = {
|
|
|
4496
4457
|
/\b\d+(?:[IlLsy]|UL|u[lsy]?)?\b/
|
|
4497
4458
|
],
|
|
4498
4459
|
operator: /([<>~&^])\1\1|([*.:<>&])\2|<-|->|[!=:]=|<?\|{1,3}>?|\??(?:<=|>=|<>|[-+*/%=<>])\??|[!?^&]|~[+~-]|:>|:\?>?/
|
|
4499
|
-
}), Prism.languages.insertBefore("fsharp", "keyword", { preprocessor: {
|
|
4460
|
+
}), Prism$1.languages.insertBefore("fsharp", "keyword", { preprocessor: {
|
|
4500
4461
|
pattern: /(^[\t ]*)#.*/m,
|
|
4501
4462
|
lookbehind: !0,
|
|
4502
4463
|
alias: "property",
|
|
@@ -4505,10 +4466,10 @@ Prism.languages.markup = {
|
|
|
4505
4466
|
lookbehind: !0,
|
|
4506
4467
|
alias: "keyword"
|
|
4507
4468
|
} }
|
|
4508
|
-
} }), Prism.languages.insertBefore("fsharp", "punctuation", { "computation-expression": {
|
|
4469
|
+
} }), Prism$1.languages.insertBefore("fsharp", "punctuation", { "computation-expression": {
|
|
4509
4470
|
pattern: /\b[_a-z]\w*(?=\s*\{)/i,
|
|
4510
4471
|
alias: "keyword"
|
|
4511
|
-
} }), Prism.languages.insertBefore("fsharp", "string", {
|
|
4472
|
+
} }), Prism$1.languages.insertBefore("fsharp", "string", {
|
|
4512
4473
|
annotation: {
|
|
4513
4474
|
pattern: /\[<.+?>\]/,
|
|
4514
4475
|
greedy: !0,
|
|
@@ -4520,7 +4481,7 @@ Prism.languages.markup = {
|
|
|
4520
4481
|
},
|
|
4521
4482
|
"annotation-content": {
|
|
4522
4483
|
pattern: /[\s\S]+/,
|
|
4523
|
-
inside: Prism.languages.fsharp
|
|
4484
|
+
inside: Prism$1.languages.fsharp
|
|
4524
4485
|
}
|
|
4525
4486
|
}
|
|
4526
4487
|
},
|
|
@@ -5330,7 +5291,7 @@ Prism.languages.markup = {
|
|
|
5330
5291
|
"input<sequence-unsafe",
|
|
5331
5292
|
"output>sequence"
|
|
5332
5293
|
]), e.languages.factor = i;
|
|
5333
|
-
})(Prism), Prism.languages.false = {
|
|
5294
|
+
})(Prism$1), Prism$1.languages.false = {
|
|
5334
5295
|
comment: { pattern: /\{[^}]*\}/ },
|
|
5335
5296
|
string: {
|
|
5336
5297
|
pattern: /"[^"]*"/,
|
|
@@ -5352,11 +5313,11 @@ Prism.languages.markup = {
|
|
|
5352
5313
|
pattern: /[()<BDO®]/,
|
|
5353
5314
|
alias: "bold"
|
|
5354
5315
|
}
|
|
5355
|
-
}, Prism.languages["firestore-security-rules"] = Prism.languages.extend("clike", {
|
|
5316
|
+
}, Prism$1.languages["firestore-security-rules"] = Prism$1.languages.extend("clike", {
|
|
5356
5317
|
comment: /\/\/.*/,
|
|
5357
5318
|
keyword: /\b(?:allow|function|if|match|null|return|rules_version|service)\b/,
|
|
5358
5319
|
operator: /&&|\|\||[<>!=]=?|[-+*/%]|\b(?:in|is)\b/
|
|
5359
|
-
}), delete Prism.languages["firestore-security-rules"]["class-name"], Prism.languages.insertBefore("firestore-security-rules", "keyword", {
|
|
5320
|
+
}), delete Prism$1.languages["firestore-security-rules"]["class-name"], Prism$1.languages.insertBefore("firestore-security-rules", "keyword", {
|
|
5360
5321
|
path: {
|
|
5361
5322
|
pattern: /(^|[\s(),])(?:\/(?:[\w\xA0-\uFFFF]+|\{[\w\xA0-\uFFFF]+(?:=\*\*)?\}|\$\([\w\xA0-\uFFFF.]+\)))+/,
|
|
5362
5323
|
lookbehind: !0,
|
|
@@ -5393,7 +5354,7 @@ Prism.languages.markup = {
|
|
|
5393
5354
|
pattern: /(^|[^$]\B)\$(?:Diff|Enum|Exact|Keys|ObjMap|PropertyType|Record|Shape|Subtype|Supertype|await)\b(?!\$)/,
|
|
5394
5355
|
lookbehind: !0
|
|
5395
5356
|
});
|
|
5396
|
-
})(Prism), Prism.languages.fortran = {
|
|
5357
|
+
})(Prism$1), Prism$1.languages.fortran = {
|
|
5397
5358
|
"quoted-number": {
|
|
5398
5359
|
pattern: /[BOZ](['"])[A-F0-9]+\1/i,
|
|
5399
5360
|
alias: "number"
|
|
@@ -5502,13 +5463,13 @@ Prism.languages.markup = {
|
|
|
5502
5463
|
}), n.hooks.add("after-tokenize", function(e$1) {
|
|
5503
5464
|
n.languages["markup-templating"].tokenizePlaceholders(e$1, "ftl");
|
|
5504
5465
|
});
|
|
5505
|
-
})(Prism), Prism.languages.gamemakerlanguage = Prism.languages.gml = Prism.languages.extend("clike", {
|
|
5466
|
+
})(Prism$1), Prism$1.languages.gamemakerlanguage = Prism$1.languages.gml = Prism$1.languages.extend("clike", {
|
|
5506
5467
|
keyword: /\b(?:break|case|continue|default|do|else|enum|exit|for|globalvar|if|repeat|return|switch|until|var|while)\b/,
|
|
5507
5468
|
number: /(?:\b0x[\da-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ulf]{0,4}/i,
|
|
5508
5469
|
operator: /--|\+\+|[-+%/=]=?|!=|\*\*?=?|<[<=>]?|>[=>]?|&&?|\^\^?|\|\|?|~|\b(?:and|at|not|or|with|xor)\b/,
|
|
5509
5470
|
constant: /\b(?:GM_build_date|GM_version|action_(?:continue|restart|reverse|stop)|all|gamespeed_(?:fps|microseconds)|global|local|noone|other|pi|pointer_(?:invalid|null)|self|timezone_(?:local|utc)|undefined|ev_(?:create|destroy|step|alarm|keyboard|mouse|collision|other|draw|draw_(?:begin|end|post|pre)|keypress|keyrelease|trigger|(?:left|middle|no|right)_button|(?:left|middle|right)_press|(?:left|middle|right)_release|mouse_(?:enter|leave|wheel_down|wheel_up)|global_(?:left|middle|right)_button|global_(?:left|middle|right)_press|global_(?:left|middle|right)_release|joystick(?:1|2)_(?:button1|button2|button3|button4|button5|button6|button7|button8|down|left|right|up)|outside|boundary|game_start|game_end|room_start|room_end|no_more_lives|animation_end|end_of_path|no_more_health|user\d|gui|gui_begin|gui_end|step_(?:begin|end|normal))|vk_(?:alt|anykey|backspace|control|delete|down|end|enter|escape|home|insert|left|nokey|pagedown|pageup|pause|printscreen|return|right|shift|space|tab|up|f\d|numpad\d|add|decimal|divide|lalt|lcontrol|lshift|multiply|ralt|rcontrol|rshift|subtract)|achievement_(?:filter_(?:all_players|favorites_only|friends_only)|friends_info|info|leaderboard_info|our_info|pic_loaded|show_(?:achievement|bank|friend_picker|leaderboard|profile|purchase_prompt|ui)|type_challenge|type_score_challenge)|asset_(?:font|object|path|room|script|shader|sound|sprite|tiles|timeline|unknown)|audio_(?:3d|falloff_(?:exponent_distance|exponent_distance_clamped|inverse_distance|inverse_distance_clamped|linear_distance|linear_distance_clamped|none)|mono|new_system|old_system|stereo)|bm_(?:add|complex|dest_alpha|dest_color|dest_colour|inv_dest_alpha|inv_dest_color|inv_dest_colour|inv_src_alpha|inv_src_color|inv_src_colour|max|normal|one|src_alpha|src_alpha_sat|src_color|src_colour|subtract|zero)|browser_(?:chrome|firefox|ie|ie_mobile|not_a_browser|opera|safari|safari_mobile|tizen|unknown|windows_store)|buffer_(?:bool|f16|f32|f64|fast|fixed|generalerror|grow|invalidtype|network|outofbounds|outofspace|s16|s32|s8|seek_end|seek_relative|seek_start|string|text|u16|u32|u64|u8|vbuffer|wrap)|c_(?:aqua|black|blue|dkgray|fuchsia|gray|green|lime|ltgray|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow)|cmpfunc_(?:always|equal|greater|greaterequal|less|lessequal|never|notequal)|cr_(?:appstart|arrow|beam|cross|default|drag|handpoint|hourglass|none|size_all|size_nesw|size_ns|size_nwse|size_we|uparrow)|cull_(?:clockwise|counterclockwise|noculling)|device_(?:emulator|tablet)|device_ios_(?:ipad|ipad_retina|iphone|iphone5|iphone6|iphone6plus|iphone_retina|unknown)|display_(?:landscape|landscape_flipped|portrait|portrait_flipped)|dll_(?:cdecl|cdel|stdcall)|ds_type_(?:grid|list|map|priority|queue|stack)|ef_(?:cloud|ellipse|explosion|firework|flare|rain|ring|smoke|smokeup|snow|spark|star)|fa_(?:archive|bottom|center|directory|hidden|left|middle|readonly|right|sysfile|top|volumeid)|fb_login_(?:default|fallback_to_webview|forcing_safari|forcing_webview|no_fallback_to_webview|use_system_account)|iap_(?:available|canceled|ev_consume|ev_product|ev_purchase|ev_restore|ev_storeload|failed|purchased|refunded|status_available|status_loading|status_processing|status_restoring|status_unavailable|status_uninitialised|storeload_failed|storeload_ok|unavailable)|leaderboard_type_(?:number|time_mins_secs)|lighttype_(?:dir|point)|matrix_(?:projection|view|world)|mb_(?:any|left|middle|none|right)|network_(?:config_(?:connect_timeout|disable_reliable_udp|enable_reliable_udp|use_non_blocking_socket)|socket_(?:bluetooth|tcp|udp)|type_(?:connect|data|disconnect|non_blocking_connect))|of_challenge_(?:lose|tie|win)|os_(?:android|ios|linux|macosx|ps3|ps4|psvita|unknown|uwp|win32|win8native|windows|winphone|xboxone)|phy_debug_render_(?:aabb|collision_pairs|coms|core_shapes|joints|obb|shapes)|phy_joint_(?:anchor_1_x|anchor_1_y|anchor_2_x|anchor_2_y|angle|angle_limits|damping_ratio|frequency|length_1|length_2|lower_angle_limit|max_force|max_length|max_motor_force|max_motor_torque|max_torque|motor_force|motor_speed|motor_torque|reaction_force_x|reaction_force_y|reaction_torque|speed|translation|upper_angle_limit)|phy_particle_data_flag_(?:category|color|colour|position|typeflags|velocity)|phy_particle_flag_(?:colormixing|colourmixing|elastic|powder|spring|tensile|viscous|wall|water|zombie)|phy_particle_group_flag_(?:rigid|solid)|pr_(?:linelist|linestrip|pointlist|trianglefan|trianglelist|trianglestrip)|ps_(?:distr|shape)_(?:diamond|ellipse|gaussian|invgaussian|line|linear|rectangle)|pt_shape_(?:circle|cloud|disk|explosion|flare|line|pixel|ring|smoke|snow|spark|sphere|square|star)|ty_(?:real|string)|gp_(?:face\d|axislh|axislv|axisrh|axisrv|padd|padl|padr|padu|select|shoulderl|shoulderlb|shoulderr|shoulderrb|start|stickl|stickr)|lb_disp_(?:none|numeric|time_ms|time_sec)|lb_sort_(?:ascending|descending|none)|ov_(?:achievements|community|friends|gamegroup|players|settings)|ugc_(?:filetype_(?:community|microtrans)|list_(?:Favorited|Followed|Published|Subscribed|UsedOrPlayed|VotedDown|VotedOn|VotedUp|WillVoteLater)|match_(?:AllGuides|Artwork|Collections|ControllerBindings|IntegratedGuides|Items|Items_Mtx|Items_ReadyToUse|Screenshots|UsableInGame|Videos|WebGuides)|query_(?:AcceptedForGameRankedByAcceptanceDate|CreatedByFriendsRankedByPublicationDate|FavoritedByFriendsRankedByPublicationDate|NotYetRated)|query_RankedBy(?:NumTimesReported|PublicationDate|TextSearch|TotalVotesAsc|Trend|Vote|VotesUp)|result_success|sortorder_CreationOrder(?:Asc|Desc)|sortorder_(?:ForModeration|LastUpdatedDesc|SubscriptionDateDesc|TitleAsc|VoteScoreDesc)|visibility_(?:friends_only|private|public))|vertex_usage_(?:binormal|blendindices|blendweight|color|colour|depth|fog|normal|position|psize|sample|tangent|texcoord|textcoord)|vertex_type_(?:float\d|color|colour|ubyte4)|input_type|layerelementtype_(?:background|instance|oldtilemap|particlesystem|sprite|tile|tilemap|undefined)|se_(?:chorus|compressor|echo|equalizer|flanger|gargle|none|reverb)|text_type|tile_(?:flip|index_mask|mirror|rotate)|(?:obj|rm|scr|spr)\w+)\b/,
|
|
5510
5471
|
variable: /\b(?:alarm|application_surface|async_load|background_(?:alpha|blend|color|colour|foreground|height|hspeed|htiled|index|showcolor|showcolour|visible|vspeed|vtiled|width|x|xscale|y|yscale)|bbox_(?:bottom|left|right|top)|browser_(?:height|width)|caption_(?:health|lives|score)|current_(?:day|hour|minute|month|second|time|weekday|year)|cursor_sprite|debug_mode|delta_time|direction|display_aa|error_(?:last|occurred)|event_(?:action|number|object|type)|fps|fps_real|friction|game_(?:display|project|save)_(?:id|name)|gamemaker_(?:pro|registered|version)|gravity|gravity_direction|(?:h|v)speed|health|iap_data|id|image_(?:alpha|angle|blend|depth|index|number|speed|xscale|yscale)|instance_(?:count|id)|keyboard_(?:key|lastchar|lastkey|string)|layer|lives|mask_index|mouse_(?:button|lastbutton|x|y)|object_index|os_(?:browser|device|type|version)|path_(?:endaction|index|orientation|position|positionprevious|scale|speed)|persistent|phy_(?:rotation|(?:col_normal|collision|com|linear_velocity|position|speed)_(?:x|y)|angular_(?:damping|velocity)|position_(?:x|y)previous|speed|linear_damping|bullet|fixed_rotation|active|mass|inertia|dynamic|kinematic|sleeping|collision_points)|pointer_(?:invalid|null)|room|room_(?:caption|first|height|last|persistent|speed|width)|score|secure_mode|show_(?:health|lives|score)|solid|speed|sprite_(?:height|index|width|xoffset|yoffset)|temp_directory|timeline_(?:index|loop|position|running|speed)|transition_(?:color|kind|steps)|undefined|view_(?:angle|current|enabled|(?:h|v)(?:border|speed)|(?:h|w|x|y)port|(?:h|w|x|y)view|object|surface_id|visible)|visible|webgl_enabled|working_directory|(?:x|y)(?:previous|start)|x|y|argument(?:_relitive|_count|\d)|argument|global|local|other|self)\b/
|
|
5511
|
-
}), Prism.languages.gap = {
|
|
5472
|
+
}), Prism$1.languages.gap = {
|
|
5512
5473
|
shell: {
|
|
5513
5474
|
pattern: /^gap>[\s\S]*?(?=^gap>|$(?![\s\S]))/m,
|
|
5514
5475
|
greedy: !0,
|
|
@@ -5549,7 +5510,7 @@ Prism.languages.markup = {
|
|
|
5549
5510
|
},
|
|
5550
5511
|
operator: /->|[-+*/^~=!]|<>|[<>]=?|:=|\.\./,
|
|
5551
5512
|
punctuation: /[()[\]{},;.:]/
|
|
5552
|
-
}, Prism.languages.gap.shell.inside.gap.inside = Prism.languages.gap, Prism.languages.gcode = {
|
|
5513
|
+
}, Prism$1.languages.gap.shell.inside.gap.inside = Prism$1.languages.gap, Prism$1.languages.gcode = {
|
|
5553
5514
|
comment: /;.*|\B\(.*?\)\B/,
|
|
5554
5515
|
string: {
|
|
5555
5516
|
pattern: /"(?:""|[^"])*"/,
|
|
@@ -5563,7 +5524,7 @@ Prism.languages.markup = {
|
|
|
5563
5524
|
alias: "number"
|
|
5564
5525
|
},
|
|
5565
5526
|
punctuation: /[:*]/
|
|
5566
|
-
}, Prism.languages.gdscript = {
|
|
5527
|
+
}, Prism$1.languages.gdscript = {
|
|
5567
5528
|
comment: /#.*/,
|
|
5568
5529
|
string: {
|
|
5569
5530
|
pattern: /@?(?:("|')(?:(?!\1)[^\n\\]|\\[\s\S])*\1(?!"|')|"""(?:[^\\]|\\[\s\S])*?""")/,
|
|
@@ -5581,7 +5542,7 @@ Prism.languages.markup = {
|
|
|
5581
5542
|
boolean: /\b(?:false|true)\b/,
|
|
5582
5543
|
operator: /->|:=|&&|\|\||<<|>>|[-+*/%&|!<>=]=?|[~^]/,
|
|
5583
5544
|
punctuation: /[.:,;()[\]{}]/
|
|
5584
|
-
}, Prism.languages.gedcom = {
|
|
5545
|
+
}, Prism$1.languages.gedcom = {
|
|
5585
5546
|
"line-value": {
|
|
5586
5547
|
pattern: /(^[\t ]*\d+ +(?:@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@ +)?\w+ ).+/m,
|
|
5587
5548
|
lookbehind: !0,
|
|
@@ -5604,7 +5565,7 @@ Prism.languages.markup = {
|
|
|
5604
5565
|
pattern: /@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@/,
|
|
5605
5566
|
alias: "variable"
|
|
5606
5567
|
}
|
|
5607
|
-
}, Prism.languages.gettext = {
|
|
5568
|
+
}, Prism$1.languages.gettext = {
|
|
5608
5569
|
comment: [
|
|
5609
5570
|
{
|
|
5610
5571
|
pattern: /# .*/,
|
|
@@ -5644,7 +5605,7 @@ Prism.languages.markup = {
|
|
|
5644
5605
|
keyword: /^msg(?:ctxt|id|id_plural|str)\b/m,
|
|
5645
5606
|
number: /\b\d+\b/,
|
|
5646
5607
|
punctuation: /[\[\]]/
|
|
5647
|
-
}, Prism.languages.po = Prism.languages.gettext, (function(e) {
|
|
5608
|
+
}, Prism$1.languages.po = Prism$1.languages.gettext, (function(e) {
|
|
5648
5609
|
var t = /(?:\r?\n|\r)[ \t]*\|.+\|(?:(?!\|).)*/.source;
|
|
5649
5610
|
e.languages.gherkin = {
|
|
5650
5611
|
pystring: {
|
|
@@ -5722,7 +5683,7 @@ Prism.languages.markup = {
|
|
|
5722
5683
|
alias: "variable"
|
|
5723
5684
|
}
|
|
5724
5685
|
};
|
|
5725
|
-
})(Prism), Prism.languages.git = {
|
|
5686
|
+
})(Prism$1), Prism$1.languages.git = {
|
|
5726
5687
|
comment: /^#.*/m,
|
|
5727
5688
|
deleted: /^[-–].*/m,
|
|
5728
5689
|
inserted: /^\+.*/m,
|
|
@@ -5733,7 +5694,7 @@ Prism.languages.markup = {
|
|
|
5733
5694
|
},
|
|
5734
5695
|
coord: /^@@.*@@$/m,
|
|
5735
5696
|
"commit-sha1": /^commit \w{40}$/m
|
|
5736
|
-
}, Prism.languages.glsl = Prism.languages.extend("c", { keyword: /\b(?:active|asm|atomic_uint|attribute|[ibdu]?vec[234]|bool|break|buffer|case|cast|centroid|class|coherent|common|const|continue|d?mat[234](?:x[234])?|default|discard|do|double|else|enum|extern|external|false|filter|fixed|flat|float|for|fvec[234]|goto|half|highp|hvec[234]|[iu]?sampler2DMS(?:Array)?|[iu]?sampler2DRect|[iu]?samplerBuffer|[iu]?samplerCube|[iu]?samplerCubeArray|[iu]?sampler[123]D|[iu]?sampler[12]DArray|[iu]?image2DMS(?:Array)?|[iu]?image2DRect|[iu]?imageBuffer|[iu]?imageCube|[iu]?imageCubeArray|[iu]?image[123]D|[iu]?image[12]DArray|if|in|inline|inout|input|int|interface|invariant|layout|long|lowp|mediump|namespace|noinline|noperspective|out|output|partition|patch|precise|precision|public|readonly|resource|restrict|return|sample|sampler[12]DArrayShadow|sampler[12]DShadow|sampler2DRectShadow|sampler3DRect|samplerCubeArrayShadow|samplerCubeShadow|shared|short|sizeof|smooth|static|struct|subroutine|superp|switch|template|this|true|typedef|uint|uniform|union|unsigned|using|varying|void|volatile|while|writeonly)\b/ }), Prism.languages.gn = {
|
|
5697
|
+
}, Prism$1.languages.glsl = Prism$1.languages.extend("c", { keyword: /\b(?:active|asm|atomic_uint|attribute|[ibdu]?vec[234]|bool|break|buffer|case|cast|centroid|class|coherent|common|const|continue|d?mat[234](?:x[234])?|default|discard|do|double|else|enum|extern|external|false|filter|fixed|flat|float|for|fvec[234]|goto|half|highp|hvec[234]|[iu]?sampler2DMS(?:Array)?|[iu]?sampler2DRect|[iu]?samplerBuffer|[iu]?samplerCube|[iu]?samplerCubeArray|[iu]?sampler[123]D|[iu]?sampler[12]DArray|[iu]?image2DMS(?:Array)?|[iu]?image2DRect|[iu]?imageBuffer|[iu]?imageCube|[iu]?imageCubeArray|[iu]?image[123]D|[iu]?image[12]DArray|if|in|inline|inout|input|int|interface|invariant|layout|long|lowp|mediump|namespace|noinline|noperspective|out|output|partition|patch|precise|precision|public|readonly|resource|restrict|return|sample|sampler[12]DArrayShadow|sampler[12]DShadow|sampler2DRectShadow|sampler3DRect|samplerCubeArrayShadow|samplerCubeShadow|shared|short|sizeof|smooth|static|struct|subroutine|superp|switch|template|this|true|typedef|uint|uniform|union|unsigned|using|varying|void|volatile|while|writeonly)\b/ }), Prism$1.languages.gn = {
|
|
5737
5698
|
comment: {
|
|
5738
5699
|
pattern: /#.*/,
|
|
5739
5700
|
greedy: !0
|
|
@@ -5773,7 +5734,7 @@ Prism.languages.markup = {
|
|
|
5773
5734
|
number: /-?\b\d+\b/,
|
|
5774
5735
|
operator: /[-+!=<>]=?|&&|\|\|/,
|
|
5775
5736
|
punctuation: /[(){}[\],.]/
|
|
5776
|
-
}, Prism.languages.gn["string-literal"].inside.interpolation.inside.expression.inside = Prism.languages.gn, Prism.languages.gni = Prism.languages.gn, Prism.languages["linker-script"] = {
|
|
5737
|
+
}, Prism$1.languages.gn["string-literal"].inside.interpolation.inside.expression.inside = Prism$1.languages.gn, Prism$1.languages.gni = Prism$1.languages.gn, Prism$1.languages["linker-script"] = {
|
|
5777
5738
|
comment: {
|
|
5778
5739
|
pattern: /(^|\s)\/\*[\s\S]*?(?:$|\*\/)/,
|
|
5779
5740
|
lookbehind: !0,
|
|
@@ -5796,7 +5757,7 @@ Prism.languages.markup = {
|
|
|
5796
5757
|
number: /\b(?:0[xX][a-fA-F0-9]+|\d+)[KM]?\b/,
|
|
5797
5758
|
operator: />>=?|<<=?|->|\+\+|--|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?/,
|
|
5798
5759
|
punctuation: /[(){},;]/
|
|
5799
|
-
}, Prism.languages.ld = Prism.languages["linker-script"], Prism.languages.go = Prism.languages.extend("clike", {
|
|
5760
|
+
}, Prism$1.languages.ld = Prism$1.languages["linker-script"], Prism$1.languages.go = Prism$1.languages.extend("clike", {
|
|
5800
5761
|
string: {
|
|
5801
5762
|
pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"|`[^`]*`/,
|
|
5802
5763
|
lookbehind: !0,
|
|
@@ -5811,10 +5772,10 @@ Prism.languages.markup = {
|
|
|
5811
5772
|
],
|
|
5812
5773
|
operator: /[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\./,
|
|
5813
5774
|
builtin: /\b(?:append|bool|byte|cap|close|complex|complex(?:64|128)|copy|delete|error|float(?:32|64)|u?int(?:8|16|32|64)?|imag|len|make|new|panic|print(?:ln)?|real|recover|rune|string|uintptr)\b/
|
|
5814
|
-
}), Prism.languages.insertBefore("go", "string", { char: {
|
|
5775
|
+
}), Prism$1.languages.insertBefore("go", "string", { char: {
|
|
5815
5776
|
pattern: /'(?:\\.|[^'\\\r\n]){0,10}'/,
|
|
5816
5777
|
greedy: !0
|
|
5817
|
-
} }), delete Prism.languages.go["class-name"], Prism.languages["go-mod"] = Prism.languages["go-module"] = {
|
|
5778
|
+
} }), delete Prism$1.languages.go["class-name"], Prism$1.languages["go-mod"] = Prism$1.languages["go-module"] = {
|
|
5818
5779
|
comment: {
|
|
5819
5780
|
pattern: /\/\/.*/,
|
|
5820
5781
|
greedy: !0
|
|
@@ -5881,7 +5842,7 @@ Prism.languages.markup = {
|
|
|
5881
5842
|
lookbehind: !0,
|
|
5882
5843
|
alias: "punctuation"
|
|
5883
5844
|
} }), t.inside.expression.inside = e.languages.gradle;
|
|
5884
|
-
})(Prism), Prism.languages.graphql = {
|
|
5845
|
+
})(Prism$1), Prism$1.languages.graphql = {
|
|
5885
5846
|
comment: /#.*/,
|
|
5886
5847
|
description: {
|
|
5887
5848
|
pattern: /(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i,
|
|
@@ -5890,7 +5851,7 @@ Prism.languages.markup = {
|
|
|
5890
5851
|
inside: { "language-markdown": {
|
|
5891
5852
|
pattern: /(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/,
|
|
5892
5853
|
lookbehind: !0,
|
|
5893
|
-
inside: Prism.languages.markdown
|
|
5854
|
+
inside: Prism$1.languages.markdown
|
|
5894
5855
|
} }
|
|
5895
5856
|
},
|
|
5896
5857
|
string: {
|
|
@@ -5939,7 +5900,7 @@ Prism.languages.markup = {
|
|
|
5939
5900
|
object: /\w+(?=\s*\{)/,
|
|
5940
5901
|
punctuation: /[!(){}\[\]:=,]/,
|
|
5941
5902
|
property: /\w+/
|
|
5942
|
-
}, Prism.hooks.add("after-tokenize", function(e) {
|
|
5903
|
+
}, Prism$1.hooks.add("after-tokenize", function(e) {
|
|
5943
5904
|
if ("graphql" === e.language) for (var o = e.tokens.filter(function(e$1) {
|
|
5944
5905
|
return "string" != typeof e$1 && "comment" !== e$1.type && "scalar" !== e$1.type;
|
|
5945
5906
|
}), s = 0; s < o.length;) {
|
|
@@ -6036,7 +5997,7 @@ Prism.languages.markup = {
|
|
|
6036
5997
|
lookbehind: !0,
|
|
6037
5998
|
alias: "punctuation"
|
|
6038
5999
|
} }), t.inside.expression.inside = e.languages.groovy;
|
|
6039
|
-
})(Prism), Prism.languages.less = Prism.languages.extend("css", {
|
|
6000
|
+
})(Prism$1), Prism$1.languages.less = Prism$1.languages.extend("css", {
|
|
6040
6001
|
comment: [/\/\*[\s\S]*?\*\//, {
|
|
6041
6002
|
pattern: /(^|[^\\])\/\/.*/,
|
|
6042
6003
|
lookbehind: !0
|
|
@@ -6051,7 +6012,7 @@ Prism.languages.markup = {
|
|
|
6051
6012
|
},
|
|
6052
6013
|
property: /(?:@\{[\w-]+\}|[\w-])+(?:\+_?)?(?=\s*:)/,
|
|
6053
6014
|
operator: /[+\-*\/]/
|
|
6054
|
-
}), Prism.languages.insertBefore("less", "property", {
|
|
6015
|
+
}), Prism$1.languages.insertBefore("less", "property", {
|
|
6055
6016
|
variable: [{
|
|
6056
6017
|
pattern: /@[\w-]+\s*:/,
|
|
6057
6018
|
inside: { punctuation: /:/ }
|
|
@@ -6061,7 +6022,7 @@ Prism.languages.markup = {
|
|
|
6061
6022
|
lookbehind: !0,
|
|
6062
6023
|
alias: "function"
|
|
6063
6024
|
}
|
|
6064
|
-
}), Prism.languages.scss = Prism.languages.extend("css", {
|
|
6025
|
+
}), Prism$1.languages.scss = Prism$1.languages.extend("css", {
|
|
6065
6026
|
comment: {
|
|
6066
6027
|
pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
|
|
6067
6028
|
lookbehind: !0
|
|
@@ -6086,10 +6047,10 @@ Prism.languages.markup = {
|
|
|
6086
6047
|
pattern: /(?:[-\w]|\$[-\w]|#\{\$[-\w]+\})+(?=\s*:)/,
|
|
6087
6048
|
inside: { variable: /\$[-\w]+|#\{\$[-\w]+\}/ }
|
|
6088
6049
|
}
|
|
6089
|
-
}), Prism.languages.insertBefore("scss", "atrule", { keyword: [/@(?:content|debug|each|else(?: if)?|extend|for|forward|function|if|import|include|mixin|return|use|warn|while)\b/i, {
|
|
6050
|
+
}), Prism$1.languages.insertBefore("scss", "atrule", { keyword: [/@(?:content|debug|each|else(?: if)?|extend|for|forward|function|if|import|include|mixin|return|use|warn|while)\b/i, {
|
|
6090
6051
|
pattern: /( )(?:from|through)(?= )/,
|
|
6091
6052
|
lookbehind: !0
|
|
6092
|
-
}] }), Prism.languages.insertBefore("scss", "important", { variable: /\$[-\w]+|#\{\$[-\w]+\}/ }), Prism.languages.insertBefore("scss", "function", {
|
|
6053
|
+
}] }), Prism$1.languages.insertBefore("scss", "important", { variable: /\$[-\w]+|#\{\$[-\w]+\}/ }), Prism$1.languages.insertBefore("scss", "function", {
|
|
6093
6054
|
"module-modifier": {
|
|
6094
6055
|
pattern: /\b(?:as|hide|show|with)\b/i,
|
|
6095
6056
|
alias: "keyword"
|
|
@@ -6111,7 +6072,7 @@ Prism.languages.markup = {
|
|
|
6111
6072
|
pattern: /(\s)(?:[-+*\/%]|[=!]=|<=?|>=?|and|not|or)(?=\s)/,
|
|
6112
6073
|
lookbehind: !0
|
|
6113
6074
|
}
|
|
6114
|
-
}), Prism.languages.scss.atrule.inside.rest = Prism.languages.scss, (function(e) {
|
|
6075
|
+
}), Prism$1.languages.scss.atrule.inside.rest = Prism$1.languages.scss, (function(e) {
|
|
6115
6076
|
var n = /\([^|()\n]+\)|\[[^\]\n]+\]|\{[^}\n]+\}/.source, a = /\)|\((?![^|()\n]+\))/.source;
|
|
6116
6077
|
function t(e$1, t$1) {
|
|
6117
6078
|
return RegExp(e$1.replace(/<MOD>/g, function() {
|
|
@@ -6299,7 +6260,7 @@ Prism.languages.markup = {
|
|
|
6299
6260
|
mark: r.mark
|
|
6300
6261
|
}, e = (e.tag.pattern = /<\/?(?!\d)[a-z0-9]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/i, r.inline.inside), e = (e.bold.inside = i, e.italic.inside = i, e.inserted.inside = i, e.deleted.inside = i, e.span.inside = i, r.table.inside);
|
|
6301
6262
|
e.inline = i.inline, e.link = i.link, e.image = i.image, e.footnote = i.footnote, e.acronym = i.acronym, e.mark = i.mark;
|
|
6302
|
-
})(Prism), (function(e) {
|
|
6263
|
+
})(Prism$1), (function(e) {
|
|
6303
6264
|
e.languages.haml = {
|
|
6304
6265
|
"multiline-comment": {
|
|
6305
6266
|
pattern: /((?:^|\r?\n|\r)([\t ]*))(?:\/|-#).*(?:(?:\r?\n|\r)\2[\t ].+)*/,
|
|
@@ -6421,7 +6382,7 @@ Prism.languages.markup = {
|
|
|
6421
6382
|
});
|
|
6422
6383
|
}
|
|
6423
6384
|
e.languages.insertBefore("haml", "filter", n);
|
|
6424
|
-
})(Prism), (function(t) {
|
|
6385
|
+
})(Prism$1), (function(t) {
|
|
6425
6386
|
t.languages.handlebars = {
|
|
6426
6387
|
comment: /\{\{![\s\S]*?\}\}/,
|
|
6427
6388
|
delimiter: {
|
|
@@ -6450,7 +6411,7 @@ Prism.languages.markup = {
|
|
|
6450
6411
|
}), t.hooks.add("after-tokenize", function(e) {
|
|
6451
6412
|
t.languages["markup-templating"].tokenizePlaceholders(e, "handlebars");
|
|
6452
6413
|
}), t.languages.hbs = t.languages.handlebars, t.languages.mustache = t.languages.handlebars;
|
|
6453
|
-
})(Prism), Prism.languages.haskell = {
|
|
6414
|
+
})(Prism$1), Prism$1.languages.haskell = {
|
|
6454
6415
|
comment: {
|
|
6455
6416
|
pattern: /(^|[^-!#$%*+=?&@|~.:<>^\\\/])(?:--(?:(?=.)[^-!#$%*+=?&@|~.:<>^\\\/].*|$)|\{-[\s\S]*?-\})/m,
|
|
6456
6417
|
lookbehind: !0
|
|
@@ -6494,7 +6455,7 @@ Prism.languages.markup = {
|
|
|
6494
6455
|
inside: { punctuation: /\./ }
|
|
6495
6456
|
},
|
|
6496
6457
|
punctuation: /[{}[\];(),.:]/
|
|
6497
|
-
}, Prism.languages.hs = Prism.languages.haskell, Prism.languages.haxe = Prism.languages.extend("clike", {
|
|
6458
|
+
}, Prism$1.languages.hs = Prism$1.languages.haskell, Prism$1.languages.haxe = Prism$1.languages.extend("clike", {
|
|
6498
6459
|
string: {
|
|
6499
6460
|
pattern: /"(?:[^"\\]|\\[\s\S])*"/,
|
|
6500
6461
|
greedy: !0
|
|
@@ -6509,7 +6470,7 @@ Prism.languages.markup = {
|
|
|
6509
6470
|
greedy: !0
|
|
6510
6471
|
},
|
|
6511
6472
|
operator: /\.{3}|\+\+|--|&&|\|\||->|=>|(?:<<?|>{1,3}|[-+*/%!=&|^])=?|[?:~]/
|
|
6512
|
-
}), Prism.languages.insertBefore("haxe", "string", { "string-interpolation": {
|
|
6473
|
+
}), Prism$1.languages.insertBefore("haxe", "string", { "string-interpolation": {
|
|
6513
6474
|
pattern: /'(?:[^'\\]|\\[\s\S])*'/,
|
|
6514
6475
|
greedy: !0,
|
|
6515
6476
|
inside: {
|
|
@@ -6523,13 +6484,13 @@ Prism.languages.markup = {
|
|
|
6523
6484
|
},
|
|
6524
6485
|
expression: {
|
|
6525
6486
|
pattern: /[\s\S]+/,
|
|
6526
|
-
inside: Prism.languages.haxe
|
|
6487
|
+
inside: Prism$1.languages.haxe
|
|
6527
6488
|
}
|
|
6528
6489
|
}
|
|
6529
6490
|
},
|
|
6530
6491
|
string: /[\s\S]+/
|
|
6531
6492
|
}
|
|
6532
|
-
} }), Prism.languages.insertBefore("haxe", "class-name", { regex: {
|
|
6493
|
+
} }), Prism$1.languages.insertBefore("haxe", "class-name", { regex: {
|
|
6533
6494
|
pattern: /~\/(?:[^\/\\\r\n]|\\.)+\/[a-z]*/,
|
|
6534
6495
|
greedy: !0,
|
|
6535
6496
|
inside: {
|
|
@@ -6538,11 +6499,11 @@ Prism.languages.markup = {
|
|
|
6538
6499
|
pattern: /^(~\/)[\s\S]+(?=\/$)/,
|
|
6539
6500
|
lookbehind: !0,
|
|
6540
6501
|
alias: "language-regex",
|
|
6541
|
-
inside: Prism.languages.regex
|
|
6502
|
+
inside: Prism$1.languages.regex
|
|
6542
6503
|
},
|
|
6543
6504
|
"regex-delimiter": /^~\/|\/$/
|
|
6544
6505
|
}
|
|
6545
|
-
} }), Prism.languages.insertBefore("haxe", "keyword", {
|
|
6506
|
+
} }), Prism$1.languages.insertBefore("haxe", "keyword", {
|
|
6546
6507
|
preprocessor: {
|
|
6547
6508
|
pattern: /#(?:else|elseif|end|if)\b.*/,
|
|
6548
6509
|
alias: "property"
|
|
@@ -6555,7 +6516,7 @@ Prism.languages.markup = {
|
|
|
6555
6516
|
pattern: /\$(?:\w+|(?=\{))/,
|
|
6556
6517
|
alias: "important"
|
|
6557
6518
|
}
|
|
6558
|
-
}), Prism.languages.hcl = {
|
|
6519
|
+
}), Prism$1.languages.hcl = {
|
|
6559
6520
|
comment: /(?:\/\/|#).*|\/\*[\s\S]*?(?:\*\/|$)/,
|
|
6560
6521
|
heredoc: {
|
|
6561
6522
|
pattern: /<<-?(\w+\b)[\s\S]*?^[ \t]*\1/m,
|
|
@@ -6608,12 +6569,12 @@ Prism.languages.markup = {
|
|
|
6608
6569
|
number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?(?:e[+-]?\d+)?/i,
|
|
6609
6570
|
boolean: /\b(?:false|true)\b/i,
|
|
6610
6571
|
punctuation: /[=\[\]{}]/
|
|
6611
|
-
}, Prism.languages.hlsl = Prism.languages.extend("c", {
|
|
6612
|
-
"class-name": [Prism.languages.c["class-name"], /\b(?:AppendStructuredBuffer|BlendState|Buffer|ByteAddressBuffer|CompileShader|ComputeShader|ConsumeStructuredBuffer|DepthStencilState|DepthStencilView|DomainShader|GeometryShader|Hullshader|InputPatch|LineStream|OutputPatch|PixelShader|PointStream|RWBuffer|RWByteAddressBuffer|RWStructuredBuffer|RWTexture(?:1D|1DArray|2D|2DArray|3D)|RasterizerState|RenderTargetView|SamplerComparisonState|SamplerState|StructuredBuffer|Texture(?:1D|1DArray|2D|2DArray|2DMS|2DMSArray|3D|Cube|CubeArray)|TriangleStream|VertexShader)\b/],
|
|
6572
|
+
}, Prism$1.languages.hlsl = Prism$1.languages.extend("c", {
|
|
6573
|
+
"class-name": [Prism$1.languages.c["class-name"], /\b(?:AppendStructuredBuffer|BlendState|Buffer|ByteAddressBuffer|CompileShader|ComputeShader|ConsumeStructuredBuffer|DepthStencilState|DepthStencilView|DomainShader|GeometryShader|Hullshader|InputPatch|LineStream|OutputPatch|PixelShader|PointStream|RWBuffer|RWByteAddressBuffer|RWStructuredBuffer|RWTexture(?:1D|1DArray|2D|2DArray|3D)|RasterizerState|RenderTargetView|SamplerComparisonState|SamplerState|StructuredBuffer|Texture(?:1D|1DArray|2D|2DArray|2DMS|2DMSArray|3D|Cube|CubeArray)|TriangleStream|VertexShader)\b/],
|
|
6613
6574
|
keyword: [/\b(?:asm|asm_fragment|auto|break|case|catch|cbuffer|centroid|char|class|column_major|compile|compile_fragment|const|const_cast|continue|default|delete|discard|do|dynamic_cast|else|enum|explicit|export|extern|for|friend|fxgroup|goto|groupshared|if|in|inline|inout|interface|line|lineadj|linear|long|matrix|mutable|namespace|new|nointerpolation|noperspective|operator|out|packoffset|pass|pixelfragment|point|precise|private|protected|public|register|reinterpret_cast|return|row_major|sample|sampler|shared|short|signed|sizeof|snorm|stateblock|stateblock_state|static|static_cast|string|struct|switch|tbuffer|technique|technique10|technique11|template|texture|this|throw|triangle|triangleadj|try|typedef|typename|uniform|union|unorm|unsigned|using|vector|vertexfragment|virtual|void|volatile|while)\b/, /\b(?:bool|double|dword|float|half|int|min(?:10float|12int|16(?:float|int|uint))|uint)(?:[1-4](?:x[1-4])?)?\b/],
|
|
6614
6575
|
number: /(?:(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+)?|\b0x[\da-fA-F]+)[fFhHlLuU]?\b/,
|
|
6615
6576
|
boolean: /\b(?:false|true)\b/
|
|
6616
|
-
}), Prism.languages.hoon = {
|
|
6577
|
+
}), Prism$1.languages.hoon = {
|
|
6617
6578
|
comment: {
|
|
6618
6579
|
pattern: /::.*/,
|
|
6619
6580
|
greedy: !0
|
|
@@ -6626,21 +6587,21 @@ Prism.languages.markup = {
|
|
|
6626
6587
|
"class-name": /@(?:[a-z0-9-]*[a-z0-9])?|\*/i,
|
|
6627
6588
|
function: /(?:\+[-+] {2})?(?:[a-z](?:[a-z0-9-]*[a-z0-9])?)/,
|
|
6628
6589
|
keyword: /\.[\^\+\*=\?]|![><:\.=\?!]|=[>|:,\.\-\^<+;/~\*\?]|\?[>|:\.\-\^<\+&~=@!]|\|[\$_%:\.\-\^~\*=@\?]|\+[|\$\+\*]|:[_\-\^\+~\*]|%[_:\.\-\^\+~\*=]|\^[|:\.\-\+&~\*=\?]|\$[|_%:<>\-\^&~@=\?]|;[:<\+;\/~\*=]|~[>|\$_%<\+\/&=\?!]|--|==/
|
|
6629
|
-
}, Prism.languages.hpkp = {
|
|
6590
|
+
}, Prism$1.languages.hpkp = {
|
|
6630
6591
|
directive: {
|
|
6631
6592
|
pattern: /\b(?:includeSubDomains|max-age|pin-sha256|preload|report-to|report-uri|strict)(?=[\s;=]|$)/i,
|
|
6632
6593
|
alias: "property"
|
|
6633
6594
|
},
|
|
6634
6595
|
operator: /=/,
|
|
6635
6596
|
punctuation: /;/
|
|
6636
|
-
}, Prism.languages.hsts = {
|
|
6597
|
+
}, Prism$1.languages.hsts = {
|
|
6637
6598
|
directive: {
|
|
6638
6599
|
pattern: /\b(?:includeSubDomains|max-age|preload)(?=[\s;=]|$)/i,
|
|
6639
6600
|
alias: "property"
|
|
6640
6601
|
},
|
|
6641
6602
|
operator: /=/,
|
|
6642
6603
|
punctuation: /;/
|
|
6643
|
-
}, Prism.languages.json = {
|
|
6604
|
+
}, Prism$1.languages.json = {
|
|
6644
6605
|
property: {
|
|
6645
6606
|
pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
|
|
6646
6607
|
lookbehind: !0,
|
|
@@ -6663,7 +6624,7 @@ Prism.languages.markup = {
|
|
|
6663
6624
|
pattern: /\bnull\b/,
|
|
6664
6625
|
alias: "keyword"
|
|
6665
6626
|
}
|
|
6666
|
-
}, Prism.languages.webmanifest = Prism.languages.json, Prism.languages.uri = {
|
|
6627
|
+
}, Prism$1.languages.webmanifest = Prism$1.languages.json, Prism$1.languages.uri = {
|
|
6667
6628
|
scheme: {
|
|
6668
6629
|
pattern: /^[a-z][a-z0-9+.-]*:/im,
|
|
6669
6630
|
greedy: !0,
|
|
@@ -6731,7 +6692,7 @@ Prism.languages.markup = {
|
|
|
6731
6692
|
pattern: /^[\w\-.~!$&'()*+,;=%:@/]+/m,
|
|
6732
6693
|
inside: { "path-separator": /\// }
|
|
6733
6694
|
}
|
|
6734
|
-
}, Prism.languages.url = Prism.languages.uri, (function(e) {
|
|
6695
|
+
}, Prism$1.languages.url = Prism$1.languages.uri, (function(e) {
|
|
6735
6696
|
function t(e$1) {
|
|
6736
6697
|
return RegExp("(^(?:" + e$1 + "):[ ]*(?![ ]))[^]+", "i");
|
|
6737
6698
|
}
|
|
@@ -6828,7 +6789,7 @@ Prism.languages.markup = {
|
|
|
6828
6789
|
inside: s[n]
|
|
6829
6790
|
});
|
|
6830
6791
|
a && e.languages.insertBefore("http", "header", a);
|
|
6831
|
-
})(Prism), Prism.languages.ichigojam = {
|
|
6792
|
+
})(Prism$1), Prism$1.languages.ichigojam = {
|
|
6832
6793
|
comment: /(?:\B'|REM)(?:[^\n\r]*)/i,
|
|
6833
6794
|
string: {
|
|
6834
6795
|
pattern: /"(?:""|[!#$%&'()*,\/:;<=>?^\w +\-.])*"/,
|
|
@@ -6840,7 +6801,7 @@ Prism.languages.markup = {
|
|
|
6840
6801
|
label: /(?:\B@\S+)/,
|
|
6841
6802
|
operator: /<[=>]?|>=?|\|\||&&|[+\-*\/=|&^~!]|\b(?:AND|NOT|OR)\b/i,
|
|
6842
6803
|
punctuation: /[\[,;:()\]]/
|
|
6843
|
-
}, Prism.languages.icon = {
|
|
6804
|
+
}, Prism$1.languages.icon = {
|
|
6844
6805
|
comment: /#.*/,
|
|
6845
6806
|
string: {
|
|
6846
6807
|
pattern: /(["'])(?:(?!\1)[^\\\r\n_]|\\.|_(?!\1)(?:\r\n|[\s\S]))*\1/,
|
|
@@ -6971,15 +6932,15 @@ Prism.languages.markup = {
|
|
|
6971
6932
|
escape: a,
|
|
6972
6933
|
string: r
|
|
6973
6934
|
}, o.inside.message.inside = e.languages["icu-message-format"], e.languages["icu-message-format"].argument.inside.content.inside["choice-style"].inside.rest = e.languages["icu-message-format"];
|
|
6974
|
-
})(Prism), Prism.languages.idris = Prism.languages.extend("haskell", {
|
|
6935
|
+
})(Prism$1), Prism$1.languages.idris = Prism$1.languages.extend("haskell", {
|
|
6975
6936
|
comment: { pattern: /(?:(?:--|\|\|\|).*$|\{-[\s\S]*?-\})/m },
|
|
6976
6937
|
keyword: /\b(?:Type|case|class|codata|constructor|corecord|data|do|dsl|else|export|if|implementation|implicit|import|impossible|in|infix|infixl|infixr|instance|interface|let|module|mutual|namespace|of|parameters|partial|postulate|private|proof|public|quoteGoal|record|rewrite|syntax|then|total|using|where|with)\b/,
|
|
6977
6938
|
builtin: void 0
|
|
6978
|
-
}), Prism.languages.insertBefore("idris", "keyword", { "import-statement": {
|
|
6939
|
+
}), Prism$1.languages.insertBefore("idris", "keyword", { "import-statement": {
|
|
6979
6940
|
pattern: /(^\s*import\s+)(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*/m,
|
|
6980
6941
|
lookbehind: !0,
|
|
6981
6942
|
inside: { punctuation: /\./ }
|
|
6982
|
-
} }), Prism.languages.idr = Prism.languages.idris, (function(e) {
|
|
6943
|
+
} }), Prism$1.languages.idr = Prism$1.languages.idris, (function(e) {
|
|
6983
6944
|
e.languages.ignore = {
|
|
6984
6945
|
comment: /^#.*/m,
|
|
6985
6946
|
entry: {
|
|
@@ -6995,7 +6956,7 @@ Prism.languages.markup = {
|
|
|
6995
6956
|
}
|
|
6996
6957
|
}
|
|
6997
6958
|
}, e.languages.gitignore = e.languages.ignore, e.languages.hgignore = e.languages.ignore, e.languages.npmignore = e.languages.ignore;
|
|
6998
|
-
})(Prism), Prism.languages.inform7 = {
|
|
6959
|
+
})(Prism$1), Prism$1.languages.inform7 = {
|
|
6999
6960
|
string: {
|
|
7000
6961
|
pattern: /"[^"]*"/,
|
|
7001
6962
|
inside: { substitution: {
|
|
@@ -7043,10 +7004,10 @@ Prism.languages.markup = {
|
|
|
7043
7004
|
alias: "variable"
|
|
7044
7005
|
},
|
|
7045
7006
|
punctuation: /[.,:;(){}]/
|
|
7046
|
-
}, Prism.languages.inform7.string.inside.substitution.inside.rest = Prism.languages.inform7, Prism.languages.inform7.string.inside.substitution.inside.rest.text = {
|
|
7007
|
+
}, Prism$1.languages.inform7.string.inside.substitution.inside.rest = Prism$1.languages.inform7, Prism$1.languages.inform7.string.inside.substitution.inside.rest.text = {
|
|
7047
7008
|
pattern: /\S(?:\s*\S)*/,
|
|
7048
7009
|
alias: "comment"
|
|
7049
|
-
}, Prism.languages.ini = {
|
|
7010
|
+
}, Prism$1.languages.ini = {
|
|
7050
7011
|
comment: {
|
|
7051
7012
|
pattern: /(^[ \f\t\v]*)[#;][^\n\r]*/m,
|
|
7052
7013
|
lookbehind: !0
|
|
@@ -7078,7 +7039,7 @@ Prism.languages.markup = {
|
|
|
7078
7039
|
} }
|
|
7079
7040
|
},
|
|
7080
7041
|
punctuation: /=/
|
|
7081
|
-
}, Prism.languages.io = {
|
|
7042
|
+
}, Prism$1.languages.io = {
|
|
7082
7043
|
comment: {
|
|
7083
7044
|
pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\/\/.*|#.*)/,
|
|
7084
7045
|
lookbehind: !0,
|
|
@@ -7099,7 +7060,7 @@ Prism.languages.markup = {
|
|
|
7099
7060
|
number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e-?\d+)?/i,
|
|
7100
7061
|
operator: /[=!*/%+\-^&|]=|>>?=?|<<?=?|:?:?=|\+\+?|--?|\*\*?|\/\/?|%|\|\|?|&&?|\b(?:and|not|or|return)\b|@@?|\?\??|\.\./,
|
|
7101
7062
|
punctuation: /[{}[\];(),.:]/
|
|
7102
|
-
}, Prism.languages.j = {
|
|
7063
|
+
}, Prism$1.languages.j = {
|
|
7103
7064
|
comment: {
|
|
7104
7065
|
pattern: /\bNB\..*/,
|
|
7105
7066
|
greedy: !0
|
|
@@ -7220,7 +7181,7 @@ Prism.languages.markup = {
|
|
|
7220
7181
|
inside: { punctuation: /\./ }
|
|
7221
7182
|
}
|
|
7222
7183
|
});
|
|
7223
|
-
})(Prism), Prism.languages.scala = Prism.languages.extend("java", {
|
|
7184
|
+
})(Prism$1), Prism$1.languages.scala = Prism$1.languages.extend("java", {
|
|
7224
7185
|
"triple-quoted-string": {
|
|
7225
7186
|
pattern: /"""[\s\S]*?"""/,
|
|
7226
7187
|
greedy: !0,
|
|
@@ -7234,7 +7195,7 @@ Prism.languages.markup = {
|
|
|
7234
7195
|
number: /\b0x(?:[\da-f]*\.)?[\da-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e\d+)?[dfl]?/i,
|
|
7235
7196
|
builtin: /\b(?:Any|AnyRef|AnyVal|Boolean|Byte|Char|Double|Float|Int|Long|Nothing|Short|String|Unit)\b/,
|
|
7236
7197
|
symbol: /'[^\d\s\\]\w*/
|
|
7237
|
-
}), Prism.languages.insertBefore("scala", "triple-quoted-string", { "string-interpolation": {
|
|
7198
|
+
}), Prism$1.languages.insertBefore("scala", "triple-quoted-string", { "string-interpolation": {
|
|
7238
7199
|
pattern: /\b[a-z]\w*(?:"""(?:[^$]|\$(?:[^{]|\{(?:[^{}]|\{[^{}]*\})*\}))*?"""|"(?:[^$"\r\n]|\$(?:[^{]|\{(?:[^{}]|\{[^{}]*\})*\}))*")/i,
|
|
7239
7200
|
greedy: !0,
|
|
7240
7201
|
inside: {
|
|
@@ -7255,13 +7216,13 @@ Prism.languages.markup = {
|
|
|
7255
7216
|
punctuation: /^\$\{?|\}$/,
|
|
7256
7217
|
expression: {
|
|
7257
7218
|
pattern: /[\s\S]+/,
|
|
7258
|
-
inside: Prism.languages.scala
|
|
7219
|
+
inside: Prism$1.languages.scala
|
|
7259
7220
|
}
|
|
7260
7221
|
}
|
|
7261
7222
|
},
|
|
7262
7223
|
string: /[\s\S]+/
|
|
7263
7224
|
}
|
|
7264
|
-
} }), delete Prism.languages.scala["class-name"], delete Prism.languages.scala.function, delete Prism.languages.scala.constant, (function(l) {
|
|
7225
|
+
} }), delete Prism$1.languages.scala["class-name"], delete Prism$1.languages.scala.function, delete Prism$1.languages.scala.constant, (function(l) {
|
|
7265
7226
|
var e = l.languages.javadoclike = {
|
|
7266
7227
|
parameter: {
|
|
7267
7228
|
pattern: /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*@(?:arg|arguments|param)\s+)\w+/m,
|
|
@@ -7293,7 +7254,7 @@ Prism.languages.markup = {
|
|
|
7293
7254
|
"javascript",
|
|
7294
7255
|
"php"
|
|
7295
7256
|
], e);
|
|
7296
|
-
})(Prism), (function(e) {
|
|
7257
|
+
})(Prism$1), (function(e) {
|
|
7297
7258
|
var t = /(^(?:[\t ]*(?:\*\s*)*))[^*\s].*$/m, n = /#\s*\w+(?:\s*\([^()]*\))?/.source, a = /(?:\b[a-zA-Z]\w+\s*\.\s*)*\b[A-Z]\w*(?:\s*<mem>)?|<mem>/.source.replace(/<mem>/g, function() {
|
|
7298
7259
|
return n;
|
|
7299
7260
|
});
|
|
@@ -7353,7 +7314,7 @@ Prism.languages.markup = {
|
|
|
7353
7314
|
tag: e.languages.markup.tag,
|
|
7354
7315
|
entity: e.languages.markup.entity
|
|
7355
7316
|
}), e.languages.javadoclike.addSupport("java", e.languages.javadoc);
|
|
7356
|
-
})(Prism), Prism.languages.javastacktrace = {
|
|
7317
|
+
})(Prism$1), Prism$1.languages.javastacktrace = {
|
|
7357
7318
|
summary: {
|
|
7358
7319
|
pattern: /^([\t ]*)(?:(?:Caused by:|Suppressed:|Exception in thread "[^"]*")[\t ]+)?[\w$.]+(?::.*)?$/m,
|
|
7359
7320
|
lookbehind: !0,
|
|
@@ -7443,7 +7404,7 @@ Prism.languages.markup = {
|
|
|
7443
7404
|
keyword: /\b[a-z]+(?: [a-z]+)*\b/
|
|
7444
7405
|
}
|
|
7445
7406
|
}
|
|
7446
|
-
}, Prism.languages.jexl = {
|
|
7407
|
+
}, Prism$1.languages.jexl = {
|
|
7447
7408
|
string: /(["'])(?:\\[\s\S]|(?!\1)[^\\])*\1/,
|
|
7448
7409
|
transform: {
|
|
7449
7410
|
pattern: /(\|\s*)[a-zA-Zа-яА-Я_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$][\wа-яА-Я\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$]*/,
|
|
@@ -7456,7 +7417,7 @@ Prism.languages.markup = {
|
|
|
7456
7417
|
boolean: /\b(?:false|true)\b/,
|
|
7457
7418
|
keyword: /\bin\b/,
|
|
7458
7419
|
punctuation: /[{}[\](),.]/
|
|
7459
|
-
}, Prism.languages.jolie = Prism.languages.extend("clike", {
|
|
7420
|
+
}, Prism$1.languages.jolie = Prism$1.languages.extend("clike", {
|
|
7460
7421
|
string: {
|
|
7461
7422
|
pattern: /(^|[^\\])"(?:\\[\s\S]|[^"\\])*"/,
|
|
7462
7423
|
lookbehind: !0,
|
|
@@ -7472,7 +7433,7 @@ Prism.languages.markup = {
|
|
|
7472
7433
|
operator: /-[-=>]?|\+[+=]?|<[<=]?|[>=*!]=?|&&|\|\||[?\/%^@|]/,
|
|
7473
7434
|
punctuation: /[()[\]{},;.:]/,
|
|
7474
7435
|
builtin: /\b(?:Byte|any|bool|char|double|enum|float|int|length|long|ranges|regex|string|undefined|void)\b/
|
|
7475
|
-
}), Prism.languages.insertBefore("jolie", "keyword", {
|
|
7436
|
+
}), Prism$1.languages.insertBefore("jolie", "keyword", {
|
|
7476
7437
|
aggregates: {
|
|
7477
7438
|
pattern: /(\bAggregates\s*:\s*)(?:\w+(?:\s+with\s+\w+)?\s*,\s*)*\w+(?:\s+with\s+\w+)?/,
|
|
7478
7439
|
lookbehind: !0,
|
|
@@ -7547,7 +7508,7 @@ Prism.languages.markup = {
|
|
|
7547
7508
|
}
|
|
7548
7509
|
};
|
|
7549
7510
|
a.interpolation.inside.content.inside = e;
|
|
7550
|
-
})(Prism), (function(g) {
|
|
7511
|
+
})(Prism$1), (function(g) {
|
|
7551
7512
|
var e = g.languages.javascript["template-string"], n = e.pattern.source, b = e.inside.interpolation, E = b.inside["interpolation-punctuation"], i = b.pattern.source;
|
|
7552
7513
|
function t(e$1, t$1) {
|
|
7553
7514
|
if (g.languages[e$1]) return {
|
|
@@ -7619,7 +7580,7 @@ Prism.languages.markup = {
|
|
|
7619
7580
|
}
|
|
7620
7581
|
})(e$1.tokens);
|
|
7621
7582
|
});
|
|
7622
|
-
})(Prism), (function(e) {
|
|
7583
|
+
})(Prism$1), (function(e) {
|
|
7623
7584
|
e.languages.typescript = e.languages.extend("javascript", {
|
|
7624
7585
|
"class-name": {
|
|
7625
7586
|
pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,
|
|
@@ -7654,7 +7615,7 @@ Prism.languages.markup = {
|
|
|
7654
7615
|
}
|
|
7655
7616
|
}
|
|
7656
7617
|
}), e.languages.ts = e.languages.typescript;
|
|
7657
|
-
})(Prism), (function(e) {
|
|
7618
|
+
})(Prism$1), (function(e) {
|
|
7658
7619
|
var t = e.languages.javascript, n = /\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})+\}/.source, a = "(@(?:arg|argument|param|property)\\s+(?:" + n + "\\s+)?)";
|
|
7659
7620
|
e.languages.jsdoc = e.languages.extend("javadoclike", { parameter: {
|
|
7660
7621
|
pattern: RegExp(a + /(?:(?!\s)[$\w\xA0-\uFFFF.])+(?=\s|$)/.source),
|
|
@@ -7708,10 +7669,10 @@ Prism.languages.markup = {
|
|
|
7708
7669
|
} }
|
|
7709
7670
|
}
|
|
7710
7671
|
}), e.languages.javadoclike.addSupport("javascript", e.languages.jsdoc);
|
|
7711
|
-
})(Prism), Prism.languages.n4js = Prism.languages.extend("javascript", { keyword: /\b(?:Array|any|boolean|break|case|catch|class|const|constructor|continue|debugger|declare|default|delete|do|else|enum|export|extends|false|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|module|new|null|number|package|private|protected|public|return|set|static|string|super|switch|this|throw|true|try|typeof|var|void|while|with|yield)\b/ }), Prism.languages.insertBefore("n4js", "constant", { annotation: {
|
|
7672
|
+
})(Prism$1), Prism$1.languages.n4js = Prism$1.languages.extend("javascript", { keyword: /\b(?:Array|any|boolean|break|case|catch|class|const|constructor|continue|debugger|declare|default|delete|do|else|enum|export|extends|false|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|module|new|null|number|package|private|protected|public|return|set|static|string|super|switch|this|throw|true|try|typeof|var|void|while|with|yield)\b/ }), Prism$1.languages.insertBefore("n4js", "constant", { annotation: {
|
|
7712
7673
|
pattern: /@+\w+/,
|
|
7713
7674
|
alias: "operator"
|
|
7714
|
-
} }), Prism.languages.n4jsd = Prism.languages.n4js, (function(e) {
|
|
7675
|
+
} }), Prism$1.languages.n4jsd = Prism$1.languages.n4js, (function(e) {
|
|
7715
7676
|
function t(e$1, t$1) {
|
|
7716
7677
|
return RegExp(e$1.replace(/<ID>/g, function() {
|
|
7717
7678
|
return /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/.source;
|
|
@@ -7796,7 +7757,7 @@ Prism.languages.markup = {
|
|
|
7796
7757
|
var r = n[a], i = e.languages.javascript[r], r = (i = "RegExp" === e.util.type(i) ? e.languages.javascript[r] = { pattern: i } : i).inside || {};
|
|
7797
7758
|
(i.inside = r)["maybe-class-name"] = /^[A-Z][\s\S]*/;
|
|
7798
7759
|
}
|
|
7799
|
-
})(Prism), (function(e) {
|
|
7760
|
+
})(Prism$1), (function(e) {
|
|
7800
7761
|
var t = /("|')(?:\\(?:\r\n?|\n|.)|(?!\1)[^\\\r\n])*\1/;
|
|
7801
7762
|
e.languages.json5 = e.languages.extend("json", {
|
|
7802
7763
|
property: [{
|
|
@@ -7812,7 +7773,7 @@ Prism.languages.markup = {
|
|
|
7812
7773
|
},
|
|
7813
7774
|
number: /[+-]?\b(?:NaN|Infinity|0x[a-fA-F\d]+)\b|[+-]?(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+\b)?/
|
|
7814
7775
|
});
|
|
7815
|
-
})(Prism), Prism.languages.jsonp = Prism.languages.extend("json", { punctuation: /[{}[\]();,.]/ }), Prism.languages.insertBefore("jsonp", "punctuation", { function: /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*\()/ }), Prism.languages.jsstacktrace = {
|
|
7776
|
+
})(Prism$1), Prism$1.languages.jsonp = Prism$1.languages.extend("json", { punctuation: /[{}[\]();,.]/ }), Prism$1.languages.insertBefore("jsonp", "punctuation", { function: /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*\()/ }), Prism$1.languages.jsstacktrace = {
|
|
7816
7777
|
"error-message": {
|
|
7817
7778
|
pattern: /^\S.*/m,
|
|
7818
7779
|
alias: "string"
|
|
@@ -7848,7 +7809,7 @@ Prism.languages.markup = {
|
|
|
7848
7809
|
}
|
|
7849
7810
|
}
|
|
7850
7811
|
}
|
|
7851
|
-
}, Prism.languages.julia = {
|
|
7812
|
+
}, Prism$1.languages.julia = {
|
|
7852
7813
|
comment: {
|
|
7853
7814
|
pattern: /(^|[^\\])(?:#=(?:[^#=]|=(?!#)|#(?!=)|#=(?:[^#=]|=(?!#)|#(?!=))*=#)*=#|#.*)/,
|
|
7854
7815
|
lookbehind: !0
|
|
@@ -7872,7 +7833,7 @@ Prism.languages.markup = {
|
|
|
7872
7833
|
operator: /&&|\|\||[-+*^%÷⊻&$\\]=?|\/[\/=]?|!=?=?|\|[=>]?|<(?:<=?|[=:|])?|>(?:=|>>?=?)?|==?=?|[~≠≤≥'√∛]/,
|
|
7873
7834
|
punctuation: /::?|[{}[\]();,.?]/,
|
|
7874
7835
|
constant: /\b(?:(?:Inf|NaN)(?:16|32|64)?|im|pi)\b|[πℯ]/
|
|
7875
|
-
}, Prism.languages.keepalived = {
|
|
7836
|
+
}, Prism$1.languages.keepalived = {
|
|
7876
7837
|
comment: {
|
|
7877
7838
|
pattern: /[#!].*/,
|
|
7878
7839
|
greedy: !0
|
|
@@ -7911,7 +7872,7 @@ Prism.languages.markup = {
|
|
|
7911
7872
|
},
|
|
7912
7873
|
boolean: /\b(?:false|no|off|on|true|yes)\b/,
|
|
7913
7874
|
punctuation: /[\{\}]/
|
|
7914
|
-
}, Prism.languages.keyman = {
|
|
7875
|
+
}, Prism$1.languages.keyman = {
|
|
7915
7876
|
comment: {
|
|
7916
7877
|
pattern: /\bc .*/i,
|
|
7917
7878
|
greedy: !0
|
|
@@ -8009,7 +7970,7 @@ Prism.languages.markup = {
|
|
|
8009
7970
|
pattern: /\b\w+@|@\w+\b/,
|
|
8010
7971
|
alias: "symbol"
|
|
8011
7972
|
} }), e.languages.kt = e.languages.kotlin, e.languages.kts = e.languages.kotlin;
|
|
8012
|
-
})(Prism), (function(e) {
|
|
7973
|
+
})(Prism$1), (function(e) {
|
|
8013
7974
|
var n = /\s\x00-\x1f\x22-\x2f\x3a-\x3f\x5b-\x5e\x60\x7b-\x7e/.source;
|
|
8014
7975
|
function t(e$1, t$1) {
|
|
8015
7976
|
return RegExp(e$1.replace(/<nonId>/g, n), t$1);
|
|
@@ -8065,7 +8026,7 @@ Prism.languages.markup = {
|
|
|
8065
8026
|
alias: "operator"
|
|
8066
8027
|
}
|
|
8067
8028
|
}, e.languages.kum = e.languages.kumir;
|
|
8068
|
-
})(Prism), Prism.languages.kusto = {
|
|
8029
|
+
})(Prism$1), Prism$1.languages.kusto = {
|
|
8069
8030
|
comment: {
|
|
8070
8031
|
pattern: /\/\/.*/,
|
|
8071
8032
|
greedy: !0
|
|
@@ -8137,7 +8098,7 @@ Prism.languages.markup = {
|
|
|
8137
8098
|
},
|
|
8138
8099
|
punctuation: /[[\]{}&]/
|
|
8139
8100
|
}, e.languages.tex = e.languages.latex, e.languages.context = e.languages.latex;
|
|
8140
|
-
})(Prism), (function(t) {
|
|
8101
|
+
})(Prism$1), (function(t) {
|
|
8141
8102
|
var e = /\/\*[\s\S]*?\*\/|\/\/.*|#(?!\[).*/, n = [
|
|
8142
8103
|
{
|
|
8143
8104
|
pattern: /\b(?:false|true)\b/i,
|
|
@@ -8409,7 +8370,7 @@ Prism.languages.markup = {
|
|
|
8409
8370
|
}), t.hooks.add("after-tokenize", function(e$1) {
|
|
8410
8371
|
t.languages["markup-templating"].tokenizePlaceholders(e$1, "php");
|
|
8411
8372
|
});
|
|
8412
|
-
})(Prism), (function(t) {
|
|
8373
|
+
})(Prism$1), (function(t) {
|
|
8413
8374
|
t.languages.latte = {
|
|
8414
8375
|
comment: /^\{\*[\s\S]*/,
|
|
8415
8376
|
"latte-tag": {
|
|
@@ -8454,7 +8415,7 @@ Prism.languages.markup = {
|
|
|
8454
8415
|
}), t.hooks.add("after-tokenize", function(e) {
|
|
8455
8416
|
t.languages["markup-templating"].tokenizePlaceholders(e, "latte");
|
|
8456
8417
|
});
|
|
8457
|
-
})(Prism), Prism.languages.scheme = {
|
|
8418
|
+
})(Prism$1), Prism$1.languages.scheme = {
|
|
8458
8419
|
comment: /;.*|#;\s*(?:\((?:[^()]|\([^()]*\))*\)|\[(?:[^\[\]]|\[[^\[\]]*\])*\])|#\|(?:[^#|]|#(?!\|)|\|(?!#)|#\|(?:[^#|]|#(?!\|)|\|(?!#))*\|#)*\|#/,
|
|
8459
8420
|
string: {
|
|
8460
8421
|
pattern: /"(?:[^"\\]|\\.)*"/,
|
|
@@ -8578,7 +8539,7 @@ Prism.languages.markup = {
|
|
|
8578
8539
|
number: /\b\d+(?:\/\d+)?\b/
|
|
8579
8540
|
};
|
|
8580
8541
|
a["embedded-scheme"].inside.scheme.inside["embedded-lilypond"].inside.lilypond.inside = a, e.languages.ly = a;
|
|
8581
|
-
})(Prism), Prism.languages.liquid = {
|
|
8542
|
+
})(Prism$1), Prism$1.languages.liquid = {
|
|
8582
8543
|
comment: {
|
|
8583
8544
|
pattern: /(^\{%\s*comment\s*%\})[\s\S]+(?=\{%\s*endcomment\s*%\}$)/,
|
|
8584
8545
|
lookbehind: !0
|
|
@@ -8613,9 +8574,9 @@ Prism.languages.markup = {
|
|
|
8613
8574
|
pattern: /\bempty\b/,
|
|
8614
8575
|
alias: "keyword"
|
|
8615
8576
|
}
|
|
8616
|
-
}, Prism.hooks.add("before-tokenize", function(e) {
|
|
8577
|
+
}, Prism$1.hooks.add("before-tokenize", function(e) {
|
|
8617
8578
|
var t = !1;
|
|
8618
|
-
Prism.languages["markup-templating"].buildPlaceholders(e, "liquid", /\{%\s*comment\s*%\}[\s\S]*?\{%\s*endcomment\s*%\}|\{(?:%[\s\S]*?%|\{\{[\s\S]*?\}\}|\{[\s\S]*?\})\}/g, function(e$1) {
|
|
8579
|
+
Prism$1.languages["markup-templating"].buildPlaceholders(e, "liquid", /\{%\s*comment\s*%\}[\s\S]*?\{%\s*endcomment\s*%\}|\{(?:%[\s\S]*?%|\{\{[\s\S]*?\}\}|\{[\s\S]*?\})\}/g, function(e$1) {
|
|
8619
8580
|
e$1 = /^\{%-?\s*(\w+)/.exec(e$1);
|
|
8620
8581
|
if (e$1) {
|
|
8621
8582
|
e$1 = e$1[1];
|
|
@@ -8624,8 +8585,8 @@ Prism.languages.markup = {
|
|
|
8624
8585
|
}
|
|
8625
8586
|
return !t;
|
|
8626
8587
|
});
|
|
8627
|
-
}), Prism.hooks.add("after-tokenize", function(e) {
|
|
8628
|
-
Prism.languages["markup-templating"].tokenizePlaceholders(e, "liquid");
|
|
8588
|
+
}), Prism$1.hooks.add("after-tokenize", function(e) {
|
|
8589
|
+
Prism$1.languages["markup-templating"].tokenizePlaceholders(e, "liquid");
|
|
8629
8590
|
}), (function(e) {
|
|
8630
8591
|
function t(e$1) {
|
|
8631
8592
|
return RegExp(/(\()/.source + "(?:" + e$1 + ")" + /(?=[\s\)])/.source);
|
|
@@ -8760,7 +8721,7 @@ Prism.languages.markup = {
|
|
|
8760
8721
|
}
|
|
8761
8722
|
};
|
|
8762
8723
|
o.lambda.inside.arguments = i, o.defun.inside.arguments = e.util.clone(i), o.defun.inside.arguments.inside.sublist = i, e.languages.lisp = o, e.languages.elisp = o, e.languages.emacs = o, e.languages["emacs-lisp"] = o;
|
|
8763
|
-
})(Prism), Prism.languages.livescript = {
|
|
8724
|
+
})(Prism$1), Prism$1.languages.livescript = {
|
|
8764
8725
|
comment: [{
|
|
8765
8726
|
pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
|
|
8766
8727
|
lookbehind: !0
|
|
@@ -8835,7 +8796,7 @@ Prism.languages.markup = {
|
|
|
8835
8796
|
lookbehind: !0
|
|
8836
8797
|
}, /\.(?:[=~]|\.\.?)|\.(?:[&|^]|<<|>>>?)\.|:(?:=|:=?)|&&|\|[|>]|<(?:<<?<?|--?!?|~~?!?|[|=?])?|>[>=?]?|-(?:->?|>)?|\+\+?|@@?|%%?|\*\*?|!(?:~?=|--?>|~?~>)?|~(?:~?>|=)?|==?|\^\^?|[\/?]/],
|
|
8837
8798
|
punctuation: /[(){}\[\]|.,:;`]/
|
|
8838
|
-
}, Prism.languages.livescript["interpolated-string"].inside.interpolation.inside.rest = Prism.languages.livescript, Prism.languages.llvm = {
|
|
8799
|
+
}, Prism$1.languages.livescript["interpolated-string"].inside.interpolation.inside.rest = Prism$1.languages.livescript, Prism$1.languages.llvm = {
|
|
8839
8800
|
comment: /;.*/,
|
|
8840
8801
|
string: {
|
|
8841
8802
|
pattern: /"[^"]*"/,
|
|
@@ -8851,7 +8812,7 @@ Prism.languages.markup = {
|
|
|
8851
8812
|
keyword: /\b[a-z_][a-z_0-9]*\b/,
|
|
8852
8813
|
number: /[+-]?\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b|\b0x[\dA-Fa-f]+\b|\b0xK[\dA-Fa-f]{20}\b|\b0x[ML][\dA-Fa-f]{32}\b|\b0xH[\dA-Fa-f]{4}\b/,
|
|
8853
8814
|
punctuation: /[{}[\];(),.!*=<>]/
|
|
8854
|
-
}, Prism.languages.log = {
|
|
8815
|
+
}, Prism$1.languages.log = {
|
|
8855
8816
|
string: {
|
|
8856
8817
|
pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?![st] | \w)(?:[^'\\\r\n]|\\.)*'/,
|
|
8857
8818
|
greedy: !0
|
|
@@ -8861,7 +8822,7 @@ Prism.languages.markup = {
|
|
|
8861
8822
|
lookbehind: !0,
|
|
8862
8823
|
greedy: !0,
|
|
8863
8824
|
alias: ["javastacktrace", "language-javastacktrace"],
|
|
8864
|
-
inside: Prism.languages.javastacktrace || {
|
|
8825
|
+
inside: Prism$1.languages.javastacktrace || {
|
|
8865
8826
|
keyword: /\bat\b/,
|
|
8866
8827
|
function: /[a-z_][\w$]*(?=\()/,
|
|
8867
8828
|
punctuation: /[.:()]/
|
|
@@ -8946,7 +8907,7 @@ Prism.languages.markup = {
|
|
|
8946
8907
|
},
|
|
8947
8908
|
operator: /[;:?<=>~/@!$%&+\-|^(){}*#]/,
|
|
8948
8909
|
punctuation: /[\[\].,]/
|
|
8949
|
-
}, Prism.languages.lolcode = {
|
|
8910
|
+
}, Prism$1.languages.lolcode = {
|
|
8950
8911
|
comment: [/\bOBTW\s[\s\S]*?\sTLDR\b/, /\bBTW.+/],
|
|
8951
8912
|
string: {
|
|
8952
8913
|
pattern: /"(?::.|[^":])*"/,
|
|
@@ -8992,7 +8953,7 @@ Prism.languages.markup = {
|
|
|
8992
8953
|
lookbehind: !0
|
|
8993
8954
|
},
|
|
8994
8955
|
punctuation: /\.{3}|…|,|!/
|
|
8995
|
-
}, Prism.languages.magma = {
|
|
8956
|
+
}, Prism$1.languages.magma = {
|
|
8996
8957
|
output: {
|
|
8997
8958
|
pattern: /^(>.*(?:\r(?:\n|(?!\n))|\n))(?!>)(?:.+|(?:\r(?:\n|(?!\n))|\n)(?!>).*)(?:(?:\r(?:\n|(?!\n))|\n)(?!>).*)*/m,
|
|
8998
8959
|
lookbehind: !0,
|
|
@@ -9020,7 +8981,7 @@ Prism.languages.markup = {
|
|
|
9020
8981
|
},
|
|
9021
8982
|
operator: /->|[-+*/^~!|#=]|:=|\.\./,
|
|
9022
8983
|
punctuation: /[()[\]{}<>,;.:]/
|
|
9023
|
-
}, Prism.languages.makefile = {
|
|
8984
|
+
}, Prism$1.languages.makefile = {
|
|
9024
8985
|
comment: {
|
|
9025
8986
|
pattern: /(^|[^\\])#(?:\\(?:\r\n|[\s\S])|[^\\\r\n])*/,
|
|
9026
8987
|
lookbehind: !0
|
|
@@ -9084,7 +9045,7 @@ Prism.languages.markup = {
|
|
|
9084
9045
|
operator: /\.\.|\+\+|--|&&|\|\||:?(?:[!=<>]=|[+\-*/^<>&|:])|[!?=\\#’`']/,
|
|
9085
9046
|
punctuation: /[()[\]{},;.]/
|
|
9086
9047
|
};
|
|
9087
|
-
})(Prism), Prism.languages.matlab = {
|
|
9048
|
+
})(Prism$1), Prism$1.languages.matlab = {
|
|
9088
9049
|
comment: [/%\{[\s\S]*?\}%/, /%.+/],
|
|
9089
9050
|
string: {
|
|
9090
9051
|
pattern: /\B'(?:''|[^'\r\n])*'/,
|
|
@@ -9097,7 +9058,7 @@ Prism.languages.markup = {
|
|
|
9097
9058
|
punctuation: /\.{3}|[.,;\[\](){}!]/
|
|
9098
9059
|
}, (function() {
|
|
9099
9060
|
var e = /\b(?:about|and|animate|as|at|attributes|by|case|catch|collect|continue|coordsys|do|else|exit|fn|for|from|function|global|if|in|local|macroscript|mapped|max|not|of|off|on|or|parameters|persistent|plugin|rcmenu|return|rollout|set|struct|then|throw|to|tool|try|undo|utility|when|where|while|with)\b/i;
|
|
9100
|
-
Prism.languages.maxscript = {
|
|
9061
|
+
Prism$1.languages.maxscript = {
|
|
9101
9062
|
comment: {
|
|
9102
9063
|
pattern: /\/\*[\s\S]*?(?:\*\/|$)|--.*/,
|
|
9103
9064
|
greedy: !0
|
|
@@ -9146,7 +9107,7 @@ Prism.languages.markup = {
|
|
|
9146
9107
|
operator: /[-+*/<>=!]=?|[&^?]|#(?!\()/,
|
|
9147
9108
|
punctuation: /[()\[\]{}.:,;]|#(?=\()|\\$/m
|
|
9148
9109
|
};
|
|
9149
|
-
})(), Prism.languages.mel = {
|
|
9110
|
+
})(), Prism$1.languages.mel = {
|
|
9150
9111
|
comment: {
|
|
9151
9112
|
pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
|
|
9152
9113
|
greedy: !0
|
|
@@ -9188,7 +9149,7 @@ Prism.languages.markup = {
|
|
|
9188
9149
|
},
|
|
9189
9150
|
operator: /\+[+=]?|-[-=]?|&&|\|\||[<>]=?|[*\/!=]=?|[%^]/,
|
|
9190
9151
|
punctuation: /[.,:;?\[\](){}]/
|
|
9191
|
-
}, Prism.languages.mel.code.inside.statement.inside = Prism.languages.mel, Prism.languages.mermaid = {
|
|
9152
|
+
}, Prism$1.languages.mel.code.inside.statement.inside = Prism$1.languages.mel, Prism$1.languages.mermaid = {
|
|
9192
9153
|
comment: {
|
|
9193
9154
|
pattern: /%%.*/,
|
|
9194
9155
|
greedy: !0
|
|
@@ -9277,7 +9238,7 @@ Prism.languages.markup = {
|
|
|
9277
9238
|
lookbehind: !0
|
|
9278
9239
|
},
|
|
9279
9240
|
punctuation: /[(){};]/
|
|
9280
|
-
}, Prism.languages.metafont = {
|
|
9241
|
+
}, Prism$1.languages.metafont = {
|
|
9281
9242
|
comment: {
|
|
9282
9243
|
pattern: /%.*/,
|
|
9283
9244
|
greedy: !0
|
|
@@ -9359,7 +9320,7 @@ Prism.languages.markup = {
|
|
|
9359
9320
|
pattern: /(^|[^@#&$])(?:@#|#@|#|@)(?![@#&$])|\b(?:aspect_ratio|currentpen|currentpicture|currenttransform|d|extra_beginchar|extra_endchar|extra_setup|h|localfont|mag|mode|screen_cols|screen_rows|w|whatever|x|y|z)\b/,
|
|
9360
9321
|
lookbehind: !0
|
|
9361
9322
|
}
|
|
9362
|
-
}, Prism.languages.mizar = {
|
|
9323
|
+
}, Prism$1.languages.mizar = {
|
|
9363
9324
|
comment: /::.+/,
|
|
9364
9325
|
keyword: /@proof\b|\b(?:according|aggregate|all|and|antonym|are|as|associativity|assume|asymmetry|attr|be|begin|being|by|canceled|case|cases|clusters?|coherence|commutativity|compatibility|connectedness|consider|consistency|constructors|contradiction|correctness|def|deffunc|define|definitions?|defpred|do|does|end|environ|equals|ex|exactly|existence|for|from|func|given|hence|hereby|holds|idempotence|identity|iff?|implies|involutiveness|irreflexivity|is|it|let|means|mode|non|not|notations?|now|of|or|otherwise|over|per|pred|prefix|projectivity|proof|provided|qua|reconsider|redefine|reduce|reducibility|reflexivity|registrations?|requirements|reserve|sch|schemes?|section|selector|set|sethood|st|struct|such|suppose|symmetry|synonym|take|that|the|then|theorems?|thesis|thus|to|transitivity|uniqueness|vocabular(?:ies|y)|when|where|with|wrt)\b/,
|
|
9365
9326
|
parameter: {
|
|
@@ -9642,7 +9603,7 @@ Prism.languages.markup = {
|
|
|
9642
9603
|
].join("|") + ")\\b"),
|
|
9643
9604
|
alias: "keyword"
|
|
9644
9605
|
} });
|
|
9645
|
-
})(Prism), Prism.languages.monkey = {
|
|
9606
|
+
})(Prism$1), Prism$1.languages.monkey = {
|
|
9646
9607
|
comment: {
|
|
9647
9608
|
pattern: /^#Rem\s[\s\S]*?^#End|'.+/im,
|
|
9648
9609
|
greedy: !0
|
|
@@ -9669,7 +9630,7 @@ Prism.languages.markup = {
|
|
|
9669
9630
|
keyword: /\b(?:Abstract|Array|Bool|Case|Catch|Class|Const|Continue|Default|Eachin|Else|ElseIf|End|EndIf|Exit|Extends|Extern|False|Field|Final|Float|For|Forever|Function|Global|If|Implements|Import|Inline|Int|Interface|Local|Method|Module|New|Next|Null|Object|Private|Property|Public|Repeat|Return|Select|Self|Step|Strict|String|Super|Then|Throw|To|True|Try|Until|Void|Wend|While)\b/i,
|
|
9670
9631
|
operator: /\.\.|<[=>]?|>=?|:?=|(?:[+\-*\/&~|]|\b(?:Mod|Shl|Shr)\b)=?|\b(?:And|Not|Or)\b/i,
|
|
9671
9632
|
punctuation: /[.,:;()\[\]]/
|
|
9672
|
-
}, Prism.languages.moonscript = {
|
|
9633
|
+
}, Prism$1.languages.moonscript = {
|
|
9673
9634
|
comment: /--.*/,
|
|
9674
9635
|
string: [{
|
|
9675
9636
|
pattern: /'[^']*'|\[(=*)\[[\s\S]*?\]\1\]/,
|
|
@@ -9710,7 +9671,7 @@ Prism.languages.markup = {
|
|
|
9710
9671
|
number: /(?:\B\.\d+|\b\d+\.\d+|\b\d+(?=[eE]))(?:[eE][-+]?\d+)?\b|\b(?:0x[a-fA-F\d]+|\d+)(?:U?LL)?\b/,
|
|
9711
9672
|
operator: /\.{3}|[-=]>|~=|(?:[-+*/%<>!=]|\.\.)=?|[:#^]|\b(?:and|or)\b=?|\b(?:not)\b/,
|
|
9712
9673
|
punctuation: /[.,()[\]{}\\]/
|
|
9713
|
-
}, Prism.languages.moonscript.string[1].inside.interpolation.inside.moonscript.inside = Prism.languages.moonscript, Prism.languages.moon = Prism.languages.moonscript, Prism.languages.n1ql = {
|
|
9674
|
+
}, Prism$1.languages.moonscript.string[1].inside.interpolation.inside.moonscript.inside = Prism$1.languages.moonscript, Prism$1.languages.moon = Prism$1.languages.moonscript, Prism$1.languages.n1ql = {
|
|
9714
9675
|
comment: {
|
|
9715
9676
|
pattern: /\/\*[\s\S]*?(?:$|\*\/)|--.*/,
|
|
9716
9677
|
greedy: !0
|
|
@@ -9730,7 +9691,7 @@ Prism.languages.markup = {
|
|
|
9730
9691
|
number: /(?:\b\d+\.|\B\.)\d+e[+\-]?\d+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i,
|
|
9731
9692
|
operator: /[-+*\/%]|!=|==?|\|\||<[>=]?|>=?|\b(?:AND|ANY|ARRAY|BETWEEN|CASE|ELSE|END|EVERY|EXISTS|FIRST|IN|LIKE|NOT|OR|THEN|VALUED|WHEN|WITHIN)\b/i,
|
|
9732
9693
|
punctuation: /[;[\](),.{}:]/
|
|
9733
|
-
}, Prism.languages["nand2tetris-hdl"] = {
|
|
9694
|
+
}, Prism$1.languages["nand2tetris-hdl"] = {
|
|
9734
9695
|
comment: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
|
|
9735
9696
|
keyword: /\b(?:BUILTIN|CHIP|CLOCKED|IN|OUT|PARTS)\b/,
|
|
9736
9697
|
boolean: /\b(?:false|true)\b/,
|
|
@@ -9857,7 +9818,7 @@ Prism.languages.markup = {
|
|
|
9857
9818
|
})(t$1 = a(e$2)) || (e$2.type = "bad-line", e$2.content = t$1);
|
|
9858
9819
|
});
|
|
9859
9820
|
});
|
|
9860
|
-
})(Prism), Prism.languages.nasm = {
|
|
9821
|
+
})(Prism$1), Prism$1.languages.nasm = {
|
|
9861
9822
|
comment: /;.*$/m,
|
|
9862
9823
|
string: /(["'`])(?:\\.|(?!\1)[^\\\r\n])*\1/,
|
|
9863
9824
|
label: {
|
|
@@ -9880,7 +9841,7 @@ Prism.languages.markup = {
|
|
|
9880
9841
|
},
|
|
9881
9842
|
number: /(?:\b|(?=\$))(?:0[hx](?:\.[\da-f]+|[\da-f]+(?:\.[\da-f]+)?)(?:p[+-]?\d+)?|\d[\da-f]+[hx]|\$\d[\da-f]*|0[oq][0-7]+|[0-7]+[oq]|0[by][01]+|[01]+[by]|0[dt]\d+|(?:\d+(?:\.\d+)?|\.\d+)(?:\.?e[+-]?\d+)?[dt]?)\b/i,
|
|
9882
9843
|
operator: /[\[\]*+\-\/%<>=&|$!]/
|
|
9883
|
-
}, Prism.languages.neon = {
|
|
9844
|
+
}, Prism$1.languages.neon = {
|
|
9884
9845
|
comment: {
|
|
9885
9846
|
pattern: /#.*/,
|
|
9886
9847
|
greedy: !0
|
|
@@ -9919,7 +9880,7 @@ Prism.languages.markup = {
|
|
|
9919
9880
|
alias: "string"
|
|
9920
9881
|
},
|
|
9921
9882
|
punctuation: /[,:=[\]{}()-]/
|
|
9922
|
-
}, Prism.languages.nevod = {
|
|
9883
|
+
}, Prism$1.languages.nevod = {
|
|
9923
9884
|
comment: /\/\/.*|(?:\/\*[\s\S]*?(?:\*\/|$))/,
|
|
9924
9885
|
string: {
|
|
9925
9886
|
pattern: /(?:"(?:""|[^"])*"(?!")|'(?:''|[^'])*'(?!'))!?\*?/,
|
|
@@ -10040,7 +10001,7 @@ Prism.languages.markup = {
|
|
|
10040
10001
|
name: /[a-zA-Z0-9\-.]+/
|
|
10041
10002
|
}, (function() {
|
|
10042
10003
|
var e = /\$(?:\w[a-z\d]*(?:_[^\x00-\x1F\s"'\\()$]*)?|\{[^}\s"'\\]+\})/i;
|
|
10043
|
-
Prism.languages.nginx = {
|
|
10004
|
+
Prism$1.languages.nginx = {
|
|
10044
10005
|
comment: {
|
|
10045
10006
|
pattern: /(^|[\s{};])#.*/,
|
|
10046
10007
|
lookbehind: !0,
|
|
@@ -10085,7 +10046,7 @@ Prism.languages.markup = {
|
|
|
10085
10046
|
},
|
|
10086
10047
|
punctuation: /[{};]/
|
|
10087
10048
|
};
|
|
10088
|
-
})(), Prism.languages.nim = {
|
|
10049
|
+
})(), Prism$1.languages.nim = {
|
|
10089
10050
|
comment: {
|
|
10090
10051
|
pattern: /#.*/,
|
|
10091
10052
|
greedy: !0
|
|
@@ -10115,7 +10076,7 @@ Prism.languages.markup = {
|
|
|
10115
10076
|
lookbehind: !0
|
|
10116
10077
|
},
|
|
10117
10078
|
punctuation: /[({\[]\.|\.[)}\]]|[`(){}\[\],:]/
|
|
10118
|
-
}, Prism.languages.nix = {
|
|
10079
|
+
}, Prism$1.languages.nix = {
|
|
10119
10080
|
comment: {
|
|
10120
10081
|
pattern: /\/\*[\s\S]*?\*\/|#.*/,
|
|
10121
10082
|
greedy: !0
|
|
@@ -10143,7 +10104,7 @@ Prism.languages.markup = {
|
|
|
10143
10104
|
boolean: /\b(?:false|true)\b/,
|
|
10144
10105
|
operator: /[=!<>]=?|\+\+?|\|\||&&|\/\/|->?|[?@]/,
|
|
10145
10106
|
punctuation: /[{}()[\].,:;]/
|
|
10146
|
-
}, Prism.languages.nix.string.inside.interpolation.inside = Prism.languages.nix, Prism.languages.nsis = {
|
|
10107
|
+
}, Prism$1.languages.nix.string.inside.interpolation.inside = Prism$1.languages.nix, Prism$1.languages.nsis = {
|
|
10147
10108
|
comment: {
|
|
10148
10109
|
pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|[#;].*)/,
|
|
10149
10110
|
lookbehind: !0,
|
|
@@ -10167,14 +10128,14 @@ Prism.languages.markup = {
|
|
|
10167
10128
|
pattern: /(^[\t ]*)!(?:addincludedir|addplugindir|appendfile|cd|define|delfile|echo|else|endif|error|execute|finalize|getdllversion|gettlbversion|if|ifdef|ifmacrodef|ifmacrondef|ifndef|include|insertmacro|macro|macroend|makensis|packhdr|pragma|searchparse|searchreplace|system|tempfile|undef|verbose|warning)\b/im,
|
|
10168
10129
|
lookbehind: !0
|
|
10169
10130
|
}
|
|
10170
|
-
}, Prism.languages.objectivec = Prism.languages.extend("c", {
|
|
10131
|
+
}, Prism$1.languages.objectivec = Prism$1.languages.extend("c", {
|
|
10171
10132
|
string: {
|
|
10172
10133
|
pattern: /@?"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
|
|
10173
10134
|
greedy: !0
|
|
10174
10135
|
},
|
|
10175
10136
|
keyword: /\b(?:asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|in|inline|int|long|register|return|self|short|signed|sizeof|static|struct|super|switch|typedef|typeof|union|unsigned|void|volatile|while)\b|(?:@interface|@end|@implementation|@protocol|@class|@public|@protected|@private|@property|@try|@catch|@finally|@throw|@synthesize|@dynamic|@selector)\b/,
|
|
10176
10137
|
operator: /-[->]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|\|?|[~^%?*\/@]/
|
|
10177
|
-
}), delete Prism.languages.objectivec["class-name"], Prism.languages.objc = Prism.languages.objectivec, Prism.languages.ocaml = {
|
|
10138
|
+
}), delete Prism$1.languages.objectivec["class-name"], Prism$1.languages.objc = Prism$1.languages.objectivec, Prism$1.languages.ocaml = {
|
|
10178
10139
|
comment: {
|
|
10179
10140
|
pattern: /\(\*[\s\S]*?\*\)/,
|
|
10180
10141
|
greedy: !0
|
|
@@ -10221,7 +10182,7 @@ Prism.languages.markup = {
|
|
|
10221
10182
|
punctuation: /;;|::|[(){}\[\].,:;#]|\b_\b/
|
|
10222
10183
|
}, (function() {
|
|
10223
10184
|
var e = /\\(?:["'\\abefnrtv]|0[0-7]{2}|U[\dA-Fa-f]{6}|u[\dA-Fa-f]{4}|x[\dA-Fa-f]{2})/;
|
|
10224
|
-
Prism.languages.odin = {
|
|
10185
|
+
Prism$1.languages.odin = {
|
|
10225
10186
|
comment: [
|
|
10226
10187
|
{
|
|
10227
10188
|
pattern: /\/\*(?:[^/*]|\/(?!\*)|\*(?!\/)|\/\*(?:\*(?!\/)|[^*])*(?:\*\/|$))*(?:\*\/|$)/,
|
|
@@ -10318,7 +10279,7 @@ Prism.languages.markup = {
|
|
|
10318
10279
|
pattern: /\b(?:Buffer|BufferGL|BufferRenderGL|CommandQueue|Context|Device|DeviceCommandQueue|EnqueueArgs|Event|Image|Image1D|Image1DArray|Image1DBuffer|Image2D|Image2DArray|Image2DGL|Image3D|Image3DGL|ImageFormat|ImageGL|Kernel|KernelFunctor|LocalSpaceArg|Memory|NDRange|Pipe|Platform|Program|SVMAllocator|SVMTraitAtomic|SVMTraitCoarse|SVMTraitFine|SVMTraitReadOnly|SVMTraitReadWrite|SVMTraitWriteOnly|Sampler|UserEvent)\b/,
|
|
10319
10280
|
alias: "keyword"
|
|
10320
10281
|
}, e.languages.insertBefore("cpp", "keyword", t));
|
|
10321
|
-
})(Prism), Prism.languages.openqasm = {
|
|
10282
|
+
})(Prism$1), Prism$1.languages.openqasm = {
|
|
10322
10283
|
comment: /\/\*[\s\S]*?\*\/|\/\/.*/,
|
|
10323
10284
|
string: {
|
|
10324
10285
|
pattern: /"[^"\r\n\t]*"|'[^'\r\n\t]*'/,
|
|
@@ -10334,7 +10295,7 @@ Prism.languages.markup = {
|
|
|
10334
10295
|
},
|
|
10335
10296
|
operator: /->|>>=?|<<=?|&&|\|\||\+\+|--|[!=<>&|~^+\-*/%]=?|@/,
|
|
10336
10297
|
punctuation: /[(){}\[\];,:.]/
|
|
10337
|
-
}, Prism.languages.qasm = Prism.languages.openqasm, Prism.languages.oz = {
|
|
10298
|
+
}, Prism$1.languages.qasm = Prism$1.languages.openqasm, Prism$1.languages.oz = {
|
|
10338
10299
|
comment: {
|
|
10339
10300
|
pattern: /\/\*[\s\S]*?\*\/|%.*/,
|
|
10340
10301
|
greedy: !0
|
|
@@ -10358,7 +10319,7 @@ Prism.languages.markup = {
|
|
|
10358
10319
|
"attr-name": /\b\w+(?=[ \t]*:(?![:=]))/,
|
|
10359
10320
|
operator: /:(?:=|::?)|<[-:=]?|=(?:=|<?:?)|>=?:?|\\=:?|!!?|[|#+\-*\/,~^@]|\b(?:andthen|div|mod|orelse)\b/,
|
|
10360
10321
|
punctuation: /[\[\](){}.:;?]/
|
|
10361
|
-
}, Prism.languages.parigp = {
|
|
10322
|
+
}, Prism$1.languages.parigp = {
|
|
10362
10323
|
comment: /\/\*[\s\S]*?\*\/|\\\\.*/,
|
|
10363
10324
|
string: {
|
|
10364
10325
|
pattern: /"(?:[^"\\\r\n]|\\.)*"/,
|
|
@@ -10465,7 +10426,7 @@ Prism.languages.markup = {
|
|
|
10465
10426
|
alias: "punctuation"
|
|
10466
10427
|
}
|
|
10467
10428
|
}, t.tag.inside["attr-value"]);
|
|
10468
|
-
})(Prism), Prism.languages.pascal = {
|
|
10429
|
+
})(Prism$1), Prism$1.languages.pascal = {
|
|
10469
10430
|
directive: {
|
|
10470
10431
|
pattern: /\{\$[\s\S]*?\}/,
|
|
10471
10432
|
greedy: !0,
|
|
@@ -10509,11 +10470,11 @@ Prism.languages.markup = {
|
|
|
10509
10470
|
lookbehind: !0
|
|
10510
10471
|
}],
|
|
10511
10472
|
punctuation: /\(\.|\.\)|[()\[\]:;,.]/
|
|
10512
|
-
}, Prism.languages.pascal.asm.inside = Prism.languages.extend("pascal", {
|
|
10473
|
+
}, Prism$1.languages.pascal.asm.inside = Prism$1.languages.extend("pascal", {
|
|
10513
10474
|
asm: void 0,
|
|
10514
10475
|
keyword: void 0,
|
|
10515
10476
|
operator: void 0
|
|
10516
|
-
}), Prism.languages.objectpascal = Prism.languages.pascal, (function(e) {
|
|
10477
|
+
}), Prism$1.languages.objectpascal = Prism$1.languages.pascal, (function(e) {
|
|
10517
10478
|
var t = /\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\)/.source, n = /(?:\b\w+(?:<braces>)?|<braces>)/.source.replace(/<braces>/g, function() {
|
|
10518
10479
|
return t;
|
|
10519
10480
|
}), a = e.languages.pascaligo = {
|
|
@@ -10572,7 +10533,7 @@ Prism.languages.markup = {
|
|
|
10572
10533
|
a["class-name"].forEach(function(e$1) {
|
|
10573
10534
|
e$1.inside = r;
|
|
10574
10535
|
});
|
|
10575
|
-
})(Prism), Prism.languages.psl = {
|
|
10536
|
+
})(Prism$1), Prism$1.languages.psl = {
|
|
10576
10537
|
comment: {
|
|
10577
10538
|
pattern: /#.*/,
|
|
10578
10539
|
greedy: !0
|
|
@@ -10604,7 +10565,7 @@ Prism.languages.markup = {
|
|
|
10604
10565
|
number: /\b(?:0x[0-9a-f]+|\d+(?:\.\d+)?)\b/i,
|
|
10605
10566
|
operator: /--|\+\+|&&=?|\|\|=?|<<=?|>>=?|[=!]~|[-+*/%&|^!=<>]=?|\.|[:?]/,
|
|
10606
10567
|
punctuation: /[(){}\[\];,]/
|
|
10607
|
-
}, Prism.languages.pcaxis = {
|
|
10568
|
+
}, Prism$1.languages.pcaxis = {
|
|
10608
10569
|
string: /"[^"]*"/,
|
|
10609
10570
|
keyword: {
|
|
10610
10571
|
pattern: /((?:^|;)\s*)[-A-Z\d]+(?:\s*\[[-\w]+\])?(?:\s*\("[^"]*"(?:,\s*"[^"]*")*\))?(?=\s*=)/,
|
|
@@ -10654,7 +10615,7 @@ Prism.languages.markup = {
|
|
|
10654
10615
|
lookbehind: !0
|
|
10655
10616
|
},
|
|
10656
10617
|
boolean: /NO|YES/
|
|
10657
|
-
}, Prism.languages.px = Prism.languages.pcaxis, Prism.languages.peoplecode = {
|
|
10618
|
+
}, Prism$1.languages.px = Prism$1.languages.pcaxis, Prism$1.languages.peoplecode = {
|
|
10658
10619
|
comment: RegExp([
|
|
10659
10620
|
/\/\*[\s\S]*?\*\//.source,
|
|
10660
10621
|
/\bREM[^;]*;/.source,
|
|
@@ -10686,7 +10647,7 @@ Prism.languages.markup = {
|
|
|
10686
10647
|
number: /\b\d+(?:\.\d+)?\b/,
|
|
10687
10648
|
operator: /<>|[<>]=?|!=|\*\*|[-+*/|=@]/,
|
|
10688
10649
|
punctuation: /[:.;,()[\]]/
|
|
10689
|
-
}, Prism.languages.pcode = Prism.languages.peoplecode, (function(e) {
|
|
10650
|
+
}, Prism$1.languages.pcode = Prism$1.languages.peoplecode, (function(e) {
|
|
10690
10651
|
var t = /(?:\((?:[^()\\]|\\[\s\S])*\)|\{(?:[^{}\\]|\\[\s\S])*\}|\[(?:[^[\]\\]|\\[\s\S])*\]|<(?:[^<>\\]|\\[\s\S])*>)/.source;
|
|
10691
10652
|
e.languages.perl = {
|
|
10692
10653
|
comment: [{
|
|
@@ -10764,7 +10725,7 @@ Prism.languages.markup = {
|
|
|
10764
10725
|
operator: /-[rwxoRWXOezsfdlpSbctugkTBMAC]\b|\+[+=]?|-[-=>]?|\*\*?=?|\/\/?=?|=[=~>]?|~[~=]?|\|\|?=?|&&?=?|<(?:=>?|<=?)?|>>?=?|![~=]?|[%^]=?|\.(?:=|\.\.?)?|[\\?]|\bx(?:=|\b)|\b(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|xor)\b/,
|
|
10765
10726
|
punctuation: /[{}[\];(),:]/
|
|
10766
10727
|
};
|
|
10767
|
-
})(Prism), (function(e) {
|
|
10728
|
+
})(Prism$1), (function(e) {
|
|
10768
10729
|
var t = /(?:\b[a-zA-Z]\w*|[|\\[\]])+/.source;
|
|
10769
10730
|
e.languages.phpdoc = e.languages.extend("javadoclike", { parameter: {
|
|
10770
10731
|
pattern: RegExp("(@(?:global|param|property(?:-read|-write)?|var)\\s+(?:" + t + "\\s+)?)\\$\\w+"),
|
|
@@ -10777,7 +10738,7 @@ Prism.languages.markup = {
|
|
|
10777
10738
|
punctuation: /[|\\[\]()]/
|
|
10778
10739
|
}
|
|
10779
10740
|
}] }), e.languages.javadoclike.addSupport("php", e.languages.phpdoc);
|
|
10780
|
-
})(Prism), Prism.languages.insertBefore("php", "variable", {
|
|
10741
|
+
})(Prism$1), Prism$1.languages.insertBefore("php", "variable", {
|
|
10781
10742
|
this: {
|
|
10782
10743
|
pattern: /\$this\b/,
|
|
10783
10744
|
alias: "keyword"
|
|
@@ -10861,17 +10822,17 @@ Prism.languages.markup = {
|
|
|
10861
10822
|
variable: t,
|
|
10862
10823
|
punctuation: /[:,;()[\]{}]|\.{3}/
|
|
10863
10824
|
}, e.languages["plant-uml"].arrow.inside.expression.inside = e.languages["plant-uml"], e.languages.plantuml = e.languages["plant-uml"];
|
|
10864
|
-
})(Prism), Prism.languages.plsql = Prism.languages.extend("sql", {
|
|
10825
|
+
})(Prism$1), Prism$1.languages.plsql = Prism$1.languages.extend("sql", {
|
|
10865
10826
|
comment: {
|
|
10866
10827
|
pattern: /\/\*[\s\S]*?\*\/|--.*/,
|
|
10867
10828
|
greedy: !0
|
|
10868
10829
|
},
|
|
10869
10830
|
keyword: /\b(?:A|ACCESSIBLE|ADD|AGENT|AGGREGATE|ALL|ALTER|AND|ANY|ARRAY|AS|ASC|AT|ATTRIBUTE|AUTHID|AVG|BEGIN|BETWEEN|BFILE_BASE|BINARY|BLOB_BASE|BLOCK|BODY|BOTH|BOUND|BULK|BY|BYTE|C|CALL|CALLING|CASCADE|CASE|CHAR|CHARACTER|CHARSET|CHARSETFORM|CHARSETID|CHAR_BASE|CHECK|CLOB_BASE|CLONE|CLOSE|CLUSTER|CLUSTERS|COLAUTH|COLLECT|COLUMNS|COMMENT|COMMIT|COMMITTED|COMPILED|COMPRESS|CONNECT|CONSTANT|CONSTRUCTOR|CONTEXT|CONTINUE|CONVERT|COUNT|CRASH|CREATE|CREDENTIAL|CURRENT|CURSOR|CUSTOMDATUM|DANGLING|DATA|DATE|DATE_BASE|DAY|DECLARE|DEFAULT|DEFINE|DELETE|DESC|DETERMINISTIC|DIRECTORY|DISTINCT|DOUBLE|DROP|DURATION|ELEMENT|ELSE|ELSIF|EMPTY|END|ESCAPE|EXCEPT|EXCEPTION|EXCEPTIONS|EXCLUSIVE|EXECUTE|EXISTS|EXIT|EXTERNAL|FETCH|FINAL|FIRST|FIXED|FLOAT|FOR|FORALL|FORCE|FROM|FUNCTION|GENERAL|GOTO|GRANT|GROUP|HASH|HAVING|HEAP|HIDDEN|HOUR|IDENTIFIED|IF|IMMEDIATE|IMMUTABLE|IN|INCLUDING|INDEX|INDEXES|INDICATOR|INDICES|INFINITE|INSERT|INSTANTIABLE|INT|INTERFACE|INTERSECT|INTERVAL|INTO|INVALIDATE|IS|ISOLATION|JAVA|LANGUAGE|LARGE|LEADING|LENGTH|LEVEL|LIBRARY|LIKE|LIKE2|LIKE4|LIKEC|LIMIT|LIMITED|LOCAL|LOCK|LONG|LOOP|MAP|MAX|MAXLEN|MEMBER|MERGE|MIN|MINUS|MINUTE|MOD|MODE|MODIFY|MONTH|MULTISET|MUTABLE|NAME|NAN|NATIONAL|NATIVE|NCHAR|NEW|NOCOMPRESS|NOCOPY|NOT|NOWAIT|NULL|NUMBER_BASE|OBJECT|OCICOLL|OCIDATE|OCIDATETIME|OCIDURATION|OCIINTERVAL|OCILOBLOCATOR|OCINUMBER|OCIRAW|OCIREF|OCIREFCURSOR|OCIROWID|OCISTRING|OCITYPE|OF|OLD|ON|ONLY|OPAQUE|OPEN|OPERATOR|OPTION|OR|ORACLE|ORADATA|ORDER|ORGANIZATION|ORLANY|ORLVARY|OTHERS|OUT|OVERLAPS|OVERRIDING|PACKAGE|PARALLEL_ENABLE|PARAMETER|PARAMETERS|PARENT|PARTITION|PASCAL|PERSISTABLE|PIPE|PIPELINED|PLUGGABLE|POLYMORPHIC|PRAGMA|PRECISION|PRIOR|PRIVATE|PROCEDURE|PUBLIC|RAISE|RANGE|RAW|READ|RECORD|REF|REFERENCE|RELIES_ON|REM|REMAINDER|RENAME|RESOURCE|RESULT|RESULT_CACHE|RETURN|RETURNING|REVERSE|REVOKE|ROLLBACK|ROW|SAMPLE|SAVE|SAVEPOINT|SB1|SB2|SB4|SECOND|SEGMENT|SELECT|SELF|SEPARATE|SEQUENCE|SERIALIZABLE|SET|SHARE|SHORT|SIZE|SIZE_T|SOME|SPARSE|SQL|SQLCODE|SQLDATA|SQLNAME|SQLSTATE|STANDARD|START|STATIC|STDDEV|STORED|STRING|STRUCT|STYLE|SUBMULTISET|SUBPARTITION|SUBSTITUTABLE|SUBTYPE|SUM|SYNONYM|TABAUTH|TABLE|TDO|THE|THEN|TIME|TIMESTAMP|TIMEZONE_ABBR|TIMEZONE_HOUR|TIMEZONE_MINUTE|TIMEZONE_REGION|TO|TRAILING|TRANSACTION|TRANSACTIONAL|TRUSTED|TYPE|UB1|UB2|UB4|UNDER|UNION|UNIQUE|UNPLUG|UNSIGNED|UNTRUSTED|UPDATE|USE|USING|VALIST|VALUE|VALUES|VARIABLE|VARIANCE|VARRAY|VARYING|VIEW|VIEWS|VOID|WHEN|WHERE|WHILE|WITH|WORK|WRAPPED|WRITE|YEAR|ZONE)\b/i,
|
|
10870
10831
|
operator: /:=?|=>|[<>^~!]=|\.\.|\|\||\*\*|[-+*/%<>=@]/
|
|
10871
|
-
}), Prism.languages.insertBefore("plsql", "operator", { label: {
|
|
10832
|
+
}), Prism$1.languages.insertBefore("plsql", "operator", { label: {
|
|
10872
10833
|
pattern: /<<\s*\w+\s*>>/,
|
|
10873
10834
|
alias: "symbol"
|
|
10874
|
-
} }), Prism.languages.powerquery = {
|
|
10835
|
+
} }), Prism$1.languages.powerquery = {
|
|
10875
10836
|
comment: {
|
|
10876
10837
|
pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
|
|
10877
10838
|
lookbehind: !0,
|
|
@@ -10920,8 +10881,8 @@ Prism.languages.markup = {
|
|
|
10920
10881
|
},
|
|
10921
10882
|
operator: /[-+*\/&?@^]|<(?:=>?|>)?|>=?|=>?|\.\.\.?/,
|
|
10922
10883
|
punctuation: /[,;\[\](){}]/
|
|
10923
|
-
}, Prism.languages.pq = Prism.languages.powerquery, Prism.languages.mscript = Prism.languages.powerquery, (function() {
|
|
10924
|
-
var e = Prism.languages.powershell = {
|
|
10884
|
+
}, Prism$1.languages.pq = Prism$1.languages.powerquery, Prism$1.languages.mscript = Prism$1.languages.powerquery, (function() {
|
|
10885
|
+
var e = Prism$1.languages.powershell = {
|
|
10925
10886
|
comment: [{
|
|
10926
10887
|
pattern: /(^|[^`])<#[\s\S]*?#>/,
|
|
10927
10888
|
lookbehind: !0
|
|
@@ -10957,17 +10918,17 @@ Prism.languages.markup = {
|
|
|
10957
10918
|
boolean: e.boolean,
|
|
10958
10919
|
variable: e.variable
|
|
10959
10920
|
};
|
|
10960
|
-
})(), Prism.languages.processing = Prism.languages.extend("clike", {
|
|
10921
|
+
})(), Prism$1.languages.processing = Prism$1.languages.extend("clike", {
|
|
10961
10922
|
keyword: /\b(?:break|case|catch|class|continue|default|else|extends|final|for|if|implements|import|new|null|private|public|return|static|super|switch|this|try|void|while)\b/,
|
|
10962
10923
|
function: /\b\w+(?=\s*\()/,
|
|
10963
10924
|
operator: /<[<=]?|>[>=]?|&&?|\|\|?|[%?]|[!=+\-*\/]=?/
|
|
10964
|
-
}), Prism.languages.insertBefore("processing", "number", {
|
|
10925
|
+
}), Prism$1.languages.insertBefore("processing", "number", {
|
|
10965
10926
|
constant: /\b(?!XML\b)[A-Z][A-Z\d_]+\b/,
|
|
10966
10927
|
type: {
|
|
10967
10928
|
pattern: /\b(?:boolean|byte|char|color|double|float|int|[A-Z]\w*)\b/,
|
|
10968
10929
|
alias: "class-name"
|
|
10969
10930
|
}
|
|
10970
|
-
}), Prism.languages.prolog = {
|
|
10931
|
+
}), Prism$1.languages.prolog = {
|
|
10971
10932
|
comment: {
|
|
10972
10933
|
pattern: /\/\*[\s\S]*?\*\/|%.*/,
|
|
10973
10934
|
greedy: !0
|
|
@@ -11057,7 +11018,7 @@ Prism.languages.markup = {
|
|
|
11057
11018
|
operator: /[\^*/%+-]|==|!=|<=|<|>=|>|\b(?:and|or|unless)\b/i,
|
|
11058
11019
|
punctuation: /[{};()`,.[\]]/
|
|
11059
11020
|
};
|
|
11060
|
-
})(Prism), Prism.languages.properties = {
|
|
11021
|
+
})(Prism$1), Prism$1.languages.properties = {
|
|
11061
11022
|
comment: /^[ \t]*[#!].*$/m,
|
|
11062
11023
|
value: {
|
|
11063
11024
|
pattern: /(^[ \t]*(?:\\(?:\r\n|[\s\S])|[^\\\s:=])+(?: *[=:] *(?! )| ))(?:\\(?:\r\n|[\s\S])|[^\\\r\n])+/m,
|
|
@@ -11101,7 +11062,7 @@ Prism.languages.markup = {
|
|
|
11101
11062
|
lookbehind: !0
|
|
11102
11063
|
}
|
|
11103
11064
|
});
|
|
11104
|
-
})(Prism), (function(e) {
|
|
11065
|
+
})(Prism$1), (function(e) {
|
|
11105
11066
|
var t = {
|
|
11106
11067
|
pattern: /(\b\d+)(?:%|[a-z]+)/,
|
|
11107
11068
|
lookbehind: !0
|
|
@@ -11216,7 +11177,7 @@ Prism.languages.markup = {
|
|
|
11216
11177
|
interpolation: t.interpolation,
|
|
11217
11178
|
punctuation: /[{}()\[\];:.]/
|
|
11218
11179
|
};
|
|
11219
|
-
})(Prism), Prism.languages.twig = {
|
|
11180
|
+
})(Prism$1), Prism$1.languages.twig = {
|
|
11220
11181
|
comment: /^\{#[\s\S]*?#\}$/,
|
|
11221
11182
|
"tag-name": {
|
|
11222
11183
|
pattern: /(^\{%-?\s*)\w+/,
|
|
@@ -11239,10 +11200,10 @@ Prism.languages.markup = {
|
|
|
11239
11200
|
lookbehind: !0
|
|
11240
11201
|
}, /[=<>]=?|!=|\*\*?|\/\/?|\?:?|[-+~%|]/],
|
|
11241
11202
|
punctuation: /[()\[\]{}:.,]/
|
|
11242
|
-
}, Prism.hooks.add("before-tokenize", function(e) {
|
|
11243
|
-
"twig" === e.language && Prism.languages["markup-templating"].buildPlaceholders(e, "twig", /\{(?:#[\s\S]*?#|%[\s\S]*?%|\{[\s\S]*?\})\}/g);
|
|
11244
|
-
}), Prism.hooks.add("after-tokenize", function(e) {
|
|
11245
|
-
Prism.languages["markup-templating"].tokenizePlaceholders(e, "twig");
|
|
11203
|
+
}, Prism$1.hooks.add("before-tokenize", function(e) {
|
|
11204
|
+
"twig" === e.language && Prism$1.languages["markup-templating"].buildPlaceholders(e, "twig", /\{(?:#[\s\S]*?#|%[\s\S]*?%|\{[\s\S]*?\})\}/g);
|
|
11205
|
+
}), Prism$1.hooks.add("after-tokenize", function(e) {
|
|
11206
|
+
Prism$1.languages["markup-templating"].tokenizePlaceholders(e, "twig");
|
|
11246
11207
|
}), (function(e) {
|
|
11247
11208
|
e.languages.pug = {
|
|
11248
11209
|
comment: {
|
|
@@ -11402,7 +11363,7 @@ Prism.languages.markup = {
|
|
|
11402
11363
|
});
|
|
11403
11364
|
}
|
|
11404
11365
|
e.languages.insertBefore("pug", "filter", a);
|
|
11405
|
-
})(Prism), (function(e) {
|
|
11366
|
+
})(Prism$1), (function(e) {
|
|
11406
11367
|
e.languages.puppet = {
|
|
11407
11368
|
heredoc: [
|
|
11408
11369
|
{
|
|
@@ -11497,7 +11458,7 @@ Prism.languages.markup = {
|
|
|
11497
11458
|
inside: { punctuation: /::/ }
|
|
11498
11459
|
}];
|
|
11499
11460
|
e.languages.puppet.heredoc[0].inside.interpolation = t, e.languages.puppet.string.inside["double-quoted"].inside.interpolation = t;
|
|
11500
|
-
})(Prism), (function(a) {
|
|
11461
|
+
})(Prism$1), (function(a) {
|
|
11501
11462
|
a.languages.pure = {
|
|
11502
11463
|
comment: [
|
|
11503
11464
|
{
|
|
@@ -11557,13 +11518,13 @@ Prism.languages.markup = {
|
|
|
11557
11518
|
inside: a.util.clone(a.languages.pure["inline-lang"].inside)
|
|
11558
11519
|
}, t["inline-lang-" + n].inside.rest = a.util.clone(a.languages[n]), a.languages.insertBefore("pure", "inline-lang", t));
|
|
11559
11520
|
}), a.languages.c && (a.languages.pure["inline-lang"].inside.rest = a.util.clone(a.languages.c));
|
|
11560
|
-
})(Prism), Prism.languages.purebasic = Prism.languages.extend("clike", {
|
|
11521
|
+
})(Prism$1), Prism$1.languages.purebasic = Prism$1.languages.extend("clike", {
|
|
11561
11522
|
comment: /;.*/,
|
|
11562
11523
|
keyword: /\b(?:align|and|as|break|calldebugger|case|compilercase|compilerdefault|compilerelse|compilerelseif|compilerendif|compilerendselect|compilererror|compilerif|compilerselect|continue|data|datasection|debug|debuglevel|declare|declarec|declarecdll|declaredll|declaremodule|default|define|dim|disableasm|disabledebugger|disableexplicit|else|elseif|enableasm|enabledebugger|enableexplicit|end|enddatasection|enddeclaremodule|endenumeration|endif|endimport|endinterface|endmacro|endmodule|endprocedure|endselect|endstructure|endstructureunion|endwith|enumeration|extends|fakereturn|for|foreach|forever|global|gosub|goto|if|import|importc|includebinary|includefile|includepath|interface|macro|module|newlist|newmap|next|not|or|procedure|procedurec|procedurecdll|proceduredll|procedurereturn|protected|prototype|prototypec|read|redim|repeat|restore|return|runtime|select|shared|static|step|structure|structureunion|swap|threaded|to|until|wend|while|with|xincludefile|xor)\b/i,
|
|
11563
11524
|
function: /\b\w+(?:\.\w+)?\s*(?=\()/,
|
|
11564
11525
|
number: /(?:\$[\da-f]+|\b-?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?)\b/i,
|
|
11565
11526
|
operator: /(?:@\*?|\?|\*)\w+\$?|-[>-]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|?\||[~^%?*/@]/
|
|
11566
|
-
}), Prism.languages.insertBefore("purebasic", "keyword", {
|
|
11527
|
+
}), Prism$1.languages.insertBefore("purebasic", "keyword", {
|
|
11567
11528
|
tag: /#\w+\$?/,
|
|
11568
11529
|
asm: {
|
|
11569
11530
|
pattern: /(^[\t ]*)!.*/m,
|
|
@@ -11605,7 +11566,7 @@ Prism.languages.markup = {
|
|
|
11605
11566
|
operator: /[\[\]*+\-/%<>=&|$!,.:]/
|
|
11606
11567
|
}
|
|
11607
11568
|
}
|
|
11608
|
-
}), delete Prism.languages.purebasic["class-name"], delete Prism.languages.purebasic.boolean, Prism.languages.pbfasm = Prism.languages.purebasic, Prism.languages.purescript = Prism.languages.extend("haskell", {
|
|
11569
|
+
}), delete Prism$1.languages.purebasic["class-name"], delete Prism$1.languages.purebasic.boolean, Prism$1.languages.pbfasm = Prism$1.languages.purebasic, Prism$1.languages.purescript = Prism$1.languages.extend("haskell", {
|
|
11609
11570
|
keyword: /\b(?:ado|case|class|data|derive|do|else|forall|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\b|∀/,
|
|
11610
11571
|
"import-statement": {
|
|
11611
11572
|
pattern: /(^[\t ]*)import\s+[A-Z][\w']*(?:\.[A-Z][\w']*)*(?:\s+as\s+[A-Z][\w']*(?:\.[A-Z][\w']*)*)?(?:\s+hiding\b)?/m,
|
|
@@ -11617,11 +11578,11 @@ Prism.languages.markup = {
|
|
|
11617
11578
|
},
|
|
11618
11579
|
builtin: /\b(?:absurd|add|ap|append|apply|between|bind|bottom|clamp|compare|comparing|compose|conj|const|degree|discard|disj|div|eq|flap|flip|gcd|identity|ifM|join|lcm|liftA1|liftM1|map|max|mempty|min|mod|mul|negate|not|notEq|one|otherwise|recip|show|sub|top|unit|unless|unlessM|void|when|whenM|zero)\b/,
|
|
11619
11580
|
operator: [
|
|
11620
|
-
Prism.languages.haskell.operator[0],
|
|
11621
|
-
Prism.languages.haskell.operator[2],
|
|
11581
|
+
Prism$1.languages.haskell.operator[0],
|
|
11582
|
+
Prism$1.languages.haskell.operator[2],
|
|
11622
11583
|
/[\xa2-\xa6\xa8\xa9\xac\xae-\xb1\xb4\xb8\xd7\xf7\u02c2-\u02c5\u02d2-\u02df\u02e5-\u02eb\u02ed\u02ef-\u02ff\u0375\u0384\u0385\u03f6\u0482\u058d-\u058f\u0606-\u0608\u060b\u060e\u060f\u06de\u06e9\u06fd\u06fe\u07f6\u07fe\u07ff\u09f2\u09f3\u09fa\u09fb\u0af1\u0b70\u0bf3-\u0bfa\u0c7f\u0d4f\u0d79\u0e3f\u0f01-\u0f03\u0f13\u0f15-\u0f17\u0f1a-\u0f1f\u0f34\u0f36\u0f38\u0fbe-\u0fc5\u0fc7-\u0fcc\u0fce\u0fcf\u0fd5-\u0fd8\u109e\u109f\u1390-\u1399\u166d\u17db\u1940\u19de-\u19ff\u1b61-\u1b6a\u1b74-\u1b7c\u1fbd\u1fbf-\u1fc1\u1fcd-\u1fcf\u1fdd-\u1fdf\u1fed-\u1fef\u1ffd\u1ffe\u2044\u2052\u207a-\u207c\u208a-\u208c\u20a0-\u20bf\u2100\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e\u213a\u213b\u2140-\u2144\u214a-\u214d\u214f\u218a\u218b\u2190-\u2307\u230c-\u2328\u232b-\u2426\u2440-\u244a\u249c-\u24e9\u2500-\u2767\u2794-\u27c4\u27c7-\u27e5\u27f0-\u2982\u2999-\u29d7\u29dc-\u29fb\u29fe-\u2b73\u2b76-\u2b95\u2b97-\u2bff\u2ce5-\u2cea\u2e50\u2e51\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3004\u3012\u3013\u3020\u3036\u3037\u303e\u303f\u309b\u309c\u3190\u3191\u3196-\u319f\u31c0-\u31e3\u3200-\u321e\u322a-\u3247\u3250\u3260-\u327f\u328a-\u32b0\u32c0-\u33ff\u4dc0-\u4dff\ua490-\ua4c6\ua700-\ua716\ua720\ua721\ua789\ua78a\ua828-\ua82b\ua836-\ua839\uaa77-\uaa79\uab5b\uab6a\uab6b\ufb29\ufbb2-\ufbc1\ufdfc\ufdfd\ufe62\ufe64-\ufe66\ufe69\uff04\uff0b\uff1c-\uff1e\uff3e\uff40\uff5c\uff5e\uffe0-\uffe6\uffe8-\uffee\ufffc\ufffd]/
|
|
11623
11584
|
]
|
|
11624
|
-
}), Prism.languages.purs = Prism.languages.purescript, Prism.languages.python = {
|
|
11585
|
+
}), Prism$1.languages.purs = Prism$1.languages.purescript, Prism$1.languages.python = {
|
|
11625
11586
|
comment: {
|
|
11626
11587
|
pattern: /(^|[^\\])#.*/,
|
|
11627
11588
|
lookbehind: !0,
|
|
@@ -11678,7 +11639,7 @@ Prism.languages.markup = {
|
|
|
11678
11639
|
number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
|
|
11679
11640
|
operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
|
|
11680
11641
|
punctuation: /[{}[\];(),.:]/
|
|
11681
|
-
}, Prism.languages.python["string-interpolation"].inside.interpolation.inside.rest = Prism.languages.python, Prism.languages.py = Prism.languages.python, (function(e) {
|
|
11642
|
+
}, Prism$1.languages.python["string-interpolation"].inside.interpolation.inside.rest = Prism$1.languages.python, Prism$1.languages.py = Prism$1.languages.python, (function(e) {
|
|
11682
11643
|
function a(e$1, n$1) {
|
|
11683
11644
|
return e$1.replace(/<<(\d+)>>/g, function(e$2, t$1) {
|
|
11684
11645
|
return "(?:" + n$1[+t$1] + ")";
|
|
@@ -11738,7 +11699,7 @@ Prism.languages.markup = {
|
|
|
11738
11699
|
string: /[\s\S]+/
|
|
11739
11700
|
}
|
|
11740
11701
|
} });
|
|
11741
|
-
})(Prism), Prism.languages.qs = Prism.languages.qsharp, Prism.languages.q = {
|
|
11702
|
+
})(Prism$1), Prism$1.languages.qs = Prism$1.languages.qsharp, Prism$1.languages.q = {
|
|
11742
11703
|
string: /"(?:\\.|[^"\\\r\n])*"/,
|
|
11743
11704
|
comment: [
|
|
11744
11705
|
{
|
|
@@ -11829,7 +11790,7 @@ Prism.languages.markup = {
|
|
|
11829
11790
|
keyword: /\b(?:as|import|on)\b/,
|
|
11830
11791
|
punctuation: /[{}[\]:;,]/
|
|
11831
11792
|
};
|
|
11832
|
-
})(Prism), Prism.languages.qore = Prism.languages.extend("clike", {
|
|
11793
|
+
})(Prism$1), Prism$1.languages.qore = Prism$1.languages.extend("clike", {
|
|
11833
11794
|
comment: {
|
|
11834
11795
|
pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:\/\/|#).*)/,
|
|
11835
11796
|
lookbehind: !0
|
|
@@ -11847,7 +11808,7 @@ Prism.languages.markup = {
|
|
|
11847
11808
|
lookbehind: !0
|
|
11848
11809
|
},
|
|
11849
11810
|
variable: /\$(?!\d)\w+\b/
|
|
11850
|
-
}), Prism.languages.r = {
|
|
11811
|
+
}), Prism$1.languages.r = {
|
|
11851
11812
|
comment: /#.*/,
|
|
11852
11813
|
string: {
|
|
11853
11814
|
pattern: /(['"])(?:\\.|(?!\1)[^\\\r\n])*\1/,
|
|
@@ -11863,14 +11824,14 @@ Prism.languages.markup = {
|
|
|
11863
11824
|
keyword: /\b(?:NA|NA_character_|NA_complex_|NA_integer_|NA_real_|NULL|break|else|for|function|if|in|next|repeat|while)\b/,
|
|
11864
11825
|
operator: /->?>?|<(?:=|<?-)?|[>=!]=?|::?|&&?|\|\|?|[+*\/^$@~]/,
|
|
11865
11826
|
punctuation: /[(){}\[\],;]/
|
|
11866
|
-
}, Prism.languages.racket = Prism.languages.extend("scheme", { "lambda-parameter": {
|
|
11827
|
+
}, Prism$1.languages.racket = Prism$1.languages.extend("scheme", { "lambda-parameter": {
|
|
11867
11828
|
pattern: /([(\[]lambda\s+[(\[])[^()\[\]'\s]+/,
|
|
11868
11829
|
lookbehind: !0
|
|
11869
|
-
} }), Prism.languages.insertBefore("racket", "string", { lang: {
|
|
11830
|
+
} }), Prism$1.languages.insertBefore("racket", "string", { lang: {
|
|
11870
11831
|
pattern: /^#lang.+/m,
|
|
11871
11832
|
greedy: !0,
|
|
11872
11833
|
alias: "keyword"
|
|
11873
|
-
} }), Prism.languages.rkt = Prism.languages.racket, (function(e) {
|
|
11834
|
+
} }), Prism$1.languages.rkt = Prism$1.languages.racket, (function(e) {
|
|
11874
11835
|
var a = /\/(?![/*])|\/\/.*[\r\n]|\/\*[^*]*(?:\*(?!\/)[^*]*)*\*\//.source, r = /@(?!")|"(?:[^\r\n\\"]|\\.)*"|@"(?:[^\\"]|""|\\[\s\S])*"(?!")/.source + "|" + /'(?:(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'|(?=[^\\](?!')))/.source;
|
|
11875
11836
|
function t(e$1, t$1) {
|
|
11876
11837
|
for (var n$1 = 0; n$1 < t$1; n$1++) e$1 = e$1.replace(/<self>/g, function() {
|
|
@@ -11937,7 +11898,7 @@ Prism.languages.markup = {
|
|
|
11937
11898
|
alias: "operator"
|
|
11938
11899
|
}
|
|
11939
11900
|
}), e.languages.razor = e.languages.cshtml;
|
|
11940
|
-
})(Prism), (function(i) {
|
|
11901
|
+
})(Prism$1), (function(i) {
|
|
11941
11902
|
var e = i.util.clone(i.languages.javascript), n = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source, a = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source, r = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source;
|
|
11942
11903
|
function t(e$1, t$1) {
|
|
11943
11904
|
return e$1 = e$1.replace(/<S>/g, function() {
|
|
@@ -11977,10 +11938,10 @@ Prism.languages.markup = {
|
|
|
11977
11938
|
i.hooks.add("after-tokenize", function(e$1) {
|
|
11978
11939
|
"jsx" !== e$1.language && "tsx" !== e$1.language || o(e$1.tokens);
|
|
11979
11940
|
});
|
|
11980
|
-
})(Prism), (function(e) {
|
|
11941
|
+
})(Prism$1), (function(e) {
|
|
11981
11942
|
var t = e.util.clone(e.languages.typescript), t = (e.languages.tsx = e.languages.extend("jsx", t), delete e.languages.tsx.parameter, delete e.languages.tsx["literal-property"], e.languages.tsx.tag);
|
|
11982
11943
|
t.pattern = RegExp(/(^|[^\w$]|(?=<\/))/.source + "(?:" + t.pattern.source + ")", t.pattern.flags), t.lookbehind = !0;
|
|
11983
|
-
})(Prism), Prism.languages.reason = Prism.languages.extend("clike", {
|
|
11944
|
+
})(Prism$1), Prism$1.languages.reason = Prism$1.languages.extend("clike", {
|
|
11984
11945
|
string: {
|
|
11985
11946
|
pattern: /"(?:\\(?:\r\n|[\s\S])|[^\\\r\n"])*"/,
|
|
11986
11947
|
greedy: !0
|
|
@@ -11988,7 +11949,7 @@ Prism.languages.markup = {
|
|
|
11988
11949
|
"class-name": /\b[A-Z]\w*/,
|
|
11989
11950
|
keyword: /\b(?:and|as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|method|module|mutable|new|nonrec|object|of|open|or|private|rec|sig|struct|switch|then|to|try|type|val|virtual|when|while|with)\b/,
|
|
11990
11951
|
operator: /\.{3}|:[:=]|\|>|->|=(?:==?|>)?|<=?|>=?|[|^?'#!~`]|[+\-*\/]\.?|\b(?:asr|land|lor|lsl|lsr|lxor|mod)\b/
|
|
11991
|
-
}), Prism.languages.insertBefore("reason", "class-name", {
|
|
11952
|
+
}), Prism$1.languages.insertBefore("reason", "class-name", {
|
|
11992
11953
|
char: {
|
|
11993
11954
|
pattern: /'(?:\\x[\da-f]{2}|\\o[0-3][0-7][0-7]|\\\d{3}|\\.|[^'\\\r\n])'/,
|
|
11994
11955
|
greedy: !0
|
|
@@ -11998,7 +11959,7 @@ Prism.languages.markup = {
|
|
|
11998
11959
|
pattern: /\b[a-z]\w*(?=::)/,
|
|
11999
11960
|
alias: "symbol"
|
|
12000
11961
|
}
|
|
12001
|
-
}), delete Prism.languages.reason.function, Prism.languages.rego = {
|
|
11962
|
+
}), delete Prism$1.languages.reason.function, Prism$1.languages.rego = {
|
|
12002
11963
|
comment: /#.*/,
|
|
12003
11964
|
property: {
|
|
12004
11965
|
pattern: /(^|[^\\.])(?:"(?:\\.|[^\\"\r\n])*"|`[^`]*`|\b[a-z_]\w*\b)(?=\s*:(?!=))/i,
|
|
@@ -12022,7 +11983,7 @@ Prism.languages.markup = {
|
|
|
12022
11983
|
number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
|
|
12023
11984
|
operator: /[-+*/%|&]|[<>:=]=?|!=|\b_\b/,
|
|
12024
11985
|
punctuation: /[,;.\[\]{}()]/
|
|
12025
|
-
}, Prism.languages.renpy = {
|
|
11986
|
+
}, Prism$1.languages.renpy = {
|
|
12026
11987
|
comment: {
|
|
12027
11988
|
pattern: /(^|[^\\])#.+/,
|
|
12028
11989
|
lookbehind: !0
|
|
@@ -12039,7 +12000,7 @@ Prism.languages.markup = {
|
|
|
12039
12000
|
number: /(?:\b(?:0[bo])?(?:(?:\d|0x[\da-f])[\da-f]*(?:\.\d*)?)|\B\.\d+)(?:e[+-]?\d+)?j?/i,
|
|
12040
12001
|
operator: /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]|\b(?:and|at|not|or|with)\b/,
|
|
12041
12002
|
punctuation: /[{}[\];(),.:]/
|
|
12042
|
-
}, Prism.languages.rpy = Prism.languages.renpy, Prism.languages.rescript = {
|
|
12003
|
+
}, Prism$1.languages.rpy = Prism$1.languages.renpy, Prism$1.languages.rescript = {
|
|
12043
12004
|
comment: {
|
|
12044
12005
|
pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
|
|
12045
12006
|
greedy: !0
|
|
@@ -12072,7 +12033,7 @@ Prism.languages.markup = {
|
|
|
12072
12033
|
keyword: /\b(?:and|as|assert|begin|bool|class|constraint|do|done|downto|else|end|exception|external|float|for|fun|function|if|in|include|inherit|initializer|int|lazy|let|method|module|mutable|new|nonrec|object|of|open|or|private|rec|string|switch|then|to|try|type|when|while|with)\b/,
|
|
12073
12034
|
operator: /\.{3}|:[:=]?|\|>|->|=(?:==?|>)?|<=?|>=?|[|^?'#!~`]|[+\-*\/]\.?|\b(?:asr|land|lor|lsl|lsr|lxor|mod)\b/,
|
|
12074
12035
|
punctuation: /[(){}[\],;.]/
|
|
12075
|
-
}, Prism.languages.insertBefore("rescript", "string", { "template-string": {
|
|
12036
|
+
}, Prism$1.languages.insertBefore("rescript", "string", { "template-string": {
|
|
12076
12037
|
pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
|
|
12077
12038
|
greedy: !0,
|
|
12078
12039
|
inside: {
|
|
@@ -12088,12 +12049,12 @@ Prism.languages.markup = {
|
|
|
12088
12049
|
pattern: /^\$\{|\}$/,
|
|
12089
12050
|
alias: "tag"
|
|
12090
12051
|
},
|
|
12091
|
-
rest: Prism.languages.rescript
|
|
12052
|
+
rest: Prism$1.languages.rescript
|
|
12092
12053
|
}
|
|
12093
12054
|
},
|
|
12094
12055
|
string: /[\s\S]+/
|
|
12095
12056
|
}
|
|
12096
|
-
} }), Prism.languages.res = Prism.languages.rescript, Prism.languages.rest = {
|
|
12057
|
+
} }), Prism$1.languages.res = Prism$1.languages.rescript, Prism$1.languages.rest = {
|
|
12097
12058
|
table: [{
|
|
12098
12059
|
pattern: /(^[\t ]*)(?:\+[=-]+)+\+(?:\r?\n|\r)(?:\1[+|].+[+|](?:\r?\n|\r))+\1(?:\+[=-]+)+\+/m,
|
|
12099
12060
|
lookbehind: !0,
|
|
@@ -12242,7 +12203,7 @@ Prism.languages.markup = {
|
|
|
12242
12203
|
pattern: /(^[\t ]*)(?:\|(?= |$)|(?:---?|—|\.\.|__)(?= )|\.\.$)/m,
|
|
12243
12204
|
lookbehind: !0
|
|
12244
12205
|
}
|
|
12245
|
-
}, Prism.languages.rip = {
|
|
12206
|
+
}, Prism$1.languages.rip = {
|
|
12246
12207
|
comment: {
|
|
12247
12208
|
pattern: /#.*/,
|
|
12248
12209
|
greedy: !0
|
|
@@ -12270,7 +12231,7 @@ Prism.languages.markup = {
|
|
|
12270
12231
|
number: /[+-]?\b(?:\d+\.\d+|\d+)\b/,
|
|
12271
12232
|
punctuation: /(?:\.{2,3})|[`,.:;=\/\\()<>\[\]{}]/,
|
|
12272
12233
|
reference: /[^\d\s`'",.:;#\/\\()<>\[\]{}][^\s`'",.:;#\/\\()<>\[\]{}]*/
|
|
12273
|
-
}, Prism.languages.roboconf = {
|
|
12234
|
+
}, Prism$1.languages.roboconf = {
|
|
12274
12235
|
comment: /#.*/,
|
|
12275
12236
|
keyword: {
|
|
12276
12237
|
pattern: /(^|\s)(?:(?:external|import)\b|(?:facet|instance of)(?=[ \t]+[\w-]+[ \t]*\{))/,
|
|
@@ -12368,7 +12329,7 @@ Prism.languages.markup = {
|
|
|
12368
12329
|
}),
|
|
12369
12330
|
comment: r
|
|
12370
12331
|
}, e.languages.robot = e.languages.robotframework;
|
|
12371
|
-
})(Prism), (function(e) {
|
|
12332
|
+
})(Prism$1), (function(e) {
|
|
12372
12333
|
for (var t = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source, n = 0; n < 2; n++) t = t.replace(/<self>/g, function() {
|
|
12373
12334
|
return t;
|
|
12374
12335
|
});
|
|
@@ -12457,7 +12418,7 @@ Prism.languages.markup = {
|
|
|
12457
12418
|
punctuation: /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/,
|
|
12458
12419
|
operator: /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/
|
|
12459
12420
|
}, e.languages.rust["closure-params"].inside.rest = e.languages.rust, e.languages.rust.attribute.inside.string = e.languages.rust.string;
|
|
12460
|
-
})(Prism), (function(e) {
|
|
12421
|
+
})(Prism$1), (function(e) {
|
|
12461
12422
|
var t = /(?:"(?:""|[^"])*"(?!")|'(?:''|[^'])*'(?!'))/.source, n = /\b(?:\d[\da-f]*x|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/i, a = {
|
|
12462
12423
|
pattern: RegExp(t + "[bx]"),
|
|
12463
12424
|
alias: "number"
|
|
@@ -12732,7 +12693,7 @@ Prism.languages.markup = {
|
|
|
12732
12693
|
operator: /\*\*?|\|\|?|!!?|¦¦?|<[>=]?|>[<=]?|[-+\/=&]|[~¬^]=?/,
|
|
12733
12694
|
punctuation: d
|
|
12734
12695
|
};
|
|
12735
|
-
})(Prism), (function(e) {
|
|
12696
|
+
})(Prism$1), (function(e) {
|
|
12736
12697
|
e.languages.sass = e.languages.extend("css", { comment: {
|
|
12737
12698
|
pattern: /^([ \t]*)\/[\/*].*(?:(?:\r?\n|\r)\1[ \t].+)*/m,
|
|
12738
12699
|
lookbehind: !0,
|
|
@@ -12775,7 +12736,7 @@ Prism.languages.markup = {
|
|
|
12775
12736
|
lookbehind: !0,
|
|
12776
12737
|
greedy: !0
|
|
12777
12738
|
} });
|
|
12778
|
-
})(Prism), (function(e) {
|
|
12739
|
+
})(Prism$1), (function(e) {
|
|
12779
12740
|
var t = [
|
|
12780
12741
|
/"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/.source,
|
|
12781
12742
|
/'[^']*'/.source,
|
|
@@ -12812,7 +12773,7 @@ Prism.languages.markup = {
|
|
|
12812
12773
|
},
|
|
12813
12774
|
output: /.(?:.*(?:[\r\n]|.$))*/
|
|
12814
12775
|
}, e.languages["sh-session"] = e.languages.shellsession = e.languages["shell-session"];
|
|
12815
|
-
})(Prism), Prism.languages.smali = {
|
|
12776
|
+
})(Prism$1), Prism$1.languages.smali = {
|
|
12816
12777
|
comment: /#.*/,
|
|
12817
12778
|
string: {
|
|
12818
12779
|
pattern: /"(?:[^\r\n\\"]|\\.)*"|'(?:[^\r\n\\']|\\(?:.|u[\da-fA-F]{4}))'/,
|
|
@@ -12883,7 +12844,7 @@ Prism.languages.markup = {
|
|
|
12883
12844
|
},
|
|
12884
12845
|
operator: /->|\.\.|[\[=]/,
|
|
12885
12846
|
punctuation: /[{}(),;:]/
|
|
12886
|
-
}, Prism.languages.smalltalk = {
|
|
12847
|
+
}, Prism$1.languages.smalltalk = {
|
|
12887
12848
|
comment: {
|
|
12888
12849
|
pattern: /"(?:""|[^"])*"/,
|
|
12889
12850
|
greedy: !0
|
|
@@ -13008,7 +12969,7 @@ Prism.languages.markup = {
|
|
|
13008
12969
|
}), n.hooks.add("after-tokenize", function(e$1) {
|
|
13009
12970
|
n.languages["markup-templating"].tokenizePlaceholders(e$1, "smarty");
|
|
13010
12971
|
});
|
|
13011
|
-
})(Prism), (function(e) {
|
|
12972
|
+
})(Prism$1), (function(e) {
|
|
13012
12973
|
var t = /\b(?:abstype|and|andalso|as|case|datatype|do|else|end|eqtype|exception|fn|fun|functor|handle|if|in|include|infix|infixr|let|local|nonfix|of|op|open|orelse|raise|rec|sharing|sig|signature|struct|structure|then|type|val|where|while|with|withtype)\b/i;
|
|
13013
12974
|
e.languages.sml = {
|
|
13014
12975
|
comment: /\(\*(?:[^*(]|\*(?!\))|\((?!\*)|\(\*(?:[^*(]|\*(?!\))|\((?!\*))*\*\))*\*\)/,
|
|
@@ -13051,18 +13012,18 @@ Prism.languages.markup = {
|
|
|
13051
13012
|
operator: /\.\.\.|:[>=:]|=>?|->|[<>]=?|[!+\-*/^#|@~]/,
|
|
13052
13013
|
punctuation: /[(){}\[\].:,;]/
|
|
13053
13014
|
}, e.languages.sml["class-name"][0].inside = e.languages.sml, e.languages.smlnj = e.languages.sml;
|
|
13054
|
-
})(Prism), Prism.languages.solidity = Prism.languages.extend("clike", {
|
|
13015
|
+
})(Prism$1), Prism$1.languages.solidity = Prism$1.languages.extend("clike", {
|
|
13055
13016
|
"class-name": {
|
|
13056
13017
|
pattern: /(\b(?:contract|enum|interface|library|new|struct|using)\s+)(?!\d)[\w$]+/,
|
|
13057
13018
|
lookbehind: !0
|
|
13058
13019
|
},
|
|
13059
13020
|
keyword: /\b(?:_|anonymous|as|assembly|assert|break|calldata|case|constant|constructor|continue|contract|default|delete|do|else|emit|enum|event|external|for|from|function|if|import|indexed|inherited|interface|internal|is|let|library|mapping|memory|modifier|new|payable|pragma|private|public|pure|require|returns?|revert|selfdestruct|solidity|storage|struct|suicide|switch|this|throw|using|var|view|while)\b/,
|
|
13060
13021
|
operator: /=>|->|:=|=:|\*\*|\+\+|--|\|\||&&|<<=?|>>=?|[-+*/%^&|<>!=]=?|[~?]/
|
|
13061
|
-
}), Prism.languages.insertBefore("solidity", "keyword", { builtin: /\b(?:address|bool|byte|u?int(?:8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?|string|bytes(?:[1-9]|[12]\d|3[0-2])?)\b/ }), Prism.languages.insertBefore("solidity", "number", { version: {
|
|
13022
|
+
}), Prism$1.languages.insertBefore("solidity", "keyword", { builtin: /\b(?:address|bool|byte|u?int(?:8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?|string|bytes(?:[1-9]|[12]\d|3[0-2])?)\b/ }), Prism$1.languages.insertBefore("solidity", "number", { version: {
|
|
13062
13023
|
pattern: /([<>]=?|\^)\d+\.\d+\.\d+\b/,
|
|
13063
13024
|
lookbehind: !0,
|
|
13064
13025
|
alias: "number"
|
|
13065
|
-
} }), Prism.languages.sol = Prism.languages.solidity, (function(e) {
|
|
13026
|
+
} }), Prism$1.languages.sol = Prism$1.languages.solidity, (function(e) {
|
|
13066
13027
|
var t = {
|
|
13067
13028
|
pattern: /\{[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}\}/i,
|
|
13068
13029
|
alias: "constant",
|
|
@@ -13095,7 +13056,7 @@ Prism.languages.markup = {
|
|
|
13095
13056
|
operator: /=/,
|
|
13096
13057
|
punctuation: /[(),]/
|
|
13097
13058
|
}, e.languages.sln = e.languages["solution-file"];
|
|
13098
|
-
})(Prism), (function(n) {
|
|
13059
|
+
})(Prism$1), (function(n) {
|
|
13099
13060
|
var e = /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/, t = /\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b|\b0x[\dA-F]+\b/;
|
|
13100
13061
|
n.languages.soy = {
|
|
13101
13062
|
comment: [/\/\*[\s\S]*?\*\//, {
|
|
@@ -13154,7 +13115,7 @@ Prism.languages.markup = {
|
|
|
13154
13115
|
}), n.hooks.add("after-tokenize", function(e$1) {
|
|
13155
13116
|
n.languages["markup-templating"].tokenizePlaceholders(e$1, "soy");
|
|
13156
13117
|
});
|
|
13157
|
-
})(Prism), Prism.languages.turtle = {
|
|
13118
|
+
})(Prism$1), Prism$1.languages.turtle = {
|
|
13158
13119
|
comment: {
|
|
13159
13120
|
pattern: /#.*/,
|
|
13160
13121
|
greedy: !0
|
|
@@ -13195,17 +13156,17 @@ Prism.languages.markup = {
|
|
|
13195
13156
|
pattern: /@[a-z]+(?:-[a-z\d]+)*/i,
|
|
13196
13157
|
inside: { punctuation: /@/ }
|
|
13197
13158
|
}
|
|
13198
|
-
}, Prism.languages.trig = Prism.languages.turtle, Prism.languages.sparql = Prism.languages.extend("turtle", {
|
|
13159
|
+
}, Prism$1.languages.trig = Prism$1.languages.turtle, Prism$1.languages.sparql = Prism$1.languages.extend("turtle", {
|
|
13199
13160
|
boolean: /\b(?:false|true)\b/i,
|
|
13200
13161
|
variable: {
|
|
13201
13162
|
pattern: /[?$]\w+/,
|
|
13202
13163
|
greedy: !0
|
|
13203
13164
|
}
|
|
13204
|
-
}), Prism.languages.insertBefore("sparql", "punctuation", { keyword: [
|
|
13165
|
+
}), Prism$1.languages.insertBefore("sparql", "punctuation", { keyword: [
|
|
13205
13166
|
/\b(?:A|ADD|ALL|AS|ASC|ASK|BNODE|BY|CLEAR|CONSTRUCT|COPY|CREATE|DATA|DEFAULT|DELETE|DESC|DESCRIBE|DISTINCT|DROP|EXISTS|FILTER|FROM|GROUP|HAVING|INSERT|INTO|LIMIT|LOAD|MINUS|MOVE|NAMED|NOT|NOW|OFFSET|OPTIONAL|ORDER|RAND|REDUCED|SELECT|SEPARATOR|SERVICE|SILENT|STRUUID|UNION|USING|UUID|VALUES|WHERE)\b/i,
|
|
13206
13167
|
/\b(?:ABS|AVG|BIND|BOUND|CEIL|COALESCE|CONCAT|CONTAINS|COUNT|DATATYPE|DAY|ENCODE_FOR_URI|FLOOR|GROUP_CONCAT|HOURS|IF|IRI|isBLANK|isIRI|isLITERAL|isNUMERIC|isURI|LANG|LANGMATCHES|LCASE|MAX|MD5|MIN|MINUTES|MONTH|REGEX|REPLACE|ROUND|sameTerm|SAMPLE|SECONDS|SHA1|SHA256|SHA384|SHA512|STR|STRAFTER|STRBEFORE|STRDT|STRENDS|STRLANG|STRLEN|STRSTARTS|SUBSTR|SUM|TIMEZONE|TZ|UCASE|URI|YEAR)\b(?=\s*\()/i,
|
|
13207
13168
|
/\b(?:BASE|GRAPH|PREFIX)\b/i
|
|
13208
|
-
] }), Prism.languages.rq = Prism.languages.sparql, Prism.languages["splunk-spl"] = {
|
|
13169
|
+
] }), Prism$1.languages.rq = Prism$1.languages.sparql, Prism$1.languages["splunk-spl"] = {
|
|
13209
13170
|
comment: /`comment\("(?:\\.|[^\\"])*"\)`/,
|
|
13210
13171
|
string: {
|
|
13211
13172
|
pattern: /"(?:\\.|[^\\"])*"/,
|
|
@@ -13226,7 +13187,7 @@ Prism.languages.markup = {
|
|
|
13226
13187
|
boolean: /\b(?:f|false|t|true)\b/i,
|
|
13227
13188
|
operator: /[<>=]=?|[-+*/%|]/,
|
|
13228
13189
|
punctuation: /[()[\],]/
|
|
13229
|
-
}, Prism.languages.sqf = Prism.languages.extend("clike", {
|
|
13190
|
+
}, Prism$1.languages.sqf = Prism$1.languages.extend("clike", {
|
|
13230
13191
|
string: {
|
|
13231
13192
|
pattern: /"(?:(?:"")?[^"])*"(?!")|'(?:[^'])*'/,
|
|
13232
13193
|
greedy: !0
|
|
@@ -13241,7 +13202,7 @@ Prism.languages.markup = {
|
|
|
13241
13202
|
alias: "keyword"
|
|
13242
13203
|
},
|
|
13243
13204
|
constant: /\bDIK(?:_[a-z\d]+)+\b/i
|
|
13244
|
-
}), Prism.languages.insertBefore("sqf", "string", { macro: {
|
|
13205
|
+
}), Prism$1.languages.insertBefore("sqf", "string", { macro: {
|
|
13245
13206
|
pattern: /(^[ \t]*)#[a-z](?:[^\r\n\\]|\\(?:\r\n|[\s\S]))*/im,
|
|
13246
13207
|
lookbehind: !0,
|
|
13247
13208
|
greedy: !0,
|
|
@@ -13251,10 +13212,10 @@ Prism.languages.markup = {
|
|
|
13251
13212
|
pattern: /#[a-z]+\b/i,
|
|
13252
13213
|
alias: "keyword"
|
|
13253
13214
|
},
|
|
13254
|
-
comment: Prism.languages.sqf.comment
|
|
13215
|
+
comment: Prism$1.languages.sqf.comment
|
|
13255
13216
|
}
|
|
13256
|
-
} }), delete Prism.languages.sqf["class-name"], Prism.languages.squirrel = Prism.languages.extend("clike", {
|
|
13257
|
-
comment: [Prism.languages.clike.comment[0], {
|
|
13217
|
+
} }), delete Prism$1.languages.sqf["class-name"], Prism$1.languages.squirrel = Prism$1.languages.extend("clike", {
|
|
13218
|
+
comment: [Prism$1.languages.clike.comment[0], {
|
|
13258
13219
|
pattern: /(^|[^\\:])(?:\/\/|#).*/,
|
|
13259
13220
|
lookbehind: !0,
|
|
13260
13221
|
greedy: !0
|
|
@@ -13273,11 +13234,11 @@ Prism.languages.markup = {
|
|
|
13273
13234
|
number: /\b(?:0x[0-9a-fA-F]+|\d+(?:\.(?:\d+|[eE][+-]?\d+))?)\b/,
|
|
13274
13235
|
operator: /\+\+|--|<=>|<[-<]|>>>?|&&?|\|\|?|[-+*/%!=<>]=?|[~^]|::?/,
|
|
13275
13236
|
punctuation: /[(){}\[\],;.]/
|
|
13276
|
-
}), Prism.languages.insertBefore("squirrel", "string", { char: {
|
|
13237
|
+
}), Prism$1.languages.insertBefore("squirrel", "string", { char: {
|
|
13277
13238
|
pattern: /(^|[^\\"'])'(?:[^\\']|\\(?:[xuU][0-9a-fA-F]{0,8}|[\s\S]))'/,
|
|
13278
13239
|
lookbehind: !0,
|
|
13279
13240
|
greedy: !0
|
|
13280
|
-
} }), Prism.languages.insertBefore("squirrel", "operator", {
|
|
13241
|
+
} }), Prism$1.languages.insertBefore("squirrel", "operator", {
|
|
13281
13242
|
"attribute-punctuation": {
|
|
13282
13243
|
pattern: /<\/|\/>/,
|
|
13283
13244
|
alias: "important"
|
|
@@ -13332,7 +13293,7 @@ Prism.languages.markup = {
|
|
|
13332
13293
|
operator: /<-|\.[*/]=?|\|\|?|&&|[!=<>+\-*/]=?|['^%~?:]/,
|
|
13333
13294
|
punctuation: /[()\[\]{},;]/
|
|
13334
13295
|
}, e.languages.stan.constraint.inside.expression.inside = e.languages.stan;
|
|
13335
|
-
})(Prism), Prism.languages.stata = {
|
|
13296
|
+
})(Prism$1), Prism$1.languages.stata = {
|
|
13336
13297
|
comment: [{
|
|
13337
13298
|
pattern: /(^[ \t]*)\*.*/m,
|
|
13338
13299
|
lookbehind: !0,
|
|
@@ -13364,21 +13325,21 @@ Prism.languages.markup = {
|
|
|
13364
13325
|
lookbehind: !0,
|
|
13365
13326
|
greedy: !0,
|
|
13366
13327
|
alias: "language-mata",
|
|
13367
|
-
inside: Prism.languages.mata
|
|
13328
|
+
inside: Prism$1.languages.mata
|
|
13368
13329
|
},
|
|
13369
13330
|
java: {
|
|
13370
13331
|
pattern: /(^[ \t]*java[ \t]*:)[\s\S]+?(?=^end\b)/m,
|
|
13371
13332
|
lookbehind: !0,
|
|
13372
13333
|
greedy: !0,
|
|
13373
13334
|
alias: "language-java",
|
|
13374
|
-
inside: Prism.languages.java
|
|
13335
|
+
inside: Prism$1.languages.java
|
|
13375
13336
|
},
|
|
13376
13337
|
python: {
|
|
13377
13338
|
pattern: /(^[ \t]*python[ \t]*:)[\s\S]+?(?=^end\b)/m,
|
|
13378
13339
|
lookbehind: !0,
|
|
13379
13340
|
greedy: !0,
|
|
13380
13341
|
alias: "language-python",
|
|
13381
|
-
inside: Prism.languages.python
|
|
13342
|
+
inside: Prism$1.languages.python
|
|
13382
13343
|
},
|
|
13383
13344
|
command: {
|
|
13384
13345
|
pattern: /(^[ \t]*(?:\.[ \t]+)?(?:(?:bayes|bootstrap|by|bysort|capture|collect|fmm|fp|frame|jackknife|mfp|mi|nestreg|noisily|permute|quietly|rolling|simulate|statsby|stepwise|svy|version|xi)\b[^:\r\n]*:[ \t]*|(?:capture|noisily|quietly|version)[ \t]+)?)[a-zA-Z]\w*/m,
|
|
@@ -13393,7 +13354,7 @@ Prism.languages.markup = {
|
|
|
13393
13354
|
function: /\b[a-z_]\w*(?=\()/i,
|
|
13394
13355
|
operator: /\+\+|--|##?|[<>!=~]=?|[+\-*^&|/]/,
|
|
13395
13356
|
punctuation: /[(){}[\],:]/
|
|
13396
|
-
}, Prism.languages.stata["string-literal"].inside.interpolation.inside.expression.inside = Prism.languages.stata, Prism.languages.iecst = {
|
|
13357
|
+
}, Prism$1.languages.stata["string-literal"].inside.interpolation.inside.expression.inside = Prism$1.languages.stata, Prism$1.languages.iecst = {
|
|
13397
13358
|
comment: [{
|
|
13398
13359
|
pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\(\*[\s\S]*?(?:\*\)|$)|\{[\s\S]*?(?:\}|$))/,
|
|
13399
13360
|
lookbehind: !0,
|
|
@@ -13418,7 +13379,7 @@ Prism.languages.markup = {
|
|
|
13418
13379
|
operator: /S?R?:?=>?|&&?|\*\*?|<[=>]?|>=?|[-:^/+#]|\b(?:AND|EQ|EXPT|GE|GT|LE|LT|MOD|NE|NOT|OR|XOR)\b/,
|
|
13419
13380
|
function: /\b[a-z_]\w*(?=\s*\()/i,
|
|
13420
13381
|
punctuation: /[()[\].,;]/
|
|
13421
|
-
}, Prism.languages.supercollider = {
|
|
13382
|
+
}, Prism$1.languages.supercollider = {
|
|
13422
13383
|
comment: {
|
|
13423
13384
|
pattern: /\/\/.*|\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/)*\*\//,
|
|
13424
13385
|
greedy: !0
|
|
@@ -13447,7 +13408,7 @@ Prism.languages.markup = {
|
|
|
13447
13408
|
"class-name": /\b[A-Z]\w*\b/,
|
|
13448
13409
|
operator: /\.{2,3}|#(?![[{])|&&|[!=]==?|\+>>|\+{1,3}|-[->]|=>|>>|\?\?|@\|?@|\|(?:@|[!=]=)?\||!\?|<[!=>]|\*{1,2}|<{2,3}\*?|[-!%&/<>?@|=`]/,
|
|
13449
13410
|
punctuation: /[{}()[\].:,;]|#[[{]/
|
|
13450
|
-
}, Prism.languages.sclang = Prism.languages.supercollider, Prism.languages.swift = {
|
|
13411
|
+
}, Prism$1.languages.sclang = Prism$1.languages.supercollider, Prism$1.languages.swift = {
|
|
13451
13412
|
comment: {
|
|
13452
13413
|
pattern: /(^|[^\\:])(?:\/\/.*|\/\*(?:[^/*]|\/(?!\*)|\*(?!\/)|\/\*(?:[^*]|\*(?!\/))*\*\/)*\*\/)/,
|
|
13453
13414
|
lookbehind: !0,
|
|
@@ -13537,8 +13498,8 @@ Prism.languages.markup = {
|
|
|
13537
13498
|
constant: /\b(?:[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\b/,
|
|
13538
13499
|
operator: /[-+*/%=!<>&|^~?]+|\.[.\-+*/%=!<>&|^~?]+/,
|
|
13539
13500
|
punctuation: /[{}[\]();,.:\\]/
|
|
13540
|
-
}, Prism.languages.swift["string-literal"].forEach(function(e) {
|
|
13541
|
-
e.inside.interpolation.inside = Prism.languages.swift;
|
|
13501
|
+
}, Prism$1.languages.swift["string-literal"].forEach(function(e) {
|
|
13502
|
+
e.inside.interpolation.inside = Prism$1.languages.swift;
|
|
13542
13503
|
}), (function(e) {
|
|
13543
13504
|
var t = {
|
|
13544
13505
|
pattern: /^[;#].*/m,
|
|
@@ -13583,7 +13544,7 @@ Prism.languages.markup = {
|
|
|
13583
13544
|
},
|
|
13584
13545
|
punctuation: /=/
|
|
13585
13546
|
};
|
|
13586
|
-
})(Prism), (function(n) {
|
|
13547
|
+
})(Prism$1), (function(n) {
|
|
13587
13548
|
function a(e, t, n$1) {
|
|
13588
13549
|
return {
|
|
13589
13550
|
pattern: RegExp("<#" + e + "[\\s\\S]*?#>"),
|
|
@@ -13620,7 +13581,7 @@ Prism.languages.markup = {
|
|
|
13620
13581
|
}
|
|
13621
13582
|
} };
|
|
13622
13583
|
} });
|
|
13623
|
-
})(Prism), Prism.languages.t4 = Prism.languages["t4-cs"] = Prism.languages["t4-templating"].createT4("csharp"), Prism.languages.vbnet = Prism.languages.extend("basic", {
|
|
13584
|
+
})(Prism$1), Prism$1.languages.t4 = Prism$1.languages["t4-cs"] = Prism$1.languages["t4-templating"].createT4("csharp"), Prism$1.languages.vbnet = Prism$1.languages.extend("basic", {
|
|
13624
13585
|
comment: [{
|
|
13625
13586
|
pattern: /(?:!|REM\b).+/i,
|
|
13626
13587
|
inside: { keyword: /^REM/i }
|
|
@@ -13636,7 +13597,7 @@ Prism.languages.markup = {
|
|
|
13636
13597
|
},
|
|
13637
13598
|
keyword: /(?:\b(?:ADDHANDLER|ADDRESSOF|ALIAS|AND|ANDALSO|AS|BEEP|BLOAD|BOOLEAN|BSAVE|BYREF|BYTE|BYVAL|CALL(?: ABSOLUTE)?|CASE|CATCH|CBOOL|CBYTE|CCHAR|CDATE|CDBL|CDEC|CHAIN|CHAR|CHDIR|CINT|CLASS|CLEAR|CLNG|CLOSE|CLS|COBJ|COM|COMMON|CONST|CONTINUE|CSBYTE|CSHORT|CSNG|CSTR|CTYPE|CUINT|CULNG|CUSHORT|DATA|DATE|DECIMAL|DECLARE|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|DEFAULT|DELEGATE|DIM|DIRECTCAST|DO|DOUBLE|ELSE|ELSEIF|END|ENUM|ENVIRON|ERASE|ERROR|EVENT|EXIT|FALSE|FIELD|FILES|FINALLY|FOR(?: EACH)?|FRIEND|FUNCTION|GET|GETTYPE|GETXMLNAMESPACE|GLOBAL|GOSUB|GOTO|HANDLES|IF|IMPLEMENTS|IMPORTS|IN|INHERITS|INPUT|INTEGER|INTERFACE|IOCTL|IS|ISNOT|KEY|KILL|LET|LIB|LIKE|LINE INPUT|LOCATE|LOCK|LONG|LOOP|LSET|ME|MKDIR|MOD|MODULE|MUSTINHERIT|MUSTOVERRIDE|MYBASE|MYCLASS|NAME|NAMESPACE|NARROWING|NEW|NEXT|NOT|NOTHING|NOTINHERITABLE|NOTOVERRIDABLE|OBJECT|OF|OFF|ON(?: COM| ERROR| KEY| TIMER)?|OPEN|OPERATOR|OPTION(?: BASE)?|OPTIONAL|OR|ORELSE|OUT|OVERLOADS|OVERRIDABLE|OVERRIDES|PARAMARRAY|PARTIAL|POKE|PRIVATE|PROPERTY|PROTECTED|PUBLIC|PUT|RAISEEVENT|READ|READONLY|REDIM|REM|REMOVEHANDLER|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SBYTE|SELECT(?: CASE)?|SET|SHADOWS|SHARED|SHELL|SHORT|SINGLE|SLEEP|STATIC|STEP|STOP|STRING|STRUCTURE|SUB|SWAP|SYNCLOCK|SYSTEM|THEN|THROW|TIMER|TO|TROFF|TRON|TRUE|TRY|TRYCAST|TYPE|TYPEOF|UINTEGER|ULONG|UNLOCK|UNTIL|USHORT|USING|VIEW PRINT|WAIT|WEND|WHEN|WHILE|WIDENING|WITH|WITHEVENTS|WRITE|WRITEONLY|XOR)|\B(?:#CONST|#ELSE|#ELSEIF|#END|#IF))(?:\$|\b)/i,
|
|
13638
13599
|
punctuation: /[,;:(){}]/
|
|
13639
|
-
}), Prism.languages["t4-vb"] = Prism.languages["t4-templating"].createT4("vbnet"), Prism.languages.tap = {
|
|
13600
|
+
}), Prism$1.languages["t4-vb"] = Prism$1.languages["t4-templating"].createT4("vbnet"), Prism$1.languages.tap = {
|
|
13640
13601
|
fail: /not ok[^#{\n\r]*/,
|
|
13641
13602
|
pass: /ok[^#{\n\r]*/,
|
|
13642
13603
|
pragma: /pragma [+-][a-z]+/,
|
|
@@ -13652,10 +13613,10 @@ Prism.languages.markup = {
|
|
|
13652
13613
|
yamlish: {
|
|
13653
13614
|
pattern: /(^[ \t]*)---[\s\S]*?[\r\n][ \t]*\.\.\.$/m,
|
|
13654
13615
|
lookbehind: !0,
|
|
13655
|
-
inside: Prism.languages.yaml,
|
|
13616
|
+
inside: Prism$1.languages.yaml,
|
|
13656
13617
|
alias: "language-yaml"
|
|
13657
13618
|
}
|
|
13658
|
-
}, Prism.languages.tcl = {
|
|
13619
|
+
}, Prism$1.languages.tcl = {
|
|
13659
13620
|
comment: {
|
|
13660
13621
|
pattern: /(^|[^\\])#.*/,
|
|
13661
13622
|
lookbehind: !0
|
|
@@ -13725,7 +13686,7 @@ Prism.languages.markup = {
|
|
|
13725
13686
|
}), t.hooks.add("after-tokenize", function(e) {
|
|
13726
13687
|
t.languages["markup-templating"].tokenizePlaceholders(e, "tt2");
|
|
13727
13688
|
});
|
|
13728
|
-
})(Prism), (function(e) {
|
|
13689
|
+
})(Prism$1), (function(e) {
|
|
13729
13690
|
var t = /(?:[\w-]+|'[^'\n\r]*'|"(?:\\.|[^\\"\r\n])*")/.source;
|
|
13730
13691
|
function n(e$1) {
|
|
13731
13692
|
return e$1.replace(/__/g, function() {
|
|
@@ -13764,7 +13725,7 @@ Prism.languages.markup = {
|
|
|
13764
13725
|
boolean: /\b(?:false|true)\b/,
|
|
13765
13726
|
punctuation: /[.,=[\]{}]/
|
|
13766
13727
|
};
|
|
13767
|
-
})(Prism), (function(e) {
|
|
13728
|
+
})(Prism$1), (function(e) {
|
|
13768
13729
|
e.languages.tremor = {
|
|
13769
13730
|
comment: {
|
|
13770
13731
|
pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,
|
|
@@ -13817,7 +13778,7 @@ Prism.languages.markup = {
|
|
|
13817
13778
|
string: /[\s\S]+/
|
|
13818
13779
|
}
|
|
13819
13780
|
}, e.languages.troy = e.languages.tremor, e.languages.trickle = e.languages.tremor;
|
|
13820
|
-
})(Prism), (function(e) {
|
|
13781
|
+
})(Prism$1), (function(e) {
|
|
13821
13782
|
var t = /\b(?:ACT|ACTIFSUB|CARRAY|CASE|CLEARGIF|COA|COA_INT|CONSTANTS|CONTENT|CUR|EDITPANEL|EFFECT|EXT|FILE|FLUIDTEMPLATE|FORM|FRAME|FRAMESET|GIFBUILDER|GMENU|GMENU_FOLDOUT|GMENU_LAYERS|GP|HMENU|HRULER|HTML|IENV|IFSUB|IMAGE|IMGMENU|IMGMENUITEM|IMGTEXT|IMG_RESOURCE|INCLUDE_TYPOSCRIPT|JSMENU|JSMENUITEM|LLL|LOAD_REGISTER|NO|PAGE|RECORDS|RESTORE_REGISTER|TEMPLATE|TEXT|TMENU|TMENUITEM|TMENU_LAYERS|USER|USER_INT|_GIFBUILDER|global|globalString|globalVar)\b/;
|
|
13822
13783
|
e.languages.typoscript = {
|
|
13823
13784
|
comment: [
|
|
@@ -13871,7 +13832,7 @@ Prism.languages.markup = {
|
|
|
13871
13832
|
punctuation: /[{}[\];(),.:|]/,
|
|
13872
13833
|
operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/
|
|
13873
13834
|
}, e.languages.tsconfig = e.languages.typoscript;
|
|
13874
|
-
})(Prism), Prism.languages.unrealscript = {
|
|
13835
|
+
})(Prism$1), Prism$1.languages.unrealscript = {
|
|
13875
13836
|
comment: /\/\/.*|\/\*[\s\S]*?\*\//,
|
|
13876
13837
|
string: {
|
|
13877
13838
|
pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
|
|
@@ -13907,7 +13868,7 @@ Prism.languages.markup = {
|
|
|
13907
13868
|
number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
|
|
13908
13869
|
operator: />>|<<|--|\+\+|\*\*|[-+*/~!=<>$@]=?|&&?|\|\|?|\^\^?|[?:%]|\b(?:ClockwiseFrom|Cross|Dot)\b/,
|
|
13909
13870
|
punctuation: /[()[\]{};,.]/
|
|
13910
|
-
}, Prism.languages.uc = Prism.languages.uscript = Prism.languages.unrealscript, Prism.languages.uorazor = {
|
|
13871
|
+
}, Prism$1.languages.uc = Prism$1.languages.uscript = Prism$1.languages.unrealscript, Prism$1.languages.uorazor = {
|
|
13911
13872
|
"comment-hash": {
|
|
13912
13873
|
pattern: /#.*/,
|
|
13913
13874
|
alias: "comment",
|
|
@@ -14013,7 +13974,7 @@ Prism.languages.markup = {
|
|
|
14013
13974
|
}
|
|
14014
13975
|
}
|
|
14015
13976
|
} });
|
|
14016
|
-
})(Prism), Prism.languages.vala = Prism.languages.extend("clike", {
|
|
13977
|
+
})(Prism$1), Prism$1.languages.vala = Prism$1.languages.extend("clike", {
|
|
14017
13978
|
"class-name": [
|
|
14018
13979
|
{
|
|
14019
13980
|
pattern: /\b[A-Z]\w*(?:\.\w+)*\b(?=(?:\?\s+|\*?\s+\*?)\w)/,
|
|
@@ -14041,7 +14002,7 @@ Prism.languages.markup = {
|
|
|
14041
14002
|
operator: /\+\+|--|&&|\|\||<<=?|>>=?|=>|->|~|[+\-*\/%&^|=!<>]=?|\?\??|\.\.\./,
|
|
14042
14003
|
punctuation: /[{}[\];(),.:]/,
|
|
14043
14004
|
constant: /\b[A-Z0-9_]+\b/
|
|
14044
|
-
}), Prism.languages.insertBefore("vala", "string", {
|
|
14005
|
+
}), Prism$1.languages.insertBefore("vala", "string", {
|
|
14045
14006
|
"raw-string": {
|
|
14046
14007
|
pattern: /"""[\s\S]*?"""/,
|
|
14047
14008
|
greedy: !0,
|
|
@@ -14058,13 +14019,13 @@ Prism.languages.markup = {
|
|
|
14058
14019
|
pattern: /^\$\(?|\)$/,
|
|
14059
14020
|
alias: "punctuation"
|
|
14060
14021
|
},
|
|
14061
|
-
rest: Prism.languages.vala
|
|
14022
|
+
rest: Prism$1.languages.vala
|
|
14062
14023
|
}
|
|
14063
14024
|
},
|
|
14064
14025
|
string: /[\s\S]+/
|
|
14065
14026
|
}
|
|
14066
14027
|
}
|
|
14067
|
-
}), Prism.languages.insertBefore("vala", "keyword", { regex: {
|
|
14028
|
+
}), Prism$1.languages.insertBefore("vala", "keyword", { regex: {
|
|
14068
14029
|
pattern: /\/(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[imsx]{0,4}(?=\s*(?:$|[\r\n,.;})\]]))/,
|
|
14069
14030
|
greedy: !0,
|
|
14070
14031
|
inside: {
|
|
@@ -14072,7 +14033,7 @@ Prism.languages.markup = {
|
|
|
14072
14033
|
pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
|
|
14073
14034
|
lookbehind: !0,
|
|
14074
14035
|
alias: "language-regex",
|
|
14075
|
-
inside: Prism.languages.regex
|
|
14036
|
+
inside: Prism$1.languages.regex
|
|
14076
14037
|
},
|
|
14077
14038
|
"regex-delimiter": /^\//,
|
|
14078
14039
|
"regex-flags": /^[a-z]+$/
|
|
@@ -14134,7 +14095,7 @@ Prism.languages.markup = {
|
|
|
14134
14095
|
},
|
|
14135
14096
|
variable: t.variable
|
|
14136
14097
|
}), e.languages.velocity.tag.inside["attr-value"].inside.rest = e.languages.velocity;
|
|
14137
|
-
})(Prism), Prism.languages.verilog = {
|
|
14098
|
+
})(Prism$1), Prism$1.languages.verilog = {
|
|
14138
14099
|
comment: {
|
|
14139
14100
|
pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
|
|
14140
14101
|
greedy: !0
|
|
@@ -14154,7 +14115,7 @@ Prism.languages.markup = {
|
|
|
14154
14115
|
number: /\B##?\d+|(?:\b\d+)?'[odbh] ?[\da-fzx_?]+|\b(?:\d*[._])?\d+(?:e[-+]?\d+)?/i,
|
|
14155
14116
|
operator: /[-+{}^~%*\/?=!<>&|]+/,
|
|
14156
14117
|
punctuation: /[[\];(),.:]/
|
|
14157
|
-
}, Prism.languages.vhdl = {
|
|
14118
|
+
}, Prism$1.languages.vhdl = {
|
|
14158
14119
|
comment: /--.+/,
|
|
14159
14120
|
"vhdl-vectors": {
|
|
14160
14121
|
pattern: /\b[oxb]"[\da-f_]+"|"[01uxzwlh-]+"/i,
|
|
@@ -14175,7 +14136,7 @@ Prism.languages.markup = {
|
|
|
14175
14136
|
number: /'[01uxzwlh-]'|\b(?:\d+#[\da-f_.]+#|\d[\d_.]*)(?:e[-+]?\d+)?/i,
|
|
14176
14137
|
operator: /[<>]=?|:=|[-+*/&=]|\b(?:abs|and|mod|nand|nor|not|or|rem|rol|ror|sla|sll|sra|srl|xnor|xor)\b/i,
|
|
14177
14138
|
punctuation: /[{}[\];(),.:]/
|
|
14178
|
-
}, Prism.languages.vim = {
|
|
14139
|
+
}, Prism$1.languages.vim = {
|
|
14179
14140
|
string: /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\r\n]|'')*'/,
|
|
14180
14141
|
comment: /".*/,
|
|
14181
14142
|
function: /\b\w+(?=\()/,
|
|
@@ -14184,7 +14145,7 @@ Prism.languages.markup = {
|
|
|
14184
14145
|
number: /\b(?:0x[\da-f]+|\d+(?:\.\d+)?)\b/i,
|
|
14185
14146
|
operator: /\|\||&&|[-+.]=?|[=!](?:[=~][#?]?)?|[<>]=?[#?]?|[*\/%?]|\b(?:is(?:not)?)\b/,
|
|
14186
14147
|
punctuation: /[{}[\](),;:]/
|
|
14187
|
-
}, Prism.languages["visual-basic"] = {
|
|
14148
|
+
}, Prism$1.languages["visual-basic"] = {
|
|
14188
14149
|
comment: {
|
|
14189
14150
|
pattern: /(?:['‘’]|REM\b)(?:[^\r\n_]|_(?:\r\n?|\n)?)*/i,
|
|
14190
14151
|
inside: { keyword: /^REM/i }
|
|
@@ -14207,7 +14168,7 @@ Prism.languages.markup = {
|
|
|
14207
14168
|
keyword: /\b(?:AddHandler|AddressOf|Alias|And(?:Also)?|As|Boolean|ByRef|Byte|ByVal|Call|Case|Catch|C(?:Bool|Byte|Char|Date|Dbl|Dec|Int|Lng|Obj|SByte|Short|Sng|Str|Type|UInt|ULng|UShort)|Char|Class|Const|Continue|Currency|Date|Decimal|Declare|Default|Delegate|Dim|DirectCast|Do|Double|Each|Else(?:If)?|End(?:If)?|Enum|Erase|Error|Event|Exit|Finally|For|Friend|Function|Get(?:Type|XMLNamespace)?|Global|GoSub|GoTo|Handles|If|Implements|Imports|In|Inherits|Integer|Interface|Is|IsNot|Let|Lib|Like|Long|Loop|Me|Mod|Module|Must(?:Inherit|Override)|My(?:Base|Class)|Namespace|Narrowing|New|Next|Not(?:Inheritable|Overridable)?|Object|Of|On|Operator|Option(?:al)?|Or(?:Else)?|Out|Overloads|Overridable|Overrides|ParamArray|Partial|Private|Property|Protected|Public|RaiseEvent|ReadOnly|ReDim|RemoveHandler|Resume|Return|SByte|Select|Set|Shadows|Shared|short|Single|Static|Step|Stop|String|Structure|Sub|SyncLock|Then|Throw|To|Try|TryCast|Type|TypeOf|U(?:Integer|Long|Short)|Until|Using|Variant|Wend|When|While|Widening|With(?:Events)?|WriteOnly|Xor)\b/i,
|
|
14208
14169
|
operator: /[+\-*/\\^<=>&#@$%!]|\b_(?=[ \t]*[\r\n])/,
|
|
14209
14170
|
punctuation: /[{}().,:?]/
|
|
14210
|
-
}, Prism.languages.vb = Prism.languages["visual-basic"], Prism.languages.vba = Prism.languages["visual-basic"], Prism.languages.warpscript = {
|
|
14171
|
+
}, Prism$1.languages.vb = Prism$1.languages["visual-basic"], Prism$1.languages.vba = Prism$1.languages["visual-basic"], Prism$1.languages.warpscript = {
|
|
14211
14172
|
comment: /#.*|\/\/.*|\/\*[\s\S]*?\*\//,
|
|
14212
14173
|
string: {
|
|
14213
14174
|
pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'|<'(?:[^\\']|'(?!>)|\\.)*'>/,
|
|
@@ -14223,7 +14184,7 @@ Prism.languages.markup = {
|
|
|
14223
14184
|
boolean: /\b(?:F|T|false|true)\b/,
|
|
14224
14185
|
punctuation: /<%|%>|[{}[\]()]/,
|
|
14225
14186
|
operator: /==|&&?|\|\|?|\*\*?|>>>?|<<|[<>!~]=?|[-/%^]|\+!?|\b(?:AND|NOT|OR)\b/
|
|
14226
|
-
}, Prism.languages.wasm = {
|
|
14187
|
+
}, Prism$1.languages.wasm = {
|
|
14227
14188
|
comment: [/\(;[\s\S]*?;\)/, {
|
|
14228
14189
|
pattern: /;;.*/,
|
|
14229
14190
|
greedy: !0
|
|
@@ -14311,7 +14272,7 @@ Prism.languages.markup = {
|
|
|
14311
14272
|
punctuation: /[(){}[\].,;]/
|
|
14312
14273
|
}, e.languages["web-idl"]) "class-name" !== t && (r[t] = e.languages["web-idl"][t]);
|
|
14313
14274
|
e.languages.webidl = e.languages["web-idl"];
|
|
14314
|
-
})(Prism), Prism.languages.wgsl = {
|
|
14275
|
+
})(Prism$1), Prism$1.languages.wgsl = {
|
|
14315
14276
|
comment: {
|
|
14316
14277
|
pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
|
|
14317
14278
|
greedy: !0
|
|
@@ -14398,7 +14359,7 @@ Prism.languages.markup = {
|
|
|
14398
14359
|
{ pattern: /->/ }
|
|
14399
14360
|
],
|
|
14400
14361
|
punctuation: /[@(){}[\],;<>:.]/
|
|
14401
|
-
}, Prism.languages.wiki = Prism.languages.extend("markup", {
|
|
14362
|
+
}, Prism$1.languages.wiki = Prism$1.languages.extend("markup", {
|
|
14402
14363
|
"block-comment": {
|
|
14403
14364
|
pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
|
|
14404
14365
|
lookbehind: !0,
|
|
@@ -14449,17 +14410,17 @@ Prism.languages.markup = {
|
|
|
14449
14410
|
pattern: /\|$/,
|
|
14450
14411
|
alias: "punctuation"
|
|
14451
14412
|
},
|
|
14452
|
-
rest: Prism.languages.markup.tag.inside
|
|
14413
|
+
rest: Prism$1.languages.markup.tag.inside
|
|
14453
14414
|
}
|
|
14454
14415
|
},
|
|
14455
14416
|
punctuation: /^(?:\{\||\|\}|\|-|[*#:;!|])|\|\||!!/m
|
|
14456
|
-
}), Prism.languages.insertBefore("wiki", "tag", { nowiki: {
|
|
14417
|
+
}), Prism$1.languages.insertBefore("wiki", "tag", { nowiki: {
|
|
14457
14418
|
pattern: /<(nowiki|pre|source)\b[^>]*>[\s\S]*?<\/\1>/i,
|
|
14458
14419
|
inside: { tag: {
|
|
14459
14420
|
pattern: /<(?:nowiki|pre|source)\b[^>]*>|<\/(?:nowiki|pre|source)>/i,
|
|
14460
|
-
inside: Prism.languages.markup.tag.inside
|
|
14421
|
+
inside: Prism$1.languages.markup.tag.inside
|
|
14461
14422
|
} }
|
|
14462
|
-
} }), Prism.languages.wolfram = {
|
|
14423
|
+
} }), Prism$1.languages.wolfram = {
|
|
14463
14424
|
comment: /\(\*(?:\(\*(?:[^*]|\*(?!\)))*\*\)|(?!\(\*)[\s\S])*?\*\)/,
|
|
14464
14425
|
string: {
|
|
14465
14426
|
pattern: /"(?:\\.|[^"\\\r\n])*"/,
|
|
@@ -14482,7 +14443,7 @@ Prism.languages.markup = {
|
|
|
14482
14443
|
number: /(?:\b(?=\d)|\B(?=\.))(?:0[bo])?(?:(?:\d|0x[\da-f])[\da-f]*(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?j?\b/i,
|
|
14483
14444
|
operator: /\/\.|;|=\.|\^=|\^:=|:=|<<|>>|<\||\|>|:>|\|->|->|<-|@@@|@@|@|\/@|=!=|===|==|=|\+|-|\[\/-+%=\]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
|
|
14484
14445
|
punctuation: /[{}[\];(),.:]/
|
|
14485
|
-
}, Prism.languages.mathematica = Prism.languages.wolfram, Prism.languages.wl = Prism.languages.wolfram, Prism.languages.nb = Prism.languages.wolfram, Prism.languages.wren = {
|
|
14446
|
+
}, Prism$1.languages.mathematica = Prism$1.languages.wolfram, Prism$1.languages.wl = Prism$1.languages.wolfram, Prism$1.languages.nb = Prism$1.languages.wolfram, Prism$1.languages.wren = {
|
|
14486
14447
|
comment: [{
|
|
14487
14448
|
pattern: /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|\/\*(?:[^*/]|\*(?!\/)|\/(?!\*))*\*\/)*\*\/)*\*\//,
|
|
14488
14449
|
greedy: !0
|
|
@@ -14521,7 +14482,7 @@ Prism.languages.markup = {
|
|
|
14521
14482
|
function: /\b[a-z_]\w*(?=\s*[({])/i,
|
|
14522
14483
|
operator: /<<|>>|[=!<>]=?|&&|\|\||[-+*/%~^&|?:]|\.{2,3}/,
|
|
14523
14484
|
punctuation: /[\[\](){}.,;]/
|
|
14524
|
-
}, Prism.languages.wren["string-literal"] = {
|
|
14485
|
+
}, Prism$1.languages.wren["string-literal"] = {
|
|
14525
14486
|
pattern: /(^|[^\\"])"(?:[^\\"%]|\\[\s\S]|%(?!\()|%\((?:[^()]|\((?:[^()]|\([^)]*\))*\))*\))*"/,
|
|
14526
14487
|
lookbehind: !0,
|
|
14527
14488
|
greedy: !0,
|
|
@@ -14533,7 +14494,7 @@ Prism.languages.markup = {
|
|
|
14533
14494
|
expression: {
|
|
14534
14495
|
pattern: /^(%\()[\s\S]+(?=\)$)/,
|
|
14535
14496
|
lookbehind: !0,
|
|
14536
|
-
inside: Prism.languages.wren
|
|
14497
|
+
inside: Prism$1.languages.wren
|
|
14537
14498
|
},
|
|
14538
14499
|
"interpolation-punctuation": {
|
|
14539
14500
|
pattern: /^%\(|\)$/,
|
|
@@ -14609,7 +14570,7 @@ Prism.languages.markup = {
|
|
|
14609
14570
|
alias: "function"
|
|
14610
14571
|
}
|
|
14611
14572
|
}), e.languages.insertBefore("inside", "punctuation", { variable: e.languages.xeora["function-inline"].inside.variable }, e.languages.xeora["function-block"]), e.languages.xeoracube = e.languages.xeora;
|
|
14612
|
-
})(Prism), (function(n) {
|
|
14573
|
+
})(Prism$1), (function(n) {
|
|
14613
14574
|
function e(e$1, t$1) {
|
|
14614
14575
|
n.languages[e$1] && n.languages.insertBefore(e$1, "comment", { "doc-comment": t$1 });
|
|
14615
14576
|
}
|
|
@@ -14625,7 +14586,7 @@ Prism.languages.markup = {
|
|
|
14625
14586
|
inside: { tag: t }
|
|
14626
14587
|
};
|
|
14627
14588
|
e("csharp", a), e("fsharp", a), e("vbnet", t);
|
|
14628
|
-
})(Prism), Prism.languages.xojo = {
|
|
14589
|
+
})(Prism$1), Prism$1.languages.xojo = {
|
|
14629
14590
|
comment: {
|
|
14630
14591
|
pattern: /(?:'|\/\/|Rem\b).+/i,
|
|
14631
14592
|
greedy: !0
|
|
@@ -14713,7 +14674,7 @@ Prism.languages.markup = {
|
|
|
14713
14674
|
i.hooks.add("after-tokenize", function(e) {
|
|
14714
14675
|
"xquery" === e.language && o(e.tokens);
|
|
14715
14676
|
});
|
|
14716
|
-
})(Prism), Prism.languages.yang = {
|
|
14677
|
+
})(Prism$1), Prism$1.languages.yang = {
|
|
14717
14678
|
comment: /\/\*[\s\S]*?\*\/|\/\/.*/,
|
|
14718
14679
|
string: {
|
|
14719
14680
|
pattern: /"(?:[^\\"]|\\.)*"|'[^']*'/,
|
|
@@ -14787,7 +14748,7 @@ Prism.languages.markup = {
|
|
|
14787
14748
|
}, t.languages.zig["class-name"].forEach(function(e$1) {
|
|
14788
14749
|
null === e$1.inside && (e$1.inside = t.languages.zig);
|
|
14789
14750
|
});
|
|
14790
|
-
})(Prism);
|
|
14751
|
+
})(Prism$1);
|
|
14791
14752
|
|
|
14792
14753
|
//#endregion
|
|
14793
14754
|
//#region src/components/code-block.tsx
|
|
@@ -14801,38 +14762,38 @@ const stylesForToken = (token, theme) => {
|
|
|
14801
14762
|
return styles;
|
|
14802
14763
|
};
|
|
14803
14764
|
const CodeBlockLine = ({ token, theme, inheritedStyles }) => {
|
|
14804
|
-
if (token instanceof Prism.Token) {
|
|
14765
|
+
if (token instanceof Prism$1.Token) {
|
|
14805
14766
|
const styleForToken = {
|
|
14806
14767
|
...inheritedStyles,
|
|
14807
14768
|
...stylesForToken(token, theme)
|
|
14808
14769
|
};
|
|
14809
|
-
if (token.content instanceof Prism.Token) return /* @__PURE__ */
|
|
14770
|
+
if (token.content instanceof Prism$1.Token) return /* @__PURE__ */ jsx("span", {
|
|
14810
14771
|
style: styleForToken,
|
|
14811
|
-
children: /* @__PURE__ */
|
|
14772
|
+
children: /* @__PURE__ */ jsx(CodeBlockLine, {
|
|
14812
14773
|
theme,
|
|
14813
14774
|
token: token.content
|
|
14814
14775
|
})
|
|
14815
14776
|
});
|
|
14816
|
-
if (typeof token.content === "string") return /* @__PURE__ */
|
|
14777
|
+
if (typeof token.content === "string") return /* @__PURE__ */ jsx("span", {
|
|
14817
14778
|
style: styleForToken,
|
|
14818
14779
|
children: token.content
|
|
14819
14780
|
});
|
|
14820
|
-
return /* @__PURE__ */
|
|
14781
|
+
return /* @__PURE__ */ jsx(Fragment, { children: token.content.map((subToken, i) => /* @__PURE__ */ jsx(CodeBlockLine, {
|
|
14821
14782
|
inheritedStyles: styleForToken,
|
|
14822
14783
|
theme,
|
|
14823
14784
|
token: subToken
|
|
14824
14785
|
}, i)) });
|
|
14825
14786
|
}
|
|
14826
|
-
return /* @__PURE__ */
|
|
14787
|
+
return /* @__PURE__ */ jsx("span", {
|
|
14827
14788
|
style: inheritedStyles,
|
|
14828
14789
|
children: token.replaceAll(" ", "\xA0")
|
|
14829
14790
|
});
|
|
14830
14791
|
};
|
|
14831
|
-
const CodeBlock =
|
|
14832
|
-
const languageGrammar = Prism.languages[language];
|
|
14792
|
+
const CodeBlock = React$1.forwardRef(({ code, fontFamily, lineNumbers, theme, language,...rest }, ref) => {
|
|
14793
|
+
const languageGrammar = Prism$1.languages[language];
|
|
14833
14794
|
if (typeof languageGrammar === "undefined") throw new Error(`CodeBlock: There is no language defined on Prism called ${language}`);
|
|
14834
|
-
const tokensPerLine = code.split(/\r\n|\r|\n/gm).map((line) => Prism.tokenize(line, languageGrammar));
|
|
14835
|
-
return /* @__PURE__ */
|
|
14795
|
+
const tokensPerLine = code.split(/\r\n|\r|\n/gm).map((line) => Prism$1.tokenize(line, languageGrammar));
|
|
14796
|
+
return /* @__PURE__ */ jsx("pre", {
|
|
14836
14797
|
...rest,
|
|
14837
14798
|
ref,
|
|
14838
14799
|
style: {
|
|
@@ -14840,8 +14801,8 @@ const CodeBlock = react.forwardRef(({ code, fontFamily, lineNumbers, theme, lang
|
|
|
14840
14801
|
width: "100%",
|
|
14841
14802
|
...rest.style
|
|
14842
14803
|
},
|
|
14843
|
-
children: /* @__PURE__ */
|
|
14844
|
-
lineNumbers ? /* @__PURE__ */
|
|
14804
|
+
children: /* @__PURE__ */ jsx("code", { children: tokensPerLine.map((tokensForLine, lineIndex) => /* @__PURE__ */ jsxs(React$1.Fragment, { children: [
|
|
14805
|
+
lineNumbers ? /* @__PURE__ */ jsx("span", {
|
|
14845
14806
|
style: {
|
|
14846
14807
|
width: "2em",
|
|
14847
14808
|
height: "1em",
|
|
@@ -14850,12 +14811,12 @@ const CodeBlock = react.forwardRef(({ code, fontFamily, lineNumbers, theme, lang
|
|
|
14850
14811
|
},
|
|
14851
14812
|
children: lineIndex + 1
|
|
14852
14813
|
}) : null,
|
|
14853
|
-
tokensForLine.map((token, i) => /* @__PURE__ */
|
|
14814
|
+
tokensForLine.map((token, i) => /* @__PURE__ */ jsx(CodeBlockLine, {
|
|
14854
14815
|
inheritedStyles: { fontFamily },
|
|
14855
14816
|
theme,
|
|
14856
14817
|
token
|
|
14857
14818
|
}, i)),
|
|
14858
|
-
/* @__PURE__ */
|
|
14819
|
+
/* @__PURE__ */ jsx("br", {})
|
|
14859
14820
|
] }, lineIndex)) })
|
|
14860
14821
|
});
|
|
14861
14822
|
});
|
|
@@ -14870,9 +14831,9 @@ CodeBlock.displayName = "CodeBlock";
|
|
|
14870
14831
|
* A hidden `<span>` fallback is revealed via CSS when the `<head>` (and its
|
|
14871
14832
|
* `<meta>` tags) are removed — a behaviour specific to Orange.fr.
|
|
14872
14833
|
*/
|
|
14873
|
-
const CodeInline =
|
|
14874
|
-
return /* @__PURE__ */
|
|
14875
|
-
/* @__PURE__ */
|
|
14834
|
+
const CodeInline = React$1.forwardRef(({ children,...props }, ref) => {
|
|
14835
|
+
return /* @__PURE__ */ jsxs(Fragment, { children: [
|
|
14836
|
+
/* @__PURE__ */ jsx("style", { children: `
|
|
14876
14837
|
meta ~ .cino {
|
|
14877
14838
|
display: none !important;
|
|
14878
14839
|
opacity: 0 !important;
|
|
@@ -14882,12 +14843,12 @@ const CodeInline = react.forwardRef(({ children,...props }, ref) => {
|
|
|
14882
14843
|
display: block !important;
|
|
14883
14844
|
}
|
|
14884
14845
|
` }),
|
|
14885
|
-
/* @__PURE__ */
|
|
14846
|
+
/* @__PURE__ */ jsx("code", {
|
|
14886
14847
|
...props,
|
|
14887
14848
|
className: `${props.className ? props.className : ""} cino`,
|
|
14888
14849
|
children
|
|
14889
14850
|
}),
|
|
14890
|
-
/* @__PURE__ */
|
|
14851
|
+
/* @__PURE__ */ jsx("span", {
|
|
14891
14852
|
...props,
|
|
14892
14853
|
className: `${props.className ? props.className : ""} cio`,
|
|
14893
14854
|
ref,
|
|
@@ -17484,8 +17445,8 @@ const vesper = {
|
|
|
17484
17445
|
|
|
17485
17446
|
//#endregion
|
|
17486
17447
|
//#region src/components/column.tsx
|
|
17487
|
-
const Column =
|
|
17488
|
-
return /* @__PURE__ */
|
|
17448
|
+
const Column = React$1.forwardRef(({ children, style,...props }, ref) => {
|
|
17449
|
+
return /* @__PURE__ */ jsx("td", {
|
|
17489
17450
|
...props,
|
|
17490
17451
|
ref,
|
|
17491
17452
|
style,
|
|
@@ -17496,8 +17457,8 @@ Column.displayName = "Column";
|
|
|
17496
17457
|
|
|
17497
17458
|
//#endregion
|
|
17498
17459
|
//#region src/components/container.tsx
|
|
17499
|
-
const Container =
|
|
17500
|
-
return /* @__PURE__ */
|
|
17460
|
+
const Container = React$1.forwardRef(({ children, style,...props }, ref) => {
|
|
17461
|
+
return /* @__PURE__ */ jsx("table", {
|
|
17501
17462
|
align: "center",
|
|
17502
17463
|
width: "100%",
|
|
17503
17464
|
...props,
|
|
@@ -17510,9 +17471,9 @@ const Container = react.forwardRef(({ children, style,...props }, ref) => {
|
|
|
17510
17471
|
maxWidth: "37.5em",
|
|
17511
17472
|
...style
|
|
17512
17473
|
},
|
|
17513
|
-
children: /* @__PURE__ */
|
|
17474
|
+
children: /* @__PURE__ */ jsx("tbody", { children: /* @__PURE__ */ jsx("tr", {
|
|
17514
17475
|
style: { width: "100%" },
|
|
17515
|
-
children: /* @__PURE__ */
|
|
17476
|
+
children: /* @__PURE__ */ jsx("td", { children })
|
|
17516
17477
|
}) })
|
|
17517
17478
|
});
|
|
17518
17479
|
});
|
|
@@ -17523,7 +17484,7 @@ Container.displayName = "Container";
|
|
|
17523
17484
|
/** The component MUST be placed inside the <Head> component */
|
|
17524
17485
|
const Font = ({ fontFamily, fallbackFontFamily, webFont, fontStyle = "normal", fontWeight = 400 }) => {
|
|
17525
17486
|
const src = webFont ? `src: url(${webFont.url}) format('${webFont.format}');` : "";
|
|
17526
|
-
return /* @__PURE__ */
|
|
17487
|
+
return /* @__PURE__ */ jsx("style", { dangerouslySetInnerHTML: { __html: `
|
|
17527
17488
|
@font-face {
|
|
17528
17489
|
font-family: '${fontFamily}';
|
|
17529
17490
|
font-style: ${fontStyle};
|
|
@@ -17540,15 +17501,15 @@ const Font = ({ fontFamily, fallbackFontFamily, webFont, fontStyle = "normal", f
|
|
|
17540
17501
|
|
|
17541
17502
|
//#endregion
|
|
17542
17503
|
//#region src/components/head.tsx
|
|
17543
|
-
const Head =
|
|
17504
|
+
const Head = React$1.forwardRef(({ children,...props }, ref) => /* @__PURE__ */ jsxs("head", {
|
|
17544
17505
|
...props,
|
|
17545
17506
|
ref,
|
|
17546
17507
|
children: [
|
|
17547
|
-
/* @__PURE__ */
|
|
17508
|
+
/* @__PURE__ */ jsx("meta", {
|
|
17548
17509
|
content: "text/html; charset=UTF-8",
|
|
17549
17510
|
httpEquiv: "Content-Type"
|
|
17550
17511
|
}),
|
|
17551
|
-
/* @__PURE__ */
|
|
17512
|
+
/* @__PURE__ */ jsx("meta", { name: "x-apple-disable-message-reformatting" }),
|
|
17552
17513
|
children
|
|
17553
17514
|
]
|
|
17554
17515
|
}));
|
|
@@ -17580,8 +17541,8 @@ const withMargin = (props) => {
|
|
|
17580
17541
|
|
|
17581
17542
|
//#endregion
|
|
17582
17543
|
//#region src/components/heading.tsx
|
|
17583
|
-
const Heading =
|
|
17584
|
-
return /* @__PURE__ */
|
|
17544
|
+
const Heading = React$1.forwardRef(({ as: Tag = "h1", children, style, m, mx, my, mt, mr, mb, ml,...props }, ref) => {
|
|
17545
|
+
return /* @__PURE__ */ jsx(Tag, {
|
|
17585
17546
|
...props,
|
|
17586
17547
|
ref,
|
|
17587
17548
|
style: {
|
|
@@ -17603,7 +17564,7 @@ Heading.displayName = "Heading";
|
|
|
17603
17564
|
|
|
17604
17565
|
//#endregion
|
|
17605
17566
|
//#region src/components/hr.tsx
|
|
17606
|
-
const Hr =
|
|
17567
|
+
const Hr = React$1.forwardRef(({ style,...props }, ref) => /* @__PURE__ */ jsx("hr", {
|
|
17607
17568
|
...props,
|
|
17608
17569
|
ref,
|
|
17609
17570
|
style: {
|
|
@@ -17617,7 +17578,7 @@ Hr.displayName = "Hr";
|
|
|
17617
17578
|
|
|
17618
17579
|
//#endregion
|
|
17619
17580
|
//#region src/components/html.tsx
|
|
17620
|
-
const Html =
|
|
17581
|
+
const Html = React$1.forwardRef(({ children, lang = "en", dir = "ltr",...props }, ref) => /* @__PURE__ */ jsx("html", {
|
|
17621
17582
|
...props,
|
|
17622
17583
|
dir,
|
|
17623
17584
|
lang,
|
|
@@ -17628,7 +17589,7 @@ Html.displayName = "Html";
|
|
|
17628
17589
|
|
|
17629
17590
|
//#endregion
|
|
17630
17591
|
//#region src/components/img.tsx
|
|
17631
|
-
const Img =
|
|
17592
|
+
const Img = React$1.forwardRef(({ alt, src, width, height, style,...props }, ref) => /* @__PURE__ */ jsx("img", {
|
|
17632
17593
|
...props,
|
|
17633
17594
|
alt,
|
|
17634
17595
|
height,
|
|
@@ -17647,7 +17608,7 @@ Img.displayName = "Img";
|
|
|
17647
17608
|
|
|
17648
17609
|
//#endregion
|
|
17649
17610
|
//#region src/components/link.tsx
|
|
17650
|
-
const Link =
|
|
17611
|
+
const Link = React$1.forwardRef(({ target = "_blank", style,...props }, ref) => /* @__PURE__ */ jsx("a", {
|
|
17651
17612
|
...props,
|
|
17652
17613
|
ref,
|
|
17653
17614
|
style: {
|
|
@@ -17808,12 +17769,12 @@ function parseCssInJsToInlineCss(cssProperties) {
|
|
|
17808
17769
|
|
|
17809
17770
|
//#endregion
|
|
17810
17771
|
//#region src/components/markdown.tsx
|
|
17811
|
-
const Markdown =
|
|
17772
|
+
const Markdown = React$1.forwardRef(({ children, markdownContainerStyles, markdownCustomStyles,...props }, ref) => {
|
|
17812
17773
|
const finalStyles = {
|
|
17813
17774
|
...defaultMarkdownStyles,
|
|
17814
17775
|
...markdownCustomStyles
|
|
17815
17776
|
};
|
|
17816
|
-
const renderer = new
|
|
17777
|
+
const renderer = new Renderer();
|
|
17817
17778
|
renderer.blockquote = ({ tokens }) => {
|
|
17818
17779
|
const text = renderer.parser.parse(tokens);
|
|
17819
17780
|
return `<blockquote${parseCssInJsToInlineCss(finalStyles.blockQuote) !== "" ? ` style="${parseCssInJsToInlineCss(finalStyles.blockQuote)}"` : ""}>\n${text}</blockquote>\n`;
|
|
@@ -17886,9 +17847,9 @@ const Markdown = react.forwardRef(({ children, markdownContainerStyles, markdown
|
|
|
17886
17847
|
renderer.tablerow = ({ text }) => {
|
|
17887
17848
|
return `<tr${parseCssInJsToInlineCss(finalStyles.tr) !== "" ? ` style="${parseCssInJsToInlineCss(finalStyles.tr)}"` : ""}>\n${text}</tr>\n`;
|
|
17888
17849
|
};
|
|
17889
|
-
return /* @__PURE__ */
|
|
17850
|
+
return /* @__PURE__ */ jsx("div", {
|
|
17890
17851
|
...props,
|
|
17891
|
-
dangerouslySetInnerHTML: { __html: marked.
|
|
17852
|
+
dangerouslySetInnerHTML: { __html: marked.parse(children, {
|
|
17892
17853
|
renderer,
|
|
17893
17854
|
async: false
|
|
17894
17855
|
}) },
|
|
@@ -17904,11 +17865,11 @@ const PREVIEW_MAX_LENGTH = 150;
|
|
|
17904
17865
|
const whiteSpaceCodes = "\xA0";
|
|
17905
17866
|
const renderWhiteSpace = (text) => {
|
|
17906
17867
|
if (text.length >= PREVIEW_MAX_LENGTH) return null;
|
|
17907
|
-
return /* @__PURE__ */
|
|
17868
|
+
return /* @__PURE__ */ jsx("div", { children: whiteSpaceCodes.repeat(PREVIEW_MAX_LENGTH - text.length) });
|
|
17908
17869
|
};
|
|
17909
|
-
const Preview =
|
|
17870
|
+
const Preview = React$1.forwardRef(({ children = "",...props }, ref) => {
|
|
17910
17871
|
const text = (Array.isArray(children) ? children.join("") : children).substring(0, PREVIEW_MAX_LENGTH);
|
|
17911
|
-
return /* @__PURE__ */
|
|
17872
|
+
return /* @__PURE__ */ jsxs("div", {
|
|
17912
17873
|
style: {
|
|
17913
17874
|
display: "none",
|
|
17914
17875
|
overflow: "hidden",
|
|
@@ -17926,8 +17887,8 @@ Preview.displayName = "Preview";
|
|
|
17926
17887
|
|
|
17927
17888
|
//#endregion
|
|
17928
17889
|
//#region src/components/row.tsx
|
|
17929
|
-
const Row =
|
|
17930
|
-
return /* @__PURE__ */
|
|
17890
|
+
const Row = React$1.forwardRef(({ children, style,...props }, ref) => {
|
|
17891
|
+
return /* @__PURE__ */ jsx("table", {
|
|
17931
17892
|
align: "center",
|
|
17932
17893
|
width: "100%",
|
|
17933
17894
|
border: 0,
|
|
@@ -17937,9 +17898,9 @@ const Row = react.forwardRef(({ children, style,...props }, ref) => {
|
|
|
17937
17898
|
...props,
|
|
17938
17899
|
ref,
|
|
17939
17900
|
style,
|
|
17940
|
-
children: /* @__PURE__ */
|
|
17901
|
+
children: /* @__PURE__ */ jsx("tbody", {
|
|
17941
17902
|
style: { width: "100%" },
|
|
17942
|
-
children: /* @__PURE__ */
|
|
17903
|
+
children: /* @__PURE__ */ jsx("tr", {
|
|
17943
17904
|
style: { width: "100%" },
|
|
17944
17905
|
children
|
|
17945
17906
|
})
|
|
@@ -17950,8 +17911,8 @@ Row.displayName = "Row";
|
|
|
17950
17911
|
|
|
17951
17912
|
//#endregion
|
|
17952
17913
|
//#region src/components/section.tsx
|
|
17953
|
-
const Section =
|
|
17954
|
-
return /* @__PURE__ */
|
|
17914
|
+
const Section = React$1.forwardRef(({ children, style,...props }, ref) => {
|
|
17915
|
+
return /* @__PURE__ */ jsx("table", {
|
|
17955
17916
|
align: "center",
|
|
17956
17917
|
width: "100%",
|
|
17957
17918
|
border: 0,
|
|
@@ -17961,7 +17922,7 @@ const Section = react.forwardRef(({ children, style,...props }, ref) => {
|
|
|
17961
17922
|
...props,
|
|
17962
17923
|
ref,
|
|
17963
17924
|
style,
|
|
17964
|
-
children: /* @__PURE__ */
|
|
17925
|
+
children: /* @__PURE__ */ jsx("tbody", { children: /* @__PURE__ */ jsx("tr", { children: /* @__PURE__ */ jsx("td", { children }) }) })
|
|
17965
17926
|
});
|
|
17966
17927
|
});
|
|
17967
17928
|
Section.displayName = "Section";
|
|
@@ -18026,7 +17987,7 @@ function computeMargins(properties) {
|
|
|
18026
17987
|
|
|
18027
17988
|
//#endregion
|
|
18028
17989
|
//#region src/components/text.tsx
|
|
18029
|
-
const Text =
|
|
17990
|
+
const Text = React$1.forwardRef(({ style,...props }, ref) => {
|
|
18030
17991
|
const defaultMargins = {};
|
|
18031
17992
|
if (style?.marginTop === void 0) defaultMargins.marginTop = "16px";
|
|
18032
17993
|
if (style?.marginBottom === void 0) defaultMargins.marginBottom = "16px";
|
|
@@ -18034,7 +17995,7 @@ const Text = react.forwardRef(({ style,...props }, ref) => {
|
|
|
18034
17995
|
...defaultMargins,
|
|
18035
17996
|
...style
|
|
18036
17997
|
});
|
|
18037
|
-
return /* @__PURE__ */
|
|
17998
|
+
return /* @__PURE__ */ jsx("p", {
|
|
18038
17999
|
...props,
|
|
18039
18000
|
ref,
|
|
18040
18001
|
style: {
|
|
@@ -18067,9 +18028,9 @@ const plainTextSelectors = [
|
|
|
18067
18028
|
//#endregion
|
|
18068
18029
|
//#region src/render/pretty.ts
|
|
18069
18030
|
async function pretty(html) {
|
|
18070
|
-
return
|
|
18031
|
+
return prettier.format(html, {
|
|
18071
18032
|
parser: "html",
|
|
18072
|
-
plugins: [
|
|
18033
|
+
plugins: [prettierHtml],
|
|
18073
18034
|
htmlWhitespaceSensitivity: "ignore"
|
|
18074
18035
|
});
|
|
18075
18036
|
}
|
|
@@ -18090,7 +18051,7 @@ async function readStream(stream) {
|
|
|
18090
18051
|
});
|
|
18091
18052
|
await stream.pipeTo(writableStream);
|
|
18092
18053
|
} else {
|
|
18093
|
-
const writable = new
|
|
18054
|
+
const writable = new Writable({
|
|
18094
18055
|
write(chunk, _encoding, callback) {
|
|
18095
18056
|
result += decoder.decode(chunk, { stream: true });
|
|
18096
18057
|
callback();
|
|
@@ -18119,8 +18080,8 @@ async function readStream(stream) {
|
|
|
18119
18080
|
//#endregion
|
|
18120
18081
|
//#region src/render/error-boundary.tsx
|
|
18121
18082
|
function createErrorBoundary(reject) {
|
|
18122
|
-
if (!
|
|
18123
|
-
return class ErrorBoundary extends
|
|
18083
|
+
if (!React.Component) return (props) => /* @__PURE__ */ jsx(Fragment, { children: props.children });
|
|
18084
|
+
return class ErrorBoundary extends React.Component {
|
|
18124
18085
|
componentDidCatch(error) {
|
|
18125
18086
|
reject(error);
|
|
18126
18087
|
}
|
|
@@ -18142,7 +18103,7 @@ async function render(element, options) {
|
|
|
18142
18103
|
await new Promise((resolve, reject) => {
|
|
18143
18104
|
if (Object.hasOwn(reactDOMServer, "renderToReadableStream") && typeof WritableStream !== "undefined") {
|
|
18144
18105
|
const ErrorBoundary = createErrorBoundary(reject);
|
|
18145
|
-
reactDOMServer.renderToReadableStream(/* @__PURE__ */
|
|
18106
|
+
reactDOMServer.renderToReadableStream(/* @__PURE__ */ jsx(ErrorBoundary, { children: /* @__PURE__ */ jsx(Suspense, { children: element }) }), {
|
|
18146
18107
|
progressiveChunkSize: Number.POSITIVE_INFINITY,
|
|
18147
18108
|
onError(error) {
|
|
18148
18109
|
throw error;
|
|
@@ -18153,7 +18114,7 @@ async function render(element, options) {
|
|
|
18153
18114
|
}).catch(reject);
|
|
18154
18115
|
} else {
|
|
18155
18116
|
const ErrorBoundary = createErrorBoundary(reject);
|
|
18156
|
-
const stream = reactDOMServer.renderToPipeableStream(/* @__PURE__ */
|
|
18117
|
+
const stream = reactDOMServer.renderToPipeableStream(/* @__PURE__ */ jsx(ErrorBoundary, { children: /* @__PURE__ */ jsx(Suspense, { children: element }) }), {
|
|
18157
18118
|
async onAllReady() {
|
|
18158
18119
|
markup = await readStream(stream);
|
|
18159
18120
|
resolve();
|
|
@@ -18165,7 +18126,7 @@ async function render(element, options) {
|
|
|
18165
18126
|
});
|
|
18166
18127
|
}
|
|
18167
18128
|
});
|
|
18168
|
-
if (options?.plainText) return
|
|
18129
|
+
if (options?.plainText) return convert(markup, {
|
|
18169
18130
|
selectors: plainTextSelectors,
|
|
18170
18131
|
...options.plainText === true ? options.htmlToTextOptions : {}
|
|
18171
18132
|
});
|
|
@@ -18177,24 +18138,24 @@ async function render(element, options) {
|
|
|
18177
18138
|
//#endregion
|
|
18178
18139
|
//#region src/tailwind/utils/is-rule-inlinable.ts
|
|
18179
18140
|
function isRuleInlinable(rule) {
|
|
18180
|
-
const hasAtRuleInside =
|
|
18181
|
-
const hasPseudoSelector =
|
|
18141
|
+
const hasAtRuleInside = find(rule, (node) => node.type === "Atrule") !== null;
|
|
18142
|
+
const hasPseudoSelector = find(rule, (node) => node.type === "PseudoClassSelector" || node.type === "PseudoElementSelector") !== null;
|
|
18182
18143
|
return !hasAtRuleInside && !hasPseudoSelector;
|
|
18183
18144
|
}
|
|
18184
18145
|
|
|
18185
18146
|
//#endregion
|
|
18186
18147
|
//#region src/tailwind/utils/is-part-inlinable.ts
|
|
18187
18148
|
function isPartInlinable(part) {
|
|
18188
|
-
const hasAtRuleInside =
|
|
18189
|
-
const hasPseudoSelector =
|
|
18149
|
+
const hasAtRuleInside = find(part, (node) => node.type === "Atrule") !== null;
|
|
18150
|
+
const hasPseudoSelector = find(part, (node) => node.type === "PseudoClassSelector" || node.type === "PseudoElementSelector") !== null;
|
|
18190
18151
|
return !hasAtRuleInside && !hasPseudoSelector;
|
|
18191
18152
|
}
|
|
18192
18153
|
|
|
18193
18154
|
//#endregion
|
|
18194
18155
|
//#region src/tailwind/utils/split-mixed-rule.ts
|
|
18195
18156
|
function splitMixedRule(rule) {
|
|
18196
|
-
const ruleCloneInlinable =
|
|
18197
|
-
const ruleCloneNonInlinable =
|
|
18157
|
+
const ruleCloneInlinable = clone(rule);
|
|
18158
|
+
const ruleCloneNonInlinable = clone(rule);
|
|
18198
18159
|
const inlinableParts = [];
|
|
18199
18160
|
const nonInlinableParts = [];
|
|
18200
18161
|
for (const part of ruleCloneInlinable.block.children.toArray()) if (isPartInlinable(part)) inlinableParts.push(part);
|
|
@@ -18204,14 +18165,14 @@ function splitMixedRule(rule) {
|
|
|
18204
18165
|
...ruleCloneInlinable,
|
|
18205
18166
|
block: {
|
|
18206
18167
|
type: "Block",
|
|
18207
|
-
children: new
|
|
18168
|
+
children: new List().fromArray(inlinableParts)
|
|
18208
18169
|
}
|
|
18209
18170
|
} : null,
|
|
18210
18171
|
nonInlinablePart: nonInlinableParts.length > 0 ? {
|
|
18211
18172
|
...ruleCloneNonInlinable,
|
|
18212
18173
|
block: {
|
|
18213
18174
|
type: "Block",
|
|
18214
|
-
children: new
|
|
18175
|
+
children: new List().fromArray(nonInlinableParts)
|
|
18215
18176
|
}
|
|
18216
18177
|
} : null
|
|
18217
18178
|
};
|
|
@@ -18223,14 +18184,14 @@ function extractRulesPerClass(root, classes) {
|
|
|
18223
18184
|
const classSet = new Set(classes);
|
|
18224
18185
|
const inlinableRules = /* @__PURE__ */ new Map();
|
|
18225
18186
|
const nonInlinableRules = /* @__PURE__ */ new Map();
|
|
18226
|
-
|
|
18187
|
+
walk(root, {
|
|
18227
18188
|
visit: "Rule",
|
|
18228
18189
|
enter(rule) {
|
|
18229
18190
|
const selectorClasses = [];
|
|
18230
|
-
|
|
18191
|
+
walk(rule, {
|
|
18231
18192
|
visit: "ClassSelector",
|
|
18232
18193
|
enter(classSelector) {
|
|
18233
|
-
selectorClasses.push(
|
|
18194
|
+
selectorClasses.push(string.decode(classSelector.name));
|
|
18234
18195
|
}
|
|
18235
18196
|
});
|
|
18236
18197
|
if (isRuleInlinable(rule)) {
|
|
@@ -18255,16 +18216,16 @@ function extractRulesPerClass(root, classes) {
|
|
|
18255
18216
|
//#region src/tailwind/utils/get-custom-properties.ts
|
|
18256
18217
|
function getCustomProperties(node) {
|
|
18257
18218
|
const customProperties = /* @__PURE__ */ new Map();
|
|
18258
|
-
|
|
18219
|
+
walk(node, {
|
|
18259
18220
|
visit: "Atrule",
|
|
18260
18221
|
enter(atrule) {
|
|
18261
18222
|
if (atrule.name === "property" && atrule.prelude) {
|
|
18262
|
-
const prelude =
|
|
18223
|
+
const prelude = generate(atrule.prelude);
|
|
18263
18224
|
if (prelude.startsWith("--")) {
|
|
18264
18225
|
let syntax;
|
|
18265
18226
|
let inherits;
|
|
18266
18227
|
let initialValue;
|
|
18267
|
-
|
|
18228
|
+
walk(atrule, {
|
|
18268
18229
|
visit: "Declaration",
|
|
18269
18230
|
enter(declaration) {
|
|
18270
18231
|
if (declaration.property === "syntax") syntax = declaration;
|
|
@@ -18311,19 +18272,19 @@ function unwrapValue(value) {
|
|
|
18311
18272
|
function makeInlineStylesFor(inlinableRules, customProperties) {
|
|
18312
18273
|
const styles = {};
|
|
18313
18274
|
const localVariableDeclarations = /* @__PURE__ */ new Map();
|
|
18314
|
-
for (const rule of inlinableRules)
|
|
18275
|
+
for (const rule of inlinableRules) walk(rule, {
|
|
18315
18276
|
visit: "Declaration",
|
|
18316
18277
|
enter(declaration) {
|
|
18317
18278
|
if (declaration.property.startsWith("--")) localVariableDeclarations.set(declaration.property, declaration);
|
|
18318
18279
|
}
|
|
18319
18280
|
});
|
|
18320
18281
|
for (const rule of inlinableRules) {
|
|
18321
|
-
|
|
18282
|
+
walk(rule, {
|
|
18322
18283
|
visit: "Function",
|
|
18323
18284
|
enter(func, funcParentListItem) {
|
|
18324
18285
|
if (func.name === "var") {
|
|
18325
18286
|
let variableName;
|
|
18326
|
-
|
|
18287
|
+
walk(func, {
|
|
18327
18288
|
visit: "Identifier",
|
|
18328
18289
|
enter(identifier) {
|
|
18329
18290
|
variableName = identifier.name;
|
|
@@ -18341,11 +18302,11 @@ function makeInlineStylesFor(inlinableRules, customProperties) {
|
|
|
18341
18302
|
}
|
|
18342
18303
|
}
|
|
18343
18304
|
});
|
|
18344
|
-
|
|
18305
|
+
walk(rule, {
|
|
18345
18306
|
visit: "Declaration",
|
|
18346
18307
|
enter(declaration) {
|
|
18347
18308
|
if (declaration.property.startsWith("--")) return;
|
|
18348
|
-
styles[getReactProperty(declaration.property)] =
|
|
18309
|
+
styles[getReactProperty(declaration.property)] = generate(declaration.value) + (declaration.important ? "!important" : "");
|
|
18349
18310
|
}
|
|
18350
18311
|
});
|
|
18351
18312
|
}
|
|
@@ -18355,15 +18316,15 @@ function makeInlineStylesFor(inlinableRules, customProperties) {
|
|
|
18355
18316
|
//#endregion
|
|
18356
18317
|
//#region src/tailwind/utils/resolve-all-css-variables.ts
|
|
18357
18318
|
function doSelectorsIntersect(first, second) {
|
|
18358
|
-
if (
|
|
18319
|
+
if (generate(first) === generate(second)) return true;
|
|
18359
18320
|
let hasSomeUniversal = false;
|
|
18360
18321
|
const walker = (node, _parentListItem, parentList) => {
|
|
18361
18322
|
if (hasSomeUniversal) return;
|
|
18362
18323
|
if (node.type === "PseudoClassSelector" && node.name === "root") hasSomeUniversal = true;
|
|
18363
18324
|
if (node.type === "TypeSelector" && node.name === "*" && parentList.size === 1) hasSomeUniversal = true;
|
|
18364
18325
|
};
|
|
18365
|
-
|
|
18366
|
-
|
|
18326
|
+
walk(first, walker);
|
|
18327
|
+
walk(second, walker);
|
|
18367
18328
|
if (hasSomeUniversal) return true;
|
|
18368
18329
|
return false;
|
|
18369
18330
|
}
|
|
@@ -18371,14 +18332,14 @@ function resolveAllCssVariables(node) {
|
|
|
18371
18332
|
const variableDefinitions = /* @__PURE__ */ new Set();
|
|
18372
18333
|
const variableUses = /* @__PURE__ */ new Set();
|
|
18373
18334
|
const path = [];
|
|
18374
|
-
|
|
18335
|
+
walk(node, {
|
|
18375
18336
|
leave() {
|
|
18376
18337
|
path.shift();
|
|
18377
18338
|
},
|
|
18378
18339
|
enter(node$1) {
|
|
18379
18340
|
if (node$1.type === "Declaration") {
|
|
18380
18341
|
const declaration = node$1;
|
|
18381
|
-
if (path.some((ancestor) => ancestor.type === "Atrule" && ancestor.name === "layer" && ancestor.prelude !== null &&
|
|
18342
|
+
if (path.some((ancestor) => ancestor.type === "Atrule" && ancestor.name === "layer" && ancestor.prelude !== null && generate(ancestor.prelude).includes("properties"))) {
|
|
18382
18343
|
path.unshift(node$1);
|
|
18383
18344
|
return;
|
|
18384
18345
|
}
|
|
@@ -18386,25 +18347,25 @@ function resolveAllCssVariables(node) {
|
|
|
18386
18347
|
declaration,
|
|
18387
18348
|
path: [...path],
|
|
18388
18349
|
variableName: declaration.property,
|
|
18389
|
-
definition:
|
|
18350
|
+
definition: generate(declaration.value)
|
|
18390
18351
|
});
|
|
18391
18352
|
else {
|
|
18392
18353
|
function parseVariableUsesFrom(node$2) {
|
|
18393
|
-
|
|
18354
|
+
walk(node$2, {
|
|
18394
18355
|
visit: "Function",
|
|
18395
18356
|
enter(funcNode) {
|
|
18396
18357
|
if (funcNode.name === "var") {
|
|
18397
18358
|
const children = funcNode.children.toArray();
|
|
18398
|
-
const name =
|
|
18399
|
-
const fallback = children[2] ?
|
|
18359
|
+
const name = generate(children[0]);
|
|
18360
|
+
const fallback = children[2] ? generate(children[2]) : void 0;
|
|
18400
18361
|
variableUses.add({
|
|
18401
18362
|
declaration,
|
|
18402
18363
|
path: [...path],
|
|
18403
18364
|
fallback,
|
|
18404
18365
|
variableName: name,
|
|
18405
|
-
raw:
|
|
18366
|
+
raw: generate(funcNode)
|
|
18406
18367
|
});
|
|
18407
|
-
if (fallback?.includes("var(")) parseVariableUsesFrom(
|
|
18368
|
+
if (fallback?.includes("var(")) parseVariableUsesFrom(parse(fallback, { context: "value" }));
|
|
18408
18369
|
}
|
|
18409
18370
|
}
|
|
18410
18371
|
});
|
|
@@ -18420,17 +18381,17 @@ function resolveAllCssVariables(node) {
|
|
|
18420
18381
|
for (const definition of variableDefinitions) {
|
|
18421
18382
|
if (use.variableName !== definition.variableName) continue;
|
|
18422
18383
|
if (use.path[0]?.type === "Block" && use.path[1]?.type === "Atrule" && use.path[2]?.type === "Block" && use.path[3]?.type === "Rule" && definition.path[0].type === "Block" && definition.path[1].type === "Rule" && doSelectorsIntersect(use.path[3].prelude, definition.path[1].prelude)) {
|
|
18423
|
-
use.declaration.value =
|
|
18384
|
+
use.declaration.value = parse(generate(use.declaration.value).replaceAll(use.raw, definition.definition), { context: "value" });
|
|
18424
18385
|
hasReplaced = true;
|
|
18425
18386
|
break;
|
|
18426
18387
|
}
|
|
18427
18388
|
if (use.path[0]?.type === "Block" && use.path[1]?.type === "Rule" && definition.path[0]?.type === "Block" && definition.path[1]?.type === "Rule" && doSelectorsIntersect(use.path[1].prelude, definition.path[1].prelude)) {
|
|
18428
|
-
use.declaration.value =
|
|
18389
|
+
use.declaration.value = parse(generate(use.declaration.value).replaceAll(use.raw, definition.definition), { context: "value" });
|
|
18429
18390
|
hasReplaced = true;
|
|
18430
18391
|
break;
|
|
18431
18392
|
}
|
|
18432
18393
|
}
|
|
18433
|
-
if (!hasReplaced && use.fallback) use.declaration.value =
|
|
18394
|
+
if (!hasReplaced && use.fallback) use.declaration.value = parse(generate(use.declaration.value).replaceAll(use.raw, use.fallback), { context: "value" });
|
|
18434
18395
|
}
|
|
18435
18396
|
}
|
|
18436
18397
|
|
|
@@ -18441,7 +18402,7 @@ function resolveAllCssVariables(node) {
|
|
|
18441
18402
|
* because this is the only thing required to run Tailwind v4.
|
|
18442
18403
|
*/
|
|
18443
18404
|
function resolveCalcExpressions(node) {
|
|
18444
|
-
|
|
18405
|
+
walk(node, {
|
|
18445
18406
|
visit: "Function",
|
|
18446
18407
|
enter(func, funcListItem) {
|
|
18447
18408
|
if (func.name === "calc") {
|
|
@@ -18528,7 +18489,7 @@ function resolveCalcExpressions(node) {
|
|
|
18528
18489
|
//#endregion
|
|
18529
18490
|
//#region src/tailwind/utils/sanitize-declarations.ts
|
|
18530
18491
|
function rgbNode(r, g, b, alpha) {
|
|
18531
|
-
const children = new
|
|
18492
|
+
const children = new List();
|
|
18532
18493
|
children.appendData({
|
|
18533
18494
|
type: "Number",
|
|
18534
18495
|
value: r.toFixed(0)
|
|
@@ -18625,11 +18586,11 @@ function separateShorthandDeclaration(shorthandToReplace, [start, end]) {
|
|
|
18625
18586
|
if (values.length === 2) {
|
|
18626
18587
|
endValue = {
|
|
18627
18588
|
type: "Value",
|
|
18628
|
-
children: new
|
|
18589
|
+
children: new List().fromArray([values[1]])
|
|
18629
18590
|
};
|
|
18630
18591
|
shorthandToReplace.value = {
|
|
18631
18592
|
type: "Value",
|
|
18632
|
-
children: new
|
|
18593
|
+
children: new List().fromArray([values[0]])
|
|
18633
18594
|
};
|
|
18634
18595
|
}
|
|
18635
18596
|
return {
|
|
@@ -18653,12 +18614,12 @@ function separateShorthandDeclaration(shorthandToReplace, [start, end]) {
|
|
|
18653
18614
|
* - convert `border-radius: calc(infinity * 1px)` into `border-radius: 9999px`
|
|
18654
18615
|
*/
|
|
18655
18616
|
function sanitizeDeclarations(nodeContainingDeclarations) {
|
|
18656
|
-
|
|
18617
|
+
walk(nodeContainingDeclarations, {
|
|
18657
18618
|
visit: "Declaration",
|
|
18658
18619
|
enter(declaration, item, list) {
|
|
18659
|
-
if (declaration.value.type === "Raw") declaration.value =
|
|
18660
|
-
if (/border-radius\s*:\s*calc\s*\(\s*infinity\s*\*\s*1px\s*\)/i.test(
|
|
18661
|
-
|
|
18620
|
+
if (declaration.value.type === "Raw") declaration.value = parse(declaration.value.value, { context: "value" });
|
|
18621
|
+
if (/border-radius\s*:\s*calc\s*\(\s*infinity\s*\*\s*1px\s*\)/i.test(generate(declaration))) declaration.value = parse("9999px", { context: "value" });
|
|
18622
|
+
walk(declaration, {
|
|
18662
18623
|
visit: "Function",
|
|
18663
18624
|
enter(func, funcParentListItem) {
|
|
18664
18625
|
const children = func.children.toArray();
|
|
@@ -18754,7 +18715,7 @@ function sanitizeDeclarations(nodeContainingDeclarations) {
|
|
|
18754
18715
|
}
|
|
18755
18716
|
}
|
|
18756
18717
|
});
|
|
18757
|
-
|
|
18718
|
+
walk(declaration, {
|
|
18758
18719
|
visit: "Hash",
|
|
18759
18720
|
enter(hash, hashParentListItem) {
|
|
18760
18721
|
const hex = hash.value.trim();
|
|
@@ -18781,7 +18742,7 @@ function sanitizeDeclarations(nodeContainingDeclarations) {
|
|
|
18781
18742
|
hashParentListItem.data = rgbNode(Number.parseInt(hex.slice(0, 2), 16), Number.parseInt(hex.slice(2, 4), 16), Number.parseInt(hex.slice(4, 6), 16), Number.parseInt(hex.slice(6, 8), 16) / 255);
|
|
18782
18743
|
}
|
|
18783
18744
|
});
|
|
18784
|
-
|
|
18745
|
+
walk(declaration, {
|
|
18785
18746
|
visit: "Function",
|
|
18786
18747
|
enter(func, parentListItem) {
|
|
18787
18748
|
if (func.name === "color-mix") {
|
|
@@ -18870,14 +18831,14 @@ function sanitizeClassName(className) {
|
|
|
18870
18831
|
* 2. Sanitizes class selectors of all non-inlinable rules
|
|
18871
18832
|
*/
|
|
18872
18833
|
function sanitizeNonInlinableRules(node) {
|
|
18873
|
-
|
|
18834
|
+
walk(node, {
|
|
18874
18835
|
visit: "Rule",
|
|
18875
18836
|
enter(rule) {
|
|
18876
18837
|
if (!isRuleInlinable(rule)) {
|
|
18877
|
-
|
|
18878
|
-
if (node$1.type === "ClassSelector") node$1.name = sanitizeClassName(
|
|
18838
|
+
walk(rule.prelude, (node$1) => {
|
|
18839
|
+
if (node$1.type === "ClassSelector") node$1.name = sanitizeClassName(string.decode(node$1.name));
|
|
18879
18840
|
});
|
|
18880
|
-
|
|
18841
|
+
walk(rule, {
|
|
18881
18842
|
visit: "Declaration",
|
|
18882
18843
|
enter(declaration) {
|
|
18883
18844
|
declaration.important = true;
|
|
@@ -18920,12 +18881,12 @@ const isComponent = (element) => {
|
|
|
18920
18881
|
* and after rendering.
|
|
18921
18882
|
*/
|
|
18922
18883
|
function mapReactTree(value, process) {
|
|
18923
|
-
const mapped =
|
|
18924
|
-
if (
|
|
18884
|
+
const mapped = React.Children.map(value, (node) => {
|
|
18885
|
+
if (React.isValidElement(node)) {
|
|
18925
18886
|
const newProps = { ...node.props };
|
|
18926
18887
|
if (node.props.children && !isComponent(node)) newProps.children = mapReactTree(node.props.children, process);
|
|
18927
|
-
const processed = process(
|
|
18928
|
-
if (
|
|
18888
|
+
const processed = process(React.cloneElement(node, newProps, newProps.children));
|
|
18889
|
+
if (React.isValidElement(processed) && isComponent(processed)) return mapReactTree((typeof processed.type === "object" ? processed.type.render : processed.type)(processed.props), process);
|
|
18929
18890
|
return processed;
|
|
18930
18891
|
}
|
|
18931
18892
|
return process(node);
|
|
@@ -18961,7 +18922,7 @@ function cloneElementWithInlinedStyles(element, inlinableRules, nonInlinableRule
|
|
|
18961
18922
|
...element.props,
|
|
18962
18923
|
...propsToOverwrite
|
|
18963
18924
|
};
|
|
18964
|
-
return
|
|
18925
|
+
return React.cloneElement(element, newProps, newProps.children);
|
|
18965
18926
|
}
|
|
18966
18927
|
|
|
18967
18928
|
//#endregion
|
|
@@ -20749,7 +20710,7 @@ async function setupTailwind(config) {
|
|
|
20749
20710
|
@import "tailwindcss/utilities.css" layer(utilities);
|
|
20750
20711
|
@config;
|
|
20751
20712
|
`;
|
|
20752
|
-
const compiler = await
|
|
20713
|
+
const compiler = await compile(baseCss, {
|
|
20753
20714
|
async loadModule(id, base, resourceHint) {
|
|
20754
20715
|
if (resourceHint === "config") return {
|
|
20755
20716
|
path: id,
|
|
@@ -20789,7 +20750,7 @@ async function setupTailwind(config) {
|
|
|
20789
20750
|
css$4 = compiler.build(candidates);
|
|
20790
20751
|
},
|
|
20791
20752
|
getStyleSheet: function getCss() {
|
|
20792
|
-
return
|
|
20753
|
+
return parse(css$4);
|
|
20793
20754
|
}
|
|
20794
20755
|
};
|
|
20795
20756
|
}
|
|
@@ -20854,7 +20815,7 @@ function Tailwind({ children, config }) {
|
|
|
20854
20815
|
const tailwindSetup = useSuspensedPromise(() => setupTailwind(config ?? {}), JSON.stringify(config, (_key, value) => typeof value === "function" ? value.toString() : value));
|
|
20855
20816
|
let classesUsed = [];
|
|
20856
20817
|
let mappedChildren = mapReactTree(children, (node) => {
|
|
20857
|
-
if (
|
|
20818
|
+
if (React$1.isValidElement(node)) {
|
|
20858
20819
|
if (node.props.className) {
|
|
20859
20820
|
const classes = node.props.className?.split(/\s+/);
|
|
20860
20821
|
classesUsed = [...classesUsed, ...classes];
|
|
@@ -20869,18 +20830,18 @@ function Tailwind({ children, config }) {
|
|
|
20869
20830
|
const customProperties = getCustomProperties(styleSheet);
|
|
20870
20831
|
const nonInlineStyles = {
|
|
20871
20832
|
type: "StyleSheet",
|
|
20872
|
-
children: new
|
|
20833
|
+
children: new List().fromArray(Array.from(nonInlinableRules.values()))
|
|
20873
20834
|
};
|
|
20874
20835
|
sanitizeNonInlinableRules(nonInlineStyles);
|
|
20875
20836
|
const hasNonInlineStylesToApply = nonInlinableRules.size > 0;
|
|
20876
20837
|
let appliedNonInlineStyles = false;
|
|
20877
20838
|
mappedChildren = mapReactTree(mappedChildren, (node) => {
|
|
20878
|
-
if (
|
|
20839
|
+
if (React$1.isValidElement(node)) {
|
|
20879
20840
|
const elementWithInlinedStyles = cloneElementWithInlinedStyles(node, inlinableRules, nonInlinableRules, customProperties);
|
|
20880
20841
|
if (elementWithInlinedStyles.type === "head") {
|
|
20881
20842
|
appliedNonInlineStyles = true;
|
|
20882
|
-
const styleElement = /* @__PURE__ */
|
|
20883
|
-
return
|
|
20843
|
+
const styleElement = /* @__PURE__ */ jsx("style", { dangerouslySetInnerHTML: { __html: generate(nonInlineStyles) } });
|
|
20844
|
+
return React$1.cloneElement(elementWithInlinedStyles, elementWithInlinedStyles.props, styleElement, elementWithInlinedStyles.props.children);
|
|
20884
20845
|
}
|
|
20885
20846
|
return elementWithInlinedStyles;
|
|
20886
20847
|
}
|
|
@@ -20896,30 +20857,5 @@ This can also be unmail's <Head> component.`);
|
|
|
20896
20857
|
}
|
|
20897
20858
|
|
|
20898
20859
|
//#endregion
|
|
20899
|
-
|
|
20900
|
-
|
|
20901
|
-
exports.CodeBlock = CodeBlock;
|
|
20902
|
-
exports.CodeInline = CodeInline;
|
|
20903
|
-
exports.Column = Column;
|
|
20904
|
-
exports.Container = Container;
|
|
20905
|
-
exports.Font = Font;
|
|
20906
|
-
exports.Head = Head;
|
|
20907
|
-
exports.Heading = Heading;
|
|
20908
|
-
exports.Hr = Hr;
|
|
20909
|
-
exports.Html = Html;
|
|
20910
|
-
exports.Img = Img;
|
|
20911
|
-
exports.Link = Link;
|
|
20912
|
-
exports.Markdown = Markdown;
|
|
20913
|
-
exports.Preview = Preview;
|
|
20914
|
-
exports.Row = Row;
|
|
20915
|
-
exports.Section = Section;
|
|
20916
|
-
exports.Tailwind = Tailwind;
|
|
20917
|
-
exports.Text = Text;
|
|
20918
|
-
Object.defineProperty(exports, 'codeBlockThemes', {
|
|
20919
|
-
enumerable: true,
|
|
20920
|
-
get: function () {
|
|
20921
|
-
return themes_exports;
|
|
20922
|
-
}
|
|
20923
|
-
});
|
|
20924
|
-
exports.pixelBasedPreset = pixelBasedPreset;
|
|
20925
|
-
exports.render = render;
|
|
20860
|
+
export { Body, Button, CodeBlock, CodeInline, Column, Container, Font, Head, Heading, Hr, Html, Img, Link, Markdown, Preview, Row, Section, Tailwind, Text, themes_exports as codeBlockThemes, pixelBasedPreset, render };
|
|
20861
|
+
//# sourceMappingURL=index.js.map
|