// -*- conding: utf-8 -*-

/* #region */

/* PrismJS 1.30.0

https://prismjs.com/download#themes=prism-dark&languages=markup+css+clike+javascript+abap+abnf+actionscript+ada+agda+al+antlr4+apacheconf+apex+apl+applescript+aql+arduino+arff+armasm+arturo+asciidoc+aspnet+asm6502+asmatmel+autohotkey+autoit+avisynth+avro-idl+awk+bash+basic+batch+bbcode+bbj+bicep+birb+bison+bnf+bqn+brainfuck+brightscript+bro+bsl+c+csharp+cpp+cfscript+chaiscript+cil+cilkc+cilkcpp+clojure+cmake+cobol+coffeescript+concurnas+csp+cooklang+coq+crystal+css-extras+csv+cue+cypher+d+dart+dataweave+dax+dhall+diff+django+dns-zone-file+docker+dot+ebnf+editorconfig+eiffel+ejs+elixir+elm+etlua+erb+erlang+excel-formula+fsharp+factor+false+firestore-security-rules+flow+fortran+ftl+gml+gap+gcode+gdscript+gedcom+gettext+gherkin+git+glsl+gn+linker-script+go+go-module+gradle+graphql+groovy+haml+handlebars+haskell+haxe+hcl+hlsl+hoon+http+hpkp+hsts+ichigojam+icon+icu-message-format+idris+ignore+inform7+ini+io+j+java+javadoc+javadoclike+javastacktrace+jexl+jolie+jq+jsdoc+js-extras+json+json5+jsonp+jsstacktrace+js-templates+julia+keepalived+keyman+kotlin+kumir+kusto+latex+latte+less+lilypond+liquid+lisp+livescript+llvm+log+lolcode+lua+magma+makefile+markdown+markup-templating+mata+matlab+maxscript+mel+mermaid+metafont+mizar+mongodb+monkey+moonscript+n1ql+n4js+nand2tetris-hdl+naniscript+nasm+neon+nevod+nginx+nim+nix+nsis+objectivec+ocaml+odin+opencl+openqasm+oz+parigp+parser+pascal+pascaligo+psl+pcaxis+peoplecode+perl+php+phpdoc+php-extras+plant-uml+plsql+powerquery+powershell+processing+prolog+promql+properties+protobuf+pug+puppet+pure+purebasic+purescript+python+qsharp+q+qml+qore+r+racket+cshtml+jsx+tsx+reason+regex+rego+renpy+rescript+rest+rip+roboconf+robotframework+ruby+rust+sas+sass+scss+scala+scheme+shell-session+smali+smalltalk+smarty+sml+solidity+solution-file+soy+sparql+splunk-spl+sqf+sql+squirrel+stan+stata+iecst+stylus+supercollider+swift+systemd+t4-templating+t4-cs+t4-vb+tap+tcl+tt2+textile+toml+tremor+turtle+twig+typescript+typoscript+unrealscript+uorazor+uri+v+vala+vbnet+velocity+verilog+vhdl+vim+visual-basic+warpscript+wasm+web-idl+wgsl+wiki+wolfram+wren+xeora+xml-doc+xojo+xquery+yaml+yang+zig&plugins=line-numbers+show-language+inline-color+toolbar+copy-to-clipboard+download-button */

/// <reference lib="WebWorker"/>

console.info("prism.js 已加载")

console.info("v1.30.0")

var _self = (typeof window !== 'undefined')

? window // if in browser

: (

(typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope)

? self // if in worker

: {} // if in node js

);

/**

* Prism: Lightweight, robust, elegant syntax highlighting

*

* @license MIT <https://opensource.org/licenses/MIT>

* @author Lea Verou <https://lea.verou.me>

* @namespace

* @public

*/

