mirror of
https://github.com/Snigdha-OS/documentation.git
synced 2025-09-07 19:25:13 +02:00
3008 lines
130 KiB
JavaScript
3008 lines
130 KiB
JavaScript
var __create = Object.create;
|
||
var __defProp = Object.defineProperty;
|
||
var __defProps = Object.defineProperties;
|
||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
|
||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
|
||
var __getProtoOf = Object.getPrototypeOf;
|
||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||
var __propIsEnum = Object.prototype.propertyIsEnumerable;
|
||
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
||
var __spreadValues = (a, b) => {
|
||
for (var prop in b || (b = {}))
|
||
if (__hasOwnProp.call(b, prop))
|
||
__defNormalProp(a, prop, b[prop]);
|
||
if (__getOwnPropSymbols)
|
||
for (var prop of __getOwnPropSymbols(b)) {
|
||
if (__propIsEnum.call(b, prop))
|
||
__defNormalProp(a, prop, b[prop]);
|
||
}
|
||
return a;
|
||
};
|
||
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
|
||
var __objRest = (source, exclude) => {
|
||
var target = {};
|
||
for (var prop in source)
|
||
if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
|
||
target[prop] = source[prop];
|
||
if (source != null && __getOwnPropSymbols)
|
||
for (var prop of __getOwnPropSymbols(source)) {
|
||
if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
|
||
target[prop] = source[prop];
|
||
}
|
||
return target;
|
||
};
|
||
var __commonJS = (cb, mod) => function __require() {
|
||
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
||
};
|
||
var __export = (target, all) => {
|
||
for (var name in all)
|
||
__defProp(target, name, { get: all[name], enumerable: true });
|
||
};
|
||
var __copyProps = (to, from, except, desc) => {
|
||
if (from && typeof from === "object" || typeof from === "function") {
|
||
for (let key of __getOwnPropNames(from))
|
||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||
}
|
||
return to;
|
||
};
|
||
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
||
// If the importer is in node compatibility mode or this is not an ESM
|
||
// file that has been converted to a CommonJS file using a Babel-
|
||
// compatible transform (i.e. "__esModule" has not been set), then set
|
||
// "default" to the CommonJS "module.exports" for node compatibility.
|
||
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
||
mod
|
||
));
|
||
|
||
// ../../node_modules/.pnpm/prismjs@1.29.0_patch_hash=vrxx3pzkik6jpmgpayxfjunetu/node_modules/prismjs/prism.js
|
||
var require_prism = __commonJS({
|
||
"../../node_modules/.pnpm/prismjs@1.29.0_patch_hash=vrxx3pzkik6jpmgpayxfjunetu/node_modules/prismjs/prism.js"(exports, module) {
|
||
var Prism2 = function() {
|
||
var lang = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i;
|
||
var uniqueId = 0;
|
||
var plainTextGrammar = {};
|
||
var _ = {
|
||
/**
|
||
* A namespace for utility methods.
|
||
*
|
||
* All function in this namespace that are not explicitly marked as _public_ are for __internal use only__ and may
|
||
* change or disappear at any time.
|
||
*
|
||
* @namespace
|
||
* @memberof Prism
|
||
*/
|
||
util: {
|
||
encode: function encode(tokens) {
|
||
if (tokens instanceof Token) {
|
||
return new Token(tokens.type, encode(tokens.content), tokens.alias);
|
||
} else if (Array.isArray(tokens)) {
|
||
return tokens.map(encode);
|
||
} else {
|
||
return tokens.replace(/&/g, "&").replace(/</g, "<").replace(/\u00a0/g, " ");
|
||
}
|
||
},
|
||
/**
|
||
* Returns the name of the type of the given value.
|
||
*
|
||
* @param {any} o
|
||
* @returns {string}
|
||
* @example
|
||
* type(null) === 'Null'
|
||
* type(undefined) === 'Undefined'
|
||
* type(123) === 'Number'
|
||
* type('foo') === 'String'
|
||
* type(true) === 'Boolean'
|
||
* type([1, 2]) === 'Array'
|
||
* type({}) === 'Object'
|
||
* type(String) === 'Function'
|
||
* type(/abc+/) === 'RegExp'
|
||
*/
|
||
type: function(o) {
|
||
return Object.prototype.toString.call(o).slice(8, -1);
|
||
},
|
||
/**
|
||
* Returns a unique number for the given object. Later calls will still return the same number.
|
||
*
|
||
* @param {Object} obj
|
||
* @returns {number}
|
||
*/
|
||
objId: function(obj) {
|
||
if (!obj["__id"]) {
|
||
Object.defineProperty(obj, "__id", { value: ++uniqueId });
|
||
}
|
||
return obj["__id"];
|
||
},
|
||
/**
|
||
* Creates a deep clone of the given object.
|
||
*
|
||
* The main intended use of this function is to clone language definitions.
|
||
*
|
||
* @param {T} o
|
||
* @param {Record<number, any>} [visited]
|
||
* @returns {T}
|
||
* @template T
|
||
*/
|
||
clone: function deepClone(o, visited) {
|
||
visited = visited || {};
|
||
var clone;
|
||
var id;
|
||
switch (_.util.type(o)) {
|
||
case "Object":
|
||
id = _.util.objId(o);
|
||
if (visited[id]) {
|
||
return visited[id];
|
||
}
|
||
clone = /** @type {Record<string, any>} */
|
||
{};
|
||
visited[id] = clone;
|
||
for (var key in o) {
|
||
if (o.hasOwnProperty(key)) {
|
||
clone[key] = deepClone(o[key], visited);
|
||
}
|
||
}
|
||
return (
|
||
/** @type {any} */
|
||
clone
|
||
);
|
||
case "Array":
|
||
id = _.util.objId(o);
|
||
if (visited[id]) {
|
||
return visited[id];
|
||
}
|
||
clone = [];
|
||
visited[id] = clone;
|
||
/** @type {Array} */
|
||
/** @type {any} */
|
||
o.forEach(function(v, i) {
|
||
clone[i] = deepClone(v, visited);
|
||
});
|
||
return (
|
||
/** @type {any} */
|
||
clone
|
||
);
|
||
default:
|
||
return o;
|
||
}
|
||
},
|
||
/**
|
||
* Returns the Prism language of the given element set by a `language-xxxx` or `lang-xxxx` class.
|
||
*
|
||
* If no language is set for the element or the element is `null` or `undefined`, `none` will be returned.
|
||
*
|
||
* @param {Element} element
|
||
* @returns {string}
|
||
*/
|
||
getLanguage: function(element) {
|
||
while (element) {
|
||
var m = lang.exec(element.className);
|
||
if (m) {
|
||
return m[1].toLowerCase();
|
||
}
|
||
element = element.parentElement;
|
||
}
|
||
return "none";
|
||
},
|
||
/**
|
||
* Sets the Prism `language-xxxx` class of the given element.
|
||
*
|
||
* @param {Element} element
|
||
* @param {string} language
|
||
* @returns {void}
|
||
*/
|
||
setLanguage: function(element, language) {
|
||
element.className = element.className.replace(RegExp(lang, "gi"), "");
|
||
element.classList.add("language-" + language);
|
||
},
|
||
/**
|
||
* Returns whether a given class is active for `element`.
|
||
*
|
||
* The class can be activated if `element` or one of its ancestors has the given class and it can be deactivated
|
||
* if `element` or one of its ancestors has the negated version of the given class. The _negated version_ of the
|
||
* given class is just the given class with a `no-` prefix.
|
||
*
|
||
* Whether the class is active is determined by the closest ancestor of `element` (where `element` itself is
|
||
* closest ancestor) that has the given class or the negated version of it. If neither `element` nor any of its
|
||
* ancestors have the given class or the negated version of it, then the default activation will be returned.
|
||
*
|
||
* In the paradoxical situation where the closest ancestor contains __both__ the given class and the negated
|
||
* version of it, the class is considered active.
|
||
*
|
||
* @param {Element} element
|
||
* @param {string} className
|
||
* @param {boolean} [defaultActivation=false]
|
||
* @returns {boolean}
|
||
*/
|
||
isActive: function(element, className, defaultActivation) {
|
||
var no = "no-" + className;
|
||
while (element) {
|
||
var classList = element.classList;
|
||
if (classList.contains(className)) {
|
||
return true;
|
||
}
|
||
if (classList.contains(no)) {
|
||
return false;
|
||
}
|
||
element = element.parentElement;
|
||
}
|
||
return !!defaultActivation;
|
||
}
|
||
},
|
||
/**
|
||
* This namespace contains all currently loaded languages and the some helper functions to create and modify languages.
|
||
*
|
||
* @namespace
|
||
* @memberof Prism
|
||
* @public
|
||
*/
|
||
languages: {
|
||
/**
|
||
* The grammar for plain, unformatted text.
|
||
*/
|
||
plain: plainTextGrammar,
|
||
plaintext: plainTextGrammar,
|
||
text: plainTextGrammar,
|
||
txt: plainTextGrammar,
|
||
/**
|
||
* Creates a deep copy of the language with the given id and appends the given tokens.
|
||
*
|
||
* If a token in `redef` also appears in the copied language, then the existing token in the copied language
|
||
* will be overwritten at its original position.
|
||
*
|
||
* ## Best practices
|
||
*
|
||
* Since the position of overwriting tokens (token in `redef` that overwrite tokens in the copied language)
|
||
* doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to
|
||
* understand the language definition because, normally, the order of tokens matters in Prism grammars.
|
||
*
|
||
* Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens.
|
||
* Furthermore, all non-overwriting tokens should be placed after the overwriting ones.
|
||
*
|
||
* @param {string} id The id of the language to extend. This has to be a key in `Prism.languages`.
|
||
* @param {Grammar} redef The new tokens to append.
|
||
* @returns {Grammar} The new language created.
|
||
* @public
|
||
* @example
|
||
* Prism.languages['css-with-colors'] = Prism.languages.extend('css', {
|
||
* // Prism.languages.css already has a 'comment' token, so this token will overwrite CSS' 'comment' token
|
||
* // at its original position
|
||
* 'comment': { ... },
|
||
* // CSS doesn't have a 'color' token, so this token will be appended
|
||
* 'color': /\b(?:red|green|blue)\b/
|
||
* });
|
||
*/
|
||
extend: function(id, redef) {
|
||
var lang2 = _.util.clone(_.languages[id]);
|
||
for (var key in redef) {
|
||
lang2[key] = redef[key];
|
||
}
|
||
return lang2;
|
||
},
|
||
/**
|
||
* Inserts tokens _before_ another token in a language definition or any other grammar.
|
||
*
|
||
* ## Usage
|
||
*
|
||
* This helper method makes it easy to modify existing languages. For example, the CSS language definition
|
||
* not only defines CSS highlighting for CSS documents, but also needs to define highlighting for CSS embedded
|
||
* in HTML through `<style>` elements. To do this, it needs to modify `Prism.languages.markup` and add the
|
||
* appropriate tokens. However, `Prism.languages.markup` is a regular JavaScript object literal, so if you do
|
||
* this:
|
||
*
|
||
* ```js
|
||
* Prism.languages.markup.style = {
|
||
* // token
|
||
* };
|
||
* ```
|
||
*
|
||
* then the `style` token will be added (and processed) at the end. `insertBefore` allows you to insert tokens
|
||
* before existing tokens. For the CSS example above, you would use it like this:
|
||
*
|
||
* ```js
|
||
* Prism.languages.insertBefore('markup', 'cdata', {
|
||
* 'style': {
|
||
* // token
|
||
* }
|
||
* });
|
||
* ```
|
||
*
|
||
* ## Special cases
|
||
*
|
||
* If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar
|
||
* will be ignored.
|
||
*
|
||
* This behavior can be used to insert tokens after `before`:
|
||
*
|
||
* ```js
|
||
* Prism.languages.insertBefore('markup', 'comment', {
|
||
* 'comment': Prism.languages.markup.comment,
|
||
* // tokens after 'comment'
|
||
* });
|
||
* ```
|
||
*
|
||
* ## Limitations
|
||
*
|
||
* The main problem `insertBefore` has to solve is iteration order. Since ES2015, the iteration order for object
|
||
* properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave
|
||
* differently when keys are deleted and re-inserted. So `insertBefore` can't be implemented by temporarily
|
||
* deleting properties which is necessary to insert at arbitrary positions.
|
||
*
|
||
* To solve this problem, `insertBefore` doesn't actually insert the given tokens into the target object.
|
||
* Instead, it will create a new object and replace all references to the target object with the new one. This
|
||
* can be done without temporarily deleting properties, so the iteration order is well-defined.
|
||
*
|
||
* However, only references that can be reached from `Prism.languages` or `insert` will be replaced. I.e. if
|
||
* you hold the target object in a variable, then the value of the variable will not change.
|
||
*
|
||
* ```js
|
||
* var oldMarkup = Prism.languages.markup;
|
||
* var newMarkup = Prism.languages.insertBefore('markup', 'comment', { ... });
|
||
*
|
||
* assert(oldMarkup !== Prism.languages.markup);
|
||
* assert(newMarkup === Prism.languages.markup);
|
||
* ```
|
||
*
|
||
* @param {string} inside The property of `root` (e.g. a language id in `Prism.languages`) that contains the
|
||
* object to be modified.
|
||
* @param {string} before The key to insert before.
|
||
* @param {Grammar} insert An object containing the key-value pairs to be inserted.
|
||
* @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the
|
||
* object to be modified.
|
||
*
|
||
* Defaults to `Prism.languages`.
|
||
* @returns {Grammar} The new grammar object.
|
||
* @public
|
||
*/
|
||
insertBefore: function(inside, before, insert, root) {
|
||
root = root || /** @type {any} */
|
||
_.languages;
|
||
var grammar = root[inside];
|
||
var ret = {};
|
||
for (var token in grammar) {
|
||
if (grammar.hasOwnProperty(token)) {
|
||
if (token == before) {
|
||
for (var newToken in insert) {
|
||
if (insert.hasOwnProperty(newToken)) {
|
||
ret[newToken] = insert[newToken];
|
||
}
|
||
}
|
||
}
|
||
if (!insert.hasOwnProperty(token)) {
|
||
ret[token] = grammar[token];
|
||
}
|
||
}
|
||
}
|
||
var old = root[inside];
|
||
root[inside] = ret;
|
||
_.languages.DFS(_.languages, function(key, value) {
|
||
if (value === old && key != inside) {
|
||
this[key] = ret;
|
||
}
|
||
});
|
||
return ret;
|
||
},
|
||
// Traverse a language definition with Depth First Search
|
||
DFS: function DFS(o, callback, type, visited) {
|
||
visited = visited || {};
|
||
var objId = _.util.objId;
|
||
for (var i in o) {
|
||
if (o.hasOwnProperty(i)) {
|
||
callback.call(o, i, o[i], type || i);
|
||
var property = o[i];
|
||
var propertyType = _.util.type(property);
|
||
if (propertyType === "Object" && !visited[objId(property)]) {
|
||
visited[objId(property)] = true;
|
||
DFS(property, callback, null, visited);
|
||
} else if (propertyType === "Array" && !visited[objId(property)]) {
|
||
visited[objId(property)] = true;
|
||
DFS(property, callback, i, visited);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
},
|
||
plugins: {},
|
||
/**
|
||
* Low-level function, only use if you know what you’re doing. It accepts a string of text as input
|
||
* and the language definitions to use, and returns a string with the HTML produced.
|
||
*
|
||
* The following hooks will be run:
|
||
* 1. `before-tokenize`
|
||
* 2. `after-tokenize`
|
||
* 3. `wrap`: On each {@link Token}.
|
||
*
|
||
* @param {string} text A string with the code to be highlighted.
|
||
* @param {Grammar} grammar An object containing the tokens to use.
|
||
*
|
||
* Usually a language definition like `Prism.languages.markup`.
|
||
* @param {string} language The name of the language definition passed to `grammar`.
|
||
* @returns {string} The highlighted HTML.
|
||
* @memberof Prism
|
||
* @public
|
||
* @example
|
||
* Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');
|
||
*/
|
||
highlight: function(text, grammar, language) {
|
||
var env = {
|
||
code: text,
|
||
grammar,
|
||
language
|
||
};
|
||
_.hooks.run("before-tokenize", env);
|
||
if (!env.grammar) {
|
||
throw new Error('The language "' + env.language + '" has no grammar.');
|
||
}
|
||
env.tokens = _.tokenize(env.code, env.grammar);
|
||
_.hooks.run("after-tokenize", env);
|
||
return Token.stringify(_.util.encode(env.tokens), env.language);
|
||
},
|
||
/**
|
||
* This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input
|
||
* and the language definitions to use, and returns an array with the tokenized code.
|
||
*
|
||
* When the language definition includes nested tokens, the function is called recursively on each of these tokens.
|
||
*
|
||
* This method could be useful in other contexts as well, as a very crude parser.
|
||
*
|
||
* @param {string} text A string with the code to be highlighted.
|
||
* @param {Grammar} grammar An object containing the tokens to use.
|
||
*
|
||
* Usually a language definition like `Prism.languages.markup`.
|
||
* @returns {TokenStream} An array of strings and tokens, a token stream.
|
||
* @memberof Prism
|
||
* @public
|
||
* @example
|
||
* let code = `var foo = 0;`;
|
||
* let tokens = Prism.tokenize(code, Prism.languages.javascript);
|
||
* tokens.forEach(token => {
|
||
* if (token instanceof Prism.Token && token.type === 'number') {
|
||
* console.log(`Found numeric literal: ${token.content}`);
|
||
* }
|
||
* });
|
||
*/
|
||
tokenize: function(text, grammar) {
|
||
var rest = grammar.rest;
|
||
if (rest) {
|
||
for (var token in rest) {
|
||
grammar[token] = rest[token];
|
||
}
|
||
delete grammar.rest;
|
||
}
|
||
var tokenList = new LinkedList();
|
||
addAfter(tokenList, tokenList.head, text);
|
||
matchGrammar(text, tokenList, grammar, tokenList.head, 0);
|
||
return toArray(tokenList);
|
||
},
|
||
/**
|
||
* @namespace
|
||
* @memberof Prism
|
||
* @public
|
||
*/
|
||
hooks: {
|
||
all: {},
|
||
/**
|
||
* Adds the given callback to the list of callbacks for the given hook.
|
||
*
|
||
* The callback will be invoked when the hook it is registered for is run.
|
||
* Hooks are usually directly run by a highlight function but you can also run hooks yourself.
|
||
*
|
||
* One callback function can be registered to multiple hooks and the same hook multiple times.
|
||
*
|
||
* @param {string} name The name of the hook.
|
||
* @param {HookCallback} callback The callback function which is given environment variables.
|
||
* @public
|
||
*/
|
||
add: function(name, callback) {
|
||
var hooks2 = _.hooks.all;
|
||
hooks2[name] = hooks2[name] || [];
|
||
hooks2[name].push(callback);
|
||
},
|
||
/**
|
||
* Runs a hook invoking all registered callbacks with the given environment variables.
|
||
*
|
||
* Callbacks will be invoked synchronously and in the order in which they were registered.
|
||
*
|
||
* @param {string} name The name of the hook.
|
||
* @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
|
||
* @public
|
||
*/
|
||
run: function(name, env) {
|
||
var callbacks = _.hooks.all[name];
|
||
if (!callbacks || !callbacks.length) {
|
||
return;
|
||
}
|
||
for (var i = 0, callback; callback = callbacks[i++]; ) {
|
||
callback(env);
|
||
}
|
||
}
|
||
},
|
||
Token
|
||
};
|
||
function Token(type, content, alias, matchedStr) {
|
||
this.type = type;
|
||
this.content = content;
|
||
this.alias = alias;
|
||
this.length = (matchedStr || "").length | 0;
|
||
}
|
||
Token.stringify = function stringify(o, language) {
|
||
if (typeof o == "string") {
|
||
return o;
|
||
}
|
||
if (Array.isArray(o)) {
|
||
var s = "";
|
||
o.forEach(function(e) {
|
||
s += stringify(e, language);
|
||
});
|
||
return s;
|
||
}
|
||
var env = {
|
||
type: o.type,
|
||
content: stringify(o.content, language),
|
||
tag: "span",
|
||
classes: ["token", o.type],
|
||
attributes: {},
|
||
language
|
||
};
|
||
var aliases = o.alias;
|
||
if (aliases) {
|
||
if (Array.isArray(aliases)) {
|
||
Array.prototype.push.apply(env.classes, aliases);
|
||
} else {
|
||
env.classes.push(aliases);
|
||
}
|
||
}
|
||
_.hooks.run("wrap", env);
|
||
var attributes = "";
|
||
for (var name in env.attributes) {
|
||
attributes += " " + name + '="' + (env.attributes[name] || "").replace(/"/g, """) + '"';
|
||
}
|
||
return "<" + env.tag + ' class="' + env.classes.join(" ") + '"' + attributes + ">" + env.content + "</" + env.tag + ">";
|
||
};
|
||
function matchPattern(pattern, pos, text, lookbehind) {
|
||
pattern.lastIndex = pos;
|
||
var match = pattern.exec(text);
|
||
if (match && lookbehind && match[1]) {
|
||
var lookbehindLength = match[1].length;
|
||
match.index += lookbehindLength;
|
||
match[0] = match[0].slice(lookbehindLength);
|
||
}
|
||
return match;
|
||
}
|
||
function matchGrammar(text, tokenList, grammar, startNode, startPos, rematch) {
|
||
for (var token in grammar) {
|
||
if (!grammar.hasOwnProperty(token) || !grammar[token]) {
|
||
continue;
|
||
}
|
||
var patterns = grammar[token];
|
||
patterns = Array.isArray(patterns) ? patterns : [patterns];
|
||
for (var j = 0; j < patterns.length; ++j) {
|
||
if (rematch && rematch.cause == token + "," + j) {
|
||
return;
|
||
}
|
||
var patternObj = patterns[j];
|
||
var inside = patternObj.inside;
|
||
var lookbehind = !!patternObj.lookbehind;
|
||
var greedy = !!patternObj.greedy;
|
||
var alias = patternObj.alias;
|
||
if (greedy && !patternObj.pattern.global) {
|
||
var flags = patternObj.pattern.toString().match(/[imsuy]*$/)[0];
|
||
patternObj.pattern = RegExp(patternObj.pattern.source, flags + "g");
|
||
}
|
||
var pattern = patternObj.pattern || patternObj;
|
||
for (var currentNode = startNode.next, pos = startPos; currentNode !== tokenList.tail; pos += currentNode.value.length, currentNode = currentNode.next) {
|
||
if (rematch && pos >= rematch.reach) {
|
||
break;
|
||
}
|
||
var str = currentNode.value;
|
||
if (tokenList.length > text.length) {
|
||
return;
|
||
}
|
||
if (str instanceof Token) {
|
||
continue;
|
||
}
|
||
var removeCount = 1;
|
||
var match;
|
||
if (greedy) {
|
||
match = matchPattern(pattern, pos, text, lookbehind);
|
||
if (!match || match.index >= text.length) {
|
||
break;
|
||
}
|
||
var from = match.index;
|
||
var to = match.index + match[0].length;
|
||
var p = pos;
|
||
p += currentNode.value.length;
|
||
while (from >= p) {
|
||
currentNode = currentNode.next;
|
||
p += currentNode.value.length;
|
||
}
|
||
p -= currentNode.value.length;
|
||
pos = p;
|
||
if (currentNode.value instanceof Token) {
|
||
continue;
|
||
}
|
||
for (var k = currentNode; k !== tokenList.tail && (p < to || typeof k.value === "string"); k = k.next) {
|
||
removeCount++;
|
||
p += k.value.length;
|
||
}
|
||
removeCount--;
|
||
str = text.slice(pos, p);
|
||
match.index -= pos;
|
||
} else {
|
||
match = matchPattern(pattern, 0, str, lookbehind);
|
||
if (!match) {
|
||
continue;
|
||
}
|
||
}
|
||
var from = match.index;
|
||
var matchStr = match[0];
|
||
var before = str.slice(0, from);
|
||
var after = str.slice(from + matchStr.length);
|
||
var reach = pos + str.length;
|
||
if (rematch && reach > rematch.reach) {
|
||
rematch.reach = reach;
|
||
}
|
||
var removeFrom = currentNode.prev;
|
||
if (before) {
|
||
removeFrom = addAfter(tokenList, removeFrom, before);
|
||
pos += before.length;
|
||
}
|
||
removeRange(tokenList, removeFrom, removeCount);
|
||
var wrapped = new Token(token, inside ? _.tokenize(matchStr, inside) : matchStr, alias, matchStr);
|
||
currentNode = addAfter(tokenList, removeFrom, wrapped);
|
||
if (after) {
|
||
addAfter(tokenList, currentNode, after);
|
||
}
|
||
if (removeCount > 1) {
|
||
var nestedRematch = {
|
||
cause: token + "," + j,
|
||
reach
|
||
};
|
||
matchGrammar(text, tokenList, grammar, currentNode.prev, pos, nestedRematch);
|
||
if (rematch && nestedRematch.reach > rematch.reach) {
|
||
rematch.reach = nestedRematch.reach;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
function LinkedList() {
|
||
var head = { value: null, prev: null, next: null };
|
||
var tail = { value: null, prev: head, next: null };
|
||
head.next = tail;
|
||
this.head = head;
|
||
this.tail = tail;
|
||
this.length = 0;
|
||
}
|
||
function addAfter(list, node, value) {
|
||
var next = node.next;
|
||
var newNode = { value, prev: node, next };
|
||
node.next = newNode;
|
||
next.prev = newNode;
|
||
list.length++;
|
||
return newNode;
|
||
}
|
||
function removeRange(list, node, count) {
|
||
var next = node.next;
|
||
for (var i = 0; i < count && next !== list.tail; i++) {
|
||
next = next.next;
|
||
}
|
||
node.next = next;
|
||
next.prev = node;
|
||
list.length -= i;
|
||
}
|
||
function toArray(list) {
|
||
var array = [];
|
||
var node = list.head.next;
|
||
while (node !== list.tail) {
|
||
array.push(node.value);
|
||
node = node.next;
|
||
}
|
||
return array;
|
||
}
|
||
return _;
|
||
}();
|
||
module.exports = Prism2;
|
||
Prism2.default = Prism2;
|
||
}
|
||
});
|
||
|
||
// src/prism-langs.ts
|
||
var Prism = __toESM(require_prism());
|
||
Prism.languages.markup = { comment: { pattern: /<!--(?:(?!<!--)[\s\S])*?-->/, greedy: true }, prolog: { pattern: /<\?[\s\S]+?\?>/, greedy: true }, doctype: { pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i, greedy: true, inside: { "internal-subset": { pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/, lookbehind: true, greedy: true, inside: null }, string: { pattern: /"[^"]*"|'[^']*'/, greedy: true }, punctuation: /^<!|>$|[[\]]/, "doctype-tag": /^DOCTYPE/i, name: /[^\s<>'"]+/ } }, cdata: { pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i, greedy: true }, tag: { pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/, greedy: true, inside: { tag: { pattern: /^<\/?[^\s>\/]+/, inside: { punctuation: /^<\/?/, namespace: /^[^\s>\/:]+:/ } }, "special-attr": [], "attr-value": { pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/, inside: { punctuation: [{ pattern: /^=/, alias: "attr-equals" }, { pattern: /^(\s*)["']|["']$/, lookbehind: true }] } }, punctuation: /\/?>/, "attr-name": { pattern: /[^\s>\/]+/, inside: { namespace: /^[^\s>\/:]+:/ } } } }, entity: [{ pattern: /&[\da-z]{1,8};/i, alias: "named-entity" }, /&#x?[\da-f]{1,8};/i] }, 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) {
|
||
"entity" === e.type && (e.attributes.title = e.content.replace(/&/, "&"));
|
||
}), Object.defineProperty(Prism.languages.markup.tag, "addInlined", { value: function(e, n) {
|
||
var t = {}, t = (t["language-" + n] = { pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i, lookbehind: true, inside: Prism.languages[n] }, t.cdata = /^<!\[CDATA\[|\]\]>$/i, { "included-cdata": { pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i, inside: t } }), n = (t["language-" + n] = { pattern: /[\s\S]+/, inside: Prism.languages[n] }, {});
|
||
n[e] = { pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function() {
|
||
return e;
|
||
}), "i"), lookbehind: true, greedy: true, inside: t }, Prism.languages.insertBefore("markup", "cdata", n);
|
||
} }), Object.defineProperty(Prism.languages.markup.tag, "addAttribute", { value: function(e, n) {
|
||
Prism.languages.markup.tag.inside["special-attr"].push({ pattern: RegExp(/(^|["'\s])/.source + "(?:" + e + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source, "i"), lookbehind: true, inside: { "attr-name": /^[^\s=]+/, "attr-value": { pattern: /=[\s\S]+/, inside: { value: { pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/, lookbehind: true, alias: [n, "language-" + n], inside: Prism.languages[n] }, punctuation: [{ pattern: /^=/, alias: "attr-equals" }, /"|'/] } } } });
|
||
} }), 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) {
|
||
var n = { pattern: /\\[\\(){}[\]^$+*?|.]/, alias: "escape" }, t = /\\(?:x[\da-fA-F]{2}|u[\da-fA-F]{4}|u\{[\da-fA-F]+\}|0[0-7]{0,2}|[123][0-7]{2}|c[a-zA-Z]|.)/, a = "(?:[^\\\\-]|" + t.source + ")", a = RegExp(a + "-" + a), r = { pattern: /(<|')[^<>']+(?=[>']$)/, lookbehind: true, alias: "variable" };
|
||
e.languages.regex = { "char-class": { pattern: /((?:^|[^\\])(?:\\\\)*)\[(?:[^\\\]]|\\[\s\S])*\]/, lookbehind: true, inside: { "char-class-negation": { pattern: /(^\[)\^/, lookbehind: true, alias: "operator" }, "char-class-punctuation": { pattern: /^\[|\]$/, alias: "punctuation" }, range: { pattern: a, inside: { escape: t, "range-punctuation": { pattern: /-/, alias: "operator" } } }, "special-escape": n, "char-set": { pattern: /\\[wsd]|\\p\{[^{}]+\}/i, alias: "class-name" }, escape: t } }, "special-escape": n, "char-set": { pattern: /\.|\\[wsd]|\\p\{[^{}]+\}/i, alias: "class-name" }, backreference: [{ pattern: /\\(?![123][0-7]{2})[1-9]/, alias: "keyword" }, { pattern: /\\k<[^<>']+>/, alias: "keyword", inside: { "group-name": r } }], anchor: { pattern: /[$^]|\\[ABbGZz]/, alias: "function" }, escape: t, group: [{ pattern: /\((?:\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[=!]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?))?/, alias: "punctuation", inside: { "group-name": r } }, { pattern: /\)/, alias: "punctuation" }], quantifier: { pattern: /(?:[+*?]|\{\d+(?:,\d*)?\})[?+]?/, alias: "number" }, alternation: { pattern: /\|/, alias: "keyword" } };
|
||
}(Prism), Prism.languages.clike = { comment: [{ pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/, lookbehind: true, greedy: true }, { pattern: /(^|[^\\:])\/\/.*/, lookbehind: true, greedy: true }], string: { pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/, greedy: true }, "class-name": { pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i, lookbehind: true, inside: { punctuation: /[.\\]/ } }, keyword: /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/, boolean: /\b(?:false|true)\b/, function: /\b\w+(?=\()/, number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i, operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/, punctuation: /[{}[\];(),.:]/ }, Prism.languages.javascript = Prism.languages.extend("clike", { "class-name": [Prism.languages.clike["class-name"], { pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/, lookbehind: true }], keyword: [{ pattern: /((?:^|\})\s*)catch\b/, lookbehind: true }, { pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/, lookbehind: true }], function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/, number: { pattern: RegExp(/(^|[^\w$])/.source + "(?:" + /NaN|Infinity/.source + "|" + /0[bB][01]+(?:_[01]+)*n?/.source + "|" + /0[oO][0-7]+(?:_[0-7]+)*n?/.source + "|" + /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + "|" + /\d+(?:_\d+)*n/.source + "|" + /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source + ")" + /(?![\w$])/.source), lookbehind: true }, operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/ }), Prism.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/, Prism.languages.insertBefore("javascript", "keyword", { regex: { 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), lookbehind: true, greedy: true, inside: { "regex-source": { pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/, lookbehind: true, alias: "language-regex", inside: Prism.languages.regex }, "regex-delimiter": /^\/|\/$/, "regex-flags": /^[a-z]+$/ } }, "function-variable": { pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/, alias: "function" }, parameter: [{ pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/, lookbehind: true, inside: Prism.languages.javascript }, { pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i, lookbehind: true, inside: Prism.languages.javascript }, { pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/, lookbehind: true, inside: Prism.languages.javascript }, { 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*\{)/, lookbehind: true, inside: Prism.languages.javascript }], constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/ }), Prism.languages.insertBefore("javascript", "string", { hashbang: { pattern: /^#!.*/, greedy: true, alias: "comment" }, "template-string": { pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/, greedy: true, inside: { "template-punctuation": { pattern: /^`|`$/, alias: "string" }, interpolation: { pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/, lookbehind: true, inside: { "interpolation-punctuation": { pattern: /^\$\{|\}$/, alias: "punctuation" }, rest: Prism.languages.javascript } }, string: /[\s\S]+/ } }, "string-property": { pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m, lookbehind: true, greedy: true, alias: "property" } }), Prism.languages.insertBefore("javascript", "operator", { "literal-property": { pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m, lookbehind: true, alias: "property" } }), 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.actionscript = Prism.languages.extend("javascript", { 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/, operator: /\+\+|--|(?:[+\-*\/%^]|&&?|\|\|?|<<?|>>?>?|[!=]=?)=?|[~?@]/ }), 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: { pattern: /(^|[^.])<\/?\w+(?:\s+[^\s>\/=]+=("|')(?:\\[\s\S]|(?!\2)[^\\])*\2)*\s*\/?>/, lookbehind: true, inside: Prism.languages.markup } }), function(e) {
|
||
var n = /#(?!\{).+/, t = { pattern: /#\{[^}]+\}/, alias: "variable" };
|
||
e.languages.coffeescript = e.languages.extend("javascript", { comment: n, string: [{ pattern: /'(?:\\[\s\S]|[^\\'])*'/, greedy: true }, { pattern: /"(?:\\[\s\S]|[^\\"])*"/, greedy: true, inside: { interpolation: t } }], keyword: /\b(?:and|break|by|catch|class|continue|debugger|delete|do|each|else|extend|extends|false|finally|for|if|in|instanceof|is|isnt|let|loop|namespace|new|no|not|null|of|off|on|or|own|return|super|switch|then|this|throw|true|try|typeof|undefined|unless|until|when|while|window|with|yes|yield)\b/, "class-member": { pattern: /@(?!\d)\w+/, alias: "variable" } }), e.languages.insertBefore("coffeescript", "comment", { "multiline-comment": { pattern: /###[\s\S]+?###/, alias: "comment" }, "block-regex": { pattern: /\/{3}[\s\S]*?\/{3}/, alias: "regex", inside: { comment: n, interpolation: t } } }), e.languages.insertBefore("coffeescript", "string", { "inline-javascript": { pattern: /`(?:\\[\s\S]|[^\\`])*`/, inside: { delimiter: { pattern: /^`|`$/, alias: "punctuation" }, script: { pattern: /[\s\S]+/, alias: "language-javascript", inside: e.languages.javascript } } }, "multiline-string": [{ pattern: /'''[\s\S]*?'''/, greedy: true, alias: "string" }, { pattern: /"""[\s\S]*?"""/, greedy: true, alias: "string", inside: { interpolation: t } }] }), e.languages.insertBefore("coffeescript", "keyword", { property: /(?!\d)\w+(?=\s*:(?!:))/ }), delete e.languages.coffeescript["template-string"], e.languages.coffee = e.languages.coffeescript;
|
||
}(Prism), function(l) {
|
||
var e = l.languages.javadoclike = { parameter: { pattern: /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*@(?:arg|arguments|param)\s+)\w+/m, lookbehind: true }, keyword: { pattern: /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*|\{)@[a-z][a-zA-Z-]+\b/m, lookbehind: true }, punctuation: /[{}]/ };
|
||
Object.defineProperty(e, "addSupport", { value: function(e2, o) {
|
||
(e2 = "string" == typeof e2 ? [e2] : e2).forEach(function(e3) {
|
||
var n = function(e4) {
|
||
e4.inside || (e4.inside = {}), e4.inside.rest = o;
|
||
}, t = "doc-comment";
|
||
if (a = l.languages[e3]) {
|
||
var a, r = a[t];
|
||
if ((r = r ? r : (a = l.languages.insertBefore(e3, "comment", { "doc-comment": { pattern: /(^|[^\\])\/\*\*[^/][\s\S]*?(?:\*\/|$)/, lookbehind: true, alias: "comment" } }))[t]) instanceof RegExp && (r = a[t] = { pattern: r }), Array.isArray(r))
|
||
for (var s = 0, i = r.length; s < i; s++)
|
||
r[s] instanceof RegExp && (r[s] = { pattern: r[s] }), n(r[s]);
|
||
else
|
||
n(r);
|
||
}
|
||
});
|
||
} }), e.addSupport(["java", "javascript", "php"], e);
|
||
}(Prism), function(e) {
|
||
var n = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/, n = (e.languages.css = { comment: /\/\*[\s\S]*?\*\//, atrule: { pattern: RegExp("@[\\w-](?:" + /[^;{\s"']|\s+(?!\s)/.source + "|" + n.source + ")*?" + /(?:;|(?=\s*\{))/.source), inside: { rule: /^@[\w-]+/, "selector-function-argument": { pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/, lookbehind: true, alias: "selector" }, keyword: { pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/, lookbehind: true } } }, url: { pattern: RegExp("\\burl\\((?:" + n.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)", "i"), greedy: true, inside: { function: /^url/i, punctuation: /^\(|\)$/, string: { pattern: RegExp("^" + n.source + "$"), alias: "url" } } }, selector: { pattern: RegExp(`(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|` + n.source + ")*(?=\\s*\\{)"), lookbehind: true }, string: { pattern: n, greedy: true }, property: { pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i, lookbehind: true }, important: /!important\b/i, function: { pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i, lookbehind: true }, punctuation: /[(){};:,]/ }, e.languages.css.atrule.inside.rest = e.languages.css, e.languages.markup);
|
||
n && (n.tag.addInlined("style", "css"), n.tag.addAttribute("style", "css"));
|
||
}(Prism), function(e) {
|
||
var n = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/, n = (e.languages.css.selector = { pattern: e.languages.css.selector.pattern, lookbehind: true, inside: n = { "pseudo-element": /:(?:after|before|first-letter|first-line|selection)|::[-\w]+/, "pseudo-class": /:[-\w]+/, class: /\.[-\w]+/, id: /#[-\w]+/, attribute: { pattern: RegExp(`\\[(?:[^[\\]"']|` + n.source + ")*\\]"), greedy: true, inside: { punctuation: /^\[|\]$/, "case-sensitivity": { pattern: /(\s)[si]$/i, lookbehind: true, alias: "keyword" }, namespace: { pattern: /^(\s*)(?:(?!\s)[-*\w\xA0-\uFFFF])*\|(?!=)/, lookbehind: true, inside: { punctuation: /\|$/ } }, "attr-name": { pattern: /^(\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+/, lookbehind: true }, "attr-value": [n, { pattern: /(=\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+(?=\s*$)/, lookbehind: true }], operator: /[|~*^$]?=/ } }, "n-th": [{ pattern: /(\(\s*)[+-]?\d*[\dn](?:\s*[+-]\s*\d+)?(?=\s*\))/, lookbehind: true, inside: { number: /[\dn]+/, operator: /[+-]/ } }, { pattern: /(\(\s*)(?:even|odd)(?=\s*\))/i, lookbehind: true }], combinator: />|\+|~|\|\|/, punctuation: /[(),]/ } }, e.languages.css.atrule.inside["selector-function-argument"].inside = n, e.languages.insertBefore("css", "property", { variable: { pattern: /(^|[^-\w\xA0-\uFFFF])--(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*/i, lookbehind: true } }), { pattern: /(\b\d+)(?:%|[a-z]+(?![\w-]))/, lookbehind: true }), t = { pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/, lookbehind: true };
|
||
e.languages.insertBefore("css", "function", { operator: { pattern: /(\s)[+\-*\/](?=\s)/, lookbehind: true }, hexcode: { pattern: /\B#[\da-f]{3,8}\b/i, alias: "color" }, color: [{ pattern: /(^|[^\w-])(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|RebeccaPurple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Transparent|Turquoise|Violet|Wheat|White|WhiteSmoke|Yellow|YellowGreen)(?![\w-])/i, lookbehind: true }, { pattern: /\b(?:hsl|rgb)\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*\)\B|\b(?:hsl|rgb)a\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*,\s*(?:0|0?\.\d+|1)\s*\)\B/i, inside: { unit: n, number: t, function: /[\w-]+(?=\()/, punctuation: /[(),]/ } }], entity: /\\[\da-f]{1,8}/i, unit: n, number: t });
|
||
}(Prism), function(e) {
|
||
var n = /[*&][^\s[\]{},]+/, t = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/, a = "(?:" + t.source + "(?:[ ]+" + n.source + ")?|" + n.source + "(?:[ ]+" + t.source + ")?)", r = /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(/<PLAIN>/g, function() {
|
||
return /[^\s\x00-\x08\x0e-\x1f,[\]{}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]/.source;
|
||
}), s = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
|
||
function i(e2, n2) {
|
||
n2 = (n2 || "").replace(/m/g, "") + "m";
|
||
var t2 = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source.replace(/<<prop>>/g, function() {
|
||
return a;
|
||
}).replace(/<<value>>/g, function() {
|
||
return e2;
|
||
});
|
||
return RegExp(t2, n2);
|
||
}
|
||
e.languages.yaml = { scalar: { pattern: RegExp(/([\-:]\s*(?:\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\S[^\r\n]*(?:\2[^\r\n]+)*)/.source.replace(/<<prop>>/g, function() {
|
||
return a;
|
||
})), lookbehind: true, alias: "string" }, comment: /#.*/, key: { pattern: RegExp(/((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source.replace(/<<prop>>/g, function() {
|
||
return a;
|
||
}).replace(/<<key>>/g, function() {
|
||
return "(?:" + r + "|" + s + ")";
|
||
})), lookbehind: true, greedy: true, alias: "atrule" }, directive: { pattern: /(^[ \t]*)%.+/m, lookbehind: true, alias: "important" }, datetime: { pattern: i(/\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/.source), lookbehind: true, alias: "number" }, boolean: { pattern: i(/false|true/.source, "i"), lookbehind: true, alias: "important" }, null: { pattern: i(/null|~/.source, "i"), lookbehind: true, alias: "important" }, string: { pattern: i(s), lookbehind: true, greedy: true }, number: { pattern: i(/[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source, "i"), lookbehind: true }, tag: t, important: n, punctuation: /---|[:[\]{}\-,|>?]|\.\.\./ }, e.languages.yml = e.languages.yaml;
|
||
}(Prism), function(o) {
|
||
var n = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
|
||
function e(e2) {
|
||
return e2 = e2.replace(/<inner>/g, function() {
|
||
return n;
|
||
}), RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + "(?:" + e2 + ")");
|
||
}
|
||
var t = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source, a = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(/__/g, function() {
|
||
return t;
|
||
}), r = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source, l = (o.languages.markdown = o.languages.extend("markup", {}), o.languages.insertBefore("markdown", "prolog", { "front-matter-block": { pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/, lookbehind: true, greedy: true, inside: { punctuation: /^---|---$/, "front-matter": { pattern: /\S+(?:\s+\S+)*/, alias: ["yaml", "language-yaml"], inside: o.languages.yaml } } }, blockquote: { pattern: /^>(?:[\t ]*>)*/m, alias: "punctuation" }, table: { pattern: RegExp("^" + a + r + "(?:" + a + ")*", "m"), inside: { "table-data-rows": { pattern: RegExp("^(" + a + r + ")(?:" + a + ")*$"), lookbehind: true, inside: { "table-data": { pattern: RegExp(t), inside: o.languages.markdown }, punctuation: /\|/ } }, "table-line": { pattern: RegExp("^(" + a + ")" + r + "$"), lookbehind: true, inside: { punctuation: /\||:?-{3,}:?/ } }, "table-header-row": { pattern: RegExp("^" + a + "$"), inside: { "table-header": { pattern: RegExp(t), alias: "important", inside: o.languages.markdown }, punctuation: /\|/ } } } }, code: [{ pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/, lookbehind: true, alias: "keyword" }, { pattern: /^```[\s\S]*?^```$/m, greedy: true, inside: { "code-block": { pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m, lookbehind: true }, "code-language": { pattern: /^(```).+/, lookbehind: true }, punctuation: /```/ } }], title: [{ pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m, alias: "important", inside: { punctuation: /==+$|--+$/ } }, { pattern: /(^\s*)#.+/m, lookbehind: true, alias: "important", inside: { punctuation: /^#+|#+$/ } }], hr: { pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m, lookbehind: true, alias: "punctuation" }, list: { pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m, lookbehind: true, alias: "punctuation" }, "url-reference": { pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/, inside: { variable: { pattern: /^(!?\[)[^\]]+/, lookbehind: true }, string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/, punctuation: /^[\[\]!:]|[<>]/ }, alias: "url" }, bold: { pattern: e(/\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source), lookbehind: true, greedy: true, inside: { content: { pattern: /(^..)[\s\S]+(?=..$)/, lookbehind: true, inside: {} }, punctuation: /\*\*|__/ } }, italic: { pattern: e(/\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source), lookbehind: true, greedy: true, inside: { content: { pattern: /(^.)[\s\S]+(?=.$)/, lookbehind: true, inside: {} }, punctuation: /[*_]/ } }, strike: { pattern: e(/(~~?)(?:(?!~)<inner>)+\2/.source), lookbehind: true, greedy: true, inside: { content: { pattern: /(^~~?)[\s\S]+(?=\1$)/, lookbehind: true, inside: {} }, punctuation: /~~?/ } }, "code-snippet": { pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/, lookbehind: true, greedy: true, alias: ["code", "keyword"] }, url: { pattern: e(/!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source), lookbehind: true, greedy: true, inside: { operator: /^!/, content: { pattern: /(^\[)[^\]]+(?=\])/, lookbehind: true, inside: {} }, variable: { pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/, lookbehind: true }, url: { pattern: /(^\]\()[^\s)]+/, lookbehind: true }, string: { pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/, lookbehind: true } } } }), ["url", "bold", "italic", "strike"].forEach(function(n2) {
|
||
["url", "bold", "italic", "strike", "code-snippet"].forEach(function(e2) {
|
||
n2 !== e2 && (o.languages.markdown[n2].inside.content.inside[e2] = o.languages.markdown[e2]);
|
||
});
|
||
}), o.hooks.add("after-tokenize", function(e2) {
|
||
"markdown" !== e2.language && "md" !== e2.language || !function e3(n2) {
|
||
if (n2 && "string" != typeof n2)
|
||
for (var t2 = 0, a2 = n2.length; t2 < a2; t2++) {
|
||
var r2, s = n2[t2];
|
||
"code" !== s.type ? e3(s.content) : (r2 = s.content[1], s = s.content[3], r2 && s && "code-language" === r2.type && "code-block" === s.type && "string" == typeof r2.content && (r2 = r2.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp"), r2 = "language-" + (r2 = (/[a-z][\w-]*/i.exec(r2) || [""])[0].toLowerCase()), s.alias ? "string" == typeof s.alias ? s.alias = [s.alias, r2] : s.alias.push(r2) : s.alias = [r2]));
|
||
}
|
||
}(e2.tokens);
|
||
}), o.hooks.add("wrap", function(e2) {
|
||
if ("code-block" === e2.type) {
|
||
for (var n2 = "", t2 = 0, a2 = e2.classes.length; t2 < a2; t2++) {
|
||
var r2 = e2.classes[t2], r2 = /language-(.+)/.exec(r2);
|
||
if (r2) {
|
||
n2 = r2[1];
|
||
break;
|
||
}
|
||
}
|
||
var s, i = o.languages[n2];
|
||
i ? e2.content = o.highlight(function(e3) {
|
||
e3 = e3.replace(l, "");
|
||
return e3 = e3.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function(e4, n3) {
|
||
var t3;
|
||
return "#" === (n3 = n3.toLowerCase())[0] ? (t3 = "x" === n3[1] ? parseInt(n3.slice(2), 16) : Number(n3.slice(1)), c(t3)) : u[n3] || e4;
|
||
});
|
||
}(e2.content), i, n2) : n2 && "none" !== n2 && o.plugins.autoloader && (s = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(1e16 * Math.random()), e2.attributes.id = s, o.plugins.autoloader.loadLanguages(n2, function() {
|
||
var e3 = document.getElementById(s);
|
||
e3 && (e3.innerHTML = o.highlight(e3.textContent, o.languages[n2], n2));
|
||
}));
|
||
}
|
||
}), RegExp(o.languages.markup.tag.pattern.source, "gi")), u = { amp: "&", lt: "<", gt: ">", quot: '"' }, c = String.fromCodePoint || String.fromCharCode;
|
||
o.languages.md = o.languages.markdown;
|
||
}(Prism), Prism.languages.graphql = { comment: /#.*/, description: { pattern: /(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i, greedy: true, alias: "string", inside: { "language-markdown": { pattern: /(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/, lookbehind: true, inside: Prism.languages.markdown } } }, string: { pattern: /"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*"/, greedy: true }, number: /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i, boolean: /\b(?:false|true)\b/, variable: /\$[a-z_]\w*/i, directive: { pattern: /@[a-z_]\w*/i, alias: "function" }, "attr-name": { pattern: /\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\"\r\n])*")*\))?:)/i, greedy: true }, "atom-input": { pattern: /\b[A-Z]\w*Input\b/, alias: "class-name" }, scalar: /\b(?:Boolean|Float|ID|Int|String)\b/, constant: /\b[A-Z][A-Z_\d]*\b/, "class-name": { pattern: /(\b(?:enum|implements|interface|on|scalar|type|union)\s+|&\s*|:\s*|\[)[A-Z_]\w*/, lookbehind: true }, fragment: { pattern: /(\bfragment\s+|\.{3}\s*(?!on\b))[a-zA-Z_]\w*/, lookbehind: true, alias: "function" }, "definition-mutation": { pattern: /(\bmutation\s+)[a-zA-Z_]\w*/, lookbehind: true, alias: "function" }, "definition-query": { pattern: /(\bquery\s+)[a-zA-Z_]\w*/, lookbehind: true, alias: "function" }, keyword: /\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\b/, operator: /[!=|&]|\.{3}/, "property-query": /\w+(?=\s*\()/, object: /\w+(?=\s*\{)/, punctuation: /[!(){}\[\]:=,]/, property: /\w+/ }, Prism.hooks.add("after-tokenize", function(e) {
|
||
if ("graphql" === e.language)
|
||
for (var i = e.tokens.filter(function(e2) {
|
||
return "string" != typeof e2 && "comment" !== e2.type && "scalar" !== e2.type;
|
||
}), o = 0; o < i.length; ) {
|
||
var n = i[o++];
|
||
if ("keyword" === n.type && "mutation" === n.content) {
|
||
var t = [];
|
||
if (p(["definition-mutation", "punctuation"]) && "(" === c(1).content) {
|
||
o += 2;
|
||
var a = d(/^\($/, /^\)$/);
|
||
if (-1 === a)
|
||
continue;
|
||
for (; o < a; o++) {
|
||
var r = c(0);
|
||
"variable" === r.type && (g(r, "variable-input"), t.push(r.content));
|
||
}
|
||
o = a + 1;
|
||
}
|
||
if (p(["punctuation", "property-query"]) && "{" === c(0).content && (o++, g(c(0), "property-mutation"), 0 < t.length)) {
|
||
var s = d(/^\{$/, /^\}$/);
|
||
if (-1 !== s)
|
||
for (var l = o; l < s; l++) {
|
||
var u = i[l];
|
||
"variable" === u.type && 0 <= t.indexOf(u.content) && g(u, "variable-input");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
function c(e2) {
|
||
return i[o + e2];
|
||
}
|
||
function p(e2, n2) {
|
||
n2 = n2 || 0;
|
||
for (var t2 = 0; t2 < e2.length; t2++) {
|
||
var a2 = c(t2 + n2);
|
||
if (!a2 || a2.type !== e2[t2])
|
||
return;
|
||
}
|
||
return 1;
|
||
}
|
||
function d(e2, n2) {
|
||
for (var t2 = 1, a2 = o; a2 < i.length; a2++) {
|
||
var r2 = i[a2], s2 = r2.content;
|
||
if ("punctuation" === r2.type && "string" == typeof s2) {
|
||
if (e2.test(s2))
|
||
t2++;
|
||
else if (n2.test(s2) && 0 === --t2)
|
||
return a2;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
function g(e2, n2) {
|
||
var t2 = e2.alias;
|
||
t2 ? Array.isArray(t2) || (e2.alias = t2 = [t2]) : e2.alias = t2 = [], t2.push(n2);
|
||
}
|
||
}), Prism.languages.sql = { comment: { pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/, lookbehind: true }, variable: [{ pattern: /@(["'`])(?:\\[\s\S]|(?!\1)[^\\])+\1/, greedy: true }, /@[\w.$]+/], string: { pattern: /(^|[^@\\])("|')(?:\\[\s\S]|(?!\2)[^\\]|\2\2)*\2/, greedy: true, lookbehind: true }, identifier: { pattern: /(^|[^@\\])`(?:\\[\s\S]|[^`\\]|``)*`/, greedy: true, lookbehind: true, inside: { punctuation: /^`|`$/ } }, function: /\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\s*\()/i, keyword: /\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR(?:ACTER|SET)?|CHECK(?:POINT)?|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMNS?|COMMENT|COMMIT(?:TED)?|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS(?:TABLE)?|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|CYCLE|DATA(?:BASES?)?|DATE(?:TIME)?|DAY|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITERS?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE|ELSE(?:IF)?|ENABLE|ENCLOSED|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPED?|EXCEPT|EXEC(?:UTE)?|EXISTS|EXIT|EXPLAIN|EXTENDED|FETCH|FIELDS|FILE|FILLFACTOR|FIRST|FIXED|FLOAT|FOLLOWING|FOR(?: EACH ROW)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|FROM|FULL|FUNCTION|GEOMETRY(?:COLLECTION)?|GLOBAL|GOTO|GRANT|GROUP|HANDLER|HASH|HAVING|HOLDLOCK|HOUR|IDENTITY(?:COL|_INSERT)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|ISOLATION|ITERATE|JOIN|KEYS?|KILL|LANGUAGE|LAST|LEAVE|LEFT|LEVEL|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|LOOP|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|NEXT|NO|NONCLUSTERED|NULLIF|NUMERIC|OFF?|OFFSETS?|ON|OPEN(?:DATASOURCE|QUERY|ROWSET)?|OPTIMIZE|OPTION(?:ALLY)?|ORDER|OUT(?:ER|FILE)?|OVER|PARTIAL|PARTITION|PERCENT|PIVOT|PLAN|POINT|POLYGON|PRECEDING|PRECISION|PREPARE|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READS?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEAT(?:ABLE)?|REPLACE|REPLICATION|REQUIRE|RESIGNAL|RESTORE|RESTRICT|RETURN(?:ING|S)?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\b/i, boolean: /\b(?:FALSE|NULL|TRUE)\b/i, number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i, operator: /[-+*\/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|DIV|ILIKE|IN|IS|LIKE|NOT|OR|REGEXP|RLIKE|SOUNDS LIKE|XOR)\b/i, punctuation: /[;[\]()`,.]/ }, function(b) {
|
||
var e = b.languages.javascript["template-string"], t = e.pattern.source, m = e.inside.interpolation, f = m.inside["interpolation-punctuation"], s = m.pattern.source;
|
||
function n(e2, n2) {
|
||
if (b.languages[e2])
|
||
return { pattern: RegExp("((?:" + n2 + ")\\s*)" + t), lookbehind: true, greedy: true, inside: { "template-punctuation": { pattern: /^`|`$/, alias: "string" }, "embedded-code": { pattern: /[\s\S]+/, alias: e2 } } };
|
||
}
|
||
function h(e2, n2, t2) {
|
||
e2 = { code: e2, grammar: n2, language: t2 };
|
||
return b.hooks.run("before-tokenize", e2), e2.tokens = b.tokenize(e2.code, e2.grammar), b.hooks.run("after-tokenize", e2), e2.tokens;
|
||
}
|
||
function l(a2, e2, r) {
|
||
var n2 = b.tokenize(a2, { interpolation: { pattern: RegExp(s), lookbehind: true } }), p = 0, d = {}, n2 = h(n2.map(function(e3) {
|
||
if ("string" == typeof e3)
|
||
return e3;
|
||
for (var n3, t2, e3 = e3.content; -1 !== a2.indexOf((t2 = p++, n3 = "___" + r.toUpperCase() + "_" + t2 + "___")); )
|
||
;
|
||
return d[n3] = e3, n3;
|
||
}).join(""), e2, r), g = Object.keys(d);
|
||
return p = 0, function e3(n3) {
|
||
for (var t2 = 0; t2 < n3.length; t2++) {
|
||
if (p >= g.length)
|
||
return;
|
||
var a3, r2, s2, i, o, l2, u2, c = n3[t2];
|
||
"string" == typeof c || "string" == typeof c.content ? (a3 = g[p], -1 !== (u2 = (l2 = "string" == typeof c ? c : c.content).indexOf(a3)) && (++p, r2 = l2.substring(0, u2), o = d[a3], s2 = void 0, (i = {})["interpolation-punctuation"] = f, 3 === (i = b.tokenize(o, i)).length && ((s2 = [1, 1]).push.apply(s2, h(i[1], b.languages.javascript, "javascript")), i.splice.apply(i, s2)), s2 = new b.Token("interpolation", i, m.alias, o), i = l2.substring(u2 + a3.length), o = [], r2 && o.push(r2), o.push(s2), i && (e3(l2 = [i]), o.push.apply(o, l2)), "string" == typeof c ? (n3.splice.apply(n3, [t2, 1].concat(o)), t2 += o.length - 1) : c.content = o)) : (u2 = c.content, Array.isArray(u2) ? e3(u2) : e3([u2]));
|
||
}
|
||
}(n2), new b.Token(r, n2, "language-" + r, a2);
|
||
}
|
||
b.languages.javascript["template-string"] = [n("css", /\b(?:styled(?:\([^)]*\))?(?:\s*\.\s*\w+(?:\([^)]*\))*)*|css(?:\s*\.\s*(?:global|resolve))?|createGlobalStyle|keyframes)/.source), n("html", /\bhtml|\.\s*(?:inner|outer)HTML\s*\+?=/.source), n("svg", /\bsvg/.source), n("markdown", /\b(?:markdown|md)/.source), n("graphql", /\b(?:gql|graphql(?:\s*\.\s*experimental)?)/.source), n("sql", /\bsql/.source), e].filter(Boolean);
|
||
var a = { javascript: true, js: true, typescript: true, ts: true, jsx: true, tsx: true };
|
||
function u(e2) {
|
||
return "string" == typeof e2 ? e2 : Array.isArray(e2) ? e2.map(u).join("") : u(e2.content);
|
||
}
|
||
b.hooks.add("after-tokenize", function(e2) {
|
||
e2.language in a && !function e3(n2) {
|
||
for (var t2 = 0, a2 = n2.length; t2 < a2; t2++) {
|
||
var r, s2, i, o = n2[t2];
|
||
"string" != typeof o && (r = o.content, Array.isArray(r) ? "template-string" === o.type ? (o = r[1], 3 === r.length && "string" != typeof o && "embedded-code" === o.type && (s2 = u(o), o = o.alias, o = Array.isArray(o) ? o[0] : o, i = b.languages[o]) && (r[1] = l(s2, i, o))) : e3(r) : "string" != typeof r && e3([r]));
|
||
}
|
||
}(e2.tokens);
|
||
});
|
||
}(Prism), function(e) {
|
||
e.languages.typescript = e.languages.extend("javascript", { "class-name": { pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/, lookbehind: true, greedy: true, inside: null }, builtin: /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/ }), e.languages.typescript.keyword.push(/\b(?:abstract|declare|is|keyof|readonly|require)\b/, /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/, /\btype\b(?=\s*(?:[\{*]|$))/), delete e.languages.typescript.parameter, delete e.languages.typescript["literal-property"];
|
||
var n = e.languages.extend("typescript", {});
|
||
delete n["class-name"], e.languages.typescript["class-name"].inside = n, e.languages.insertBefore("typescript", "function", { decorator: { pattern: /@[$\w\xA0-\uFFFF]+/, inside: { at: { pattern: /^@/, alias: "operator" }, function: /^[\s\S]+/ } }, "generic-function": { pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/, greedy: true, inside: { function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/, generic: { pattern: /<[\s\S]+/, alias: "class-name", inside: n } } } }), e.languages.ts = e.languages.typescript;
|
||
}(Prism), function(e) {
|
||
var n = e.languages.javascript, t = /\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})+\}/.source, a = "(@(?:arg|argument|param|property)\\s+(?:" + t + "\\s+)?)";
|
||
e.languages.jsdoc = e.languages.extend("javadoclike", { parameter: { pattern: RegExp(a + /(?:(?!\s)[$\w\xA0-\uFFFF.])+(?=\s|$)/.source), lookbehind: true, inside: { punctuation: /\./ } } }), e.languages.insertBefore("jsdoc", "keyword", { "optional-parameter": { pattern: RegExp(a + /\[(?:(?!\s)[$\w\xA0-\uFFFF.])+(?:=[^[\]]+)?\](?=\s|$)/.source), lookbehind: true, inside: { parameter: { pattern: /(^\[)[$\w\xA0-\uFFFF\.]+/, lookbehind: true, inside: { punctuation: /\./ } }, code: { pattern: /(=)[\s\S]*(?=\]$)/, lookbehind: true, inside: n, alias: "language-javascript" }, punctuation: /[=[\]]/ } }, "class-name": [{ pattern: RegExp(/(@(?:augments|class|extends|interface|memberof!?|template|this|typedef)\s+(?:<TYPE>\s+)?)[A-Z]\w*(?:\.[A-Z]\w*)*/.source.replace(/<TYPE>/g, function() {
|
||
return t;
|
||
})), lookbehind: true, inside: { punctuation: /\./ } }, { pattern: RegExp("(@[a-z]+\\s+)" + t), lookbehind: true, inside: { string: n.string, number: n.number, boolean: n.boolean, keyword: e.languages.typescript.keyword, operator: /=>|\.\.\.|[&|?:*]/, punctuation: /[.,;=<>{}()[\]]/ } }], example: { pattern: /(@example\s+(?!\s))(?:[^@\s]|\s+(?!\s))+?(?=\s*(?:\*\s*)?(?:@\w|\*\/))/, lookbehind: true, inside: { code: { pattern: /^([\t ]*(?:\*\s*)?)\S.*$/m, lookbehind: true, inside: n, alias: "language-javascript" } } } }), e.languages.javadoclike.addSupport("javascript", e.languages.jsdoc);
|
||
}(Prism), function(e) {
|
||
e.languages.flow = e.languages.extend("javascript", {}), e.languages.insertBefore("flow", "keyword", { type: [{ pattern: /\b(?:[Bb]oolean|Function|[Nn]umber|[Ss]tring|[Ss]ymbol|any|mixed|null|void)\b/, alias: "class-name" }] }), e.languages.flow["function-variable"].pattern = /(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=\s*(?:function\b|(?:\([^()]*\)(?:\s*:\s*\w+)?|(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/i, delete e.languages.flow.parameter, e.languages.insertBefore("flow", "operator", { "flow-punctuation": { pattern: /\{\||\|\}/, alias: "punctuation" } }), Array.isArray(e.languages.flow.keyword) || (e.languages.flow.keyword = [e.languages.flow.keyword]), e.languages.flow.keyword.unshift({ pattern: /(^|[^$]\b)(?:Class|declare|opaque|type)\b(?!\$)/, lookbehind: true }, { pattern: /(^|[^$]\B)\$(?:Diff|Enum|Exact|Keys|ObjMap|PropertyType|Record|Shape|Subtype|Supertype|await)\b(?!\$)/, lookbehind: true });
|
||
}(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: { pattern: /@+\w+/, alias: "operator" } }), Prism.languages.n4jsd = Prism.languages.n4js, function(e) {
|
||
function n(e2, n2) {
|
||
return RegExp(e2.replace(/<ID>/g, function() {
|
||
return /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/.source;
|
||
}), n2);
|
||
}
|
||
e.languages.insertBefore("javascript", "function-variable", { "method-variable": { pattern: RegExp("(\\.\\s*)" + e.languages.javascript["function-variable"].pattern.source), lookbehind: true, alias: ["function-variable", "method", "function", "property-access"] } }), e.languages.insertBefore("javascript", "function", { method: { pattern: RegExp("(\\.\\s*)" + e.languages.javascript.function.source), lookbehind: true, alias: ["function", "property-access"] } }), e.languages.insertBefore("javascript", "constant", { "known-class-name": [{ pattern: /\b(?:(?:Float(?:32|64)|(?:Int|Uint)(?:8|16|32)|Uint8Clamped)?Array|ArrayBuffer|BigInt|Boolean|DataView|Date|Error|Function|Intl|JSON|(?:Weak)?(?:Map|Set)|Math|Number|Object|Promise|Proxy|Reflect|RegExp|String|Symbol|WebAssembly)\b/, alias: "class-name" }, { pattern: /\b(?:[A-Z]\w*)Error\b/, alias: "class-name" }] }), e.languages.insertBefore("javascript", "keyword", { imports: { pattern: n(/(\bimport\b\s*)(?:<ID>(?:\s*,\s*(?:\*\s*as\s+<ID>|\{[^{}]*\}))?|\*\s*as\s+<ID>|\{[^{}]*\})(?=\s*\bfrom\b)/.source), lookbehind: true, inside: e.languages.javascript }, exports: { pattern: n(/(\bexport\b\s*)(?:\*(?:\s*as\s+<ID>)?(?=\s*\bfrom\b)|\{[^{}]*\})/.source), lookbehind: true, inside: e.languages.javascript } }), e.languages.javascript.keyword.unshift({ pattern: /\b(?:as|default|export|from|import)\b/, alias: "module" }, { pattern: /\b(?:await|break|catch|continue|do|else|finally|for|if|return|switch|throw|try|while|yield)\b/, alias: "control-flow" }, { pattern: /\bnull\b/, alias: ["null", "nil"] }, { pattern: /\bundefined\b/, alias: "nil" }), e.languages.insertBefore("javascript", "operator", { spread: { pattern: /\.{3}/, alias: "operator" }, arrow: { pattern: /=>/, alias: "operator" } }), e.languages.insertBefore("javascript", "punctuation", { "property-access": { pattern: n(/(\.\s*)#?<ID>/.source), lookbehind: true }, "maybe-class-name": { pattern: /(^|[^$\w\xA0-\uFFFF])[A-Z][$\w\xA0-\uFFFF]+/, lookbehind: true }, dom: { pattern: /\b(?:document|(?:local|session)Storage|location|navigator|performance|window)\b/, alias: "variable" }, console: { pattern: /\bconsole(?=\s*\.)/, alias: "class-name" } });
|
||
for (var t = ["function", "function-variable", "method", "method-variable", "property-access"], a = 0; a < t.length; a++) {
|
||
var r = t[a], s = e.languages.javascript[r], r = (s = "RegExp" === e.util.type(s) ? e.languages.javascript[r] = { pattern: s } : s).inside || {};
|
||
(s.inside = r)["maybe-class-name"] = /^[A-Z][\s\S]*/;
|
||
}
|
||
}(Prism), function(s) {
|
||
var e = s.util.clone(s.languages.javascript), t = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source, a = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source, r = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source;
|
||
function n(e2, n2) {
|
||
return e2 = e2.replace(/<S>/g, function() {
|
||
return t;
|
||
}).replace(/<BRACES>/g, function() {
|
||
return a;
|
||
}).replace(/<SPREAD>/g, function() {
|
||
return r;
|
||
}), RegExp(e2, n2);
|
||
}
|
||
r = n(r).source, s.languages.jsx = s.languages.extend("markup", e), s.languages.jsx.tag.pattern = n(/<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/.source), s.languages.jsx.tag.inside.tag.pattern = /^<\/?[^\s>\/]*/, s.languages.jsx.tag.inside["attr-value"].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/, s.languages.jsx.tag.inside.tag.inside["class-name"] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/, s.languages.jsx.tag.inside.comment = e.comment, s.languages.insertBefore("inside", "attr-name", { spread: { pattern: n(/<SPREAD>/.source), inside: s.languages.jsx } }, s.languages.jsx.tag), s.languages.insertBefore("inside", "special-attr", { script: { pattern: n(/=<BRACES>/.source), alias: "language-javascript", inside: { "script-punctuation": { pattern: /^=(?=\{)/, alias: "punctuation" }, rest: s.languages.jsx } } }, s.languages.jsx.tag);
|
||
function i(e2) {
|
||
for (var n2 = [], t2 = 0; t2 < e2.length; t2++) {
|
||
var a2 = e2[t2], r2 = false;
|
||
"string" != typeof a2 && ("tag" === a2.type && a2.content[0] && "tag" === a2.content[0].type ? "</" === a2.content[0].content[0].content ? 0 < n2.length && n2[n2.length - 1].tagName === o(a2.content[0].content[1]) && n2.pop() : "/>" !== a2.content[a2.content.length - 1].content && n2.push({ tagName: o(a2.content[0].content[1]), openedBraces: 0 }) : 0 < n2.length && "punctuation" === a2.type && "{" === a2.content ? n2[n2.length - 1].openedBraces++ : 0 < n2.length && 0 < n2[n2.length - 1].openedBraces && "punctuation" === a2.type && "}" === a2.content ? n2[n2.length - 1].openedBraces-- : r2 = true), (r2 || "string" == typeof a2) && 0 < n2.length && 0 === n2[n2.length - 1].openedBraces && (r2 = o(a2), t2 < e2.length - 1 && ("string" == typeof e2[t2 + 1] || "plain-text" === e2[t2 + 1].type) && (r2 += o(e2[t2 + 1]), e2.splice(t2 + 1, 1)), 0 < t2 && ("string" == typeof e2[t2 - 1] || "plain-text" === e2[t2 - 1].type) && (r2 = o(e2[t2 - 1]) + r2, e2.splice(t2 - 1, 1), t2--), e2[t2] = new s.Token("plain-text", r2, null, r2)), a2.content && "string" != typeof a2.content && i(a2.content);
|
||
}
|
||
}
|
||
var o = function(e2) {
|
||
return e2 ? "string" == typeof e2 ? e2 : "string" == typeof e2.content ? e2.content : e2.content.map(o).join("") : "";
|
||
};
|
||
s.hooks.add("after-tokenize", function(e2) {
|
||
"jsx" !== e2.language && "tsx" !== e2.language || i(e2.tokens);
|
||
});
|
||
}(Prism), function(e) {
|
||
var n = e.util.clone(e.languages.typescript), n = (e.languages.tsx = e.languages.extend("jsx", n), delete e.languages.tsx.parameter, delete e.languages.tsx["literal-property"], e.languages.tsx.tag);
|
||
n.pattern = RegExp(/(^|[^\w$]|(?=<\/))/.source + "(?:" + n.pattern.source + ")", n.pattern.flags), n.lookbehind = true;
|
||
}(Prism), Prism.languages.swift = { comment: { pattern: /(^|[^\\:])(?:\/\/.*|\/\*(?:[^/*]|\/(?!\*)|\*(?!\/)|\/\*(?:[^*]|\*(?!\/))*\*\/)*\*\/)/, lookbehind: true, greedy: true }, "string-literal": [{ pattern: RegExp(/(^|[^"#])/.source + "(?:" + /"(?:\\(?:\((?:[^()]|\([^()]*\))*\)|\r\n|[^(])|[^\\\r\n"])*"/.source + "|" + /"""(?:\\(?:\((?:[^()]|\([^()]*\))*\)|[^(])|[^\\"]|"(?!""))*"""/.source + ")" + /(?!["#])/.source), lookbehind: true, greedy: true, inside: { interpolation: { pattern: /(\\\()(?:[^()]|\([^()]*\))*(?=\))/, lookbehind: true, inside: null }, "interpolation-punctuation": { pattern: /^\)|\\\($/, alias: "punctuation" }, punctuation: /\\(?=[\r\n])/, string: /[\s\S]+/ } }, { pattern: RegExp(/(^|[^"#])(#+)/.source + "(?:" + /"(?:\\(?:#+\((?:[^()]|\([^()]*\))*\)|\r\n|[^#])|[^\\\r\n])*?"/.source + "|" + /"""(?:\\(?:#+\((?:[^()]|\([^()]*\))*\)|[^#])|[^\\])*?"""/.source + ")\\2"), lookbehind: true, greedy: true, inside: { interpolation: { pattern: /(\\#+\()(?:[^()]|\([^()]*\))*(?=\))/, lookbehind: true, inside: null }, "interpolation-punctuation": { pattern: /^\)|\\#+\($/, alias: "punctuation" }, string: /[\s\S]+/ } }], directive: { pattern: RegExp(/#/.source + "(?:" + /(?:elseif|if)\b/.source + "(?:[ ]*" + /(?:![ \t]*)?(?:\b\w+\b(?:[ \t]*\((?:[^()]|\([^()]*\))*\))?|\((?:[^()]|\([^()]*\))*\))(?:[ \t]*(?:&&|\|\|))?/.source + ")+|" + /(?:else|endif)\b/.source + ")"), alias: "property", inside: { "directive-name": /^#\w+/, boolean: /\b(?:false|true)\b/, number: /\b\d+(?:\.\d+)*\b/, operator: /!|&&|\|\||[<>]=?/, punctuation: /[(),]/ } }, literal: { pattern: /#(?:colorLiteral|column|dsohandle|file(?:ID|Literal|Path)?|function|imageLiteral|line)\b/, alias: "constant" }, "other-directive": { pattern: /#\w+\b/, alias: "property" }, attribute: { pattern: /@\w+/, alias: "atrule" }, "function-definition": { pattern: /(\bfunc\s+)\w+/, lookbehind: true, alias: "function" }, label: { pattern: /\b(break|continue)\s+\w+|\b[a-zA-Z_]\w*(?=\s*:\s*(?:for|repeat|while)\b)/, lookbehind: true, alias: "important" }, keyword: /\b(?:Any|Protocol|Self|Type|actor|as|assignment|associatedtype|associativity|async|await|break|case|catch|class|continue|convenience|default|defer|deinit|didSet|do|dynamic|else|enum|extension|fallthrough|fileprivate|final|for|func|get|guard|higherThan|if|import|in|indirect|infix|init|inout|internal|is|isolated|lazy|left|let|lowerThan|mutating|none|nonisolated|nonmutating|open|operator|optional|override|postfix|precedencegroup|prefix|private|protocol|public|repeat|required|rethrows|return|right|safe|self|set|some|static|struct|subscript|super|switch|throw|throws|try|typealias|unowned|unsafe|var|weak|where|while|willSet)\b/, boolean: /\b(?:false|true)\b/, nil: { pattern: /\bnil\b/, alias: "constant" }, "short-argument": /\$\d+\b/, omit: { pattern: /\b_\b/, alias: "keyword" }, number: /\b(?:[\d_]+(?:\.[\de_]+)?|0x[a-f0-9_]+(?:\.[a-f0-9p_]+)?|0b[01_]+|0o[0-7_]+)\b/i, "class-name": /\b[A-Z](?:[A-Z_\d]*[a-z]\w*)?\b/, function: /\b[a-z_]\w*(?=\s*\()/i, constant: /\b(?:[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\b/, operator: /[-+*/%=!<>&|^~?]+|\.[.\-+*/%=!<>&|^~?]+/, punctuation: /[{}[\]();,.:\\]/ }, Prism.languages.swift["string-literal"].forEach(function(e) {
|
||
e.inside.interpolation.inside = Prism.languages.swift;
|
||
}), function(e) {
|
||
e.languages.kotlin = e.languages.extend("clike", { keyword: { pattern: /(^|[^.])\b(?:abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|dynamic|else|enum|expect|external|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|to|try|typealias|val|var|vararg|when|where|while)\b/, lookbehind: true }, function: [{ pattern: /(?:`[^\r\n`]+`|\b\w+)(?=\s*\()/, greedy: true }, { pattern: /(\.)(?:`[^\r\n`]+`|\w+)(?=\s*\{)/, lookbehind: true, greedy: true }], number: /\b(?:0[xX][\da-fA-F]+(?:_[\da-fA-F]+)*|0[bB][01]+(?:_[01]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?[fFL]?)\b/, operator: /\+[+=]?|-[-=>]?|==?=?|!(?:!|==?)?|[\/*%<>]=?|[?:]:?|\.\.|&&|\|\||\b(?:and|inv|or|shl|shr|ushr|xor)\b/ }), delete e.languages.kotlin["class-name"];
|
||
var n = { "interpolation-punctuation": { pattern: /^\$\{?|\}$/, alias: "punctuation" }, expression: { pattern: /[\s\S]+/, inside: e.languages.kotlin } };
|
||
e.languages.insertBefore("kotlin", "string", { "string-literal": [{ pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/, alias: "multiline", inside: { interpolation: { pattern: /\$(?:[a-z_]\w*|\{[^{}]*\})/i, inside: n }, string: /[\s\S]+/ } }, { pattern: /"(?:[^"\\\r\n$]|\\.|\$(?:(?!\{)|\{[^{}]*\}))*"/, alias: "singleline", inside: { interpolation: { pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:[a-z_]\w*|\{[^{}]*\})/i, lookbehind: true, inside: n }, string: /[\s\S]+/ } }], char: { pattern: /'(?:[^'\\\r\n]|\\(?:.|u[a-fA-F0-9]{0,4}))'/, greedy: true } }), delete e.languages.kotlin.string, e.languages.insertBefore("kotlin", "keyword", { annotation: { pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/, alias: "builtin" } }), e.languages.insertBefore("kotlin", "function", { label: { pattern: /\b\w+@|@\w+\b/, alias: "symbol" } }), e.languages.kt = e.languages.kotlin, e.languages.kts = e.languages.kotlin;
|
||
}(Prism), Prism.languages.c = Prism.languages.extend("clike", { comment: { pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/, greedy: true }, string: { pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/, greedy: true }, "class-name": { pattern: /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/, lookbehind: true }, keyword: /\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\b/, function: /\b[a-z_]\w*(?=\s*\()/i, number: /(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i, operator: />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/ }), Prism.languages.insertBefore("c", "string", { char: { pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/, greedy: true } }), Prism.languages.insertBefore("c", "string", { macro: { pattern: /(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im, lookbehind: true, greedy: true, alias: "property", inside: { string: [{ pattern: /^(#\s*include\s*)<[^>]+>/, lookbehind: true }, Prism.languages.c.string], char: Prism.languages.c.char, comment: Prism.languages.c.comment, "macro-name": [{ pattern: /(^#\s*define\s+)\w+\b(?!\()/i, lookbehind: true }, { pattern: /(^#\s*define\s+)\w+\b(?=\()/i, lookbehind: true, alias: "function" }], directive: { pattern: /^(#\s*)[a-z]+/, lookbehind: true, alias: "keyword" }, "directive-hash": /^#/, punctuation: /##|\\(?=[\r\n])/, expression: { pattern: /\S[\s\S]*/, inside: Prism.languages.c } } } }), 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, Prism.languages.objectivec = Prism.languages.extend("c", { string: { pattern: /@?"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/, greedy: true }, 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/, operator: /-[->]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|\|?|[~^%?*\/@]/ }), delete Prism.languages.objectivec["class-name"], Prism.languages.objc = Prism.languages.objectivec, Prism.languages.reason = Prism.languages.extend("clike", { string: { pattern: /"(?:\\(?:\r\n|[\s\S])|[^\\\r\n"])*"/, greedy: true }, "class-name": /\b[A-Z]\w*/, 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/, operator: /\.{3}|:[:=]|\|>|->|=(?:==?|>)?|<=?|>=?|[|^?'#!~`]|[+\-*\/]\.?|\b(?:asr|land|lor|lsl|lsr|lxor|mod)\b/ }), Prism.languages.insertBefore("reason", "class-name", { char: { pattern: /'(?:\\x[\da-f]{2}|\\o[0-3][0-7][0-7]|\\\d{3}|\\.|[^'\\\r\n])'/, greedy: true }, constructor: /\b[A-Z]\w*\b(?!\s*\.)/, label: { pattern: /\b[a-z]\w*(?=::)/, alias: "symbol" } }), delete Prism.languages.reason.function, function(e) {
|
||
for (var n = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source, t = 0; t < 2; t++)
|
||
n = n.replace(/<self>/g, function() {
|
||
return n;
|
||
});
|
||
n = n.replace(/<self>/g, function() {
|
||
return /[^\s\S]/.source;
|
||
}), e.languages.rust = { comment: [{ pattern: RegExp(/(^|[^\\])/.source + n), lookbehind: true, greedy: true }, { pattern: /(^|[^\\:])\/\/.*/, lookbehind: true, greedy: true }], string: { pattern: /b?"(?:\\[\s\S]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/, greedy: true }, char: { pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u\{(?:[\da-fA-F]_*){1,6}\}|.)|[^\\\r\n\t'])'/, greedy: true }, attribute: { pattern: /#!?\[(?:[^\[\]"]|"(?:\\[\s\S]|[^\\"])*")*\]/, greedy: true, alias: "attr-name", inside: { string: null } }, "closure-params": { pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/, lookbehind: true, greedy: true, inside: { "closure-punctuation": { pattern: /^\||\|$/, alias: "punctuation" }, rest: null } }, "lifetime-annotation": { pattern: /'\w+/, alias: "symbol" }, "fragment-specifier": { pattern: /(\$\w+:)[a-z]+/, lookbehind: true, alias: "punctuation" }, variable: /\$\w+/, "function-definition": { pattern: /(\bfn\s+)\w+/, lookbehind: true, alias: "function" }, "type-definition": { pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/, lookbehind: true, alias: "class-name" }, "module-declaration": [{ pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/, lookbehind: true, alias: "namespace" }, { pattern: /(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/, lookbehind: true, alias: "namespace", inside: { punctuation: /::/ } }], keyword: [/\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\b/, /\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/], function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())/, macro: { pattern: /\b\w+!/, alias: "property" }, constant: /\b[A-Z_][A-Z_\d]+\b/, "class-name": /\b[A-Z]\w*\b/, namespace: { pattern: /(?:\b[a-z][a-z_\d]*\s*::\s*)*\b[a-z][a-z_\d]*\s*::(?!\s*<)/, inside: { punctuation: /::/ } }, number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/, boolean: /\b(?:false|true)\b/, punctuation: /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/, operator: /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/ }, e.languages.rust["closure-params"].inside.rest = e.languages.rust, e.languages.rust.attribute.inside.string = e.languages.rust.string;
|
||
}(Prism), Prism.languages.go = Prism.languages.extend("clike", { string: { pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"|`[^`]*`/, lookbehind: true, greedy: true }, keyword: /\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(?:to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/, boolean: /\b(?:_|false|iota|nil|true)\b/, number: [/\b0(?:b[01_]+|o[0-7_]+)i?\b/i, /\b0x(?:[a-f\d_]+(?:\.[a-f\d_]*)?|\.[a-f\d_]+)(?:p[+-]?\d+(?:_\d+)*)?i?(?!\w)/i, /(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?[\d_]+)?i?(?!\w)/i], operator: /[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\./, 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/ }), Prism.languages.insertBefore("go", "string", { char: { pattern: /'(?:\\.|[^'\\\r\n]){0,10}'/, greedy: true } }), delete Prism.languages.go["class-name"], function(e) {
|
||
var n = /\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/, t = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(/<keyword>/g, function() {
|
||
return n.source;
|
||
});
|
||
e.languages.cpp = e.languages.extend("c", { "class-name": [{ pattern: RegExp(/(\b(?:class|concept|enum|struct|typename)\s+)(?!<keyword>)\w+/.source.replace(/<keyword>/g, function() {
|
||
return n.source;
|
||
})), lookbehind: true }, /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/, /\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i, /\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/], keyword: n, number: { pattern: /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i, greedy: true }, operator: />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/, boolean: /\b(?:false|true)\b/ }), e.languages.insertBefore("cpp", "string", { module: { pattern: RegExp(/(\b(?:import|module)\s+)/.source + "(?:" + /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source + "|" + /<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(/<mod-name>/g, function() {
|
||
return t;
|
||
}) + ")"), lookbehind: true, greedy: true, inside: { string: /^[<"][\s\S]+/, operator: /:/, punctuation: /\./ } }, "raw-string": { pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/, alias: "string", greedy: true } }), e.languages.insertBefore("cpp", "keyword", { "generic-function": { pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i, inside: { function: /^\w+/, generic: { pattern: /<[\s\S]+/, alias: "class-name", inside: e.languages.cpp } } } }), e.languages.insertBefore("cpp", "operator", { "double-colon": { pattern: /::/, alias: "punctuation" } }), e.languages.insertBefore("cpp", "class-name", { "base-clause": { pattern: /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/, lookbehind: true, greedy: true, inside: e.languages.extend("cpp", {}) } }), e.languages.insertBefore("inside", "double-colon", { "class-name": /\b[a-z_]\w*\b(?!\s*::)/i }, e.languages.cpp["base-clause"]);
|
||
}(Prism), Prism.languages.python = { comment: { pattern: /(^|[^\\])#.*/, lookbehind: true, greedy: true }, "string-interpolation": { pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i, greedy: true, inside: { interpolation: { pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/, lookbehind: true, inside: { "format-spec": { pattern: /(:)[^:(){}]+(?=\}$)/, lookbehind: true }, "conversion-option": { pattern: //, alias: "punctuation" }, rest: null } }, string: /[\s\S]+/ } }, "triple-quoted-string": { pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i, greedy: true, alias: "string" }, string: { pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i, greedy: true }, function: { pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g, lookbehind: true }, "class-name": { pattern: /(\bclass\s+)\w+/i, lookbehind: true }, decorator: { pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m, lookbehind: true, alias: ["annotation", "punctuation"], inside: { punctuation: /\./ } }, keyword: /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/, builtin: /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/, boolean: /\b(?:False|None|True)\b/, 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, operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/, punctuation: /[{}[\];(),.:]/ }, Prism.languages.python["string-interpolation"].inside.interpolation.inside.rest = Prism.languages.python, Prism.languages.py = Prism.languages.python;
|
||
|
||
// src/themes/index.ts
|
||
var themes_exports = {};
|
||
__export(themes_exports, {
|
||
dracula: () => dracula_default,
|
||
duotoneDark: () => duotoneDark_default,
|
||
duotoneLight: () => duotoneLight_default,
|
||
github: () => github_default,
|
||
jettwaveDark: () => jettwaveDark_default,
|
||
jettwaveLight: () => jettwaveLight_default,
|
||
nightOwl: () => nightOwl_default,
|
||
nightOwlLight: () => nightOwlLight_default,
|
||
oceanicNext: () => oceanicNext_default,
|
||
okaidia: () => okaidia_default,
|
||
oneDark: () => oneDark_default,
|
||
oneLight: () => oneLight_default,
|
||
palenight: () => palenight_default,
|
||
shadesOfPurple: () => shadesOfPurple_default,
|
||
synthwave84: () => synthwave84_default,
|
||
ultramin: () => ultramin_default,
|
||
vsDark: () => vsDark_default,
|
||
vsLight: () => vsLight_default
|
||
});
|
||
|
||
// src/themes/dracula.ts
|
||
var theme = {
|
||
plain: {
|
||
color: "#F8F8F2",
|
||
backgroundColor: "#282A36"
|
||
},
|
||
styles: [
|
||
{
|
||
types: ["prolog", "constant", "builtin"],
|
||
style: {
|
||
color: "rgb(189, 147, 249)"
|
||
}
|
||
},
|
||
{
|
||
types: ["inserted", "function"],
|
||
style: {
|
||
color: "rgb(80, 250, 123)"
|
||
}
|
||
},
|
||
{
|
||
types: ["deleted"],
|
||
style: {
|
||
color: "rgb(255, 85, 85)"
|
||
}
|
||
},
|
||
{
|
||
types: ["changed"],
|
||
style: {
|
||
color: "rgb(255, 184, 108)"
|
||
}
|
||
},
|
||
{
|
||
types: ["punctuation", "symbol"],
|
||
style: {
|
||
color: "rgb(248, 248, 242)"
|
||
}
|
||
},
|
||
{
|
||
types: ["string", "char", "tag", "selector"],
|
||
style: {
|
||
color: "rgb(255, 121, 198)"
|
||
}
|
||
},
|
||
{
|
||
types: ["keyword", "variable"],
|
||
style: {
|
||
color: "rgb(189, 147, 249)",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["comment"],
|
||
style: {
|
||
color: "rgb(98, 114, 164)"
|
||
}
|
||
},
|
||
{
|
||
types: ["attr-name"],
|
||
style: {
|
||
color: "rgb(241, 250, 140)"
|
||
}
|
||
}
|
||
]
|
||
};
|
||
var dracula_default = theme;
|
||
|
||
// src/themes/duotoneDark.ts
|
||
var theme2 = {
|
||
plain: {
|
||
backgroundColor: "#2a2734",
|
||
color: "#9a86fd"
|
||
},
|
||
styles: [
|
||
{
|
||
types: ["comment", "prolog", "doctype", "cdata", "punctuation"],
|
||
style: {
|
||
color: "#6c6783"
|
||
}
|
||
},
|
||
{
|
||
types: ["namespace"],
|
||
style: {
|
||
opacity: 0.7
|
||
}
|
||
},
|
||
{
|
||
types: ["tag", "operator", "number"],
|
||
style: {
|
||
color: "#e09142"
|
||
}
|
||
},
|
||
{
|
||
types: ["property", "function"],
|
||
style: {
|
||
color: "#9a86fd"
|
||
}
|
||
},
|
||
{
|
||
types: ["tag-id", "selector", "atrule-id"],
|
||
style: {
|
||
color: "#eeebff"
|
||
}
|
||
},
|
||
{
|
||
types: ["attr-name"],
|
||
style: {
|
||
color: "#c4b9fe"
|
||
}
|
||
},
|
||
{
|
||
types: [
|
||
"boolean",
|
||
"string",
|
||
"entity",
|
||
"url",
|
||
"attr-value",
|
||
"keyword",
|
||
"control",
|
||
"directive",
|
||
"unit",
|
||
"statement",
|
||
"regex",
|
||
"atrule",
|
||
"placeholder",
|
||
"variable"
|
||
],
|
||
style: {
|
||
color: "#ffcc99"
|
||
}
|
||
},
|
||
{
|
||
types: ["deleted"],
|
||
style: {
|
||
textDecorationLine: "line-through"
|
||
}
|
||
},
|
||
{
|
||
types: ["inserted"],
|
||
style: {
|
||
textDecorationLine: "underline"
|
||
}
|
||
},
|
||
{
|
||
types: ["italic"],
|
||
style: {
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["important", "bold"],
|
||
style: {
|
||
fontWeight: "bold"
|
||
}
|
||
},
|
||
{
|
||
types: ["important"],
|
||
style: {
|
||
color: "#c4b9fe"
|
||
}
|
||
}
|
||
]
|
||
};
|
||
var duotoneDark_default = theme2;
|
||
|
||
// src/themes/duotoneLight.ts
|
||
var theme3 = {
|
||
plain: {
|
||
backgroundColor: "#faf8f5",
|
||
color: "#728fcb"
|
||
},
|
||
styles: [
|
||
{
|
||
types: ["comment", "prolog", "doctype", "cdata", "punctuation"],
|
||
style: {
|
||
color: "#b6ad9a"
|
||
}
|
||
},
|
||
{
|
||
types: ["namespace"],
|
||
style: {
|
||
opacity: 0.7
|
||
}
|
||
},
|
||
{
|
||
types: ["tag", "operator", "number"],
|
||
style: {
|
||
color: "#063289"
|
||
}
|
||
},
|
||
{
|
||
types: ["property", "function"],
|
||
style: {
|
||
color: "#b29762"
|
||
}
|
||
},
|
||
{
|
||
types: ["tag-id", "selector", "atrule-id"],
|
||
style: {
|
||
color: "#2d2006"
|
||
}
|
||
},
|
||
{
|
||
types: ["attr-name"],
|
||
style: {
|
||
color: "#896724"
|
||
}
|
||
},
|
||
{
|
||
types: [
|
||
"boolean",
|
||
"string",
|
||
"entity",
|
||
"url",
|
||
"attr-value",
|
||
"keyword",
|
||
"control",
|
||
"directive",
|
||
"unit",
|
||
"statement",
|
||
"regex",
|
||
"atrule"
|
||
],
|
||
style: {
|
||
color: "#728fcb"
|
||
}
|
||
},
|
||
{
|
||
types: ["placeholder", "variable"],
|
||
style: {
|
||
color: "#93abdc"
|
||
}
|
||
},
|
||
{
|
||
types: ["deleted"],
|
||
style: {
|
||
textDecorationLine: "line-through"
|
||
}
|
||
},
|
||
{
|
||
types: ["inserted"],
|
||
style: {
|
||
textDecorationLine: "underline"
|
||
}
|
||
},
|
||
{
|
||
types: ["italic"],
|
||
style: {
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["important", "bold"],
|
||
style: {
|
||
fontWeight: "bold"
|
||
}
|
||
},
|
||
{
|
||
types: ["important"],
|
||
style: {
|
||
color: "#896724"
|
||
}
|
||
}
|
||
]
|
||
};
|
||
var duotoneLight_default = theme3;
|
||
|
||
// src/themes/github.ts
|
||
var theme4 = {
|
||
plain: {
|
||
color: "#393A34",
|
||
backgroundColor: "#f6f8fa"
|
||
},
|
||
styles: [
|
||
{
|
||
types: ["comment", "prolog", "doctype", "cdata"],
|
||
style: {
|
||
color: "#999988",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["namespace"],
|
||
style: {
|
||
opacity: 0.7
|
||
}
|
||
},
|
||
{
|
||
types: ["string", "attr-value"],
|
||
style: {
|
||
color: "#e3116c"
|
||
}
|
||
},
|
||
{
|
||
types: ["punctuation", "operator"],
|
||
style: {
|
||
color: "#393A34"
|
||
}
|
||
},
|
||
{
|
||
types: [
|
||
"entity",
|
||
"url",
|
||
"symbol",
|
||
"number",
|
||
"boolean",
|
||
"variable",
|
||
"constant",
|
||
"property",
|
||
"regex",
|
||
"inserted"
|
||
],
|
||
style: {
|
||
color: "#36acaa"
|
||
}
|
||
},
|
||
{
|
||
types: ["atrule", "keyword", "attr-name", "selector"],
|
||
style: {
|
||
color: "#00a4db"
|
||
}
|
||
},
|
||
{
|
||
types: ["function", "deleted", "tag"],
|
||
style: {
|
||
color: "#d73a49"
|
||
}
|
||
},
|
||
{
|
||
types: ["function-variable"],
|
||
style: {
|
||
color: "#6f42c1"
|
||
}
|
||
},
|
||
{
|
||
types: ["tag", "selector", "keyword"],
|
||
style: {
|
||
color: "#00009f"
|
||
}
|
||
}
|
||
]
|
||
};
|
||
var github_default = theme4;
|
||
|
||
// src/themes/nightOwl.ts
|
||
var theme5 = {
|
||
plain: {
|
||
color: "#d6deeb",
|
||
backgroundColor: "#011627"
|
||
},
|
||
styles: [
|
||
{
|
||
types: ["changed"],
|
||
style: {
|
||
color: "rgb(162, 191, 252)",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["deleted"],
|
||
style: {
|
||
color: "rgba(239, 83, 80, 0.56)",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["inserted", "attr-name"],
|
||
style: {
|
||
color: "rgb(173, 219, 103)",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["comment"],
|
||
style: {
|
||
color: "rgb(99, 119, 119)",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["string", "url"],
|
||
style: {
|
||
color: "rgb(173, 219, 103)"
|
||
}
|
||
},
|
||
{
|
||
types: ["variable"],
|
||
style: {
|
||
color: "rgb(214, 222, 235)"
|
||
}
|
||
},
|
||
{
|
||
types: ["number"],
|
||
style: {
|
||
color: "rgb(247, 140, 108)"
|
||
}
|
||
},
|
||
{
|
||
types: ["builtin", "char", "constant", "function"],
|
||
style: {
|
||
color: "rgb(130, 170, 255)"
|
||
}
|
||
},
|
||
{
|
||
// This was manually added after the auto-generation
|
||
// so that punctuations are not italicised
|
||
types: ["punctuation"],
|
||
style: {
|
||
color: "rgb(199, 146, 234)"
|
||
}
|
||
},
|
||
{
|
||
types: ["selector", "doctype"],
|
||
style: {
|
||
color: "rgb(199, 146, 234)",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["class-name"],
|
||
style: {
|
||
color: "rgb(255, 203, 139)"
|
||
}
|
||
},
|
||
{
|
||
types: ["tag", "operator", "keyword"],
|
||
style: {
|
||
color: "rgb(127, 219, 202)"
|
||
}
|
||
},
|
||
{
|
||
types: ["boolean"],
|
||
style: {
|
||
color: "rgb(255, 88, 116)"
|
||
}
|
||
},
|
||
{
|
||
types: ["property"],
|
||
style: {
|
||
color: "rgb(128, 203, 196)"
|
||
}
|
||
},
|
||
{
|
||
types: ["namespace"],
|
||
style: {
|
||
color: "rgb(178, 204, 214)"
|
||
}
|
||
}
|
||
]
|
||
};
|
||
var nightOwl_default = theme5;
|
||
|
||
// src/themes/nightOwlLight.ts
|
||
var theme6 = {
|
||
plain: {
|
||
color: "#403f53",
|
||
backgroundColor: "#FBFBFB"
|
||
},
|
||
styles: [
|
||
{
|
||
types: ["changed"],
|
||
style: {
|
||
color: "rgb(162, 191, 252)",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["deleted"],
|
||
style: {
|
||
color: "rgba(239, 83, 80, 0.56)",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["inserted", "attr-name"],
|
||
style: {
|
||
color: "rgb(72, 118, 214)",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["comment"],
|
||
style: {
|
||
color: "rgb(152, 159, 177)",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["string", "builtin", "char", "constant", "url"],
|
||
style: {
|
||
color: "rgb(72, 118, 214)"
|
||
}
|
||
},
|
||
{
|
||
types: ["variable"],
|
||
style: {
|
||
color: "rgb(201, 103, 101)"
|
||
}
|
||
},
|
||
{
|
||
types: ["number"],
|
||
style: {
|
||
color: "rgb(170, 9, 130)"
|
||
}
|
||
},
|
||
{
|
||
// This was manually added after the auto-generation
|
||
// so that punctuations are not italicised
|
||
types: ["punctuation"],
|
||
style: {
|
||
color: "rgb(153, 76, 195)"
|
||
}
|
||
},
|
||
{
|
||
types: ["function", "selector", "doctype"],
|
||
style: {
|
||
color: "rgb(153, 76, 195)",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["class-name"],
|
||
style: {
|
||
color: "rgb(17, 17, 17)"
|
||
}
|
||
},
|
||
{
|
||
types: ["tag"],
|
||
style: {
|
||
color: "rgb(153, 76, 195)"
|
||
}
|
||
},
|
||
{
|
||
types: ["operator", "property", "keyword", "namespace"],
|
||
style: {
|
||
color: "rgb(12, 150, 155)"
|
||
}
|
||
},
|
||
{
|
||
types: ["boolean"],
|
||
style: {
|
||
color: "rgb(188, 84, 84)"
|
||
}
|
||
}
|
||
]
|
||
};
|
||
var nightOwlLight_default = theme6;
|
||
|
||
// src/themes/oceanicNext.ts
|
||
var colors = {
|
||
char: "#D8DEE9",
|
||
comment: "#999999",
|
||
keyword: "#c5a5c5",
|
||
primitive: "#5a9bcf",
|
||
string: "#8dc891",
|
||
variable: "#d7deea",
|
||
boolean: "#ff8b50",
|
||
punctuation: "#5FB3B3",
|
||
tag: "#fc929e",
|
||
function: "#79b6f2",
|
||
className: "#FAC863",
|
||
method: "#6699CC",
|
||
operator: "#fc929e"
|
||
};
|
||
var theme7 = {
|
||
plain: {
|
||
backgroundColor: "#282c34",
|
||
color: "#ffffff"
|
||
},
|
||
styles: [
|
||
{
|
||
types: ["attr-name"],
|
||
style: {
|
||
color: colors.keyword
|
||
}
|
||
},
|
||
{
|
||
types: ["attr-value"],
|
||
style: {
|
||
color: colors.string
|
||
}
|
||
},
|
||
{
|
||
types: [
|
||
"comment",
|
||
"block-comment",
|
||
"prolog",
|
||
"doctype",
|
||
"cdata",
|
||
"shebang"
|
||
],
|
||
style: {
|
||
color: colors.comment
|
||
}
|
||
},
|
||
{
|
||
types: [
|
||
"property",
|
||
"number",
|
||
"function-name",
|
||
"constant",
|
||
"symbol",
|
||
"deleted"
|
||
],
|
||
style: {
|
||
color: colors.primitive
|
||
}
|
||
},
|
||
{
|
||
types: ["boolean"],
|
||
style: {
|
||
color: colors.boolean
|
||
}
|
||
},
|
||
{
|
||
types: ["tag"],
|
||
style: {
|
||
color: colors.tag
|
||
}
|
||
},
|
||
{
|
||
types: ["string"],
|
||
style: {
|
||
color: colors.string
|
||
}
|
||
},
|
||
{
|
||
types: ["punctuation"],
|
||
style: {
|
||
color: colors.string
|
||
}
|
||
},
|
||
{
|
||
types: ["selector", "char", "builtin", "inserted"],
|
||
style: {
|
||
color: colors.char
|
||
}
|
||
},
|
||
{
|
||
types: ["function"],
|
||
style: {
|
||
color: colors.function
|
||
}
|
||
},
|
||
{
|
||
types: ["operator", "entity", "url", "variable"],
|
||
style: {
|
||
color: colors.variable
|
||
}
|
||
},
|
||
{
|
||
types: ["keyword"],
|
||
style: {
|
||
color: colors.keyword
|
||
}
|
||
},
|
||
{
|
||
types: ["atrule", "class-name"],
|
||
style: {
|
||
color: colors.className
|
||
}
|
||
},
|
||
{
|
||
types: ["important"],
|
||
style: {
|
||
fontWeight: "400"
|
||
}
|
||
},
|
||
{
|
||
types: ["bold"],
|
||
style: {
|
||
fontWeight: "bold"
|
||
}
|
||
},
|
||
{
|
||
types: ["italic"],
|
||
style: {
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["namespace"],
|
||
style: {
|
||
opacity: 0.7
|
||
}
|
||
}
|
||
]
|
||
};
|
||
var oceanicNext_default = theme7;
|
||
|
||
// src/themes/okaidia.ts
|
||
var theme8 = {
|
||
plain: {
|
||
color: "#f8f8f2",
|
||
backgroundColor: "#272822"
|
||
},
|
||
styles: [
|
||
{
|
||
types: ["changed"],
|
||
style: {
|
||
color: "rgb(162, 191, 252)",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["deleted"],
|
||
style: {
|
||
color: "#f92672",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["inserted"],
|
||
style: {
|
||
color: "rgb(173, 219, 103)",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["comment"],
|
||
style: {
|
||
color: "#8292a2",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["string", "url"],
|
||
style: {
|
||
color: "#a6e22e"
|
||
}
|
||
},
|
||
{
|
||
types: ["variable"],
|
||
style: {
|
||
color: "#f8f8f2"
|
||
}
|
||
},
|
||
{
|
||
types: ["number"],
|
||
style: {
|
||
color: "#ae81ff"
|
||
}
|
||
},
|
||
{
|
||
types: ["builtin", "char", "constant", "function", "class-name"],
|
||
style: {
|
||
color: "#e6db74"
|
||
}
|
||
},
|
||
{
|
||
types: ["punctuation"],
|
||
style: {
|
||
color: "#f8f8f2"
|
||
}
|
||
},
|
||
{
|
||
types: ["selector", "doctype"],
|
||
style: {
|
||
color: "#a6e22e",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["tag", "operator", "keyword"],
|
||
style: {
|
||
color: "#66d9ef"
|
||
}
|
||
},
|
||
{
|
||
types: ["boolean"],
|
||
style: {
|
||
color: "#ae81ff"
|
||
}
|
||
},
|
||
{
|
||
types: ["namespace"],
|
||
style: {
|
||
color: "rgb(178, 204, 214)",
|
||
opacity: 0.7
|
||
}
|
||
},
|
||
{
|
||
types: ["tag", "property"],
|
||
style: {
|
||
color: "#f92672"
|
||
}
|
||
},
|
||
{
|
||
types: ["attr-name"],
|
||
style: {
|
||
color: "#a6e22e !important"
|
||
}
|
||
},
|
||
{
|
||
types: ["doctype"],
|
||
style: {
|
||
color: "#8292a2"
|
||
}
|
||
},
|
||
{
|
||
types: ["rule"],
|
||
style: {
|
||
color: "#e6db74"
|
||
}
|
||
}
|
||
]
|
||
};
|
||
var okaidia_default = theme8;
|
||
|
||
// src/themes/palenight.ts
|
||
var theme9 = {
|
||
plain: {
|
||
color: "#bfc7d5",
|
||
backgroundColor: "#292d3e"
|
||
},
|
||
styles: [
|
||
{
|
||
types: ["comment"],
|
||
style: {
|
||
color: "rgb(105, 112, 152)",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["string", "inserted"],
|
||
style: {
|
||
color: "rgb(195, 232, 141)"
|
||
}
|
||
},
|
||
{
|
||
types: ["number"],
|
||
style: {
|
||
color: "rgb(247, 140, 108)"
|
||
}
|
||
},
|
||
{
|
||
types: ["builtin", "char", "constant", "function"],
|
||
style: {
|
||
color: "rgb(130, 170, 255)"
|
||
}
|
||
},
|
||
{
|
||
types: ["punctuation", "selector"],
|
||
style: {
|
||
color: "rgb(199, 146, 234)"
|
||
}
|
||
},
|
||
{
|
||
types: ["variable"],
|
||
style: {
|
||
color: "rgb(191, 199, 213)"
|
||
}
|
||
},
|
||
{
|
||
types: ["class-name", "attr-name"],
|
||
style: {
|
||
color: "rgb(255, 203, 107)"
|
||
}
|
||
},
|
||
{
|
||
types: ["tag", "deleted"],
|
||
style: {
|
||
color: "rgb(255, 85, 114)"
|
||
}
|
||
},
|
||
{
|
||
types: ["operator"],
|
||
style: {
|
||
color: "rgb(137, 221, 255)"
|
||
}
|
||
},
|
||
{
|
||
types: ["boolean"],
|
||
style: {
|
||
color: "rgb(255, 88, 116)"
|
||
}
|
||
},
|
||
{
|
||
types: ["keyword"],
|
||
style: {
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["doctype"],
|
||
style: {
|
||
color: "rgb(199, 146, 234)",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["namespace"],
|
||
style: {
|
||
color: "rgb(178, 204, 214)"
|
||
}
|
||
},
|
||
{
|
||
types: ["url"],
|
||
style: {
|
||
color: "rgb(221, 221, 221)"
|
||
}
|
||
}
|
||
]
|
||
};
|
||
var palenight_default = theme9;
|
||
|
||
// src/themes/shadesOfPurple.ts
|
||
var theme10 = {
|
||
plain: {
|
||
color: "#9EFEFF",
|
||
backgroundColor: "#2D2A55"
|
||
},
|
||
styles: [
|
||
{
|
||
types: ["changed"],
|
||
style: {
|
||
color: "rgb(255, 238, 128)"
|
||
}
|
||
},
|
||
{
|
||
types: ["deleted"],
|
||
style: {
|
||
color: "rgba(239, 83, 80, 0.56)"
|
||
}
|
||
},
|
||
{
|
||
types: ["inserted"],
|
||
style: {
|
||
color: "rgb(173, 219, 103)"
|
||
}
|
||
},
|
||
{
|
||
types: ["comment"],
|
||
style: {
|
||
color: "rgb(179, 98, 255)",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["punctuation"],
|
||
style: {
|
||
color: "rgb(255, 255, 255)"
|
||
}
|
||
},
|
||
{
|
||
types: ["constant"],
|
||
style: {
|
||
color: "rgb(255, 98, 140)"
|
||
}
|
||
},
|
||
{
|
||
types: ["string", "url"],
|
||
style: {
|
||
color: "rgb(165, 255, 144)"
|
||
}
|
||
},
|
||
{
|
||
types: ["variable"],
|
||
style: {
|
||
color: "rgb(255, 238, 128)"
|
||
}
|
||
},
|
||
{
|
||
types: ["number", "boolean"],
|
||
style: {
|
||
color: "rgb(255, 98, 140)"
|
||
}
|
||
},
|
||
{
|
||
types: ["attr-name"],
|
||
style: {
|
||
color: "rgb(255, 180, 84)"
|
||
}
|
||
},
|
||
{
|
||
types: [
|
||
"keyword",
|
||
"operator",
|
||
"property",
|
||
"namespace",
|
||
"tag",
|
||
"selector",
|
||
"doctype"
|
||
],
|
||
style: {
|
||
color: "rgb(255, 157, 0)"
|
||
}
|
||
},
|
||
{
|
||
types: ["builtin", "char", "constant", "function", "class-name"],
|
||
style: {
|
||
color: "rgb(250, 208, 0)"
|
||
}
|
||
}
|
||
]
|
||
};
|
||
var shadesOfPurple_default = theme10;
|
||
|
||
// src/themes/synthwave84.ts
|
||
var theme11 = {
|
||
plain: {
|
||
backgroundColor: "linear-gradient(to bottom, #2a2139 75%, #34294f)",
|
||
backgroundImage: "#34294f",
|
||
color: "#f92aad",
|
||
textShadow: "0 0 2px #100c0f, 0 0 5px #dc078e33, 0 0 10px #fff3"
|
||
},
|
||
styles: [
|
||
{
|
||
types: ["comment", "block-comment", "prolog", "doctype", "cdata"],
|
||
style: {
|
||
color: "#495495",
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["punctuation"],
|
||
style: {
|
||
color: "#ccc"
|
||
}
|
||
},
|
||
{
|
||
types: [
|
||
"tag",
|
||
"attr-name",
|
||
"namespace",
|
||
"number",
|
||
"unit",
|
||
"hexcode",
|
||
"deleted"
|
||
],
|
||
style: {
|
||
color: "#e2777a"
|
||
}
|
||
},
|
||
{
|
||
types: ["property", "selector"],
|
||
style: {
|
||
color: "#72f1b8",
|
||
textShadow: "0 0 2px #100c0f, 0 0 10px #257c5575, 0 0 35px #21272475"
|
||
}
|
||
},
|
||
{
|
||
types: ["function-name"],
|
||
style: {
|
||
color: "#6196cc"
|
||
}
|
||
},
|
||
{
|
||
types: ["boolean", "selector-id", "function"],
|
||
style: {
|
||
color: "#fdfdfd",
|
||
textShadow: "0 0 2px #001716, 0 0 3px #03edf975, 0 0 5px #03edf975, 0 0 8px #03edf975"
|
||
}
|
||
},
|
||
{
|
||
types: ["class-name", "maybe-class-name", "builtin"],
|
||
style: {
|
||
color: "#fff5f6",
|
||
textShadow: "0 0 2px #000, 0 0 10px #fc1f2c75, 0 0 5px #fc1f2c75, 0 0 25px #fc1f2c75"
|
||
}
|
||
},
|
||
{
|
||
types: ["constant", "symbol"],
|
||
style: {
|
||
color: "#f92aad",
|
||
textShadow: "0 0 2px #100c0f, 0 0 5px #dc078e33, 0 0 10px #fff3"
|
||
}
|
||
},
|
||
{
|
||
types: ["important", "atrule", "keyword", "selector-class"],
|
||
style: {
|
||
color: "#f4eee4",
|
||
textShadow: "0 0 2px #393a33, 0 0 8px #f39f0575, 0 0 2px #f39f0575"
|
||
}
|
||
},
|
||
{
|
||
types: ["string", "char", "attr-value", "regex", "variable"],
|
||
style: {
|
||
color: "#f87c32"
|
||
}
|
||
},
|
||
{
|
||
types: ["parameter"],
|
||
style: {
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["entity", "url"],
|
||
style: {
|
||
color: "#67cdcc"
|
||
}
|
||
},
|
||
{
|
||
types: ["operator"],
|
||
style: {
|
||
color: "ffffffee"
|
||
}
|
||
},
|
||
{
|
||
types: ["important", "bold"],
|
||
style: {
|
||
fontWeight: "bold"
|
||
}
|
||
},
|
||
{
|
||
types: ["italic"],
|
||
style: {
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["entity"],
|
||
style: {
|
||
cursor: "help"
|
||
}
|
||
},
|
||
{
|
||
types: ["inserted"],
|
||
style: {
|
||
color: "green"
|
||
}
|
||
}
|
||
]
|
||
};
|
||
var synthwave84_default = theme11;
|
||
|
||
// src/themes/ultramin.ts
|
||
var theme12 = {
|
||
plain: {
|
||
color: "#282a2e",
|
||
backgroundColor: "#ffffff"
|
||
},
|
||
styles: [
|
||
{
|
||
types: ["comment"],
|
||
style: {
|
||
color: "rgb(197, 200, 198)"
|
||
}
|
||
},
|
||
{
|
||
types: ["string", "number", "builtin", "variable"],
|
||
style: {
|
||
color: "rgb(150, 152, 150)"
|
||
}
|
||
},
|
||
{
|
||
types: ["class-name", "function", "tag", "attr-name"],
|
||
style: {
|
||
color: "rgb(40, 42, 46)"
|
||
}
|
||
}
|
||
]
|
||
};
|
||
var ultramin_default = theme12;
|
||
|
||
// src/themes/vsDark.ts
|
||
var theme13 = {
|
||
plain: {
|
||
color: "#9CDCFE",
|
||
backgroundColor: "#1E1E1E"
|
||
},
|
||
styles: [
|
||
{
|
||
types: ["prolog"],
|
||
style: {
|
||
color: "rgb(0, 0, 128)"
|
||
}
|
||
},
|
||
{
|
||
types: ["comment"],
|
||
style: {
|
||
color: "rgb(106, 153, 85)"
|
||
}
|
||
},
|
||
{
|
||
types: ["builtin", "changed", "keyword", "interpolation-punctuation"],
|
||
style: {
|
||
color: "rgb(86, 156, 214)"
|
||
}
|
||
},
|
||
{
|
||
types: ["number", "inserted"],
|
||
style: {
|
||
color: "rgb(181, 206, 168)"
|
||
}
|
||
},
|
||
{
|
||
types: ["constant"],
|
||
style: {
|
||
color: "rgb(100, 102, 149)"
|
||
}
|
||
},
|
||
{
|
||
types: ["attr-name", "variable"],
|
||
style: {
|
||
color: "rgb(156, 220, 254)"
|
||
}
|
||
},
|
||
{
|
||
types: ["deleted", "string", "attr-value", "template-punctuation"],
|
||
style: {
|
||
color: "rgb(206, 145, 120)"
|
||
}
|
||
},
|
||
{
|
||
types: ["selector"],
|
||
style: {
|
||
color: "rgb(215, 186, 125)"
|
||
}
|
||
},
|
||
{
|
||
// Fix tag color
|
||
types: ["tag"],
|
||
style: {
|
||
color: "rgb(78, 201, 176)"
|
||
}
|
||
},
|
||
{
|
||
// Fix tag color for HTML
|
||
types: ["tag"],
|
||
languages: ["markup"],
|
||
style: {
|
||
color: "rgb(86, 156, 214)"
|
||
}
|
||
},
|
||
{
|
||
types: ["punctuation", "operator"],
|
||
style: {
|
||
color: "rgb(212, 212, 212)"
|
||
}
|
||
},
|
||
{
|
||
// Fix punctuation color for HTML
|
||
types: ["punctuation"],
|
||
languages: ["markup"],
|
||
style: {
|
||
color: "#808080"
|
||
}
|
||
},
|
||
{
|
||
types: ["function"],
|
||
style: {
|
||
color: "rgb(220, 220, 170)"
|
||
}
|
||
},
|
||
{
|
||
types: ["class-name"],
|
||
style: {
|
||
color: "rgb(78, 201, 176)"
|
||
}
|
||
},
|
||
{
|
||
types: ["char"],
|
||
style: {
|
||
color: "rgb(209, 105, 105)"
|
||
}
|
||
}
|
||
]
|
||
};
|
||
var vsDark_default = theme13;
|
||
|
||
// src/themes/vsLight.ts
|
||
var theme14 = {
|
||
plain: {
|
||
color: "#000000",
|
||
backgroundColor: "#ffffff"
|
||
},
|
||
styles: [
|
||
{
|
||
types: ["comment"],
|
||
style: {
|
||
color: "rgb(0, 128, 0)"
|
||
}
|
||
},
|
||
{
|
||
types: ["builtin"],
|
||
style: {
|
||
color: "rgb(0, 112, 193)"
|
||
}
|
||
},
|
||
{
|
||
types: ["number", "variable", "inserted"],
|
||
style: {
|
||
color: "rgb(9, 134, 88)"
|
||
}
|
||
},
|
||
{
|
||
types: ["operator"],
|
||
style: {
|
||
color: "rgb(0, 0, 0)"
|
||
}
|
||
},
|
||
{
|
||
types: ["constant", "char"],
|
||
style: {
|
||
color: "rgb(129, 31, 63)"
|
||
}
|
||
},
|
||
{
|
||
types: ["tag"],
|
||
style: {
|
||
color: "rgb(128, 0, 0)"
|
||
}
|
||
},
|
||
{
|
||
types: ["attr-name"],
|
||
style: {
|
||
color: "rgb(255, 0, 0)"
|
||
}
|
||
},
|
||
{
|
||
types: ["deleted", "string"],
|
||
style: {
|
||
color: "rgb(163, 21, 21)"
|
||
}
|
||
},
|
||
{
|
||
types: ["changed", "punctuation"],
|
||
style: {
|
||
color: "rgb(4, 81, 165)"
|
||
}
|
||
},
|
||
{
|
||
types: ["function", "keyword"],
|
||
style: {
|
||
color: "rgb(0, 0, 255)"
|
||
}
|
||
},
|
||
{
|
||
types: ["class-name"],
|
||
style: {
|
||
color: "rgb(38, 127, 153)"
|
||
}
|
||
}
|
||
]
|
||
};
|
||
var vsLight_default = theme14;
|
||
|
||
// src/themes/jettwaveDark.ts
|
||
var theme15 = {
|
||
plain: {
|
||
color: "#f8fafc",
|
||
backgroundColor: "#011627"
|
||
},
|
||
styles: [
|
||
{
|
||
types: ["prolog"],
|
||
style: {
|
||
color: "#000080"
|
||
}
|
||
},
|
||
{
|
||
types: ["comment"],
|
||
style: {
|
||
color: "#6A9955"
|
||
}
|
||
},
|
||
{
|
||
types: ["builtin", "changed", "keyword", "interpolation-punctuation"],
|
||
style: {
|
||
color: "#569CD6"
|
||
}
|
||
},
|
||
{
|
||
types: ["number", "inserted"],
|
||
style: {
|
||
color: "#B5CEA8"
|
||
}
|
||
},
|
||
{
|
||
types: ["constant"],
|
||
style: {
|
||
color: "#f8fafc"
|
||
}
|
||
},
|
||
{
|
||
types: ["attr-name", "variable"],
|
||
style: {
|
||
color: "#9CDCFE"
|
||
}
|
||
},
|
||
{
|
||
types: ["deleted", "string", "attr-value", "template-punctuation"],
|
||
style: {
|
||
color: "#cbd5e1"
|
||
}
|
||
},
|
||
{
|
||
types: ["selector"],
|
||
style: {
|
||
color: "#D7BA7D"
|
||
}
|
||
},
|
||
{
|
||
types: ["tag"],
|
||
style: {
|
||
color: "#0ea5e9"
|
||
}
|
||
},
|
||
{
|
||
types: ["tag"],
|
||
languages: ["markup"],
|
||
style: {
|
||
color: "#0ea5e9"
|
||
}
|
||
},
|
||
{
|
||
types: ["punctuation", "operator"],
|
||
style: {
|
||
color: "#D4D4D4"
|
||
}
|
||
},
|
||
{
|
||
types: ["punctuation"],
|
||
languages: ["markup"],
|
||
style: {
|
||
color: "#808080"
|
||
}
|
||
},
|
||
{
|
||
types: ["function"],
|
||
style: {
|
||
color: "#7dd3fc"
|
||
}
|
||
},
|
||
{
|
||
types: ["class-name"],
|
||
style: {
|
||
color: "#0ea5e9"
|
||
}
|
||
},
|
||
{
|
||
types: ["char"],
|
||
style: {
|
||
color: "#D16969"
|
||
}
|
||
}
|
||
]
|
||
};
|
||
var jettwaveDark_default = theme15;
|
||
|
||
// src/themes/jettwaveLight.ts
|
||
var theme16 = {
|
||
plain: {
|
||
color: "#0f172a",
|
||
backgroundColor: "#f1f5f9"
|
||
},
|
||
styles: [
|
||
{
|
||
types: ["prolog"],
|
||
style: {
|
||
color: "#000080"
|
||
}
|
||
},
|
||
{
|
||
types: ["comment"],
|
||
style: {
|
||
color: "#6A9955"
|
||
}
|
||
},
|
||
{
|
||
types: ["builtin", "changed", "keyword", "interpolation-punctuation"],
|
||
style: {
|
||
color: "#0c4a6e"
|
||
}
|
||
},
|
||
{
|
||
types: ["number", "inserted"],
|
||
style: {
|
||
color: "#B5CEA8"
|
||
}
|
||
},
|
||
{
|
||
types: ["constant"],
|
||
style: {
|
||
color: "#0f172a"
|
||
}
|
||
},
|
||
{
|
||
types: ["attr-name", "variable"],
|
||
style: {
|
||
color: "#0c4a6e"
|
||
}
|
||
},
|
||
{
|
||
types: ["deleted", "string", "attr-value", "template-punctuation"],
|
||
style: {
|
||
color: "#64748b"
|
||
}
|
||
},
|
||
{
|
||
types: ["selector"],
|
||
style: {
|
||
color: "#D7BA7D"
|
||
}
|
||
},
|
||
{
|
||
types: ["tag"],
|
||
style: {
|
||
color: "#0ea5e9"
|
||
}
|
||
},
|
||
{
|
||
types: ["tag"],
|
||
languages: ["markup"],
|
||
style: {
|
||
color: "#0ea5e9"
|
||
}
|
||
},
|
||
{
|
||
types: ["punctuation", "operator"],
|
||
style: {
|
||
color: "#475569"
|
||
}
|
||
},
|
||
{
|
||
types: ["punctuation"],
|
||
languages: ["markup"],
|
||
style: {
|
||
color: "#808080"
|
||
}
|
||
},
|
||
{
|
||
types: ["function"],
|
||
style: {
|
||
color: "#0e7490"
|
||
}
|
||
},
|
||
{
|
||
types: ["class-name"],
|
||
style: {
|
||
color: "#0ea5e9"
|
||
}
|
||
},
|
||
{
|
||
types: ["char"],
|
||
style: {
|
||
color: "#D16969"
|
||
}
|
||
}
|
||
]
|
||
};
|
||
var jettwaveLight_default = theme16;
|
||
|
||
// src/themes/oneDark.ts
|
||
var theme17 = {
|
||
plain: {
|
||
backgroundColor: "hsl(220, 13%, 18%)",
|
||
color: "hsl(220, 14%, 71%)",
|
||
textShadow: "0 1px rgba(0, 0, 0, 0.3)"
|
||
},
|
||
styles: [
|
||
{
|
||
types: ["comment", "prolog", "cdata"],
|
||
style: {
|
||
color: "hsl(220, 10%, 40%)"
|
||
}
|
||
},
|
||
{
|
||
types: ["doctype", "punctuation", "entity"],
|
||
style: {
|
||
color: "hsl(220, 14%, 71%)"
|
||
}
|
||
},
|
||
{
|
||
types: [
|
||
"attr-name",
|
||
"class-name",
|
||
"maybe-class-name",
|
||
"boolean",
|
||
"constant",
|
||
"number",
|
||
"atrule"
|
||
],
|
||
style: { color: "hsl(29, 54%, 61%)" }
|
||
},
|
||
{
|
||
types: ["keyword"],
|
||
style: { color: "hsl(286, 60%, 67%)" }
|
||
},
|
||
{
|
||
types: ["property", "tag", "symbol", "deleted", "important"],
|
||
style: {
|
||
color: "hsl(355, 65%, 65%)"
|
||
}
|
||
},
|
||
{
|
||
types: [
|
||
"selector",
|
||
"string",
|
||
"char",
|
||
"builtin",
|
||
"inserted",
|
||
"regex",
|
||
"attr-value"
|
||
],
|
||
style: {
|
||
color: "hsl(95, 38%, 62%)"
|
||
}
|
||
},
|
||
{
|
||
types: ["variable", "operator", "function"],
|
||
style: {
|
||
color: "hsl(207, 82%, 66%)"
|
||
}
|
||
},
|
||
{
|
||
types: ["url"],
|
||
style: {
|
||
color: "hsl(187, 47%, 55%)"
|
||
}
|
||
},
|
||
{
|
||
types: ["deleted"],
|
||
style: {
|
||
textDecorationLine: "line-through"
|
||
}
|
||
},
|
||
{
|
||
types: ["inserted"],
|
||
style: {
|
||
textDecorationLine: "underline"
|
||
}
|
||
},
|
||
{
|
||
types: ["italic"],
|
||
style: {
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["important", "bold"],
|
||
style: {
|
||
fontWeight: "bold"
|
||
}
|
||
},
|
||
{
|
||
types: ["important"],
|
||
style: {
|
||
color: "hsl(220, 14%, 71%)"
|
||
}
|
||
}
|
||
]
|
||
};
|
||
var oneDark_default = theme17;
|
||
|
||
// src/themes/oneLight.ts
|
||
var theme18 = {
|
||
plain: {
|
||
backgroundColor: "hsl(230, 1%, 98%)",
|
||
color: "hsl(230, 8%, 24%)"
|
||
},
|
||
styles: [
|
||
{
|
||
types: ["comment", "prolog", "cdata"],
|
||
style: {
|
||
color: "hsl(230, 4%, 64%)"
|
||
}
|
||
},
|
||
{
|
||
types: ["doctype", "punctuation", "entity"],
|
||
style: {
|
||
color: "hsl(230, 8%, 24%)"
|
||
}
|
||
},
|
||
{
|
||
types: [
|
||
"attr-name",
|
||
"class-name",
|
||
"boolean",
|
||
"constant",
|
||
"number",
|
||
"atrule"
|
||
],
|
||
style: {
|
||
color: "hsl(35, 99%, 36%)"
|
||
}
|
||
},
|
||
{
|
||
types: ["keyword"],
|
||
style: {
|
||
color: "hsl(301, 63%, 40%)"
|
||
}
|
||
},
|
||
{
|
||
types: ["property", "tag", "symbol", "deleted", "important"],
|
||
style: {
|
||
color: "hsl(5, 74%, 59%)"
|
||
}
|
||
},
|
||
{
|
||
types: [
|
||
"selector",
|
||
"string",
|
||
"char",
|
||
"builtin",
|
||
"inserted",
|
||
"regex",
|
||
"attr-value",
|
||
"punctuation"
|
||
],
|
||
style: {
|
||
color: "hsl(119, 34%, 47%)"
|
||
}
|
||
},
|
||
{
|
||
types: ["variable", "operator", "function"],
|
||
style: {
|
||
color: "hsl(221, 87%, 60%)"
|
||
}
|
||
},
|
||
{
|
||
types: ["url"],
|
||
style: {
|
||
color: "hsl(198, 99%, 37%)"
|
||
}
|
||
},
|
||
{
|
||
types: ["deleted"],
|
||
style: {
|
||
textDecorationLine: "line-through"
|
||
}
|
||
},
|
||
{
|
||
types: ["inserted"],
|
||
style: {
|
||
textDecorationLine: "underline"
|
||
}
|
||
},
|
||
{
|
||
types: ["italic"],
|
||
style: {
|
||
fontStyle: "italic"
|
||
}
|
||
},
|
||
{
|
||
types: ["important", "bold"],
|
||
style: {
|
||
fontWeight: "bold"
|
||
}
|
||
},
|
||
{
|
||
types: ["important"],
|
||
style: {
|
||
color: "hsl(230, 8%, 24%)"
|
||
}
|
||
}
|
||
]
|
||
};
|
||
var oneLight_default = theme18;
|
||
|
||
// src/index.ts
|
||
import { createElement } from "react";
|
||
|
||
// src/components/useThemeDictionary.ts
|
||
import { useEffect, useRef, useState } from "react";
|
||
|
||
// src/utils/themeToDict.ts
|
||
var themeToDict = (theme19, language) => {
|
||
const { plain } = theme19;
|
||
const themeDict = theme19.styles.reduce((acc, themeEntry) => {
|
||
const { languages: languages2, style } = themeEntry;
|
||
if (languages2 && !languages2.includes(language)) {
|
||
return acc;
|
||
}
|
||
themeEntry.types.forEach((type) => {
|
||
const accStyle = __spreadValues(__spreadValues({}, acc[type]), style);
|
||
acc[type] = accStyle;
|
||
});
|
||
return acc;
|
||
}, {});
|
||
themeDict.root = plain;
|
||
themeDict.plain = __spreadProps(__spreadValues({}, plain), { backgroundColor: void 0 });
|
||
return themeDict;
|
||
};
|
||
var themeToDict_default = themeToDict;
|
||
|
||
// src/components/useThemeDictionary.ts
|
||
var useThemeDictionary = (language, theme19) => {
|
||
const [themeDictionary, setThemeDictionary] = useState(
|
||
themeToDict_default(theme19, language)
|
||
);
|
||
const previousTheme = useRef();
|
||
const previousLanguage = useRef();
|
||
useEffect(() => {
|
||
if (theme19 !== previousTheme.current || language !== previousLanguage.current) {
|
||
previousTheme.current = theme19;
|
||
previousLanguage.current = language;
|
||
setThemeDictionary(themeToDict_default(theme19, language));
|
||
}
|
||
}, [language, theme19]);
|
||
return themeDictionary;
|
||
};
|
||
|
||
// src/components/useGetLineProps.ts
|
||
import { useCallback } from "react";
|
||
import clsx from "clsx";
|
||
var useGetLineProps = (themeDictionary) => useCallback(
|
||
(_a) => {
|
||
var _b = _a, { className, style, line } = _b, rest = __objRest(_b, ["className", "style", "line"]);
|
||
const output = __spreadProps(__spreadValues({}, rest), {
|
||
className: clsx("token-line", className)
|
||
});
|
||
if (typeof themeDictionary === "object" && "plain" in themeDictionary)
|
||
output.style = themeDictionary.plain;
|
||
if (typeof style === "object")
|
||
output.style = __spreadValues(__spreadValues({}, output.style || {}), style);
|
||
return output;
|
||
},
|
||
[themeDictionary]
|
||
);
|
||
|
||
// src/components/useGetTokenProps.ts
|
||
import { useCallback as useCallback2 } from "react";
|
||
import clsx2 from "clsx";
|
||
var useGetTokenProps = (themeDictionary) => {
|
||
const styleForToken = useCallback2(
|
||
({ types, empty }) => {
|
||
if (themeDictionary == null)
|
||
return void 0;
|
||
else if (types.length === 1 && types[0] === "plain") {
|
||
return empty != null ? { display: "inline-block" } : void 0;
|
||
} else if (types.length === 1 && empty != null) {
|
||
return themeDictionary[types[0]];
|
||
}
|
||
return Object.assign(
|
||
empty != null ? { display: "inline-block" } : {},
|
||
...types.map((type) => themeDictionary[type])
|
||
);
|
||
},
|
||
[themeDictionary]
|
||
);
|
||
return useCallback2(
|
||
(_a) => {
|
||
var _b = _a, { token, className, style } = _b, rest = __objRest(_b, ["token", "className", "style"]);
|
||
const output = __spreadProps(__spreadValues({}, rest), {
|
||
className: clsx2("token", ...token.types, className),
|
||
children: token.content,
|
||
style: styleForToken(token)
|
||
});
|
||
if (style != null) {
|
||
output.style = __spreadValues(__spreadValues({}, output.style || {}), style);
|
||
}
|
||
return output;
|
||
},
|
||
[styleForToken]
|
||
);
|
||
};
|
||
|
||
// src/utils/normalizeTokens.ts
|
||
var newlineRe = /\r\n|\r|\n/;
|
||
var normalizeEmptyLines = (line) => {
|
||
if (line.length === 0) {
|
||
line.push({
|
||
types: ["plain"],
|
||
content: "\n",
|
||
empty: true
|
||
});
|
||
} else if (line.length === 1 && line[0].content === "") {
|
||
line[0].content = "\n";
|
||
line[0].empty = true;
|
||
}
|
||
};
|
||
var appendTypes = (types, add) => {
|
||
const typesSize = types.length;
|
||
if (typesSize > 0 && types[typesSize - 1] === add) {
|
||
return types;
|
||
}
|
||
return types.concat(add);
|
||
};
|
||
var normalizeTokens = (tokens) => {
|
||
const typeArrStack = [[]];
|
||
const tokenArrStack = [tokens];
|
||
const tokenArrIndexStack = [0];
|
||
const tokenArrSizeStack = [tokens.length];
|
||
let i = 0;
|
||
let stackIndex = 0;
|
||
let currentLine = [];
|
||
const acc = [currentLine];
|
||
while (stackIndex > -1) {
|
||
while ((i = tokenArrIndexStack[stackIndex]++) < tokenArrSizeStack[stackIndex]) {
|
||
let content;
|
||
let types = typeArrStack[stackIndex];
|
||
const tokenArr = tokenArrStack[stackIndex];
|
||
const token = tokenArr[i];
|
||
if (typeof token === "string") {
|
||
types = stackIndex > 0 ? types : ["plain"];
|
||
content = token;
|
||
} else {
|
||
types = appendTypes(types, token.type);
|
||
if (token.alias) {
|
||
types = appendTypes(types, token.alias);
|
||
}
|
||
content = token.content;
|
||
}
|
||
if (typeof content !== "string") {
|
||
stackIndex++;
|
||
typeArrStack.push(types);
|
||
tokenArrStack.push(content);
|
||
tokenArrIndexStack.push(0);
|
||
tokenArrSizeStack.push(content.length);
|
||
continue;
|
||
}
|
||
const splitByNewlines = content.split(newlineRe);
|
||
const newlineCount = splitByNewlines.length;
|
||
currentLine.push({
|
||
types,
|
||
content: splitByNewlines[0]
|
||
});
|
||
for (let i2 = 1; i2 < newlineCount; i2++) {
|
||
normalizeEmptyLines(currentLine);
|
||
acc.push(currentLine = []);
|
||
currentLine.push({
|
||
types,
|
||
content: splitByNewlines[i2]
|
||
});
|
||
}
|
||
}
|
||
stackIndex--;
|
||
typeArrStack.pop();
|
||
tokenArrStack.pop();
|
||
tokenArrIndexStack.pop();
|
||
tokenArrSizeStack.pop();
|
||
}
|
||
normalizeEmptyLines(currentLine);
|
||
return acc;
|
||
};
|
||
var normalizeTokens_default = normalizeTokens;
|
||
|
||
// src/components/useTokenize.ts
|
||
import { useMemo, useRef as useRef2 } from "react";
|
||
var useTokenize = ({ prism, code, grammar, language }) => {
|
||
const prismRef = useRef2(prism);
|
||
return useMemo(() => {
|
||
if (grammar == null)
|
||
return normalizeTokens_default([code]);
|
||
const prismConfig = {
|
||
code,
|
||
grammar,
|
||
language,
|
||
tokens: []
|
||
};
|
||
prismRef.current.hooks.run("before-tokenize", prismConfig);
|
||
prismConfig.tokens = prismRef.current.tokenize(code, grammar);
|
||
prismRef.current.hooks.run("after-tokenize", prismConfig);
|
||
return normalizeTokens_default(prismConfig.tokens);
|
||
}, [code, grammar, language]);
|
||
};
|
||
|
||
// src/components/highlight.ts
|
||
var Highlight = ({
|
||
children,
|
||
language: _language,
|
||
code,
|
||
theme: theme19,
|
||
prism
|
||
}) => {
|
||
const language = _language.toLowerCase();
|
||
const themeDictionary = useThemeDictionary(language, theme19);
|
||
const getLineProps = useGetLineProps(themeDictionary);
|
||
const getTokenProps = useGetTokenProps(themeDictionary);
|
||
const grammar = prism.languages[language];
|
||
const tokens = useTokenize({ prism, language, code, grammar });
|
||
return children({
|
||
tokens,
|
||
className: `prism-code language-${language}`,
|
||
style: themeDictionary != null ? themeDictionary.root : {},
|
||
getLineProps,
|
||
getTokenProps
|
||
});
|
||
};
|
||
|
||
// src/index.ts
|
||
var Highlight2 = (props) => createElement(Highlight, __spreadProps(__spreadValues({}, props), {
|
||
prism: props.prism || Prism,
|
||
theme: props.theme || vsDark_default,
|
||
code: props.code,
|
||
language: props.language
|
||
}));
|
||
export {
|
||
Highlight2 as Highlight,
|
||
Prism,
|
||
normalizeTokens_default as normalizeTokens,
|
||
themes_exports as themes,
|
||
useTokenize
|
||
};
|
||
/*! Bundled license information:
|
||
|
||
prismjs/prism.js:
|
||
(**
|
||
* Prism: Lightweight, robust, elegant syntax highlighting
|
||
*
|
||
* @license MIT <https://opensource.org/licenses/MIT>
|
||
* @author Lea Verou <https://lea.verou.me>
|
||
* @namespace
|
||
* @public
|
||
*)
|
||
*/
|
||
//# sourceMappingURL=index.mjs.map
|