var Prism = (function (_self) {

// Private helper vars

var lang = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i;

var uniqueId = 0;

// The grammar object for plaintext

var plainTextGrammar = {};

var _ = {

/**

* By default, Prism will attempt to highlight all code elements (by calling {@link Prism.highlightAll}) on the

* current page after the page finished loading. This might be a problem if e.g. you wanted to asynchronously load

* additional languages or plugins yourself.

*

* By setting this value to `true`, Prism will not automatically highlight all code elements on the page.

*

* You obviously have to change this value before the automatic highlighting started. To do this, you can add an

* empty Prism object into the global scope before loading the Prism script like this:

*

* ```js

* window.Prism = window.Prism || {};

* Prism.manual = true;

* // add a new <script> to load Prism's script

* ```

*

* @default false

* @type {boolean}

* @memberof Prism

* @public

*/

manual: _self.Prism && _self.Prism.manual,

/**

* By default, if Prism is in a web worker, it assumes that it is in a worker it created itself, so it uses

* `addEventListener` to communicate with its parent instance. However, if you're using Prism manually in your

* own worker, you don't want it to do this.

*

* By setting this value to `true`, Prism will not add its own listeners to the worker.

*

* You obviously have to change this value before Prism executes. To do this, you can add an

* empty Prism object into the global scope before loading the Prism script like this:

*

* ```js

* window.Prism = window.Prism || {};

* Prism.disableWorkerMessageHandler = true;

* // Load Prism's script

* ```

*

* @default false

* @type {boolean}

* @memberof Prism

* @public

*/

disableWorkerMessageHandler: _self.Prism && _self.Prism.disableWorkerMessageHandler,

/**

* 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) {

},

/**

* 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) {

},

/**

* 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) {

},

/**

* 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) {

},

/**

* Sets the Prism `language-xxxx` class of the given element.

*

* @param {Element} element

* @param {string} language

* @returns {void}

*/

setLanguage: function (element, language) {

},

/**

* Returns the script element that is currently executing.

*

* This does __not__ work for line script element.

*

* @returns {HTMLScriptElement | null}

*/

currentScript: function () {

},

/**

* 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) {

}

},

/**

* 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) {

},

/**

* 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) {

},

// Traverse a language definition with Depth First Search

DFS: function DFS(o, callback, type, visited) {

}

},

plugins: {},

/**

* This is the most high-level function in Prism’s API.

* It fetches all the elements that have a `.language-xxxx` class and then calls {@link Prism.highlightElement} on

* each one of them.

*

* This is equivalent to `Prism.highlightAllUnder(document, async, callback)`.

*

* @param {boolean} [async=false] Same as in {@link Prism.highlightAllUnder}.

* @param {HighlightCallback} [callback] Same as in {@link Prism.highlightAllUnder}.

* @memberof Prism

* @public

*/

highlightAll: function (async, callback) {

_.highlightAllUnder(document, async, callback);

},

/**

* Fetches all the descendants of `container` that have a `.language-xxxx` class and then calls

* {@link Prism.highlightElement} on each one of them.

*

* The following hooks will be run:

* 1. `before-highlightall`

* 2. `before-all-elements-highlight`

* 3. All hooks of {@link Prism.highlightElement} for each element.

*

* @param {ParentNode} container The root element, whose descendants that have a `.language-xxxx` class will be highlighted.

* @param {boolean} [async=false] Whether each element is to be highlighted asynchronously using Web Workers.

* @param {HighlightCallback} [callback] An optional callback to be invoked on each element after its highlighting is done.

* @memberof Prism

* @public

*/

highlightAllUnder: function (container, async, callback) {

},

/**

* Highlights the code inside a single element.

*

* The following hooks will be run:

* 1. `before-sanity-check`

* 2. `before-highlight`

* 3. All hooks of {@link Prism.highlight}. These hooks will be run by an asynchronous worker if `async` is `true`.

* 4. `before-insert`

* 5. `after-highlight`

* 6. `complete`

*

* Some the above hooks will be skipped if the element doesn't contain any text or there is no grammar loaded for

* the element's language.

*

* @param {Element} element The element containing the code.

* It must have a class of `language-xxxx` to be processed, where `xxxx` is a valid language identifier.

* @param {boolean} [async=false] Whether the element is to be highlighted asynchronously using Web Workers

* to improve performance and avoid blocking the UI when highlighting very large chunks of code. This option is

* [disabled by default](https://prismjs.com/faq.html#why-is-asynchronous-highlighting-disabled-by-default).

*

* Note: All language definitions required to highlight the code must be included in the main `prism.js` file for

* asynchronous highlighting to work. You can build your own bundle on the

* [Download page](https://prismjs.com/download.html).

* @param {HighlightCallback} [callback] An optional callback to be invoked after the highlighting is done.

* Mostly useful when `async` is `true`, since in that case, the highlighting is done asynchronously.

* @memberof Prism

* @public

*/

highlightElement: function (element, async, callback) {

},

/**

* 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) {

},

/**

* 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) {

},

/**

* @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) {

},

/**

* 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) {

}

},

Token: Token

};

_self.Prism = _;

// Typescript note:

// The following can be used to import the Token type in JSDoc:

//

// @typedef {InstanceType<import("./prism-core")["Token"]>} Token

/**

* Creates a new token.

*

* @param {string} type See {@link Token#type type}

* @param {string | TokenStream} content See {@link Token#content content}

* @param {string|string[]} [alias] The alias(es) of the token.

* @param {string} [matchedStr=""] A copy of the full string this token was created from.

* @class

* @global

* @public

*/

function Token(type, content, alias, matchedStr) {

}

/**

* A token stream is an array of strings and {@link Token Token} objects.

*

* Token streams have to fulfill a few properties that are assumed by most functions (mostly internal ones) that process

* them.

*

* 1. No adjacent strings.

* 2. No empty strings.

*

* The only exception here is the token stream that only contains the empty string and nothing else.

*

* @typedef {Array<string | Token>} TokenStream

* @global

* @public

*/

/**

* Converts the given token or token stream to an HTML representation.

*

* The following hooks will be run:

* 1. `wrap`: On each {@link Token}.

*

* @param {string | Token | TokenStream} o The token or token stream to be converted.

* @param {string} language The name of current language.

* @returns {string} The HTML representation of the token or token stream.

* @memberof Token

* @static

*/

Token.stringify = function stringify(o, language) {

};

/**

* @param {RegExp} pattern

* @param {number} pos

* @param {string} text

* @param {boolean} lookbehind

* @returns {RegExpExecArray | null}

*/

function matchPattern(pattern, pos, text, lookbehind) {

}

/**

* @param {string} text

* @param {LinkedList<string | Token>} tokenList

* @param {any} grammar

* @param {LinkedListNode<string | Token>} startNode

* @param {number} startPos

* @param {RematchOptions} [rematch]

* @returns {void}

* @private

*

* @typedef RematchOptions

* @property {string} cause

* @property {number} reach

*/

function matchGrammar(text, tokenList, grammar, startNode, startPos, rematch) {