+
-> A full-featured markdown parser and compiler, written in JavaScript. Built
-> for speed.
+# Marked
-[][badge]
+[](https://www.npmjs.com/package/marked)
+[](https://cdn.jsdelivr.net/npm/marked/marked.min.js)
+[](https://packagephobia.now.sh/result?p=marked)
+[](https://www.npmjs.com/package/marked)
+[](https://github.com/markedjs/marked/actions)
+[](https://snyk.io/test/npm/marked)
-## Install
+- ⚡ built for speed
+- ⬇️ low-level compiler for parsing markdown without caching or blocking for long periods of time
+- ⚖️ light-weight while implementing all markdown features from the supported flavors & specifications
+- 🌐 works in a browser, on a server, or from a command line interface (CLI)
-``` bash
-npm install marked --save
-```
-
-## Usage
-
-Minimal usage:
-
-```js
-var marked = require('marked');
-console.log(marked('I am using __markdown__.'));
-// Outputs: I am using markdown.
-``` - -Example setting options with default values: - -```js -var marked = require('marked'); -marked.setOptions({ - renderer: new marked.Renderer(), - gfm: true, - tables: true, - breaks: false, - pedantic: false, - sanitize: true, - smartLists: true, - smartypants: false -}); - -console.log(marked('I am using __markdown__.')); -``` - -### Browser - -```html - - - - -hello world
``` -## Philosophy behind marked - -The point of marked was to create a markdown compiler where it was possible to -frequently parse huge chunks of markdown without having to worry about -caching the compiled output somehow...or blocking for an unnecesarily long time. - -marked is very concise and still implements all markdown features. It is also -now fully compatible with the client-side. - -marked more or less passes the official markdown test suite in its -entirety. This is important because a surprising number of markdown compilers -cannot pass more than a few tests. It was very difficult to get marked as -compliant as it is. It could have cut corners in several areas for the sake -of performance, but did not in order to be exactly what you expect in terms -of a markdown rendering. In fact, this is why marked could be considered at a -disadvantage in the benchmarks above. - -Along with implementing every markdown feature, marked also implements [GFM -features][gfmf]. - -## Benchmarks - -node v0.8.x - -``` bash -$ node test --bench -marked completed in 3411ms. -marked (gfm) completed in 3727ms. -marked (pedantic) completed in 3201ms. -robotskirt completed in 808ms. -showdown (reuse converter) completed in 11954ms. -showdown (new converter) completed in 17774ms. -markdown-js completed in 17191ms. +```bash +# Print all options +$ marked --help ``` -__Marked is now faster than Discount, which is written in C.__ - -For those feeling skeptical: These benchmarks run the entire markdown test suite 1000 times. The test suite tests every feature. It doesn't cater to specific aspects. +**Browser** -### Pro level - -You also have direct access to the lexer and parser if you so desire. - -``` js -var tokens = marked.lexer(text, options); -console.log(marked.parser(tokens)); -``` - -``` js -var lexer = new marked.Lexer(options); -var tokens = lexer.lex(text); -console.log(tokens); -console.log(lexer.rules); -``` - -``` bash -$ node -> require('marked').lexer('> i am using marked.') -[ { type: 'blockquote_start' }, - { type: 'paragraph', - text: 'i am using marked.' }, - { type: 'blockquote_end' }, - links: {} ] -``` - -## Running Tests & Contributing - -If you want to submit a pull request, make sure your changes pass the test -suite. If you're adding a new feature, be sure to add your own test. - -The marked test suite is set up slightly strangely: `test/new` is for all tests -that are not part of the original markdown.pl test suite (this is where your -test should go if you make one). `test/original` is only for the original -markdown.pl tests. `test/tests` houses both types of tests after they have been -combined and moved/generated by running `node test --fix` or `marked --test ---fix`. - -In other words, if you have a test to add, add it to `test/new/` and then -regenerate the tests with `node test --fix`. Commit the result. If your test -uses a certain feature, for example, maybe it assumes GFM is *not* enabled, you -can add `.nogfm` to the filename. So, `my-test.text` becomes -`my-test.nogfm.text`. You can do this with any marked option. Say you want -line breaks and smartypants enabled, your filename should be: -`my-test.breaks.smartypants.text`. - -To run the tests: - -``` bash -cd marked/ -node test +```html + + + + +
+
+ 
+
+ + Christopher Jeffrey + Original Author
+ Started the fire
+ |
+
+
+ 
+
+ + Josh Bruce + Publisher
+ Release Wrangler; Humaning Helper; Heckler of Hypertext
+ |
+
+
+ 
+
+ + Steven + Publisher
+ Release Wrangler; Dr. Docs; Open source, of course; GitHub Guru; Humaning Helper
+ |
+
+
+ 
+
+ + Jamie Davis + Committer
+ Seeker of Security
+ |
+
+
+ 
+
+ + Tony Brix + Publisher
+ Release Wrangler; Titan of the test harness; Dr. DevOps
+ |
+
+
+ 
+
+ + Trevor Buckner + Committer
+ Master of Marked
+ |
+
+
+ 
+
+ + Brandon der Blätter + Contributor
+ Curious Contributor
+ |
+
+
+ 
+
+ + Carlos Valle + Contributor
+ Maker of the Marked mark from 2018 to present
+ |
+
+
+ 
+
+ + Federico Soave + Contributor
+ Regent of the Regex; Master of Marked
+ |
+
+
+ 
+
+ + Karen Yavine + Contributor
+ Snyk's Security Saint
+ |
+
+
+ 
+
+ + Костя Третяк + Contributor
+
+ |
+
+
+ 
+
+ + Tom Theisen + Contributor
+ Defibrillator
+ |
+
+
+ 
+
+ + Mateus Craveiro + Contributor
+ Defibrillator
+ |
+ + | +
Someone who understands and contributes to improving the developer experience and flow of Marked into the world.
++ "The main characteristic of the DevOps movement is to strongly advocate automation and monitoring at all steps of software construction, from integration, testing, releasing to deployment and infrastructure management. DevOps aims at shorter development cycles, increased deployment frequency, more dependable releases, in close alignment with business objectives." ~ Wikipedia ++
Can you demonstrate you understand the following without Google and Stackoverflow?
+/^( *)(bull) [\s\S]+?(?:hr|def|\n{2,}(?! )(?!\1bull )\n*|\s*$)/
Because this author can't yet. That's who gets these.
+* Still working on metrics for comparative analysis and definition.
+** As few dependencies as possible.
+*** Strict compliance could result in slower processing when running comparative benchmarking.
hello world
+``` + +``` bash +# Example with string input +$ marked -s "*hello world*" +hello world
+``` + +```bash +# Example with file input + +echo "**bold text example**" > readme.md + +$ marked -i readme.md -o readme.html +$ cat readme.html +bold text example
+``` + +```bash +# Print all options +$ marked --help +``` + +**Browser** + +```html + + + + +` block. Useful for syntax highlighting.|
+|mangle |`boolean` |`true` |v0.3.4 |If true, autolinked email address is escaped with HTML character references.|
+|pedantic |`boolean` |`false` |v0.2.1 |If true, conform to the original `markdown.pl` as much as possible. Don't fix original markdown bugs or behavior. Turns off and overrides `gfm`.|
+|renderer |`object` |`new Renderer()`|v0.3.0|An object containing functions to render tokens to HTML. See [extensibility](/using_pro) for more details.|
+|sanitize |`boolean` |`false` |v0.2.1 |If true, sanitize the HTML passed into `markdownString` with the `sanitizer` function.
**Warning**: This feature is deprecated and it should NOT be used as it cannot be considered secure.
Instead use a sanitize library, like [DOMPurify](https://github.com/cure53/DOMPurify) (recommended), [sanitize-html](https://github.com/apostrophecms/sanitize-html) or [insane](https://github.com/bevacqua/insane) on the output HTML! |
+|sanitizer |`function`|`null` |v0.3.4 |A function to sanitize the HTML passed into `markdownString`.|
+|silent |`boolean` |`false` |v0.2.7 |If true, the parser does not throw any exception.|
+|smartLists |`boolean` |`false` |v0.2.8 |If true, use smarter list behavior than those found in `markdown.pl`.|
+|smartypants |`boolean` |`false` |v0.2.9 |If true, use "smart" typographic punctuation for things like quotes and dashes.|
+|tokenizer |`object` |`new Tokenizer()`|v1.0.0|An object containing functions to create tokens from markdown. See [extensibility](/using_pro) for more details.|
+|walkTokens |`function` |`null`|v1.1.0|A function which is called for every token. See [extensibility](/using_pro) for more details.|
+|xhtml |`boolean` |`false` |v0.3.2 |If true, emit self-closing HTML tags for void elements (<br/>, <img/>, etc.) with a "/" as required by XHTML.|
+
+Inline Markdown
+
+You can parse inline markdown by running markdown through `marked.parseInline`.
+
+```js
+const blockHtml = marked.parse('**strong** _em_');
+console.log(blockHtml); // 'strong em
'
+
+const inlineHtml = marked.parseInline('**strong** _em_');
+console.log(inlineHtml); // 'strong em'
+```
+
+Asynchronous highlighting
+
+Unlike `highlight.js` the `pygmentize.js` library uses asynchronous highlighting. This example demonstrates that marked is agnostic when it comes to the highlighter you use.
+
+```js
+marked.setOptions({
+ highlight: function(code, lang, callback) {
+ require('pygmentize-bundled') ({ lang: lang, format: 'html' }, code, function (err, result) {
+ callback(err, result.toString());
+ });
+ }
+});
+
+marked.parse(markdownString, (err, html) => {
+ console.log(html);
+});
+```
+
+In both examples, `code` is a `string` representing the section of code to pass to the highlighter. In this example, `lang` is a `string` informing the highlighter what programming language to use for the `code` and `callback` is the `function` the asynchronous highlighter will call once complete.
+
+Workers
+
+To prevent ReDoS attacks you can run marked on a worker and terminate it when parsing takes longer than usual.
+
+Marked can be run in a [worker thread](https://nodejs.org/api/worker_threads.html) on a node server, or a [web worker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) in a browser.
+
+### Node Worker Thread
+
+```js
+// markedWorker.js
+
+import { marked } from 'marked';
+import { parentPort } from 'worker_threads';
+
+parentPort.on('message', (markdownString) => {
+ parentPort.postMessage(marked.parse(markdownString));
+});
+```
+
+```js
+// index.js
+
+import { Worker } from 'worker_threads';
+const markedWorker = new Worker('./markedWorker.js');
+
+const markedTimeout = setTimeout(() => {
+ markedWorker.terminate();
+ throw new Error('Marked took too long!');
+}, timeoutLimit);
+
+markedWorker.on('message', (html) => {
+ clearTimeout(markedTimeout);
+ console.log(html);
+ markedWorker.terminate();
+});
+
+markedWorker.postMessage(markdownString);
+```
+
+### Web Worker
+
+> **NOTE**: Web Workers send the payload from `postMessage` in an object with the payload in a `.data` property
+
+```js
+// markedWorker.js
+
+importScripts('path/to/marked.min.js');
+
+onmessage = (e) => {
+ const markdownString = e.data
+ postMessage(marked.parse(markdownString));
+};
+```
+
+```js
+// script.js
+
+const markedWorker = new Worker('./markedWorker.js');
+
+const markedTimeout = setTimeout(() => {
+ markedWorker.terminate();
+ throw new Error('Marked took too long!');
+}, timeoutLimit);
+
+markedWorker.onmessage = (e) => {
+ clearTimeout(markedTimeout);
+ const html = e.data;
+ console.log(html);
+ markedWorker.terminate();
+};
+
+markedWorker.postMessage(markdownString);
+```
diff --git a/docs/USING_PRO.md b/docs/USING_PRO.md
new file mode 100644
index 0000000000..92c478094f
--- /dev/null
+++ b/docs/USING_PRO.md
@@ -0,0 +1,570 @@
+## Extending Marked
+
+To champion the single-responsibility and open/closed principles, we have tried to make it relatively painless to extend Marked. If you are looking to add custom functionality, this is the place to start.
+
+marked.use()
+
+`marked.use(extension)` is the recommended way to extend Marked. The `extension` object can contain any [option](/using_advanced#options) available in Marked:
+
+
+```js
+import { marked } from 'marked';
+
+marked.use({
+ pedantic: false,
+ gfm: true,
+ breaks: false,
+ sanitize: false,
+ smartLists: true,
+ smartypants: false,
+ xhtml: false
+});
+```
+
+You can also supply multiple `extension` objects at once.
+
+```
+marked.use(myExtension, extension2, extension3);
+
+\\ EQUIVALENT TO:
+
+marked.use(myExtension);
+marked.use(extension2);
+marked.use(extension3);
+
+```
+
+All options will overwrite those previously set, except for the following options which will be merged with the existing framework and can be used to change or extend the functionality of Marked: `renderer`, `tokenizer`, `walkTokens`, and `extensions`.
+
+* The `renderer` and `tokenizer` options are objects with functions that will be merged into the built-in `renderer` and `tokenizer` respectively.
+
+* The `walkTokens` option is a function that will be called to post-process every token before rendering.
+
+* The `extensions` option is an array of objects that can contain additional custom `renderer` and `tokenizer` steps that will execute before any of the default parsing logic occurs.
+
+***
+
+The Marked Pipeline
+
+Before building your custom extensions, it is important to understand the components that Marked uses to translate from Markdown to HTML:
+
+1) The user supplies Marked with an input string to be translated.
+2) The `lexer` feeds segments of the input text string into each `tokenizer`, and from their output, generates a series of tokens in a nested tree structure.
+3) Each `tokenizer` receives a segment of Markdown text and, if it matches a particular pattern, generates a token object containing any relevant information.
+4) The `walkTokens` function will traverse every token in the tree and perform any final adjustments to the token contents.
+4) The `parser` traverses the token tree and feeds each token into the appropriate `renderer`, and concatenates their outputs into the final HTML result.
+5) Each `renderer` receives a token and manipulates its contents to generate a segment of HTML.
+
+Marked provides methods of directly overriding the `renderer` and `tokenizer` for any existing token type, as well as inserting additional custom `renderer` and `tokenizer` functions to handle entirely custom syntax.
+
+***
+
+The Renderer : renderer
+
+The renderer defines the HTML output of a given token. If you supply a `renderer` object to the Marked options, it will be merged with the built-in renderer and any functions inside will override the default handling of that token type.
+
+Calling `marked.use()` to override the same function multiple times will give priority to the version that was assigned *last*. Overriding functions can return `false` to fall back to the previous override in the sequence, or resume default behavior if all overrides return `false`. Returning any other value (including nothing) will prevent fallback behavior.
+
+**Example:** Overriding output of the default `heading` token by adding an embedded anchor tag like on GitHub.
+
+```js
+// Create reference instance
+import { marked } from 'marked';
+
+// Override function
+const renderer = {
+ heading(text, level) {
+ const escapedText = text.toLowerCase().replace(/[^\w]+/g, '-');
+
+ return `
+
+
+
+
+ ${text}
+ `;
+ }
+};
+
+marked.use({ renderer });
+
+// Run marked
+console.log(marked.parse('# heading+'));
+```
+
+**Output:**
+
+```html
+
+
+
+
+ heading+
+
+```
+
+### Block-level renderer methods
+
+- **code**(*string* code, *string* infostring, *boolean* escaped)
+- **blockquote**(*string* quote)
+- **html**(*string* html)
+- **heading**(*string* text, *number* level, *string* raw, *Slugger* slugger)
+- **hr**()
+- **list**(*string* body, *boolean* ordered, *number* start)
+- **listitem**(*string* text, *boolean* task, *boolean* checked)
+- **checkbox**(*boolean* checked)
+- **paragraph**(*string* text)
+- **table**(*string* header, *string* body)
+- **tablerow**(*string* content)
+- **tablecell**(*string* content, *object* flags)
+
+### Inline-level renderer methods
+
+- **strong**(*string* text)
+- **em**(*string* text)
+- **codespan**(*string* code)
+- **br**()
+- **del**(*string* text)
+- **link**(*string* href, *string* title, *string* text)
+- **image**(*string* href, *string* title, *string* text)
+- **text**(*string* text)
+
+`slugger` has the `slug` method to create a unique id from value:
+
+```js
+slugger.slug('foo') // foo
+slugger.slug('foo') // foo-1
+slugger.slug('foo') // foo-2
+slugger.slug('foo 1') // foo-1-1
+slugger.slug('foo-1') // foo-1-2
+...
+```
+
+`slugger.slug` can also be called with the `dryrun` option for stateless operation:
+```js
+slugger.slug('foo') // foo
+slugger.slug('foo') // foo-1
+slugger.slug('foo') // foo-2
+slugger.slug('foo', { dryrun: true }) // foo-3
+slugger.slug('foo', { dryrun: true }) // foo-3
+slugger.slug('foo') // foo-3
+slugger.slug('foo') // foo-4
+...
+```
+
+`flags` has the following properties:
+
+```js
+{
+ header: true || false,
+ align: 'center' || 'left' || 'right'
+}
+```
+
+***
+
+The Tokenizer : tokenizer
+
+The tokenizer defines how to turn markdown text into tokens. If you supply a `tokenizer` object to the Marked options, it will be merged with the built-in tokenizer and any functions inside will override the default handling of that token type.
+
+Calling `marked.use()` to override the same function multiple times will give priority to the version that was assigned *last*. Overriding functions can return `false` to fall back to the previous override in the sequence, or resume default behavior if all overrides return `false`. Returning any other value (including nothing) will prevent fallback behavior.
+
+**Example:** Overriding default `codespan` tokenizer to include LaTeX.
+
+```js
+// Create reference instance
+import { marked } from 'marked';
+
+// Override function
+const tokenizer = {
+ codespan(src) {
+ const match = src.match(/\$+([^\$\n]+?)\$+/);
+ if (match) {
+ return {
+ type: 'codespan',
+ raw: match[0],
+ text: match[1].trim()
+ };
+ }
+
+ // return false to use original codespan tokenizer
+ return false;
+ }
+};
+
+marked.use({ tokenizer });
+
+// Run marked
+console.log(marked.parse('$ latex code $\n\n` other code `'));
+```
+
+**Output:**
+
+```html
+latex code
+other code
+```
+**NOTE**: This does not fully support latex, see issue [#1948](https://github.com/markedjs/marked/issues/1948).
+
+### Block level tokenizer methods
+
+- **space**(*string* src)
+- **code**(*string* src)
+- **fences**(*string* src)
+- **heading**(*string* src)
+- **hr**(*string* src)
+- **blockquote**(*string* src)
+- **list**(*string* src)
+- **html**(*string* src)
+- **def**(*string* src)
+- **table**(*string* src)
+- **lheading**(*string* src)
+- **paragraph**(*string* src)
+- **text**(*string* src)
+
+### Inline level tokenizer methods
+
+- **escape**(*string* src)
+- **tag**(*string* src)
+- **link**(*string* src)
+- **reflink**(*string* src, *object* links)
+- **emStrong**(*string* src, *string* maskedSrc, *string* prevChar)
+- **codespan**(*string* src)
+- **br**(*string* src)
+- **del**(*string* src)
+- **autolink**(*string* src, *function* mangle)
+- **url**(*string* src, *function* mangle)
+- **inlineText**(*string* src, *function* smartypants)
+
+`mangle` is a method that changes text to HTML character references:
+
+```js
+mangle('test@example.com')
+// "test@example.com"
+```
+
+`smartypants` is a method that translates plain ASCII punctuation characters into “smart” typographic punctuation HTML entities:
+
+https://daringfireball.net/projects/smartypants/
+
+```js
+smartypants('"this ... string"')
+// "“this … string”"
+```
+
+***
+
+Walk Tokens : walkTokens
+
+The walkTokens function gets called with every token. Child tokens are called before moving on to sibling tokens. Each token is passed by reference so updates are persisted when passed to the parser. The return value of the function is ignored.
+
+`marked.use()` can be called multiple times with different `walkTokens` functions. Each function will be called in order, starting with the function that was assigned *last*.
+
+**Example:** Overriding heading tokens to start at h2.
+
+```js
+import { marked } from 'marked';
+
+// Override function
+const walkTokens = (token) => {
+ if (token.type === 'heading') {
+ token.depth += 1;
+ }
+};
+
+marked.use({ walkTokens });
+
+// Run marked
+console.log(marked.parse('# heading 2\n\n## heading 3'));
+```
+
+**Output:**
+
+```html
+heading 2
+heading 3
+```
+
+***
+
+Custom Extensions : extensions
+
+You may supply an `extensions` array to the `options` object. This array can contain any number of `extension` objects, using the following properties:
+
+
+name- A string used to identify the token that will be handled by this extension.
+
+If the name matches an existing extension name, or an existing method in the tokenizer/renderer methods listed above, they will override the previously assigned behavior, with priority on the extension that was assigned **last**. An extension can return `false` to fall back to the previous behavior.
+
+level- A string to determine when to run the extension tokenizer. Must be equal to 'block' or 'inline'.
+
+A **block-level** extension will be handled before any of the block-level tokenizer methods listed above, and generally consists of 'container-type' text (paragraphs, tables, blockquotes, etc.).
+
+An **inline-level** extension will be handled inside each block-level token, before any of the inline-level tokenizer methods listed above. These generally consist of 'style-type' text (italics, bold, etc.).
+
+start(string src)- A function that returns the index of the next potential start of the custom token.
+
+The index can be the result of a
src.match().index, or even a simple src.index(). Marked will use this function to ensure that it does not skip over any text that should be part of the custom token.
+
+tokenizer(string src, array tokens)- A function that reads a string of Markdown text and returns a generated token. The
tokens parameter contains the array of tokens that have been generated by the lexer up to that point, and can be used to access the previous token, for instance.
+
+The return value should be an object with the following parameters:
+
+
+type- A string that matches the
name parameter of the extension.
+
+raw- A string containing all of the text that this token consumes from the source.
+
+tokens [optional]- An array of child tokens that will be traversed by the
walkTokens function by default.
+
+
+The returned token can also contain any other custom parameters of your choice that your custom `renderer` might need to access.
+
+The tokenizer function has access to the lexer in the `this` object, which can be used if any internal section of the string needs to be parsed further, such as in handling any inline syntax on the text within a block token. The key functions that may be useful include:
+
+
+this.lexer.blockTokens(string text, array tokens)- This runs the block tokenizer functions (including any block-level extensions) on the provided text, and appends any resulting tokens onto the
tokens array. The tokens array is also returned by the function. You might use this, for example, if your extension creates a "container"-type token (such as a blockquote) that can potentially include other block-level tokens inside.
+
+this.lexer.inline(string text, array tokens)- Parsing of inline-level tokens only occurs after all block-level tokens have been generated. This function adds
text and tokens to a queue to be processed using inline-level tokenizers (including any inline-level extensions) at that later step. Tokens will be generated using the provided text, and any resulting tokens will be appended to the tokens array. Note that this function does **NOT** return anything since the inline processing cannot happen until the block-level processing is complete.
+
+this.lexer.inlineTokens(string text, array tokens)- Sometimes an inline-level token contains further nested inline tokens (such as a
**strong**
token inside of a ### Heading
). This runs the inline tokenizer functions (including any inline-level extensions) on the provided text, and appends any resulting tokens onto the tokens array. The tokens array is also returned by the function.
+
+
+
+renderer(object token)- A function that reads a token and returns the generated HTML output string.
+
+The renderer function has access to the parser in the `this` object, which can be used if any part of the token needs needs to be parsed further, such as any child tokens. The key functions that may be useful include:
+
+
+this.parser.parse(array tokens)- Runs the block renderer functions (including any extensions) on the provided array of tokens, and returns the resulting HTML string output. This is used to generate the HTML from any child block-level tokens, for example if your extension is a "container"-type token (such as a blockquote) that can potentially include other block-level tokens inside.
+
+this.parser.parseInline(array tokens)- Runs the inline renderer functions (including any extensions) on the provided array of tokens, and returns the resulting HTML string output. This is used to generate the HTML from any child inline-level tokens.
+
+
+
+childTokens [optional]- An array of strings that match the names of any token parameters that should be traversed by the
walkTokens functions. For instance, if you want to use a second custom parameter to contain child tokens in addition to tokens, it could be listed here. If childTokens is provided, the tokens array will not be walked by default unless it is also included in the childTokens array.
+
+
+**Example:** Add a custom syntax to generate `` description lists.
+
+``` js
+const descriptionList = {
+ name: 'descriptionList',
+ level: 'block', // Is this a block-level or inline-level tokenizer?
+ start(src) { return src.match(/:[^:\n]/)?.index; }, // Hint to Marked.js to stop and check for a match
+ tokenizer(src, tokens) {
+ const rule = /^(?::[^:\n]+:[^:\n]*(?:\n|$))+/; // Regex for the complete token
+ const match = rule.exec(src);
+ if (match) {
+ const token = { // Token to generate
+ type: 'descriptionList', // Should match "name" above
+ raw: match[0], // Text to consume from the source
+ text: match[0].trim(), // Additional custom properties
+ tokens: [] // Array where child inline tokens will be generated
+ };
+ this.lexer.inline(token.text, token.tokens); // Queue this data to be processed for inline tokens
+ return token;
+ }
+ },
+ renderer(token) {
+ return `${this.parser.parseInline(token.tokens)}\n
`; // parseInline to turn child tokens into HTML
+ }
+};
+
+const description = {
+ name: 'description',
+ level: 'inline', // Is this a block-level or inline-level tokenizer?
+ start(src) { return src.match(/:/)?.index; }, // Hint to Marked.js to stop and check for a match
+ tokenizer(src, tokens) {
+ const rule = /^:([^:\n]+):([^:\n]*)(?:\n|$)/; // Regex for the complete token
+ const match = rule.exec(src);
+ if (match) {
+ return { // Token to generate
+ type: 'description', // Should match "name" above
+ raw: match[0], // Text to consume from the source
+ dt: this.lexer.inlineTokens(match[1].trim()), // Additional custom properties, including
+ dd: this.lexer.inlineTokens(match[2].trim()) // any further-nested inline tokens
+ };
+ }
+ },
+ renderer(token) {
+ return `\n- ${this.parser.parseInline(token.dt)}
- ${this.parser.parseInline(token.dd)}
`;
+ },
+ childTokens: ['dt', 'dd'], // Any child tokens to be visited by walkTokens
+};
+
+function walkTokens(token) { // Post-processing on the completed token tree
+ if (token.type === 'strong') {
+ token.text += ' walked';
+ token.tokens = this.Lexer.lexInline(token.text)
+ }
+}
+marked.use({ extensions: [descriptionList, description], walkTokens });
+
+// EQUIVALENT TO:
+
+marked.use({ extensions: [descriptionList] });
+marked.use({ extensions: [description] });
+marked.use({ walkTokens })
+
+console.log(marked.parse('A Description List:\n'
+ + ': Topic 1 : Description 1\n'
+ + ': **Topic 2** : *Description 2*'));
+```
+
+**Output**
+
+``` bash
+A Description List:
+
+- Topic 1
- Description 1
+- Topic 2 walked
- Description 2
+
+```
+
+***
+
+The Lexer
+
+The lexer takes a markdown string and calls the tokenizer functions.
+
+
+The Parser
+
+The parser takes tokens as input and calls the renderer functions.
+
+Access to Lexer and Parser
+
+You also have direct access to the lexer and parser if you so desire.
+
+``` js
+const tokens = marked.lexer(markdown, options);
+console.log(marked.parser(tokens, options));
+```
+
+``` js
+const lexer = new marked.Lexer(options);
+const tokens = lexer.lex(markdown);
+console.log(tokens);
+console.log(lexer.tokenizer.rules.block); // block level rules used
+console.log(lexer.tokenizer.rules.inline); // inline level rules used
+console.log(marked.Lexer.rules.block); // all block level rules
+console.log(marked.Lexer.rules.inline); // all inline level rules
+```
+
+``` bash
+$ node
+> require('marked').lexer('> I am using marked.')
+[
+ {
+ type: "blockquote",
+ raw: "> I am using marked.",
+ tokens: [
+ {
+ type: "paragraph",
+ raw: "I am using marked.",
+ text: "I am using marked.",
+ tokens: [
+ {
+ type: "text",
+ raw: "I am using marked.",
+ text: "I am using marked."
+ }
+ ]
+ }
+ ]
+ },
+ links: {}
+]
+```
+
+The Lexer builds an array of tokens, which will be passed to the Parser.
+The Parser processes each token in the token array:
+
+``` js
+import { marked } from 'marked';
+
+const md = `
+ # heading
+
+ [link][1]
+
+ [1]: #heading "heading"
+`;
+
+const tokens = marked.lexer(md);
+console.log(tokens);
+
+const html = marked.parser(tokens);
+console.log(html);
+```
+
+``` bash
+[
+ {
+ type: "heading",
+ raw: " # heading\n\n",
+ depth: 1,
+ text: "heading",
+ tokens: [
+ {
+ type: "text",
+ raw: "heading",
+ text: "heading"
+ }
+ ]
+ },
+ {
+ type: "paragraph",
+ raw: " [link][1]",
+ text: " [link][1]",
+ tokens: [
+ {
+ type: "text",
+ raw: " ",
+ text: " "
+ },
+ {
+ type: "link",
+ raw: "[link][1]",
+ text: "link",
+ href: "#heading",
+ title: "heading",
+ tokens: [
+ {
+ type: "text",
+ raw: "link",
+ text: "link"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ type: "space",
+ raw: "\n\n"
+ },
+ links: {
+ "1": {
+ href: "#heading",
+ title: "heading"
+ }
+ }
+]
+heading
+
+```
diff --git a/docs/_document.html b/docs/_document.html
new file mode 100644
index 0000000000..3527ebc1e9
--- /dev/null
+++ b/docs/_document.html
@@ -0,0 +1,108 @@
+
+
+
+
+ <!--{{title}}-->Marked Documentation
+
+
+
+
+
+
+
+
+
+
+ 
+
+ Marked Documentation
+
+
+
+
+
+
+
+
+
diff --git a/doc/broken.md b/docs/broken.md
similarity index 100%
rename from doc/broken.md
rename to docs/broken.md
diff --git a/docs/css/hljs-github.css b/docs/css/hljs-github.css
new file mode 100644
index 0000000000..ad278bbbc7
--- /dev/null
+++ b/docs/css/hljs-github.css
@@ -0,0 +1,99 @@
+/*
+
+github.com style (c) Vasily Polovnyov
+
+*/
+
+pre {
+ display: block;
+ overflow-x: auto;
+ padding: 0.5em;
+ color: #333;
+ background: #f8f8f8;
+ }
+
+ .hljs-comment,
+ .hljs-quote {
+ color: #998;
+ font-style: italic;
+ }
+
+ .hljs-keyword,
+ .hljs-selector-tag,
+ .hljs-subst {
+ color: #333;
+ font-weight: bold;
+ }
+
+ .hljs-number,
+ .hljs-literal,
+ .hljs-variable,
+ .hljs-template-variable,
+ .hljs-tag .hljs-attr {
+ color: #008080;
+ }
+
+ .hljs-string,
+ .hljs-doctag {
+ color: #d14;
+ }
+
+ .hljs-title,
+ .hljs-section,
+ .hljs-selector-id {
+ color: #900;
+ font-weight: bold;
+ }
+
+ .hljs-subst {
+ font-weight: normal;
+ }
+
+ .hljs-type,
+ .hljs-class .hljs-title {
+ color: #458;
+ font-weight: bold;
+ }
+
+ .hljs-tag,
+ .hljs-name,
+ .hljs-attribute {
+ color: #000080;
+ font-weight: normal;
+ }
+
+ .hljs-regexp,
+ .hljs-link {
+ color: #009926;
+ }
+
+ .hljs-symbol,
+ .hljs-bullet {
+ color: #990073;
+ }
+
+ .hljs-built_in,
+ .hljs-builtin-name {
+ color: #0086b3;
+ }
+
+ .hljs-meta {
+ color: #999;
+ font-weight: bold;
+ }
+
+ .hljs-deletion {
+ background: #fdd;
+ }
+
+ .hljs-addition {
+ background: #dfd;
+ }
+
+ .hljs-emphasis {
+ font-style: italic;
+ }
+
+ .hljs-strong {
+ font-weight: bold;
+ }
\ No newline at end of file
diff --git a/docs/css/style.css b/docs/css/style.css
new file mode 100644
index 0000000000..16777e5366
--- /dev/null
+++ b/docs/css/style.css
@@ -0,0 +1,107 @@
+body {
+ font-family: -apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol";
+ font-size: 16px;
+ line-height: 1.5;
+ word-wrap: break-word;
+ background: #F9F9F9;
+}
+
+#container {
+ max-width: 900px;
+ margin: auto;
+}
+
+#content {
+ padding: 5px 10px;
+ border: 1px solid #ddd;
+ border-radius: 3px;
+ background: white;
+}
+
+#content h1:first-child {
+ margin-top: 0px;
+}
+
+nav {
+ border: 1px solid #ddd;
+ border-radius: 3px;
+ background: white;
+ margin-right: 10px;
+}
+
+nav > ul {
+ position: sticky;
+ top: 5px;
+ margin: 10px 0px;
+ padding: 0;
+ list-style-type: none;
+ font-size: 14px;
+}
+
+nav > ul > li {
+ min-width: 125px;
+ padding: 0px 15px;
+}
+
+nav > ul > li > ul {
+ padding-left: 25px;
+}
+
+nav > ul > li > ul > li {
+ font-size: 0.8em;
+}
+
+nav .selected {
+ color: #111;
+ font-weight: bold;
+}
+
+nav .selected:hover {
+ text-decoration: none;
+}
+
+header {
+ display: flex;
+}
+
+header h1 { margin: 0; }
+
+table {
+ border-spacing: 0;
+ border-collapse: collapse;
+ border: 1px solid #ddd;
+}
+
+td, th {
+ border: 1px solid #ddd;
+ padding: 5px;
+}
+
+a {
+ color: #0366d6;
+ text-decoration: none;
+}
+
+a:hover {
+ text-decoration: underline;
+}
+
+pre {
+ font-family: "SFMono-Regular",Consolas,"Liberation Mono",Menlo,Courier,monospace;
+ padding: 16px;
+ overflow: auto;
+ font-size: 85%;
+ line-height: 1.45;
+ background-color: #f6f8fa;
+ border-radius: 3px;
+}
+
+code:not([class]) {
+ padding: 0.2em 0.4em;
+ margin: 0;
+ font-size: 85%;
+ background-color: rgba(27,31,35,0.05);
+ border-radius: 3px;
+}
+
+.github-corner:hover .octo-arm{animation:octocat-wave 560ms ease-in-out}@keyframes octocat-wave{0%,100%{transform:rotate(0)}20%,60%{transform:rotate(-25deg)}40%,80%{transform:rotate(10deg)}}@media (max-width:500px){.github-corner:hover .octo-arm{animation:none}.github-corner .octo-arm{animation:octocat-wave 560ms ease-in-out}}
diff --git a/docs/demo/demo.css b/docs/demo/demo.css
new file mode 100644
index 0000000000..8c39573b67
--- /dev/null
+++ b/docs/demo/demo.css
@@ -0,0 +1,76 @@
+html, body {
+ margin: 0;
+ padding: 0;
+ font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+ color: #333;
+ background-color: #fbfbfb;
+ height: 100%;
+}
+
+textarea {
+ font-family: Menlo, Monaco, Consolas, "Courier New", monospace;
+ font-size: 12px;
+ resize: none;
+}
+
+header {
+ padding-top: 10px;
+ display: flex;
+ height: 58px;
+}
+
+header h1 {
+ margin: 0;
+}
+
+.github-ribbon {
+ position: absolute;
+ top: 0;
+ right: 0;
+ border: 0;
+ z-index: 1000;
+}
+
+.other-demos {
+ margin-left: 3em;
+}
+
+.containers {
+ display: flex;
+ height: calc(100vh - 68px);
+}
+
+.container {
+ flex-basis: 50%;
+ padding: 5px;
+ display: flex;
+ flex-direction: column;
+ height: 100%;
+ box-sizing: border-box;
+}
+
+.pane, .inputPane {
+ margin-top: 5px;
+ padding: 0.6em;
+ border: 1px solid #ccc;
+ overflow: auto;
+ flex-grow: 1;
+ flex-shrink: 1;
+}
+
+#preview {
+ display: flex;
+}
+
+#preview iframe {
+ flex-grow: 1;
+}
+
+#main {
+ display: none;
+}
+
+.error {
+ border-color: red;
+ background-color: #FEE
+}
diff --git a/docs/demo/demo.js b/docs/demo/demo.js
new file mode 100644
index 0000000000..40a8c4840a
--- /dev/null
+++ b/docs/demo/demo.js
@@ -0,0 +1,576 @@
+/* globals marked, unfetch, ES6Promise, Promise */ // eslint-disable-line no-redeclare
+
+if (!window.Promise) {
+ window.Promise = ES6Promise;
+}
+if (!window.fetch) {
+ window.fetch = unfetch;
+}
+
+onunhandledrejection = function(e) {
+ throw e.reason;
+};
+
+var $loadingElem = document.querySelector('#loading');
+var $mainElem = document.querySelector('#main');
+var $markdownElem = document.querySelector('#markdown');
+var $markedVerElem = document.querySelector('#markedVersion');
+var $commitVerElem = document.querySelector('#commitVersion');
+var $markedVer = document.querySelector('#markedCdn');
+var $optionsElem = document.querySelector('#options');
+var $outputTypeElem = document.querySelector('#outputType');
+var $inputTypeElem = document.querySelector('#inputType');
+var $responseTimeElem = document.querySelector('#responseTime');
+var $previewElem = document.querySelector('#preview');
+var $previewIframe = document.querySelector('#preview iframe');
+var $permalinkElem = document.querySelector('#permalink');
+var $clearElem = document.querySelector('#clear');
+var $htmlElem = document.querySelector('#html');
+var $lexerElem = document.querySelector('#lexer');
+var $panes = document.querySelectorAll('.pane');
+var $inputPanes = document.querySelectorAll('.inputPane');
+var lastInput = '';
+var inputDirty = true;
+var $activeOutputElem = null;
+var search = searchToObject();
+var markedVersions = {
+ master: 'https://cdn.jsdelivr.net/gh/markedjs/marked/marked.min.js'
+};
+var markedVersionCache = {};
+var delayTime = 1;
+var checkChangeTimeout = null;
+var markedWorker;
+
+$previewIframe.addEventListener('load', handleIframeLoad);
+
+$outputTypeElem.addEventListener('change', handleOutputChange, false);
+
+$inputTypeElem.addEventListener('change', handleInputChange, false);
+
+$markedVerElem.addEventListener('change', handleVersionChange, false);
+
+$markdownElem.addEventListener('change', handleInput, false);
+$markdownElem.addEventListener('keyup', handleInput, false);
+$markdownElem.addEventListener('keypress', handleInput, false);
+$markdownElem.addEventListener('keydown', handleInput, false);
+
+$optionsElem.addEventListener('change', handleInput, false);
+$optionsElem.addEventListener('keyup', handleInput, false);
+$optionsElem.addEventListener('keypress', handleInput, false);
+$optionsElem.addEventListener('keydown', handleInput, false);
+
+$commitVerElem.style.display = 'none';
+$commitVerElem.addEventListener('keypress', handleAddVersion, false);
+
+$clearElem.addEventListener('click', handleClearClick, false);
+
+Promise.all([
+ setInitialQuickref(),
+ setInitialOutputType(),
+ setInitialText(),
+ setInitialVersion()
+ .then(setInitialOptions)
+]).then(function() {
+ handleInputChange();
+ handleOutputChange();
+ checkForChanges();
+ setScrollPercent(0);
+ $loadingElem.style.display = 'none';
+ $mainElem.style.display = 'block';
+});
+
+function setInitialText() {
+ if ('text' in search) {
+ $markdownElem.value = search.text;
+ } else {
+ return fetch('./initial.md')
+ .then(function(res) { return res.text(); })
+ .then(function(text) {
+ if ($markdownElem.value === '') {
+ $markdownElem.value = text;
+ }
+ });
+ }
+}
+
+function setInitialQuickref() {
+ return fetch('./quickref.md')
+ .then(function(res) { return res.text(); })
+ .then(function(text) {
+ document.querySelector('#quickref').value = text;
+ });
+}
+
+function setInitialVersion() {
+ return fetch('https://data.jsdelivr.com/v1/package/npm/marked')
+ .then(function(res) {
+ return res.json();
+ })
+ .then(function(json) {
+ for (var i = 0; i < json.versions.length; i++) {
+ var ver = json.versions[i];
+ markedVersions[ver] = 'https://cdn.jsdelivr.net/npm/marked@' + ver + '/marked.min.js';
+ var opt = document.createElement('option');
+ opt.textContent = ver;
+ opt.value = ver;
+ $markedVerElem.appendChild(opt);
+ }
+ })
+ .then(function() {
+ return fetch('https://api.github.com/repos/markedjs/marked/commits')
+ .then(function(res) {
+ return res.json();
+ })
+ .then(function(json) {
+ markedVersions.master = 'https://cdn.jsdelivr.net/gh/markedjs/marked@' + json[0].sha + '/marked.min.js';
+ })
+ .catch(function() {
+ // do nothing
+ // uses url without commit
+ });
+ })
+ .then(function() {
+ if (search.version) {
+ if (markedVersions[search.version]) {
+ return search.version;
+ } else {
+ var match = search.version.match(/^(\w+):(.+)$/);
+ if (match) {
+ switch (match[1]) {
+ case 'commit':
+ addCommitVersion(search.version, match[2].substring(0, 7), match[2]);
+ return search.version;
+ case 'pr':
+ return getPrCommit(match[2])
+ .then(function(commit) {
+ if (!commit) {
+ return 'master';
+ }
+ addCommitVersion(search.version, 'PR #' + match[2], commit);
+ return search.version;
+ });
+ }
+ }
+ }
+ }
+
+ return 'master';
+ })
+ .then(function(version) {
+ $markedVerElem.value = version;
+ })
+ .then(updateVersion);
+}
+
+function setInitialOptions() {
+ if ('options' in search) {
+ $optionsElem.value = search.options;
+ } else {
+ return setDefaultOptions();
+ }
+}
+
+function setInitialOutputType() {
+ if (search.outputType) {
+ $outputTypeElem.value = search.outputType;
+ }
+}
+
+function handleIframeLoad() {
+ lastInput = '';
+ inputDirty = true;
+}
+
+function handleInput() {
+ inputDirty = true;
+}
+
+function handleVersionChange() {
+ if ($markedVerElem.value === 'commit' || $markedVerElem.value === 'pr') {
+ $commitVerElem.style.display = '';
+ } else {
+ $commitVerElem.style.display = 'none';
+ updateVersion();
+ }
+}
+
+function handleClearClick() {
+ $markdownElem.value = '';
+ $markedVerElem.value = 'master';
+ $commitVerElem.style.display = 'none';
+ updateVersion().then(setDefaultOptions);
+}
+
+function handleAddVersion(e) {
+ if (e.which === 13) {
+ switch ($markedVerElem.value) {
+ case 'commit':
+ var commit = $commitVerElem.value.toLowerCase();
+ if (!commit.match(/^[0-9a-f]{40}$/)) {
+ alert('That is not a valid commit');
+ return;
+ }
+ addCommitVersion('commit:' + commit, commit.substring(0, 7), commit);
+ $markedVerElem.value = 'commit:' + commit;
+ $commitVerElem.style.display = 'none';
+ $commitVerElem.value = '';
+ updateVersion();
+ break;
+ case 'pr':
+ $commitVerElem.disabled = true;
+ var pr = $commitVerElem.value.replace(/\D/g, '');
+ getPrCommit(pr)
+ .then(function(commit) {
+ $commitVerElem.disabled = false;
+ if (!commit) {
+ alert('That is not a valid PR');
+ return;
+ }
+ addCommitVersion('pr:' + pr, 'PR #' + pr, commit);
+ $markedVerElem.value = 'pr:' + pr;
+ $commitVerElem.style.display = 'none';
+ $commitVerElem.value = '';
+ updateVersion();
+ });
+ }
+ }
+}
+
+function handleInputChange() {
+ handleChange($inputPanes, $inputTypeElem.value);
+}
+
+function handleOutputChange() {
+ $activeOutputElem = handleChange($panes, $outputTypeElem.value);
+ updateLink();
+}
+
+function handleChange(panes, visiblePane) {
+ var active = null;
+ for (var i = 0; i < panes.length; i++) {
+ if (panes[i].id === visiblePane) {
+ panes[i].style.display = '';
+ active = panes[i];
+ } else {
+ panes[i].style.display = 'none';
+ }
+ }
+ return active;
+}
+
+function addCommitVersion(value, text, commit) {
+ if (markedVersions[value]) {
+ return;
+ }
+ markedVersions[value] = 'https://cdn.jsdelivr.net/gh/markedjs/marked@' + commit + '/marked.min.js';
+ var opt = document.createElement('option');
+ opt.textContent = text;
+ opt.value = value;
+ $markedVerElem.insertBefore(opt, $markedVerElem.firstChild);
+}
+
+function getPrCommit(pr) {
+ return fetch('https://api.github.com/repos/markedjs/marked/pulls/' + pr + '/commits')
+ .then(function(res) {
+ return res.json();
+ })
+ .then(function(json) {
+ return json[json.length - 1].sha;
+ }).catch(function() {
+ // return undefined
+ });
+}
+
+function setDefaultOptions() {
+ if (window.Worker) {
+ return messageWorker({
+ task: 'defaults',
+ version: markedVersions[$markedVerElem.value]
+ });
+ } else {
+ var defaults = marked.getDefaults();
+ setOptions(defaults);
+ }
+}
+
+function setOptions(opts) {
+ $optionsElem.value = JSON.stringify(
+ opts,
+ function(key, value) {
+ if (value && typeof value === 'object' && Object.getPrototypeOf(value) !== Object.prototype) {
+ return undefined;
+ }
+ return value;
+ }, ' ');
+}
+
+function searchToObject() {
+ // modified from https://stackoverflow.com/a/7090123/806777
+ var pairs = location.search.slice(1).split('&');
+ var obj = {};
+
+ for (var i = 0; i < pairs.length; i++) {
+ if (pairs[i] === '') {
+ continue;
+ }
+
+ var pair = pairs[i].split('=');
+
+ obj[decodeURIComponent(pair.shift())] = decodeURIComponent(pair.join('='));
+ }
+
+ return obj;
+}
+
+function isArray(arr) {
+ return Object.prototype.toString.call(arr) === '[object Array]';
+}
+
+function stringRepeat(char, times) {
+ var s = '';
+ for (var i = 0; i < times; i++) {
+ s += char;
+ }
+ return s;
+}
+
+function jsonString(input, level) {
+ level = level || 0;
+ if (isArray(input)) {
+ if (input.length === 0) {
+ return '[]';
+ }
+ var items = [],
+ i;
+ if (!isArray(input[0]) && typeof input[0] === 'object' && input[0] !== null) {
+ for (i = 0; i < input.length; i++) {
+ items.push(stringRepeat(' ', 2 * level) + jsonString(input[i], level + 1));
+ }
+ return '[\n' + items.join('\n') + '\n]';
+ }
+ for (i = 0; i < input.length; i++) {
+ items.push(jsonString(input[i], level));
+ }
+ return '[' + items.join(', ') + ']';
+ } else if (typeof input === 'object' && input !== null) {
+ var props = [];
+ for (var prop in input) {
+ props.push(prop + ':' + jsonString(input[prop], level));
+ }
+ return '{' + props.join(', ') + '}';
+ } else {
+ return JSON.stringify(input);
+ }
+}
+
+function getScrollSize() {
+ var e = $activeOutputElem;
+
+ return e.scrollHeight - e.clientHeight;
+}
+
+function getScrollPercent() {
+ var size = getScrollSize();
+
+ if (size <= 0) {
+ return 1;
+ }
+
+ return $activeOutputElem.scrollTop / size;
+}
+
+function setScrollPercent(percent) {
+ $activeOutputElem.scrollTop = percent * getScrollSize();
+}
+
+function updateLink() {
+ var outputType = '';
+ if ($outputTypeElem.value !== 'preview') {
+ outputType = 'outputType=' + $outputTypeElem.value + '&';
+ }
+
+ $permalinkElem.href = '?' + outputType + 'text=' + encodeURIComponent($markdownElem.value)
+ + '&options=' + encodeURIComponent($optionsElem.value)
+ + '&version=' + encodeURIComponent($markedVerElem.value);
+ history.replaceState('', document.title, $permalinkElem.href);
+}
+
+function updateVersion() {
+ if (window.Worker) {
+ handleInput();
+ return Promise.resolve();
+ }
+ var promise;
+ if (markedVersionCache[$markedVerElem.value]) {
+ promise = Promise.resolve(markedVersionCache[$markedVerElem.value]);
+ } else {
+ promise = fetch(markedVersions[$markedVerElem.value])
+ .then(function(res) { return res.text(); })
+ .then(function(text) {
+ markedVersionCache[$markedVerElem.value] = text;
+ return text;
+ });
+ }
+ return promise.then(function(text) {
+ var script = document.createElement('script');
+ script.textContent = text;
+
+ $markedVer.parentNode.replaceChild(script, $markedVer);
+ $markedVer = script;
+ }).then(handleInput);
+}
+
+function checkForChanges() {
+ if (inputDirty && $markedVerElem.value !== 'commit' && $markedVerElem.value !== 'pr' && (typeof marked !== 'undefined' || window.Worker)) {
+ inputDirty = false;
+
+ updateLink();
+
+ var options = {};
+ var optionsString = $optionsElem.value || '{}';
+ try {
+ var newOptions = JSON.parse(optionsString);
+ options = newOptions;
+ $optionsElem.classList.remove('error');
+ } catch (err) {
+ $optionsElem.classList.add('error');
+ }
+
+ var version = markedVersions[$markedVerElem.value];
+ var markdown = $markdownElem.value;
+ var hash = version + markdown + optionsString;
+ if (lastInput !== hash) {
+ lastInput = hash;
+ if (window.Worker) {
+ delayTime = 100;
+ messageWorker({
+ task: 'parse',
+ version: version,
+ markdown: markdown,
+ options: options
+ });
+ } else {
+ var startTime = new Date();
+ var lexed = marked.lexer(markdown, options);
+ var lexedList = jsonString(lexed);
+ var parsed = marked.parser(lexed, options);
+ var endTime = new Date();
+
+ $previewElem.classList.remove('error');
+ $htmlElem.classList.remove('error');
+ $lexerElem.classList.remove('error');
+ var scrollPercent = getScrollPercent();
+ setParsed(parsed, lexedList);
+ setScrollPercent(scrollPercent);
+ delayTime = endTime - startTime;
+ setResponseTime(delayTime);
+ if (delayTime < 50) {
+ delayTime = 50;
+ } else if (delayTime > 500) {
+ delayTime = 1000;
+ }
+ }
+ }
+ }
+ checkChangeTimeout = window.setTimeout(checkForChanges, delayTime);
+}
+
+function setResponseTime(ms) {
+ var amount = ms;
+ var suffix = 'ms';
+ if (ms > 1000 * 60 * 60) {
+ amount = 'Too Long';
+ suffix = '';
+ } else if (ms > 1000 * 60) {
+ amount = '>' + Math.floor(ms / (1000 * 60));
+ suffix = 'm';
+ } else if (ms > 1000) {
+ amount = '>' + Math.floor(ms / 1000);
+ suffix = 's';
+ }
+ $responseTimeElem.textContent = amount + suffix;
+}
+
+function setParsed(parsed, lexed) {
+ try {
+ $previewIframe.contentDocument.body.innerHTML = parsed;
+ } catch (ex) {}
+ $htmlElem.value = parsed;
+ $lexerElem.value = lexed;
+}
+
+var workerPromises = {};
+function messageWorker(message) {
+ if (!markedWorker || markedWorker.working) {
+ if (markedWorker) {
+ clearTimeout(markedWorker.timeout);
+ markedWorker.terminate();
+ }
+ markedWorker = new Worker('worker.js');
+ markedWorker.onmessage = function(e) {
+ clearTimeout(markedWorker.timeout);
+ markedWorker.working = false;
+ switch (e.data.task) {
+ case 'defaults':
+ setOptions(e.data.defaults);
+ break;
+ case 'parse':
+ $previewElem.classList.remove('error');
+ $htmlElem.classList.remove('error');
+ $lexerElem.classList.remove('error');
+ var scrollPercent = getScrollPercent();
+ setParsed(e.data.parsed, e.data.lexed);
+ setScrollPercent(scrollPercent);
+ setResponseTime(e.data.time);
+ break;
+ }
+ clearTimeout(checkChangeTimeout);
+ delayTime = 10;
+ checkForChanges();
+ workerPromises[e.data.id]();
+ delete workerPromises[e.data.id];
+ };
+ markedWorker.onerror = markedWorker.onmessageerror = function(err) {
+ clearTimeout(markedWorker.timeout);
+ var error = 'There was an error in the Worker';
+ if (err) {
+ if (err.message) {
+ error = err.message;
+ } else {
+ error = err;
+ }
+ }
+ error = error.replace(/^Uncaught Error: /, '');
+ $previewElem.classList.add('error');
+ $htmlElem.classList.add('error');
+ $lexerElem.classList.add('error');
+ setParsed(error, error);
+ setScrollPercent(0);
+ };
+ }
+ if (message.task !== 'defaults') {
+ markedWorker.working = true;
+ workerTimeout(0);
+ }
+ return new Promise(function(resolve) {
+ message.id = uniqueWorkerMessageId();
+ workerPromises[message.id] = resolve;
+ markedWorker.postMessage(message);
+ });
+}
+
+function uniqueWorkerMessageId() {
+ var id;
+ do {
+ id = Math.random().toString(36);
+ } while (id in workerPromises);
+ return id;
+}
+
+function workerTimeout(seconds) {
+ markedWorker.timeout = setTimeout(function() {
+ seconds++;
+ markedWorker.onerror('Marked has taken longer than ' + seconds + ' second' + (seconds > 1 ? 's' : '') + ' to respond...');
+ workerTimeout(seconds);
+ }, 1000);
+}
diff --git a/docs/demo/index.html b/docs/demo/index.html
new file mode 100644
index 0000000000..6fba36f76e
--- /dev/null
+++ b/docs/demo/index.html
@@ -0,0 +1,83 @@
+
+
+
+
+ Marked Demo
+
+
+
+
+
+ 
+
+
+
+
+ 
+
+ Marked Demo
+
+
+
+ Loading...
+
+
+
+
+
+
+
+
+
+
+ ·
+ Response Time:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/demo/initial.md b/docs/demo/initial.md
new file mode 100644
index 0000000000..d2b7d77c10
--- /dev/null
+++ b/docs/demo/initial.md
@@ -0,0 +1,36 @@
+Marked - Markdown Parser
+========================
+
+[Marked] lets you convert [Markdown] into HTML. Markdown is a simple text format whose goal is to be very easy to read and write, even when not converted to HTML. This demo page will let you type anything you like and see how it gets converted. Live. No more waiting around.
+
+How To Use The Demo
+-------------------
+
+1. Type in stuff on the left.
+2. See the live updates on the right.
+
+That's it. Pretty simple. There's also a drop-down option in the upper right to switch between various views:
+
+- **Preview:** A live display of the generated HTML as it would render in a browser.
+- **HTML Source:** The generated HTML before your browser makes it pretty.
+- **Lexer Data:** What [marked] uses internally, in case you like gory stuff like this.
+- **Quick Reference:** A brief run-down of how to format things using markdown.
+
+Why Markdown?
+-------------
+
+It's easy. It's not overly bloated, unlike HTML. Also, as the creator of [markdown] says,
+
+> The overriding design goal for Markdown's
+> formatting syntax is to make it as readable
+> as possible. The idea is that a
+> Markdown-formatted document should be
+> publishable as-is, as plain text, without
+> looking like it's been marked up with tags
+> or formatting instructions.
+
+Ready to start writing? Either start changing stuff on the left or
+[clear everything](/demo/?text=) with a simple click.
+
+[Marked]: https://github.com/markedjs/marked/
+[Markdown]: http://daringfireball.net/projects/markdown/
diff --git a/docs/demo/preview.html b/docs/demo/preview.html
new file mode 100644
index 0000000000..7e8c89fec5
--- /dev/null
+++ b/docs/demo/preview.html
@@ -0,0 +1,12 @@
+
+
+
+
+
+ marked.js preview
+
+ ` HTML tags work, or maybe you are a programmer and you are discussing `someMethod()`.
+
+If you want to include code and have new
+lines preserved, indent the line with a tab
+or at least four spaces:
+
+ Extra spaces work here too.
+ This is also called preformatted text and it is useful for showing examples.
+ The text will stay as text, so any *markdown* or HTML you add will
+ not show up formatted. This way you can show markdown examples in a
+ markdown document.
+
+> You can also use preformatted text with your blockquotes
+> as long as you add at least five spaces.
+
+
+Headings
+========
+
+There are a couple of ways to make headings. Using three or more equals signs on a line under a heading makes it into an "h1" style. Three or more hyphens under a line makes it "h2" (slightly smaller). You can also use multiple pound symbols (`#`) before and after a heading. Pounds after the title are ignored. Here are some examples:
+
+This is H1
+==========
+
+This is H2
+----------
+
+# This is H1
+## This is H2
+### This is H3 with some extra pounds ###
+#### You get the idea ####
+##### I don't need extra pounds at the end
+###### H6 is the max
+
+
+Links
+=====
+
+Let's link to a few sites. First, let's use the bare URL, like . Great for text, but ugly for HTML.
+Next is an inline link to [Google](https://www.google.com). A little nicer.
+This is a reference-style link to [Wikipedia] [1].
+Lastly, here's a pretty link to [Yahoo]. The reference-style and pretty links both automatically use the links defined below, but they could be defined *anywhere* in the markdown and are removed from the HTML. The names are also case insensitive, so you can use [YaHoO] and have it link properly.
+
+[1]: https://www.wikipedia.org
+[Yahoo]: https://www.yahoo.com
+
+Title attributes may be added to links by adding text after a link.
+This is the [inline link](https://www.bing.com "Bing") with a "Bing" title.
+You can also go to [W3C] [2] and maybe visit a [friend].
+
+[2]: https://w3c.org (The W3C puts out specs for web-based things)
+[Friend]: https://facebook.com "Facebook!"
+
+Email addresses in plain text are not linked: test@example.com.
+Email addresses wrapped in angle brackets are linked: .
+They are also obfuscated so that email harvesting spam robots hopefully won't get them.
+
+
+Lists
+=====
+
+* This is a bulleted list
+* Great for shopping lists
+- You can also use hyphens
++ Or plus symbols
+
+The above is an "unordered" list. Now, on for a bit of order.
+
+1. Numbered lists are also easy
+2. Just start with a number
+3738762. However, the actual number doesn't matter when converted to HTML.
+1. This will still show up as 4.
+
+You might want a few advanced lists:
+
+- This top-level list is wrapped in paragraph tags
+- This generates an extra space between each top-level item.
+
+- You do it by adding a blank line
+
+- This nested list also has blank lines between the list items.
+
+- How to create nested lists
+ 1. Start your regular list
+ 2. Indent nested lists with two spaces
+ 3. Further nesting means you should indent with two more spaces
+ * This line is indented with four spaces.
+
+- List items can be quite lengthy. You can keep typing and either continue
+them on the next line with no indentation.
+
+- Alternately, if that looks ugly, you can also
+ indent the next line a bit for a prettier look.
+
+- You can put large blocks of text in your list by just indenting with two spaces.
+
+ This is formatted the same as code, but you can inspect the HTML
+ and find that it's just wrapped in a `` tag and *won't* be shown
+ as preformatted text.
+
+ You can keep adding more and more paragraphs to a single
+ list item by adding the traditional blank line and then keep
+ on indenting the paragraphs with two spaces.
+
+ You really only need to indent the first line,
+but that looks ugly.
+
+- Lists support blockquotes
+
+ > Just like this example here. By the way, you can
+ > nest lists inside blockquotes!
+ > - Fantastic!
+
+- Lists support preformatted text
+
+ You just need to indent an additional four spaces.
+
+
+Even More
+=========
+
+Horizontal Rule
+---------------
+
+If you need a horizontal rule you just need to put at least three hyphens, asterisks, or underscores on a line by themselves. You can also even put spaces between the characters.
+
+---
+****************************
+_ _ _ _ _ _ _
+
+Those three all produced horizontal lines. Keep in mind that three hyphens under any text turns that text into a heading, so add a blank like if you use hyphens.
+
+Images
+------
+
+Images work exactly like links, but they have exclamation points in front. They work with references and titles too.
+
+ and ![Happy].
+
+[Happy]: https://wpclipart.com/smiley/happy/simple_colors/smiley_face_simple_green_small.png ("Smiley face")
+
+
+Inline HTML
+-----------
+
+If markdown is too limiting, you can just insert your own crazy HTML. Span-level HTML can *still* use markdown. Block level elements must be separated from text by a blank line and must not have any spaces before the opening and closing HTML.
+
+
+It is a pity, but markdown does **not** work in here for most markdown parsers.
+[Marked] handles it pretty well.
+
diff --git a/docs/demo/worker.js b/docs/demo/worker.js
new file mode 100644
index 0000000000..828284c047
--- /dev/null
+++ b/docs/demo/worker.js
@@ -0,0 +1,125 @@
+/* globals marked, unfetch, ES6Promise, Promise */ // eslint-disable-line no-redeclare
+
+if (!self.Promise) {
+ self.importScripts('https://cdn.jsdelivr.net/npm/es6-promise/dist/es6-promise.js');
+ self.Promise = ES6Promise;
+}
+if (!self.fetch) {
+ self.importScripts('https://cdn.jsdelivr.net/npm/unfetch/dist/unfetch.umd.js');
+ self.fetch = unfetch;
+}
+
+var versionCache = {};
+var currentVersion;
+
+onunhandledrejection = function(e) {
+ throw e.reason;
+};
+
+onmessage = function(e) {
+ if (e.data.version === currentVersion) {
+ parse(e);
+ } else {
+ loadVersion(e.data.version).then(function() {
+ parse(e);
+ });
+ }
+};
+
+function parse(e) {
+ switch (e.data.task) {
+ case 'defaults':
+
+ var defaults = {};
+ if (typeof marked.getDefaults === 'function') {
+ defaults = marked.getDefaults();
+ delete defaults.renderer;
+ } else if ('defaults' in marked) {
+ for (var prop in marked.defaults) {
+ if (prop !== 'renderer') {
+ defaults[prop] = marked.defaults[prop];
+ }
+ }
+ }
+ postMessage({
+ id: e.data.id,
+ task: e.data.task,
+ defaults: defaults
+ });
+ break;
+ case 'parse':
+ var startTime = new Date();
+ var lexed = marked.lexer(e.data.markdown, e.data.options);
+ var lexedList = jsonString(lexed);
+ var parsed = marked.parser(lexed, e.data.options);
+ var endTime = new Date();
+ postMessage({
+ id: e.data.id,
+ task: e.data.task,
+ lexed: lexedList,
+ parsed: parsed,
+ time: endTime - startTime
+ });
+ break;
+ }
+}
+
+function stringRepeat(char, times) {
+ var s = '';
+ for (var i = 0; i < times; i++) {
+ s += char;
+ }
+ return s;
+}
+
+function jsonString(input, level) {
+ level = level || 0;
+ if (Array.isArray(input)) {
+ if (input.length === 0) {
+ return '[]';
+ }
+ var items = [],
+ i;
+ if (!Array.isArray(input[0]) && typeof input[0] === 'object' && input[0] !== null) {
+ for (i = 0; i < input.length; i++) {
+ items.push(stringRepeat(' ', 2 * level) + jsonString(input[i], level + 1));
+ }
+ return '[\n' + items.join('\n') + '\n]';
+ }
+ for (i = 0; i < input.length; i++) {
+ items.push(jsonString(input[i], level));
+ }
+ return '[' + items.join(', ') + ']';
+ } else if (typeof input === 'object' && input !== null) {
+ var props = [];
+ for (var prop in input) {
+ props.push(prop + ':' + jsonString(input[prop], level));
+ }
+ return '{' + props.join(', ') + '}';
+ } else {
+ return JSON.stringify(input);
+ }
+}
+
+function loadVersion(ver) {
+ var promise;
+ if (versionCache[ver]) {
+ promise = Promise.resolve(versionCache[ver]);
+ } else {
+ promise = fetch(ver)
+ .then(function(res) { return res.text(); })
+ .then(function(text) {
+ versionCache[ver] = text;
+ return text;
+ });
+ }
+ return promise.then(function(text) {
+ try {
+ // eslint-disable-next-line no-new-func
+ Function(text)();
+ } catch (err) {
+ throw new Error('Cannot load that version of marked');
+ }
+ currentVersion = ver;
+ });
+}
diff --git a/docs/favicon.ico b/docs/favicon.ico
new file mode 100644
index 0000000000..cc3f13a2d0
Binary files /dev/null and b/docs/favicon.ico differ
diff --git a/docs/img/logo-black-and-white.svg b/docs/img/logo-black-and-white.svg
new file mode 100644
index 0000000000..5f6c0b781b
--- /dev/null
+++ b/docs/img/logo-black-and-white.svg
@@ -0,0 +1,133 @@
+
+
+
+
\ No newline at end of file
diff --git a/docs/img/logo-black.svg b/docs/img/logo-black.svg
new file mode 100644
index 0000000000..adbc248fa5
--- /dev/null
+++ b/docs/img/logo-black.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/index.js b/index.js
deleted file mode 100644
index a12f90569f..0000000000
--- a/index.js
+++ /dev/null
@@ -1 +0,0 @@
-module.exports = require('./lib/marked');
diff --git a/jasmine.json b/jasmine.json
new file mode 100644
index 0000000000..c2728eef27
--- /dev/null
+++ b/jasmine.json
@@ -0,0 +1,12 @@
+{
+ "spec_dir": "test",
+ "spec_files": [
+ "**/*-spec.js"
+ ],
+ "helpers": [
+ "helpers/helpers.js"
+ ],
+ "jsLoader": "import",
+ "stopSpecOnExpectationFailure": false,
+ "random": true
+}
diff --git a/lib/marked.cjs b/lib/marked.cjs
new file mode 100644
index 0000000000..5ce847148f
--- /dev/null
+++ b/lib/marked.cjs
@@ -0,0 +1,2931 @@
+/**
+ * marked - a markdown parser
+ * Copyright (c) 2011-2022, Christopher Jeffrey. (MIT Licensed)
+ * https://github.com/markedjs/marked
+ */
+
+/**
+ * DO NOT EDIT THIS FILE
+ * The code in this file is generated from files in ./src/
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _defineProperties(target, props) {
+ for (var i = 0; i < props.length; i++) {
+ var descriptor = props[i];
+ descriptor.enumerable = descriptor.enumerable || false;
+ descriptor.configurable = true;
+ if ("value" in descriptor) descriptor.writable = true;
+ Object.defineProperty(target, descriptor.key, descriptor);
+ }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+ if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+ if (staticProps) _defineProperties(Constructor, staticProps);
+ Object.defineProperty(Constructor, "prototype", {
+ writable: false
+ });
+ return Constructor;
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+ if (!o) return;
+ if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+ var n = Object.prototype.toString.call(o).slice(8, -1);
+ if (n === "Object" && o.constructor) n = o.constructor.name;
+ if (n === "Map" || n === "Set") return Array.from(o);
+ if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _arrayLikeToArray(arr, len) {
+ if (len == null || len > arr.length) len = arr.length;
+
+ for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+ return arr2;
+}
+
+function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+ var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+ if (it) return (it = it.call(o)).next.bind(it);
+
+ if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+ if (it) o = it;
+ var i = 0;
+ return function () {
+ if (i >= o.length) return {
+ done: true
+ };
+ return {
+ done: false,
+ value: o[i++]
+ };
+ };
+ }
+
+ throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function getDefaults() {
+ return {
+ baseUrl: null,
+ breaks: false,
+ extensions: null,
+ gfm: true,
+ headerIds: true,
+ headerPrefix: '',
+ highlight: null,
+ langPrefix: 'language-',
+ mangle: true,
+ pedantic: false,
+ renderer: null,
+ sanitize: false,
+ sanitizer: null,
+ silent: false,
+ smartLists: false,
+ smartypants: false,
+ tokenizer: null,
+ walkTokens: null,
+ xhtml: false
+ };
+}
+exports.defaults = getDefaults();
+function changeDefaults(newDefaults) {
+ exports.defaults = newDefaults;
+}
+
+/**
+ * Helpers
+ */
+var escapeTest = /[&<>"']/;
+var escapeReplace = /[&<>"']/g;
+var escapeTestNoEncode = /[<>"']|&(?!#?\w+;)/;
+var escapeReplaceNoEncode = /[<>"']|&(?!#?\w+;)/g;
+var escapeReplacements = {
+ '&': '&',
+ '<': '<',
+ '>': '>',
+ '"': '"',
+ "'": '''
+};
+
+var getEscapeReplacement = function getEscapeReplacement(ch) {
+ return escapeReplacements[ch];
+};
+
+function escape(html, encode) {
+ if (encode) {
+ if (escapeTest.test(html)) {
+ return html.replace(escapeReplace, getEscapeReplacement);
+ }
+ } else {
+ if (escapeTestNoEncode.test(html)) {
+ return html.replace(escapeReplaceNoEncode, getEscapeReplacement);
+ }
+ }
+
+ return html;
+}
+var unescapeTest = /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig;
+function unescape(html) {
+ // explicitly match decimal, hex, and named HTML entities
+ return html.replace(unescapeTest, function (_, n) {
+ n = n.toLowerCase();
+ if (n === 'colon') return ':';
+
+ if (n.charAt(0) === '#') {
+ return n.charAt(1) === 'x' ? String.fromCharCode(parseInt(n.substring(2), 16)) : String.fromCharCode(+n.substring(1));
+ }
+
+ return '';
+ });
+}
+var caret = /(^|[^\[])\^/g;
+function edit(regex, opt) {
+ regex = regex.source || regex;
+ opt = opt || '';
+ var obj = {
+ replace: function replace(name, val) {
+ val = val.source || val;
+ val = val.replace(caret, '$1');
+ regex = regex.replace(name, val);
+ return obj;
+ },
+ getRegex: function getRegex() {
+ return new RegExp(regex, opt);
+ }
+ };
+ return obj;
+}
+var nonWordAndColonTest = /[^\w:]/g;
+var originIndependentUrl = /^$|^[a-z][a-z0-9+.-]*:|^[?#]/i;
+function cleanUrl(sanitize, base, href) {
+ if (sanitize) {
+ var prot;
+
+ try {
+ prot = decodeURIComponent(unescape(href)).replace(nonWordAndColonTest, '').toLowerCase();
+ } catch (e) {
+ return null;
+ }
+
+ if (prot.indexOf('javascript:') === 0 || prot.indexOf('vbscript:') === 0 || prot.indexOf('data:') === 0) {
+ return null;
+ }
+ }
+
+ if (base && !originIndependentUrl.test(href)) {
+ href = resolveUrl(base, href);
+ }
+
+ try {
+ href = encodeURI(href).replace(/%25/g, '%');
+ } catch (e) {
+ return null;
+ }
+
+ return href;
+}
+var baseUrls = {};
+var justDomain = /^[^:]+:\/*[^/]*$/;
+var protocol = /^([^:]+:)[\s\S]*$/;
+var domain = /^([^:]+:\/*[^/]*)[\s\S]*$/;
+function resolveUrl(base, href) {
+ if (!baseUrls[' ' + base]) {
+ // we can ignore everything in base after the last slash of its path component,
+ // but we might need to add _that_
+ // https://tools.ietf.org/html/rfc3986#section-3
+ if (justDomain.test(base)) {
+ baseUrls[' ' + base] = base + '/';
+ } else {
+ baseUrls[' ' + base] = rtrim(base, '/', true);
+ }
+ }
+
+ base = baseUrls[' ' + base];
+ var relativeBase = base.indexOf(':') === -1;
+
+ if (href.substring(0, 2) === '//') {
+ if (relativeBase) {
+ return href;
+ }
+
+ return base.replace(protocol, '$1') + href;
+ } else if (href.charAt(0) === '/') {
+ if (relativeBase) {
+ return href;
+ }
+
+ return base.replace(domain, '$1') + href;
+ } else {
+ return base + href;
+ }
+}
+var noopTest = {
+ exec: function noopTest() {}
+};
+function merge(obj) {
+ var i = 1,
+ target,
+ key;
+
+ for (; i < arguments.length; i++) {
+ target = arguments[i];
+
+ for (key in target) {
+ if (Object.prototype.hasOwnProperty.call(target, key)) {
+ obj[key] = target[key];
+ }
+ }
+ }
+
+ return obj;
+}
+function splitCells(tableRow, count) {
+ // ensure that every cell-delimiting pipe has a space
+ // before it to distinguish it from an escaped pipe
+ var row = tableRow.replace(/\|/g, function (match, offset, str) {
+ var escaped = false,
+ curr = offset;
+
+ while (--curr >= 0 && str[curr] === '\\') {
+ escaped = !escaped;
+ }
+
+ if (escaped) {
+ // odd number of slashes means | is escaped
+ // so we leave it alone
+ return '|';
+ } else {
+ // add space before unescaped |
+ return ' |';
+ }
+ }),
+ cells = row.split(/ \|/);
+ var i = 0; // First/last cell in a row cannot be empty if it has no leading/trailing pipe
+
+ if (!cells[0].trim()) {
+ cells.shift();
+ }
+
+ if (!cells[cells.length - 1].trim()) {
+ cells.pop();
+ }
+
+ if (cells.length > count) {
+ cells.splice(count);
+ } else {
+ while (cells.length < count) {
+ cells.push('');
+ }
+ }
+
+ for (; i < cells.length; i++) {
+ // leading or trailing whitespace is ignored per the gfm spec
+ cells[i] = cells[i].trim().replace(/\\\|/g, '|');
+ }
+
+ return cells;
+} // Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').
+// /c*$/ is vulnerable to REDOS.
+// invert: Remove suffix of non-c chars instead. Default falsey.
+
+function rtrim(str, c, invert) {
+ var l = str.length;
+
+ if (l === 0) {
+ return '';
+ } // Length of suffix matching the invert condition.
+
+
+ var suffLen = 0; // Step left until we fail to match the invert condition.
+
+ while (suffLen < l) {
+ var currChar = str.charAt(l - suffLen - 1);
+
+ if (currChar === c && !invert) {
+ suffLen++;
+ } else if (currChar !== c && invert) {
+ suffLen++;
+ } else {
+ break;
+ }
+ }
+
+ return str.substr(0, l - suffLen);
+}
+function findClosingBracket(str, b) {
+ if (str.indexOf(b[1]) === -1) {
+ return -1;
+ }
+
+ var l = str.length;
+ var level = 0,
+ i = 0;
+
+ for (; i < l; i++) {
+ if (str[i] === '\\') {
+ i++;
+ } else if (str[i] === b[0]) {
+ level++;
+ } else if (str[i] === b[1]) {
+ level--;
+
+ if (level < 0) {
+ return i;
+ }
+ }
+ }
+
+ return -1;
+}
+function checkSanitizeDeprecation(opt) {
+ if (opt && opt.sanitize && !opt.silent) {
+ console.warn('marked(): sanitize and sanitizer parameters are deprecated since version 0.7.0, should not be used and will be removed in the future. Read more here: https://marked.js.org/#/USING_ADVANCED.md#options');
+ }
+} // copied from https://stackoverflow.com/a/5450113/806777
+
+function repeatString(pattern, count) {
+ if (count < 1) {
+ return '';
+ }
+
+ var result = '';
+
+ while (count > 1) {
+ if (count & 1) {
+ result += pattern;
+ }
+
+ count >>= 1;
+ pattern += pattern;
+ }
+
+ return result + pattern;
+}
+
+function outputLink(cap, link, raw, lexer) {
+ var href = link.href;
+ var title = link.title ? escape(link.title) : null;
+ var text = cap[1].replace(/\\([\[\]])/g, '$1');
+
+ if (cap[0].charAt(0) !== '!') {
+ lexer.state.inLink = true;
+ var token = {
+ type: 'link',
+ raw: raw,
+ href: href,
+ title: title,
+ text: text,
+ tokens: lexer.inlineTokens(text, [])
+ };
+ lexer.state.inLink = false;
+ return token;
+ } else {
+ return {
+ type: 'image',
+ raw: raw,
+ href: href,
+ title: title,
+ text: escape(text)
+ };
+ }
+}
+
+function indentCodeCompensation(raw, text) {
+ var matchIndentToCode = raw.match(/^(\s+)(?:```)/);
+
+ if (matchIndentToCode === null) {
+ return text;
+ }
+
+ var indentToCode = matchIndentToCode[1];
+ return text.split('\n').map(function (node) {
+ var matchIndentInNode = node.match(/^\s+/);
+
+ if (matchIndentInNode === null) {
+ return node;
+ }
+
+ var indentInNode = matchIndentInNode[0];
+
+ if (indentInNode.length >= indentToCode.length) {
+ return node.slice(indentToCode.length);
+ }
+
+ return node;
+ }).join('\n');
+}
+/**
+ * Tokenizer
+ */
+
+
+var Tokenizer = /*#__PURE__*/function () {
+ function Tokenizer(options) {
+ this.options = options || exports.defaults;
+ }
+
+ var _proto = Tokenizer.prototype;
+
+ _proto.space = function space(src) {
+ var cap = this.rules.block.newline.exec(src);
+
+ if (cap && cap[0].length > 0) {
+ return {
+ type: 'space',
+ raw: cap[0]
+ };
+ }
+ };
+
+ _proto.code = function code(src) {
+ var cap = this.rules.block.code.exec(src);
+
+ if (cap) {
+ var text = cap[0].replace(/^ {1,4}/gm, '');
+ return {
+ type: 'code',
+ raw: cap[0],
+ codeBlockStyle: 'indented',
+ text: !this.options.pedantic ? rtrim(text, '\n') : text
+ };
+ }
+ };
+
+ _proto.fences = function fences(src) {
+ var cap = this.rules.block.fences.exec(src);
+
+ if (cap) {
+ var raw = cap[0];
+ var text = indentCodeCompensation(raw, cap[3] || '');
+ return {
+ type: 'code',
+ raw: raw,
+ lang: cap[2] ? cap[2].trim() : cap[2],
+ text: text
+ };
+ }
+ };
+
+ _proto.heading = function heading(src) {
+ var cap = this.rules.block.heading.exec(src);
+
+ if (cap) {
+ var text = cap[2].trim(); // remove trailing #s
+
+ if (/#$/.test(text)) {
+ var trimmed = rtrim(text, '#');
+
+ if (this.options.pedantic) {
+ text = trimmed.trim();
+ } else if (!trimmed || / $/.test(trimmed)) {
+ // CommonMark requires space before trailing #s
+ text = trimmed.trim();
+ }
+ }
+
+ var token = {
+ type: 'heading',
+ raw: cap[0],
+ depth: cap[1].length,
+ text: text,
+ tokens: []
+ };
+ this.lexer.inline(token.text, token.tokens);
+ return token;
+ }
+ };
+
+ _proto.hr = function hr(src) {
+ var cap = this.rules.block.hr.exec(src);
+
+ if (cap) {
+ return {
+ type: 'hr',
+ raw: cap[0]
+ };
+ }
+ };
+
+ _proto.blockquote = function blockquote(src) {
+ var cap = this.rules.block.blockquote.exec(src);
+
+ if (cap) {
+ var text = cap[0].replace(/^ *> ?/gm, '');
+ return {
+ type: 'blockquote',
+ raw: cap[0],
+ tokens: this.lexer.blockTokens(text, []),
+ text: text
+ };
+ }
+ };
+
+ _proto.list = function list(src) {
+ var cap = this.rules.block.list.exec(src);
+
+ if (cap) {
+ var raw, istask, ischecked, indent, i, blankLine, endsWithBlankLine, line, nextLine, rawLine, itemContents, endEarly;
+ var bull = cap[1].trim();
+ var isordered = bull.length > 1;
+ var list = {
+ type: 'list',
+ raw: '',
+ ordered: isordered,
+ start: isordered ? +bull.slice(0, -1) : '',
+ loose: false,
+ items: []
+ };
+ bull = isordered ? "\\d{1,9}\\" + bull.slice(-1) : "\\" + bull;
+
+ if (this.options.pedantic) {
+ bull = isordered ? bull : '[*+-]';
+ } // Get next list item
+
+
+ var itemRegex = new RegExp("^( {0,3}" + bull + ")((?: [^\\n]*)?(?:\\n|$))"); // Check if current bullet point can start a new List Item
+
+ while (src) {
+ endEarly = false;
+
+ if (!(cap = itemRegex.exec(src))) {
+ break;
+ }
+
+ if (this.rules.block.hr.test(src)) {
+ // End list if bullet was actually HR (possibly move into itemRegex?)
+ break;
+ }
+
+ raw = cap[0];
+ src = src.substring(raw.length);
+ line = cap[2].split('\n', 1)[0];
+ nextLine = src.split('\n', 1)[0];
+
+ if (this.options.pedantic) {
+ indent = 2;
+ itemContents = line.trimLeft();
+ } else {
+ indent = cap[2].search(/[^ ]/); // Find first non-space char
+
+ indent = indent > 4 ? 1 : indent; // Treat indented code blocks (> 4 spaces) as having only 1 indent
+
+ itemContents = line.slice(indent);
+ indent += cap[1].length;
+ }
+
+ blankLine = false;
+
+ if (!line && /^ *$/.test(nextLine)) {
+ // Items begin with at most one blank line
+ raw += nextLine + '\n';
+ src = src.substring(nextLine.length + 1);
+ endEarly = true;
+ }
+
+ if (!endEarly) {
+ var nextBulletRegex = new RegExp("^ {0," + Math.min(3, indent - 1) + "}(?:[*+-]|\\d{1,9}[.)])"); // Check if following lines should be included in List Item
+
+ while (src) {
+ rawLine = src.split('\n', 1)[0];
+ line = rawLine; // Re-align to follow commonmark nesting rules
+
+ if (this.options.pedantic) {
+ line = line.replace(/^ {1,4}(?=( {4})*[^ ])/g, ' ');
+ } // End list item if found start of new bullet
+
+
+ if (nextBulletRegex.test(line)) {
+ break;
+ }
+
+ if (line.search(/[^ ]/) >= indent || !line.trim()) {
+ // Dedent if possible
+ itemContents += '\n' + line.slice(indent);
+ } else if (!blankLine) {
+ // Until blank line, item doesn't need indentation
+ itemContents += '\n' + line;
+ } else {
+ // Otherwise, improper indentation ends this item
+ break;
+ }
+
+ if (!blankLine && !line.trim()) {
+ // Check if current line is blank
+ blankLine = true;
+ }
+
+ raw += rawLine + '\n';
+ src = src.substring(rawLine.length + 1);
+ }
+ }
+
+ if (!list.loose) {
+ // If the previous item ended with a blank line, the list is loose
+ if (endsWithBlankLine) {
+ list.loose = true;
+ } else if (/\n *\n *$/.test(raw)) {
+ endsWithBlankLine = true;
+ }
+ } // Check for task list items
+
+
+ if (this.options.gfm) {
+ istask = /^\[[ xX]\] /.exec(itemContents);
+
+ if (istask) {
+ ischecked = istask[0] !== '[ ] ';
+ itemContents = itemContents.replace(/^\[[ xX]\] +/, '');
+ }
+ }
+
+ list.items.push({
+ type: 'list_item',
+ raw: raw,
+ task: !!istask,
+ checked: ischecked,
+ loose: false,
+ text: itemContents
+ });
+ list.raw += raw;
+ } // Do not consume newlines at end of final item. Alternatively, make itemRegex *start* with any newlines to simplify/speed up endsWithBlankLine logic
+
+
+ list.items[list.items.length - 1].raw = raw.trimRight();
+ list.items[list.items.length - 1].text = itemContents.trimRight();
+ list.raw = list.raw.trimRight();
+ var l = list.items.length; // Item child tokens handled here at end because we needed to have the final item to trim it first
+
+ for (i = 0; i < l; i++) {
+ this.lexer.state.top = false;
+ list.items[i].tokens = this.lexer.blockTokens(list.items[i].text, []);
+ var spacers = list.items[i].tokens.filter(function (t) {
+ return t.type === 'space';
+ });
+ var hasMultipleLineBreaks = spacers.every(function (t) {
+ var chars = t.raw.split('');
+ var lineBreaks = 0;
+
+ for (var _iterator = _createForOfIteratorHelperLoose(chars), _step; !(_step = _iterator()).done;) {
+ var _char = _step.value;
+
+ if (_char === '\n') {
+ lineBreaks += 1;
+ }
+
+ if (lineBreaks > 1) {
+ return true;
+ }
+ }
+
+ return false;
+ });
+
+ if (!list.loose && spacers.length && hasMultipleLineBreaks) {
+ // Having a single line break doesn't mean a list is loose. A single line break is terminating the last list item
+ list.loose = true;
+ list.items[i].loose = true;
+ }
+ }
+
+ return list;
+ }
+ };
+
+ _proto.html = function html(src) {
+ var cap = this.rules.block.html.exec(src);
+
+ if (cap) {
+ var token = {
+ type: 'html',
+ raw: cap[0],
+ pre: !this.options.sanitizer && (cap[1] === 'pre' || cap[1] === 'script' || cap[1] === 'style'),
+ text: cap[0]
+ };
+
+ if (this.options.sanitize) {
+ token.type = 'paragraph';
+ token.text = this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]);
+ token.tokens = [];
+ this.lexer.inline(token.text, token.tokens);
+ }
+
+ return token;
+ }
+ };
+
+ _proto.def = function def(src) {
+ var cap = this.rules.block.def.exec(src);
+
+ if (cap) {
+ if (cap[3]) cap[3] = cap[3].substring(1, cap[3].length - 1);
+ var tag = cap[1].toLowerCase().replace(/\s+/g, ' ');
+ return {
+ type: 'def',
+ tag: tag,
+ raw: cap[0],
+ href: cap[2],
+ title: cap[3]
+ };
+ }
+ };
+
+ _proto.table = function table(src) {
+ var cap = this.rules.block.table.exec(src);
+
+ if (cap) {
+ var item = {
+ type: 'table',
+ header: splitCells(cap[1]).map(function (c) {
+ return {
+ text: c
+ };
+ }),
+ align: cap[2].replace(/^ *|\| *$/g, '').split(/ *\| */),
+ rows: cap[3] ? cap[3].replace(/\n[ \t]*$/, '').split('\n') : []
+ };
+
+ if (item.header.length === item.align.length) {
+ item.raw = cap[0];
+ var l = item.align.length;
+ var i, j, k, row;
+
+ for (i = 0; i < l; i++) {
+ if (/^ *-+: *$/.test(item.align[i])) {
+ item.align[i] = 'right';
+ } else if (/^ *:-+: *$/.test(item.align[i])) {
+ item.align[i] = 'center';
+ } else if (/^ *:-+ *$/.test(item.align[i])) {
+ item.align[i] = 'left';
+ } else {
+ item.align[i] = null;
+ }
+ }
+
+ l = item.rows.length;
+
+ for (i = 0; i < l; i++) {
+ item.rows[i] = splitCells(item.rows[i], item.header.length).map(function (c) {
+ return {
+ text: c
+ };
+ });
+ } // parse child tokens inside headers and cells
+ // header child tokens
+
+
+ l = item.header.length;
+
+ for (j = 0; j < l; j++) {
+ item.header[j].tokens = [];
+ this.lexer.inlineTokens(item.header[j].text, item.header[j].tokens);
+ } // cell child tokens
+
+
+ l = item.rows.length;
+
+ for (j = 0; j < l; j++) {
+ row = item.rows[j];
+
+ for (k = 0; k < row.length; k++) {
+ row[k].tokens = [];
+ this.lexer.inlineTokens(row[k].text, row[k].tokens);
+ }
+ }
+
+ return item;
+ }
+ }
+ };
+
+ _proto.lheading = function lheading(src) {
+ var cap = this.rules.block.lheading.exec(src);
+
+ if (cap) {
+ var token = {
+ type: 'heading',
+ raw: cap[0],
+ depth: cap[2].charAt(0) === '=' ? 1 : 2,
+ text: cap[1],
+ tokens: []
+ };
+ this.lexer.inline(token.text, token.tokens);
+ return token;
+ }
+ };
+
+ _proto.paragraph = function paragraph(src) {
+ var cap = this.rules.block.paragraph.exec(src);
+
+ if (cap) {
+ var token = {
+ type: 'paragraph',
+ raw: cap[0],
+ text: cap[1].charAt(cap[1].length - 1) === '\n' ? cap[1].slice(0, -1) : cap[1],
+ tokens: []
+ };
+ this.lexer.inline(token.text, token.tokens);
+ return token;
+ }
+ };
+
+ _proto.text = function text(src) {
+ var cap = this.rules.block.text.exec(src);
+
+ if (cap) {
+ var token = {
+ type: 'text',
+ raw: cap[0],
+ text: cap[0],
+ tokens: []
+ };
+ this.lexer.inline(token.text, token.tokens);
+ return token;
+ }
+ };
+
+ _proto.escape = function escape$1(src) {
+ var cap = this.rules.inline.escape.exec(src);
+
+ if (cap) {
+ return {
+ type: 'escape',
+ raw: cap[0],
+ text: escape(cap[1])
+ };
+ }
+ };
+
+ _proto.tag = function tag(src) {
+ var cap = this.rules.inline.tag.exec(src);
+
+ if (cap) {
+ if (!this.lexer.state.inLink && /^/i.test(cap[0])) {
+ this.lexer.state.inLink = false;
+ }
+
+ if (!this.lexer.state.inRawBlock && /^<(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
+ this.lexer.state.inRawBlock = true;
+ } else if (this.lexer.state.inRawBlock && /^<\/(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
+ this.lexer.state.inRawBlock = false;
+ }
+
+ return {
+ type: this.options.sanitize ? 'text' : 'html',
+ raw: cap[0],
+ inLink: this.lexer.state.inLink,
+ inRawBlock: this.lexer.state.inRawBlock,
+ text: this.options.sanitize ? this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]) : cap[0]
+ };
+ }
+ };
+
+ _proto.link = function link(src) {
+ var cap = this.rules.inline.link.exec(src);
+
+ if (cap) {
+ var trimmedUrl = cap[2].trim();
+
+ if (!this.options.pedantic && /^$/.test(trimmedUrl)) {
+ return;
+ } // ending angle bracket cannot be escaped
+
+
+ var rtrimSlash = rtrim(trimmedUrl.slice(0, -1), '\\');
+
+ if ((trimmedUrl.length - rtrimSlash.length) % 2 === 0) {
+ return;
+ }
+ } else {
+ // find closing parenthesis
+ var lastParenIndex = findClosingBracket(cap[2], '()');
+
+ if (lastParenIndex > -1) {
+ var start = cap[0].indexOf('!') === 0 ? 5 : 4;
+ var linkLen = start + cap[1].length + lastParenIndex;
+ cap[2] = cap[2].substring(0, lastParenIndex);
+ cap[0] = cap[0].substring(0, linkLen).trim();
+ cap[3] = '';
+ }
+ }
+
+ var href = cap[2];
+ var title = '';
+
+ if (this.options.pedantic) {
+ // split pedantic href and title
+ var link = /^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(href);
+
+ if (link) {
+ href = link[1];
+ title = link[3];
+ }
+ } else {
+ title = cap[3] ? cap[3].slice(1, -1) : '';
+ }
+
+ href = href.trim();
+
+ if (/^$/.test(trimmedUrl)) {
+ // pedantic allows starting angle bracket without ending angle bracket
+ href = href.slice(1);
+ } else {
+ href = href.slice(1, -1);
+ }
+ }
+
+ return outputLink(cap, {
+ href: href ? href.replace(this.rules.inline._escapes, '$1') : href,
+ title: title ? title.replace(this.rules.inline._escapes, '$1') : title
+ }, cap[0], this.lexer);
+ }
+ };
+
+ _proto.reflink = function reflink(src, links) {
+ var cap;
+
+ if ((cap = this.rules.inline.reflink.exec(src)) || (cap = this.rules.inline.nolink.exec(src))) {
+ var link = (cap[2] || cap[1]).replace(/\s+/g, ' ');
+ link = links[link.toLowerCase()];
+
+ if (!link || !link.href) {
+ var text = cap[0].charAt(0);
+ return {
+ type: 'text',
+ raw: text,
+ text: text
+ };
+ }
+
+ return outputLink(cap, link, cap[0], this.lexer);
+ }
+ };
+
+ _proto.emStrong = function emStrong(src, maskedSrc, prevChar) {
+ if (prevChar === void 0) {
+ prevChar = '';
+ }
+
+ var match = this.rules.inline.emStrong.lDelim.exec(src);
+ if (!match) return; // _ can't be between two alphanumerics. \p{L}\p{N} includes non-english alphabet/numbers as well
+
+ if (match[3] && prevChar.match(/(?:[0-9A-Za-z\xAA\xB2\xB3\xB5\xB9\xBA\xBC-\xBE\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u0660-\u0669\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07C0-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088E\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0966-\u096F\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09E6-\u09F1\u09F4-\u09F9\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A66-\u0A6F\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AE6-\u0AEF\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B66-\u0B6F\u0B71-\u0B77\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0BE6-\u0BF2\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5D\u0C60\u0C61\u0C66-\u0C6F\u0C78-\u0C7E\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDD\u0CDE\u0CE0\u0CE1\u0CE6-\u0CEF\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D58-\u0D61\u0D66-\u0D78\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DE6-\u0DEF\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F20-\u0F33\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F-\u1049\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u1090-\u1099\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1369-\u137C\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u17E0-\u17E9\u17F0-\u17F9\u1810-\u1819\u1820-\u1878\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A16\u1A20-\u1A54\u1A80-\u1A89\u1A90-\u1A99\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B50-\u1B59\u1B83-\u1BA0\u1BAE-\u1BE5\u1C00-\u1C23\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2070\u2071\u2074-\u2079\u207F-\u2089\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2150-\u2189\u2460-\u249B\u24EA-\u24FF\u2776-\u2793\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2CFD\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u3192-\u3195\u31A0-\u31BF\u31F0-\u31FF\u3220-\u3229\u3248-\u324F\u3251-\u325F\u3280-\u3289\u32B1-\u32BF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7CA\uA7D0\uA7D1\uA7D3\uA7D5-\uA7D9\uA7F2-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA830-\uA835\uA840-\uA873\uA882-\uA8B3\uA8D0-\uA8D9\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA900-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF-\uA9D9\uA9E0-\uA9E4\uA9E6-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA50-\uAA59\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD07-\uDD33\uDD40-\uDD78\uDD8A\uDD8B\uDE80-\uDE9C\uDEA0-\uDED0\uDEE1-\uDEFB\uDF00-\uDF23\uDF2D-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDD70-\uDD7A\uDD7C-\uDD8A\uDD8C-\uDD92\uDD94\uDD95\uDD97-\uDDA1\uDDA3-\uDDB1\uDDB3-\uDDB9\uDDBB\uDDBC\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67\uDF80-\uDF85\uDF87-\uDFB0\uDFB2-\uDFBA]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC58-\uDC76\uDC79-\uDC9E\uDCA7-\uDCAF\uDCE0-\uDCF2\uDCF4\uDCF5\uDCFB-\uDD1B\uDD20-\uDD39\uDD80-\uDDB7\uDDBC-\uDDCF\uDDD2-\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE40-\uDE48\uDE60-\uDE7E\uDE80-\uDE9F\uDEC0-\uDEC7\uDEC9-\uDEE4\uDEEB-\uDEEF\uDF00-\uDF35\uDF40-\uDF55\uDF58-\uDF72\uDF78-\uDF91\uDFA9-\uDFAF]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2\uDCFA-\uDD23\uDD30-\uDD39\uDE60-\uDE7E\uDE80-\uDEA9\uDEB0\uDEB1\uDF00-\uDF27\uDF30-\uDF45\uDF51-\uDF54\uDF70-\uDF81\uDFB0-\uDFCB\uDFE0-\uDFF6]|\uD804[\uDC03-\uDC37\uDC52-\uDC6F\uDC71\uDC72\uDC75\uDC83-\uDCAF\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD03-\uDD26\uDD36-\uDD3F\uDD44\uDD47\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDD0-\uDDDA\uDDDC\uDDE1-\uDDF4\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDEF0-\uDEF9\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC50-\uDC59\uDC5F-\uDC61\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE50-\uDE59\uDE80-\uDEAA\uDEB8\uDEC0-\uDEC9\uDF00-\uDF1A\uDF30-\uDF3B\uDF40-\uDF46]|\uD806[\uDC00-\uDC2B\uDCA0-\uDCF2\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD2F\uDD3F\uDD41\uDD50-\uDD59\uDDA0-\uDDA7\uDDAA-\uDDD0\uDDE1\uDDE3\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE89\uDE9D\uDEB0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC50-\uDC6C\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46\uDD50-\uDD59\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD89\uDD98\uDDA0-\uDDA9\uDEE0-\uDEF2\uDFB0\uDFC0-\uDFD4]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|\uD80B[\uDF90-\uDFF0]|[\uD80C\uD81C-\uD820\uD822\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879\uD880-\uD883][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDE70-\uDEBE\uDEC0-\uDEC9\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF50-\uDF59\uDF5B-\uDF61\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDE40-\uDE96\uDF00-\uDF4A\uDF50\uDF93-\uDF9F\uDFE0\uDFE1\uDFE3]|\uD821[\uDC00-\uDFF7]|\uD823[\uDC00-\uDCD5\uDD00-\uDD08]|\uD82B[\uDFF0-\uDFF3\uDFF5-\uDFFB\uDFFD\uDFFE]|\uD82C[\uDC00-\uDD22\uDD50-\uDD52\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD834[\uDEE0-\uDEF3\uDF60-\uDF78]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD837[\uDF00-\uDF1E]|\uD838[\uDD00-\uDD2C\uDD37-\uDD3D\uDD40-\uDD49\uDD4E\uDE90-\uDEAD\uDEC0-\uDEEB\uDEF0-\uDEF9]|\uD839[\uDFE0-\uDFE6\uDFE8-\uDFEB\uDFED\uDFEE\uDFF0-\uDFFE]|\uD83A[\uDC00-\uDCC4\uDCC7-\uDCCF\uDD00-\uDD43\uDD4B\uDD50-\uDD59]|\uD83B[\uDC71-\uDCAB\uDCAD-\uDCAF\uDCB1-\uDCB4\uDD01-\uDD2D\uDD2F-\uDD3D\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD83C[\uDD00-\uDD0C]|\uD83E[\uDFF0-\uDFF9]|\uD869[\uDC00-\uDEDF\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF38\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A])/)) return;
+ var nextChar = match[1] || match[2] || '';
+
+ if (!nextChar || nextChar && (prevChar === '' || this.rules.inline.punctuation.exec(prevChar))) {
+ var lLength = match[0].length - 1;
+ var rDelim,
+ rLength,
+ delimTotal = lLength,
+ midDelimTotal = 0;
+ var endReg = match[0][0] === '*' ? this.rules.inline.emStrong.rDelimAst : this.rules.inline.emStrong.rDelimUnd;
+ endReg.lastIndex = 0; // Clip maskedSrc to same section of string as src (move to lexer?)
+
+ maskedSrc = maskedSrc.slice(-1 * src.length + lLength);
+
+ while ((match = endReg.exec(maskedSrc)) != null) {
+ rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];
+ if (!rDelim) continue; // skip single * in __abc*abc__
+
+ rLength = rDelim.length;
+
+ if (match[3] || match[4]) {
+ // found another Left Delim
+ delimTotal += rLength;
+ continue;
+ } else if (match[5] || match[6]) {
+ // either Left or Right Delim
+ if (lLength % 3 && !((lLength + rLength) % 3)) {
+ midDelimTotal += rLength;
+ continue; // CommonMark Emphasis Rules 9-10
+ }
+ }
+
+ delimTotal -= rLength;
+ if (delimTotal > 0) continue; // Haven't found enough closing delimiters
+ // Remove extra characters. *a*** -> *a*
+
+ rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal); // Create `em` if smallest delimiter has odd char count. *a***
+
+ if (Math.min(lLength, rLength) % 2) {
+ var _text = src.slice(1, lLength + match.index + rLength);
+
+ return {
+ type: 'em',
+ raw: src.slice(0, lLength + match.index + rLength + 1),
+ text: _text,
+ tokens: this.lexer.inlineTokens(_text, [])
+ };
+ } // Create 'strong' if smallest delimiter has even char count. **a***
+
+
+ var text = src.slice(2, lLength + match.index + rLength - 1);
+ return {
+ type: 'strong',
+ raw: src.slice(0, lLength + match.index + rLength + 1),
+ text: text,
+ tokens: this.lexer.inlineTokens(text, [])
+ };
+ }
+ }
+ };
+
+ _proto.codespan = function codespan(src) {
+ var cap = this.rules.inline.code.exec(src);
+
+ if (cap) {
+ var text = cap[2].replace(/\n/g, ' ');
+ var hasNonSpaceChars = /[^ ]/.test(text);
+ var hasSpaceCharsOnBothEnds = /^ /.test(text) && / $/.test(text);
+
+ if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {
+ text = text.substring(1, text.length - 1);
+ }
+
+ text = escape(text, true);
+ return {
+ type: 'codespan',
+ raw: cap[0],
+ text: text
+ };
+ }
+ };
+
+ _proto.br = function br(src) {
+ var cap = this.rules.inline.br.exec(src);
+
+ if (cap) {
+ return {
+ type: 'br',
+ raw: cap[0]
+ };
+ }
+ };
+
+ _proto.del = function del(src) {
+ var cap = this.rules.inline.del.exec(src);
+
+ if (cap) {
+ return {
+ type: 'del',
+ raw: cap[0],
+ text: cap[2],
+ tokens: this.lexer.inlineTokens(cap[2], [])
+ };
+ }
+ };
+
+ _proto.autolink = function autolink(src, mangle) {
+ var cap = this.rules.inline.autolink.exec(src);
+
+ if (cap) {
+ var text, href;
+
+ if (cap[2] === '@') {
+ text = escape(this.options.mangle ? mangle(cap[1]) : cap[1]);
+ href = 'mailto:' + text;
+ } else {
+ text = escape(cap[1]);
+ href = text;
+ }
+
+ return {
+ type: 'link',
+ raw: cap[0],
+ text: text,
+ href: href,
+ tokens: [{
+ type: 'text',
+ raw: text,
+ text: text
+ }]
+ };
+ }
+ };
+
+ _proto.url = function url(src, mangle) {
+ var cap;
+
+ if (cap = this.rules.inline.url.exec(src)) {
+ var text, href;
+
+ if (cap[2] === '@') {
+ text = escape(this.options.mangle ? mangle(cap[0]) : cap[0]);
+ href = 'mailto:' + text;
+ } else {
+ // do extended autolink path validation
+ var prevCapZero;
+
+ do {
+ prevCapZero = cap[0];
+ cap[0] = this.rules.inline._backpedal.exec(cap[0])[0];
+ } while (prevCapZero !== cap[0]);
+
+ text = escape(cap[0]);
+
+ if (cap[1] === 'www.') {
+ href = 'http://' + text;
+ } else {
+ href = text;
+ }
+ }
+
+ return {
+ type: 'link',
+ raw: cap[0],
+ text: text,
+ href: href,
+ tokens: [{
+ type: 'text',
+ raw: text,
+ text: text
+ }]
+ };
+ }
+ };
+
+ _proto.inlineText = function inlineText(src, smartypants) {
+ var cap = this.rules.inline.text.exec(src);
+
+ if (cap) {
+ var text;
+
+ if (this.lexer.state.inRawBlock) {
+ text = this.options.sanitize ? this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]) : cap[0];
+ } else {
+ text = escape(this.options.smartypants ? smartypants(cap[0]) : cap[0]);
+ }
+
+ return {
+ type: 'text',
+ raw: cap[0],
+ text: text
+ };
+ }
+ };
+
+ return Tokenizer;
+}();
+
+/**
+ * Block-Level Grammar
+ */
+
+var block = {
+ newline: /^(?: *(?:\n|$))+/,
+ code: /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/,
+ fences: /^ {0,3}(`{3,}(?=[^`\n]*\n)|~{3,})([^\n]*)\n(?:|([\s\S]*?)\n)(?: {0,3}\1[~`]* *(?=\n|$)|$)/,
+ hr: /^ {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\* *){3,})(?:\n+|$)/,
+ heading: /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,
+ blockquote: /^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/,
+ list: /^( {0,3}bull)( [^\n]+?)?(?:\n|$)/,
+ html: '^ {0,3}(?:' // optional indentation
+ + '<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:[^\\n]*\\n+|$)' // (1)
+ + '|comment[^\\n]*(\\n+|$)' // (2)
+ + '|<\\?[\\s\\S]*?(?:\\?>\\n*|$)' // (3)
+ + '|\\n*|$)' // (4)
+ + '|\\n*|$)' // (5)
+ + '|)[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (6)
+ + '|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (7) open tag
+ + '|(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (7) closing tag
+ + ')',
+ def: /^ {0,3}\[(label)\]: *(?:\n *)?]+)>?(?:(?: +(?:\n *)?| *\n *)(title))? *(?:\n+|$)/,
+ table: noopTest,
+ lheading: /^([^\n]+)\n {0,3}(=+|-+) *(?:\n+|$)/,
+ // regex template, placeholders will be replaced according to different paragraph
+ // interruption rules of commonmark and the original markdown spec:
+ _paragraph: /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/,
+ text: /^[^\n]+/
+};
+block._label = /(?!\s*\])(?:\\.|[^\[\]\\])+/;
+block._title = /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/;
+block.def = edit(block.def).replace('label', block._label).replace('title', block._title).getRegex();
+block.bullet = /(?:[*+-]|\d{1,9}[.)])/;
+block.listItemStart = edit(/^( *)(bull) */).replace('bull', block.bullet).getRegex();
+block.list = edit(block.list).replace(/bull/g, block.bullet).replace('hr', '\\n+(?=\\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$))').replace('def', '\\n+(?=' + block.def.source + ')').getRegex();
+block._tag = 'address|article|aside|base|basefont|blockquote|body|caption' + '|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption' + '|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe' + '|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option' + '|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr' + '|track|ul';
+block._comment = /|$)/;
+block.html = edit(block.html, 'i').replace('comment', block._comment).replace('tag', block._tag).replace('attribute', / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
+block.paragraph = edit(block._paragraph).replace('hr', block.hr).replace('heading', ' {0,3}#{1,6} ').replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs
+.replace('|table', '').replace('blockquote', ' {0,3}>').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
+.replace('html', ')|<(?:script|pre|style|textarea|!--)').replace('tag', block._tag) // pars can be interrupted by type (6) html blocks
+.getRegex();
+block.blockquote = edit(block.blockquote).replace('paragraph', block.paragraph).getRegex();
+/**
+ * Normal Block Grammar
+ */
+
+block.normal = merge({}, block);
+/**
+ * GFM Block Grammar
+ */
+
+block.gfm = merge({}, block.normal, {
+ table: '^ *([^\\n ].*\\|.*)\\n' // Header
+ + ' {0,3}(?:\\| *)?(:?-+:? *(?:\\| *:?-+:? *)*)(?:\\| *)?' // Align
+ + '(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)' // Cells
+
+});
+block.gfm.table = edit(block.gfm.table).replace('hr', block.hr).replace('heading', ' {0,3}#{1,6} ').replace('blockquote', ' {0,3}>').replace('code', ' {4}[^\\n]').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
+.replace('html', ')|<(?:script|pre|style|textarea|!--)').replace('tag', block._tag) // tables can be interrupted by type (6) html blocks
+.getRegex();
+block.gfm.paragraph = edit(block._paragraph).replace('hr', block.hr).replace('heading', ' {0,3}#{1,6} ').replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs
+.replace('table', block.gfm.table) // interrupt paragraphs with table
+.replace('blockquote', ' {0,3}>').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
+.replace('html', ')|<(?:script|pre|style|textarea|!--)').replace('tag', block._tag) // pars can be interrupted by type (6) html blocks
+.getRegex();
+/**
+ * Pedantic grammar (original John Gruber's loose markdown specification)
+ */
+
+block.pedantic = merge({}, block.normal, {
+ html: edit('^ *(?:comment *(?:\\n|\\s*$)' + '|<(tag)[\\s\\S]+? *(?:\\n{2,}|\\s*$)' // closed tag
+ + '|' + (escaped ? _code : escape(_code, true)) + '
\n';
+ }
+
+ return '' + (escaped ? _code : escape(_code, true)) + '
\n';
+ };
+
+ _proto.blockquote = function blockquote(quote) {
+ return '\n' + quote + '
\n';
+ };
+
+ _proto.html = function html(_html) {
+ return _html;
+ };
+
+ _proto.heading = function heading(text, level, raw, slugger) {
+ if (this.options.headerIds) {
+ return '' + text + ' \n';
+ } // ignore IDs
+
+
+ return '' + text + ' \n';
+ };
+
+ _proto.hr = function hr() {
+ return this.options.xhtml ? '
\n' : '
\n';
+ };
+
+ _proto.list = function list(body, ordered, start) {
+ var type = ordered ? 'ol' : 'ul',
+ startatt = ordered && start !== 1 ? ' start="' + start + '"' : '';
+ return '<' + type + startatt + '>\n' + body + '\n';
+ };
+
+ _proto.listitem = function listitem(text) {
+ return '- ' + text + '
\n';
+ };
+
+ _proto.checkbox = function checkbox(checked) {
+ return ' ';
+ };
+
+ _proto.paragraph = function paragraph(text) {
+ return '' + text + '
\n';
+ };
+
+ _proto.table = function table(header, body) {
+ if (body) body = '' + body + '';
+ return '\n' + '\n' + header + '\n' + body + '
\n';
+ };
+
+ _proto.tablerow = function tablerow(content) {
+ return '\n' + content + ' \n';
+ };
+
+ _proto.tablecell = function tablecell(content, flags) {
+ var type = flags.header ? 'th' : 'td';
+ var tag = flags.align ? '<' + type + ' align="' + flags.align + '">' : '<' + type + '>';
+ return tag + content + '\n';
+ } // span level renderer
+ ;
+
+ _proto.strong = function strong(text) {
+ return '' + text + '';
+ };
+
+ _proto.em = function em(text) {
+ return '' + text + '';
+ };
+
+ _proto.codespan = function codespan(text) {
+ return '' + text + '';
+ };
+
+ _proto.br = function br() {
+ return this.options.xhtml ? '
' : '
';
+ };
+
+ _proto.del = function del(text) {
+ return '' + text + '';
+ };
+
+ _proto.link = function link(href, title, text) {
+ href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
+
+ if (href === null) {
+ return text;
+ }
+
+ var out = '';
+ return out;
+ };
+
+ _proto.image = function image(href, title, text) {
+ href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
+
+ if (href === null) {
+ return text;
+ }
+
+ var out = '
' : '>';
+ return out;
+ };
+
+ _proto.text = function text(_text) {
+ return _text;
+ };
+
+ return Renderer;
+}();
+
+/**
+ * TextRenderer
+ * returns only the textual part of the token
+ */
+var TextRenderer = /*#__PURE__*/function () {
+ function TextRenderer() {}
+
+ var _proto = TextRenderer.prototype;
+
+ // no need for block level renderers
+ _proto.strong = function strong(text) {
+ return text;
+ };
+
+ _proto.em = function em(text) {
+ return text;
+ };
+
+ _proto.codespan = function codespan(text) {
+ return text;
+ };
+
+ _proto.del = function del(text) {
+ return text;
+ };
+
+ _proto.html = function html(text) {
+ return text;
+ };
+
+ _proto.text = function text(_text) {
+ return _text;
+ };
+
+ _proto.link = function link(href, title, text) {
+ return '' + text;
+ };
+
+ _proto.image = function image(href, title, text) {
+ return '' + text;
+ };
+
+ _proto.br = function br() {
+ return '';
+ };
+
+ return TextRenderer;
+}();
+
+/**
+ * Slugger generates header id
+ */
+var Slugger = /*#__PURE__*/function () {
+ function Slugger() {
+ this.seen = {};
+ }
+
+ var _proto = Slugger.prototype;
+
+ _proto.serialize = function serialize(value) {
+ return value.toLowerCase().trim() // remove html tags
+ .replace(/<[!\/a-z].*?>/ig, '') // remove unwanted chars
+ .replace(/[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g, '').replace(/\s/g, '-');
+ }
+ /**
+ * Finds the next safe (unique) slug to use
+ */
+ ;
+
+ _proto.getNextSafeSlug = function getNextSafeSlug(originalSlug, isDryRun) {
+ var slug = originalSlug;
+ var occurenceAccumulator = 0;
+
+ if (this.seen.hasOwnProperty(slug)) {
+ occurenceAccumulator = this.seen[originalSlug];
+
+ do {
+ occurenceAccumulator++;
+ slug = originalSlug + '-' + occurenceAccumulator;
+ } while (this.seen.hasOwnProperty(slug));
+ }
+
+ if (!isDryRun) {
+ this.seen[originalSlug] = occurenceAccumulator;
+ this.seen[slug] = 0;
+ }
+
+ return slug;
+ }
+ /**
+ * Convert string to unique id
+ * @param {object} options
+ * @param {boolean} options.dryrun Generates the next unique slug without updating the internal accumulator.
+ */
+ ;
+
+ _proto.slug = function slug(value, options) {
+ if (options === void 0) {
+ options = {};
+ }
+
+ var slug = this.serialize(value);
+ return this.getNextSafeSlug(slug, options.dryrun);
+ };
+
+ return Slugger;
+}();
+
+/**
+ * Parsing & Compiling
+ */
+
+var Parser = /*#__PURE__*/function () {
+ function Parser(options) {
+ this.options = options || exports.defaults;
+ this.options.renderer = this.options.renderer || new Renderer();
+ this.renderer = this.options.renderer;
+ this.renderer.options = this.options;
+ this.textRenderer = new TextRenderer();
+ this.slugger = new Slugger();
+ }
+ /**
+ * Static Parse Method
+ */
+
+
+ Parser.parse = function parse(tokens, options) {
+ var parser = new Parser(options);
+ return parser.parse(tokens);
+ }
+ /**
+ * Static Parse Inline Method
+ */
+ ;
+
+ Parser.parseInline = function parseInline(tokens, options) {
+ var parser = new Parser(options);
+ return parser.parseInline(tokens);
+ }
+ /**
+ * Parse Loop
+ */
+ ;
+
+ var _proto = Parser.prototype;
+
+ _proto.parse = function parse(tokens, top) {
+ if (top === void 0) {
+ top = true;
+ }
+
+ var out = '',
+ i,
+ j,
+ k,
+ l2,
+ l3,
+ row,
+ cell,
+ header,
+ body,
+ token,
+ ordered,
+ start,
+ loose,
+ itemBody,
+ item,
+ checked,
+ task,
+ checkbox,
+ ret;
+ var l = tokens.length;
+
+ for (i = 0; i < l; i++) {
+ token = tokens[i]; // Run any renderer extensions
+
+ if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
+ ret = this.options.extensions.renderers[token.type].call({
+ parser: this
+ }, token);
+
+ if (ret !== false || !['space', 'hr', 'heading', 'code', 'table', 'blockquote', 'list', 'html', 'paragraph', 'text'].includes(token.type)) {
+ out += ret || '';
+ continue;
+ }
+ }
+
+ switch (token.type) {
+ case 'space':
+ {
+ continue;
+ }
+
+ case 'hr':
+ {
+ out += this.renderer.hr();
+ continue;
+ }
+
+ case 'heading':
+ {
+ out += this.renderer.heading(this.parseInline(token.tokens), token.depth, unescape(this.parseInline(token.tokens, this.textRenderer)), this.slugger);
+ continue;
+ }
+
+ case 'code':
+ {
+ out += this.renderer.code(token.text, token.lang, token.escaped);
+ continue;
+ }
+
+ case 'table':
+ {
+ header = ''; // header
+
+ cell = '';
+ l2 = token.header.length;
+
+ for (j = 0; j < l2; j++) {
+ cell += this.renderer.tablecell(this.parseInline(token.header[j].tokens), {
+ header: true,
+ align: token.align[j]
+ });
+ }
+
+ header += this.renderer.tablerow(cell);
+ body = '';
+ l2 = token.rows.length;
+
+ for (j = 0; j < l2; j++) {
+ row = token.rows[j];
+ cell = '';
+ l3 = row.length;
+
+ for (k = 0; k < l3; k++) {
+ cell += this.renderer.tablecell(this.parseInline(row[k].tokens), {
+ header: false,
+ align: token.align[k]
+ });
+ }
+
+ body += this.renderer.tablerow(cell);
+ }
+
+ out += this.renderer.table(header, body);
+ continue;
+ }
+
+ case 'blockquote':
+ {
+ body = this.parse(token.tokens);
+ out += this.renderer.blockquote(body);
+ continue;
+ }
+
+ case 'list':
+ {
+ ordered = token.ordered;
+ start = token.start;
+ loose = token.loose;
+ l2 = token.items.length;
+ body = '';
+
+ for (j = 0; j < l2; j++) {
+ item = token.items[j];
+ checked = item.checked;
+ task = item.task;
+ itemBody = '';
+
+ if (item.task) {
+ checkbox = this.renderer.checkbox(checked);
+
+ if (loose) {
+ if (item.tokens.length > 0 && item.tokens[0].type === 'paragraph') {
+ item.tokens[0].text = checkbox + ' ' + item.tokens[0].text;
+
+ if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === 'text') {
+ item.tokens[0].tokens[0].text = checkbox + ' ' + item.tokens[0].tokens[0].text;
+ }
+ } else {
+ item.tokens.unshift({
+ type: 'text',
+ text: checkbox
+ });
+ }
+ } else {
+ itemBody += checkbox;
+ }
+ }
+
+ itemBody += this.parse(item.tokens, loose);
+ body += this.renderer.listitem(itemBody, task, checked);
+ }
+
+ out += this.renderer.list(body, ordered, start);
+ continue;
+ }
+
+ case 'html':
+ {
+ // TODO parse inline content if parameter markdown=1
+ out += this.renderer.html(token.text);
+ continue;
+ }
+
+ case 'paragraph':
+ {
+ out += this.renderer.paragraph(this.parseInline(token.tokens));
+ continue;
+ }
+
+ case 'text':
+ {
+ body = token.tokens ? this.parseInline(token.tokens) : token.text;
+
+ while (i + 1 < l && tokens[i + 1].type === 'text') {
+ token = tokens[++i];
+ body += '\n' + (token.tokens ? this.parseInline(token.tokens) : token.text);
+ }
+
+ out += top ? this.renderer.paragraph(body) : body;
+ continue;
+ }
+
+ default:
+ {
+ var errMsg = 'Token with "' + token.type + '" type was not found.';
+
+ if (this.options.silent) {
+ console.error(errMsg);
+ return;
+ } else {
+ throw new Error(errMsg);
+ }
+ }
+ }
+ }
+
+ return out;
+ }
+ /**
+ * Parse Inline Tokens
+ */
+ ;
+
+ _proto.parseInline = function parseInline(tokens, renderer) {
+ renderer = renderer || this.renderer;
+ var out = '',
+ i,
+ token,
+ ret;
+ var l = tokens.length;
+
+ for (i = 0; i < l; i++) {
+ token = tokens[i]; // Run any renderer extensions
+
+ if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
+ ret = this.options.extensions.renderers[token.type].call({
+ parser: this
+ }, token);
+
+ if (ret !== false || !['escape', 'html', 'link', 'image', 'strong', 'em', 'codespan', 'br', 'del', 'text'].includes(token.type)) {
+ out += ret || '';
+ continue;
+ }
+ }
+
+ switch (token.type) {
+ case 'escape':
+ {
+ out += renderer.text(token.text);
+ break;
+ }
+
+ case 'html':
+ {
+ out += renderer.html(token.text);
+ break;
+ }
+
+ case 'link':
+ {
+ out += renderer.link(token.href, token.title, this.parseInline(token.tokens, renderer));
+ break;
+ }
+
+ case 'image':
+ {
+ out += renderer.image(token.href, token.title, token.text);
+ break;
+ }
+
+ case 'strong':
+ {
+ out += renderer.strong(this.parseInline(token.tokens, renderer));
+ break;
+ }
+
+ case 'em':
+ {
+ out += renderer.em(this.parseInline(token.tokens, renderer));
+ break;
+ }
+
+ case 'codespan':
+ {
+ out += renderer.codespan(token.text);
+ break;
+ }
+
+ case 'br':
+ {
+ out += renderer.br();
+ break;
+ }
+
+ case 'del':
+ {
+ out += renderer.del(this.parseInline(token.tokens, renderer));
+ break;
+ }
+
+ case 'text':
+ {
+ out += renderer.text(token.text);
+ break;
+ }
+
+ default:
+ {
+ var errMsg = 'Token with "' + token.type + '" type was not found.';
+
+ if (this.options.silent) {
+ console.error(errMsg);
+ return;
+ } else {
+ throw new Error(errMsg);
+ }
+ }
+ }
+ }
+
+ return out;
+ };
+
+ return Parser;
+}();
+
+/**
+ * Marked
+ */
+
+function marked(src, opt, callback) {
+ // throw error in case of non string input
+ if (typeof src === 'undefined' || src === null) {
+ throw new Error('marked(): input parameter is undefined or null');
+ }
+
+ if (typeof src !== 'string') {
+ throw new Error('marked(): input parameter is of type ' + Object.prototype.toString.call(src) + ', string expected');
+ }
+
+ if (typeof opt === 'function') {
+ callback = opt;
+ opt = null;
+ }
+
+ opt = merge({}, marked.defaults, opt || {});
+ checkSanitizeDeprecation(opt);
+
+ if (callback) {
+ var highlight = opt.highlight;
+ var tokens;
+
+ try {
+ tokens = Lexer.lex(src, opt);
+ } catch (e) {
+ return callback(e);
+ }
+
+ var done = function done(err) {
+ var out;
+
+ if (!err) {
+ try {
+ if (opt.walkTokens) {
+ marked.walkTokens(tokens, opt.walkTokens);
+ }
+
+ out = Parser.parse(tokens, opt);
+ } catch (e) {
+ err = e;
+ }
+ }
+
+ opt.highlight = highlight;
+ return err ? callback(err) : callback(null, out);
+ };
+
+ if (!highlight || highlight.length < 3) {
+ return done();
+ }
+
+ delete opt.highlight;
+ if (!tokens.length) return done();
+ var pending = 0;
+ marked.walkTokens(tokens, function (token) {
+ if (token.type === 'code') {
+ pending++;
+ setTimeout(function () {
+ highlight(token.text, token.lang, function (err, code) {
+ if (err) {
+ return done(err);
+ }
+
+ if (code != null && code !== token.text) {
+ token.text = code;
+ token.escaped = true;
+ }
+
+ pending--;
+
+ if (pending === 0) {
+ done();
+ }
+ });
+ }, 0);
+ }
+ });
+
+ if (pending === 0) {
+ done();
+ }
+
+ return;
+ }
+
+ try {
+ var _tokens = Lexer.lex(src, opt);
+
+ if (opt.walkTokens) {
+ marked.walkTokens(_tokens, opt.walkTokens);
+ }
+
+ return Parser.parse(_tokens, opt);
+ } catch (e) {
+ e.message += '\nPlease report this to https://github.com/markedjs/marked.';
+
+ if (opt.silent) {
+ return 'An error occurred:
' + escape(e.message + '', true) + '
';
+ }
+
+ throw e;
+ }
+}
+/**
+ * Options
+ */
+
+marked.options = marked.setOptions = function (opt) {
+ merge(marked.defaults, opt);
+ changeDefaults(marked.defaults);
+ return marked;
+};
+
+marked.getDefaults = getDefaults;
+marked.defaults = exports.defaults;
+/**
+ * Use Extension
+ */
+
+marked.use = function () {
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ var opts = merge.apply(void 0, [{}].concat(args));
+ var extensions = marked.defaults.extensions || {
+ renderers: {},
+ childTokens: {}
+ };
+ var hasExtensions;
+ args.forEach(function (pack) {
+ // ==-- Parse "addon" extensions --== //
+ if (pack.extensions) {
+ hasExtensions = true;
+ pack.extensions.forEach(function (ext) {
+ if (!ext.name) {
+ throw new Error('extension name required');
+ }
+
+ if (ext.renderer) {
+ // Renderer extensions
+ var prevRenderer = extensions.renderers ? extensions.renderers[ext.name] : null;
+
+ if (prevRenderer) {
+ // Replace extension with func to run new extension but fall back if false
+ extensions.renderers[ext.name] = function () {
+ for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+ args[_key2] = arguments[_key2];
+ }
+
+ var ret = ext.renderer.apply(this, args);
+
+ if (ret === false) {
+ ret = prevRenderer.apply(this, args);
+ }
+
+ return ret;
+ };
+ } else {
+ extensions.renderers[ext.name] = ext.renderer;
+ }
+ }
+
+ if (ext.tokenizer) {
+ // Tokenizer Extensions
+ if (!ext.level || ext.level !== 'block' && ext.level !== 'inline') {
+ throw new Error("extension level must be 'block' or 'inline'");
+ }
+
+ if (extensions[ext.level]) {
+ extensions[ext.level].unshift(ext.tokenizer);
+ } else {
+ extensions[ext.level] = [ext.tokenizer];
+ }
+
+ if (ext.start) {
+ // Function to check for start of token
+ if (ext.level === 'block') {
+ if (extensions.startBlock) {
+ extensions.startBlock.push(ext.start);
+ } else {
+ extensions.startBlock = [ext.start];
+ }
+ } else if (ext.level === 'inline') {
+ if (extensions.startInline) {
+ extensions.startInline.push(ext.start);
+ } else {
+ extensions.startInline = [ext.start];
+ }
+ }
+ }
+ }
+
+ if (ext.childTokens) {
+ // Child tokens to be visited by walkTokens
+ extensions.childTokens[ext.name] = ext.childTokens;
+ }
+ });
+ } // ==-- Parse "overwrite" extensions --== //
+
+
+ if (pack.renderer) {
+ (function () {
+ var renderer = marked.defaults.renderer || new Renderer();
+
+ var _loop = function _loop(prop) {
+ var prevRenderer = renderer[prop]; // Replace renderer with func to run extension, but fall back if false
+
+ renderer[prop] = function () {
+ for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+ args[_key3] = arguments[_key3];
+ }
+
+ var ret = pack.renderer[prop].apply(renderer, args);
+
+ if (ret === false) {
+ ret = prevRenderer.apply(renderer, args);
+ }
+
+ return ret;
+ };
+ };
+
+ for (var prop in pack.renderer) {
+ _loop(prop);
+ }
+
+ opts.renderer = renderer;
+ })();
+ }
+
+ if (pack.tokenizer) {
+ (function () {
+ var tokenizer = marked.defaults.tokenizer || new Tokenizer();
+
+ var _loop2 = function _loop2(prop) {
+ var prevTokenizer = tokenizer[prop]; // Replace tokenizer with func to run extension, but fall back if false
+
+ tokenizer[prop] = function () {
+ for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+ args[_key4] = arguments[_key4];
+ }
+
+ var ret = pack.tokenizer[prop].apply(tokenizer, args);
+
+ if (ret === false) {
+ ret = prevTokenizer.apply(tokenizer, args);
+ }
+
+ return ret;
+ };
+ };
+
+ for (var prop in pack.tokenizer) {
+ _loop2(prop);
+ }
+
+ opts.tokenizer = tokenizer;
+ })();
+ } // ==-- Parse WalkTokens extensions --== //
+
+
+ if (pack.walkTokens) {
+ var _walkTokens = marked.defaults.walkTokens;
+
+ opts.walkTokens = function (token) {
+ pack.walkTokens.call(this, token);
+
+ if (_walkTokens) {
+ _walkTokens.call(this, token);
+ }
+ };
+ }
+
+ if (hasExtensions) {
+ opts.extensions = extensions;
+ }
+
+ marked.setOptions(opts);
+ });
+};
+/**
+ * Run callback for every token
+ */
+
+
+marked.walkTokens = function (tokens, callback) {
+ var _loop3 = function _loop3() {
+ var token = _step.value;
+ callback.call(marked, token);
+
+ switch (token.type) {
+ case 'table':
+ {
+ for (var _iterator2 = _createForOfIteratorHelperLoose(token.header), _step2; !(_step2 = _iterator2()).done;) {
+ var cell = _step2.value;
+ marked.walkTokens(cell.tokens, callback);
+ }
+
+ for (var _iterator3 = _createForOfIteratorHelperLoose(token.rows), _step3; !(_step3 = _iterator3()).done;) {
+ var row = _step3.value;
+
+ for (var _iterator4 = _createForOfIteratorHelperLoose(row), _step4; !(_step4 = _iterator4()).done;) {
+ var _cell = _step4.value;
+ marked.walkTokens(_cell.tokens, callback);
+ }
+ }
+
+ break;
+ }
+
+ case 'list':
+ {
+ marked.walkTokens(token.items, callback);
+ break;
+ }
+
+ default:
+ {
+ if (marked.defaults.extensions && marked.defaults.extensions.childTokens && marked.defaults.extensions.childTokens[token.type]) {
+ // Walk any extensions
+ marked.defaults.extensions.childTokens[token.type].forEach(function (childTokens) {
+ marked.walkTokens(token[childTokens], callback);
+ });
+ } else if (token.tokens) {
+ marked.walkTokens(token.tokens, callback);
+ }
+ }
+ }
+ };
+
+ for (var _iterator = _createForOfIteratorHelperLoose(tokens), _step; !(_step = _iterator()).done;) {
+ _loop3();
+ }
+};
+/**
+ * Parse Inline
+ */
+
+
+marked.parseInline = function (src, opt) {
+ // throw error in case of non string input
+ if (typeof src === 'undefined' || src === null) {
+ throw new Error('marked.parseInline(): input parameter is undefined or null');
+ }
+
+ if (typeof src !== 'string') {
+ throw new Error('marked.parseInline(): input parameter is of type ' + Object.prototype.toString.call(src) + ', string expected');
+ }
+
+ opt = merge({}, marked.defaults, opt || {});
+ checkSanitizeDeprecation(opt);
+
+ try {
+ var tokens = Lexer.lexInline(src, opt);
+
+ if (opt.walkTokens) {
+ marked.walkTokens(tokens, opt.walkTokens);
+ }
+
+ return Parser.parseInline(tokens, opt);
+ } catch (e) {
+ e.message += '\nPlease report this to https://github.com/markedjs/marked.';
+
+ if (opt.silent) {
+ return 'An error occurred:
' + escape(e.message + '', true) + '
';
+ }
+
+ throw e;
+ }
+};
+/**
+ * Expose
+ */
+
+
+marked.Parser = Parser;
+marked.parser = Parser.parse;
+marked.Renderer = Renderer;
+marked.TextRenderer = TextRenderer;
+marked.Lexer = Lexer;
+marked.lexer = Lexer.lex;
+marked.Tokenizer = Tokenizer;
+marked.Slugger = Slugger;
+marked.parse = marked;
+var options = marked.options;
+var setOptions = marked.setOptions;
+var use = marked.use;
+var walkTokens = marked.walkTokens;
+var parseInline = marked.parseInline;
+var parse = marked;
+var parser = Parser.parse;
+var lexer = Lexer.lex;
+
+exports.Lexer = Lexer;
+exports.Parser = Parser;
+exports.Renderer = Renderer;
+exports.Slugger = Slugger;
+exports.TextRenderer = TextRenderer;
+exports.Tokenizer = Tokenizer;
+exports.getDefaults = getDefaults;
+exports.lexer = lexer;
+exports.marked = marked;
+exports.options = options;
+exports.parse = parse;
+exports.parseInline = parseInline;
+exports.parser = parser;
+exports.setOptions = setOptions;
+exports.use = use;
+exports.walkTokens = walkTokens;
diff --git a/lib/marked.esm.js b/lib/marked.esm.js
new file mode 100644
index 0000000000..2a91970ee8
--- /dev/null
+++ b/lib/marked.esm.js
@@ -0,0 +1,2701 @@
+/**
+ * marked - a markdown parser
+ * Copyright (c) 2011-2022, Christopher Jeffrey. (MIT Licensed)
+ * https://github.com/markedjs/marked
+ */
+
+/**
+ * DO NOT EDIT THIS FILE
+ * The code in this file is generated from files in ./src/
+ */
+
+function getDefaults() {
+ return {
+ baseUrl: null,
+ breaks: false,
+ extensions: null,
+ gfm: true,
+ headerIds: true,
+ headerPrefix: '',
+ highlight: null,
+ langPrefix: 'language-',
+ mangle: true,
+ pedantic: false,
+ renderer: null,
+ sanitize: false,
+ sanitizer: null,
+ silent: false,
+ smartLists: false,
+ smartypants: false,
+ tokenizer: null,
+ walkTokens: null,
+ xhtml: false
+ };
+}
+
+let defaults = getDefaults();
+
+function changeDefaults(newDefaults) {
+ defaults = newDefaults;
+}
+
+/**
+ * Helpers
+ */
+const escapeTest = /[&<>"']/;
+const escapeReplace = /[&<>"']/g;
+const escapeTestNoEncode = /[<>"']|&(?!#?\w+;)/;
+const escapeReplaceNoEncode = /[<>"']|&(?!#?\w+;)/g;
+const escapeReplacements = {
+ '&': '&',
+ '<': '<',
+ '>': '>',
+ '"': '"',
+ "'": '''
+};
+const getEscapeReplacement = (ch) => escapeReplacements[ch];
+function escape(html, encode) {
+ if (encode) {
+ if (escapeTest.test(html)) {
+ return html.replace(escapeReplace, getEscapeReplacement);
+ }
+ } else {
+ if (escapeTestNoEncode.test(html)) {
+ return html.replace(escapeReplaceNoEncode, getEscapeReplacement);
+ }
+ }
+
+ return html;
+}
+
+const unescapeTest = /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig;
+
+function unescape(html) {
+ // explicitly match decimal, hex, and named HTML entities
+ return html.replace(unescapeTest, (_, n) => {
+ n = n.toLowerCase();
+ if (n === 'colon') return ':';
+ if (n.charAt(0) === '#') {
+ return n.charAt(1) === 'x'
+ ? String.fromCharCode(parseInt(n.substring(2), 16))
+ : String.fromCharCode(+n.substring(1));
+ }
+ return '';
+ });
+}
+
+const caret = /(^|[^\[])\^/g;
+function edit(regex, opt) {
+ regex = regex.source || regex;
+ opt = opt || '';
+ const obj = {
+ replace: (name, val) => {
+ val = val.source || val;
+ val = val.replace(caret, '$1');
+ regex = regex.replace(name, val);
+ return obj;
+ },
+ getRegex: () => {
+ return new RegExp(regex, opt);
+ }
+ };
+ return obj;
+}
+
+const nonWordAndColonTest = /[^\w:]/g;
+const originIndependentUrl = /^$|^[a-z][a-z0-9+.-]*:|^[?#]/i;
+function cleanUrl(sanitize, base, href) {
+ if (sanitize) {
+ let prot;
+ try {
+ prot = decodeURIComponent(unescape(href))
+ .replace(nonWordAndColonTest, '')
+ .toLowerCase();
+ } catch (e) {
+ return null;
+ }
+ if (prot.indexOf('javascript:') === 0 || prot.indexOf('vbscript:') === 0 || prot.indexOf('data:') === 0) {
+ return null;
+ }
+ }
+ if (base && !originIndependentUrl.test(href)) {
+ href = resolveUrl(base, href);
+ }
+ try {
+ href = encodeURI(href).replace(/%25/g, '%');
+ } catch (e) {
+ return null;
+ }
+ return href;
+}
+
+const baseUrls = {};
+const justDomain = /^[^:]+:\/*[^/]*$/;
+const protocol = /^([^:]+:)[\s\S]*$/;
+const domain = /^([^:]+:\/*[^/]*)[\s\S]*$/;
+
+function resolveUrl(base, href) {
+ if (!baseUrls[' ' + base]) {
+ // we can ignore everything in base after the last slash of its path component,
+ // but we might need to add _that_
+ // https://tools.ietf.org/html/rfc3986#section-3
+ if (justDomain.test(base)) {
+ baseUrls[' ' + base] = base + '/';
+ } else {
+ baseUrls[' ' + base] = rtrim(base, '/', true);
+ }
+ }
+ base = baseUrls[' ' + base];
+ const relativeBase = base.indexOf(':') === -1;
+
+ if (href.substring(0, 2) === '//') {
+ if (relativeBase) {
+ return href;
+ }
+ return base.replace(protocol, '$1') + href;
+ } else if (href.charAt(0) === '/') {
+ if (relativeBase) {
+ return href;
+ }
+ return base.replace(domain, '$1') + href;
+ } else {
+ return base + href;
+ }
+}
+
+const noopTest = { exec: function noopTest() {} };
+
+function merge(obj) {
+ let i = 1,
+ target,
+ key;
+
+ for (; i < arguments.length; i++) {
+ target = arguments[i];
+ for (key in target) {
+ if (Object.prototype.hasOwnProperty.call(target, key)) {
+ obj[key] = target[key];
+ }
+ }
+ }
+
+ return obj;
+}
+
+function splitCells(tableRow, count) {
+ // ensure that every cell-delimiting pipe has a space
+ // before it to distinguish it from an escaped pipe
+ const row = tableRow.replace(/\|/g, (match, offset, str) => {
+ let escaped = false,
+ curr = offset;
+ while (--curr >= 0 && str[curr] === '\\') escaped = !escaped;
+ if (escaped) {
+ // odd number of slashes means | is escaped
+ // so we leave it alone
+ return '|';
+ } else {
+ // add space before unescaped |
+ return ' |';
+ }
+ }),
+ cells = row.split(/ \|/);
+ let i = 0;
+
+ // First/last cell in a row cannot be empty if it has no leading/trailing pipe
+ if (!cells[0].trim()) { cells.shift(); }
+ if (!cells[cells.length - 1].trim()) { cells.pop(); }
+
+ if (cells.length > count) {
+ cells.splice(count);
+ } else {
+ while (cells.length < count) cells.push('');
+ }
+
+ for (; i < cells.length; i++) {
+ // leading or trailing whitespace is ignored per the gfm spec
+ cells[i] = cells[i].trim().replace(/\\\|/g, '|');
+ }
+ return cells;
+}
+
+// Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').
+// /c*$/ is vulnerable to REDOS.
+// invert: Remove suffix of non-c chars instead. Default falsey.
+function rtrim(str, c, invert) {
+ const l = str.length;
+ if (l === 0) {
+ return '';
+ }
+
+ // Length of suffix matching the invert condition.
+ let suffLen = 0;
+
+ // Step left until we fail to match the invert condition.
+ while (suffLen < l) {
+ const currChar = str.charAt(l - suffLen - 1);
+ if (currChar === c && !invert) {
+ suffLen++;
+ } else if (currChar !== c && invert) {
+ suffLen++;
+ } else {
+ break;
+ }
+ }
+
+ return str.substr(0, l - suffLen);
+}
+
+function findClosingBracket(str, b) {
+ if (str.indexOf(b[1]) === -1) {
+ return -1;
+ }
+ const l = str.length;
+ let level = 0,
+ i = 0;
+ for (; i < l; i++) {
+ if (str[i] === '\\') {
+ i++;
+ } else if (str[i] === b[0]) {
+ level++;
+ } else if (str[i] === b[1]) {
+ level--;
+ if (level < 0) {
+ return i;
+ }
+ }
+ }
+ return -1;
+}
+
+function checkSanitizeDeprecation(opt) {
+ if (opt && opt.sanitize && !opt.silent) {
+ console.warn('marked(): sanitize and sanitizer parameters are deprecated since version 0.7.0, should not be used and will be removed in the future. Read more here: https://marked.js.org/#/USING_ADVANCED.md#options');
+ }
+}
+
+// copied from https://stackoverflow.com/a/5450113/806777
+function repeatString(pattern, count) {
+ if (count < 1) {
+ return '';
+ }
+ let result = '';
+ while (count > 1) {
+ if (count & 1) {
+ result += pattern;
+ }
+ count >>= 1;
+ pattern += pattern;
+ }
+ return result + pattern;
+}
+
+function outputLink(cap, link, raw, lexer) {
+ const href = link.href;
+ const title = link.title ? escape(link.title) : null;
+ const text = cap[1].replace(/\\([\[\]])/g, '$1');
+
+ if (cap[0].charAt(0) !== '!') {
+ lexer.state.inLink = true;
+ const token = {
+ type: 'link',
+ raw,
+ href,
+ title,
+ text,
+ tokens: lexer.inlineTokens(text, [])
+ };
+ lexer.state.inLink = false;
+ return token;
+ } else {
+ return {
+ type: 'image',
+ raw,
+ href,
+ title,
+ text: escape(text)
+ };
+ }
+}
+
+function indentCodeCompensation(raw, text) {
+ const matchIndentToCode = raw.match(/^(\s+)(?:```)/);
+
+ if (matchIndentToCode === null) {
+ return text;
+ }
+
+ const indentToCode = matchIndentToCode[1];
+
+ return text
+ .split('\n')
+ .map(node => {
+ const matchIndentInNode = node.match(/^\s+/);
+ if (matchIndentInNode === null) {
+ return node;
+ }
+
+ const [indentInNode] = matchIndentInNode;
+
+ if (indentInNode.length >= indentToCode.length) {
+ return node.slice(indentToCode.length);
+ }
+
+ return node;
+ })
+ .join('\n');
+}
+
+/**
+ * Tokenizer
+ */
+class Tokenizer {
+ constructor(options) {
+ this.options = options || defaults;
+ }
+
+ space(src) {
+ const cap = this.rules.block.newline.exec(src);
+ if (cap && cap[0].length > 0) {
+ return {
+ type: 'space',
+ raw: cap[0]
+ };
+ }
+ }
+
+ code(src) {
+ const cap = this.rules.block.code.exec(src);
+ if (cap) {
+ const text = cap[0].replace(/^ {1,4}/gm, '');
+ return {
+ type: 'code',
+ raw: cap[0],
+ codeBlockStyle: 'indented',
+ text: !this.options.pedantic
+ ? rtrim(text, '\n')
+ : text
+ };
+ }
+ }
+
+ fences(src) {
+ const cap = this.rules.block.fences.exec(src);
+ if (cap) {
+ const raw = cap[0];
+ const text = indentCodeCompensation(raw, cap[3] || '');
+
+ return {
+ type: 'code',
+ raw,
+ lang: cap[2] ? cap[2].trim() : cap[2],
+ text
+ };
+ }
+ }
+
+ heading(src) {
+ const cap = this.rules.block.heading.exec(src);
+ if (cap) {
+ let text = cap[2].trim();
+
+ // remove trailing #s
+ if (/#$/.test(text)) {
+ const trimmed = rtrim(text, '#');
+ if (this.options.pedantic) {
+ text = trimmed.trim();
+ } else if (!trimmed || / $/.test(trimmed)) {
+ // CommonMark requires space before trailing #s
+ text = trimmed.trim();
+ }
+ }
+
+ const token = {
+ type: 'heading',
+ raw: cap[0],
+ depth: cap[1].length,
+ text: text,
+ tokens: []
+ };
+ this.lexer.inline(token.text, token.tokens);
+ return token;
+ }
+ }
+
+ hr(src) {
+ const cap = this.rules.block.hr.exec(src);
+ if (cap) {
+ return {
+ type: 'hr',
+ raw: cap[0]
+ };
+ }
+ }
+
+ blockquote(src) {
+ const cap = this.rules.block.blockquote.exec(src);
+ if (cap) {
+ const text = cap[0].replace(/^ *> ?/gm, '');
+
+ return {
+ type: 'blockquote',
+ raw: cap[0],
+ tokens: this.lexer.blockTokens(text, []),
+ text
+ };
+ }
+ }
+
+ list(src) {
+ let cap = this.rules.block.list.exec(src);
+ if (cap) {
+ let raw, istask, ischecked, indent, i, blankLine, endsWithBlankLine,
+ line, nextLine, rawLine, itemContents, endEarly;
+
+ let bull = cap[1].trim();
+ const isordered = bull.length > 1;
+
+ const list = {
+ type: 'list',
+ raw: '',
+ ordered: isordered,
+ start: isordered ? +bull.slice(0, -1) : '',
+ loose: false,
+ items: []
+ };
+
+ bull = isordered ? `\\d{1,9}\\${bull.slice(-1)}` : `\\${bull}`;
+
+ if (this.options.pedantic) {
+ bull = isordered ? bull : '[*+-]';
+ }
+
+ // Get next list item
+ const itemRegex = new RegExp(`^( {0,3}${bull})((?: [^\\n]*)?(?:\\n|$))`);
+
+ // Check if current bullet point can start a new List Item
+ while (src) {
+ endEarly = false;
+ if (!(cap = itemRegex.exec(src))) {
+ break;
+ }
+
+ if (this.rules.block.hr.test(src)) { // End list if bullet was actually HR (possibly move into itemRegex?)
+ break;
+ }
+
+ raw = cap[0];
+ src = src.substring(raw.length);
+
+ line = cap[2].split('\n', 1)[0];
+ nextLine = src.split('\n', 1)[0];
+
+ if (this.options.pedantic) {
+ indent = 2;
+ itemContents = line.trimLeft();
+ } else {
+ indent = cap[2].search(/[^ ]/); // Find first non-space char
+ indent = indent > 4 ? 1 : indent; // Treat indented code blocks (> 4 spaces) as having only 1 indent
+ itemContents = line.slice(indent);
+ indent += cap[1].length;
+ }
+
+ blankLine = false;
+
+ if (!line && /^ *$/.test(nextLine)) { // Items begin with at most one blank line
+ raw += nextLine + '\n';
+ src = src.substring(nextLine.length + 1);
+ endEarly = true;
+ }
+
+ if (!endEarly) {
+ const nextBulletRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:[*+-]|\\d{1,9}[.)])`);
+
+ // Check if following lines should be included in List Item
+ while (src) {
+ rawLine = src.split('\n', 1)[0];
+ line = rawLine;
+
+ // Re-align to follow commonmark nesting rules
+ if (this.options.pedantic) {
+ line = line.replace(/^ {1,4}(?=( {4})*[^ ])/g, ' ');
+ }
+
+ // End list item if found start of new bullet
+ if (nextBulletRegex.test(line)) {
+ break;
+ }
+
+ if (line.search(/[^ ]/) >= indent || !line.trim()) { // Dedent if possible
+ itemContents += '\n' + line.slice(indent);
+ } else if (!blankLine) { // Until blank line, item doesn't need indentation
+ itemContents += '\n' + line;
+ } else { // Otherwise, improper indentation ends this item
+ break;
+ }
+
+ if (!blankLine && !line.trim()) { // Check if current line is blank
+ blankLine = true;
+ }
+
+ raw += rawLine + '\n';
+ src = src.substring(rawLine.length + 1);
+ }
+ }
+
+ if (!list.loose) {
+ // If the previous item ended with a blank line, the list is loose
+ if (endsWithBlankLine) {
+ list.loose = true;
+ } else if (/\n *\n *$/.test(raw)) {
+ endsWithBlankLine = true;
+ }
+ }
+
+ // Check for task list items
+ if (this.options.gfm) {
+ istask = /^\[[ xX]\] /.exec(itemContents);
+ if (istask) {
+ ischecked = istask[0] !== '[ ] ';
+ itemContents = itemContents.replace(/^\[[ xX]\] +/, '');
+ }
+ }
+
+ list.items.push({
+ type: 'list_item',
+ raw: raw,
+ task: !!istask,
+ checked: ischecked,
+ loose: false,
+ text: itemContents
+ });
+
+ list.raw += raw;
+ }
+
+ // Do not consume newlines at end of final item. Alternatively, make itemRegex *start* with any newlines to simplify/speed up endsWithBlankLine logic
+ list.items[list.items.length - 1].raw = raw.trimRight();
+ list.items[list.items.length - 1].text = itemContents.trimRight();
+ list.raw = list.raw.trimRight();
+
+ const l = list.items.length;
+
+ // Item child tokens handled here at end because we needed to have the final item to trim it first
+ for (i = 0; i < l; i++) {
+ this.lexer.state.top = false;
+ list.items[i].tokens = this.lexer.blockTokens(list.items[i].text, []);
+ const spacers = list.items[i].tokens.filter(t => t.type === 'space');
+ const hasMultipleLineBreaks = spacers.every(t => {
+ const chars = t.raw.split('');
+ let lineBreaks = 0;
+ for (const char of chars) {
+ if (char === '\n') {
+ lineBreaks += 1;
+ }
+ if (lineBreaks > 1) {
+ return true;
+ }
+ }
+
+ return false;
+ });
+
+ if (!list.loose && spacers.length && hasMultipleLineBreaks) {
+ // Having a single line break doesn't mean a list is loose. A single line break is terminating the last list item
+ list.loose = true;
+ list.items[i].loose = true;
+ }
+ }
+
+ return list;
+ }
+ }
+
+ html(src) {
+ const cap = this.rules.block.html.exec(src);
+ if (cap) {
+ const token = {
+ type: 'html',
+ raw: cap[0],
+ pre: !this.options.sanitizer
+ && (cap[1] === 'pre' || cap[1] === 'script' || cap[1] === 'style'),
+ text: cap[0]
+ };
+ if (this.options.sanitize) {
+ token.type = 'paragraph';
+ token.text = this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]);
+ token.tokens = [];
+ this.lexer.inline(token.text, token.tokens);
+ }
+ return token;
+ }
+ }
+
+ def(src) {
+ const cap = this.rules.block.def.exec(src);
+ if (cap) {
+ if (cap[3]) cap[3] = cap[3].substring(1, cap[3].length - 1);
+ const tag = cap[1].toLowerCase().replace(/\s+/g, ' ');
+ return {
+ type: 'def',
+ tag,
+ raw: cap[0],
+ href: cap[2],
+ title: cap[3]
+ };
+ }
+ }
+
+ table(src) {
+ const cap = this.rules.block.table.exec(src);
+ if (cap) {
+ const item = {
+ type: 'table',
+ header: splitCells(cap[1]).map(c => { return { text: c }; }),
+ align: cap[2].replace(/^ *|\| *$/g, '').split(/ *\| */),
+ rows: cap[3] ? cap[3].replace(/\n[ \t]*$/, '').split('\n') : []
+ };
+
+ if (item.header.length === item.align.length) {
+ item.raw = cap[0];
+
+ let l = item.align.length;
+ let i, j, k, row;
+ for (i = 0; i < l; i++) {
+ if (/^ *-+: *$/.test(item.align[i])) {
+ item.align[i] = 'right';
+ } else if (/^ *:-+: *$/.test(item.align[i])) {
+ item.align[i] = 'center';
+ } else if (/^ *:-+ *$/.test(item.align[i])) {
+ item.align[i] = 'left';
+ } else {
+ item.align[i] = null;
+ }
+ }
+
+ l = item.rows.length;
+ for (i = 0; i < l; i++) {
+ item.rows[i] = splitCells(item.rows[i], item.header.length).map(c => { return { text: c }; });
+ }
+
+ // parse child tokens inside headers and cells
+
+ // header child tokens
+ l = item.header.length;
+ for (j = 0; j < l; j++) {
+ item.header[j].tokens = [];
+ this.lexer.inlineTokens(item.header[j].text, item.header[j].tokens);
+ }
+
+ // cell child tokens
+ l = item.rows.length;
+ for (j = 0; j < l; j++) {
+ row = item.rows[j];
+ for (k = 0; k < row.length; k++) {
+ row[k].tokens = [];
+ this.lexer.inlineTokens(row[k].text, row[k].tokens);
+ }
+ }
+
+ return item;
+ }
+ }
+ }
+
+ lheading(src) {
+ const cap = this.rules.block.lheading.exec(src);
+ if (cap) {
+ const token = {
+ type: 'heading',
+ raw: cap[0],
+ depth: cap[2].charAt(0) === '=' ? 1 : 2,
+ text: cap[1],
+ tokens: []
+ };
+ this.lexer.inline(token.text, token.tokens);
+ return token;
+ }
+ }
+
+ paragraph(src) {
+ const cap = this.rules.block.paragraph.exec(src);
+ if (cap) {
+ const token = {
+ type: 'paragraph',
+ raw: cap[0],
+ text: cap[1].charAt(cap[1].length - 1) === '\n'
+ ? cap[1].slice(0, -1)
+ : cap[1],
+ tokens: []
+ };
+ this.lexer.inline(token.text, token.tokens);
+ return token;
+ }
+ }
+
+ text(src) {
+ const cap = this.rules.block.text.exec(src);
+ if (cap) {
+ const token = {
+ type: 'text',
+ raw: cap[0],
+ text: cap[0],
+ tokens: []
+ };
+ this.lexer.inline(token.text, token.tokens);
+ return token;
+ }
+ }
+
+ escape(src) {
+ const cap = this.rules.inline.escape.exec(src);
+ if (cap) {
+ return {
+ type: 'escape',
+ raw: cap[0],
+ text: escape(cap[1])
+ };
+ }
+ }
+
+ tag(src) {
+ const cap = this.rules.inline.tag.exec(src);
+ if (cap) {
+ if (!this.lexer.state.inLink && /^/i.test(cap[0])) {
+ this.lexer.state.inLink = false;
+ }
+ if (!this.lexer.state.inRawBlock && /^<(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
+ this.lexer.state.inRawBlock = true;
+ } else if (this.lexer.state.inRawBlock && /^<\/(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
+ this.lexer.state.inRawBlock = false;
+ }
+
+ return {
+ type: this.options.sanitize
+ ? 'text'
+ : 'html',
+ raw: cap[0],
+ inLink: this.lexer.state.inLink,
+ inRawBlock: this.lexer.state.inRawBlock,
+ text: this.options.sanitize
+ ? (this.options.sanitizer
+ ? this.options.sanitizer(cap[0])
+ : escape(cap[0]))
+ : cap[0]
+ };
+ }
+ }
+
+ link(src) {
+ const cap = this.rules.inline.link.exec(src);
+ if (cap) {
+ const trimmedUrl = cap[2].trim();
+ if (!this.options.pedantic && /^$/.test(trimmedUrl))) {
+ return;
+ }
+
+ // ending angle bracket cannot be escaped
+ const rtrimSlash = rtrim(trimmedUrl.slice(0, -1), '\\');
+ if ((trimmedUrl.length - rtrimSlash.length) % 2 === 0) {
+ return;
+ }
+ } else {
+ // find closing parenthesis
+ const lastParenIndex = findClosingBracket(cap[2], '()');
+ if (lastParenIndex > -1) {
+ const start = cap[0].indexOf('!') === 0 ? 5 : 4;
+ const linkLen = start + cap[1].length + lastParenIndex;
+ cap[2] = cap[2].substring(0, lastParenIndex);
+ cap[0] = cap[0].substring(0, linkLen).trim();
+ cap[3] = '';
+ }
+ }
+ let href = cap[2];
+ let title = '';
+ if (this.options.pedantic) {
+ // split pedantic href and title
+ const link = /^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(href);
+
+ if (link) {
+ href = link[1];
+ title = link[3];
+ }
+ } else {
+ title = cap[3] ? cap[3].slice(1, -1) : '';
+ }
+
+ href = href.trim();
+ if (/^$/.test(trimmedUrl))) {
+ // pedantic allows starting angle bracket without ending angle bracket
+ href = href.slice(1);
+ } else {
+ href = href.slice(1, -1);
+ }
+ }
+ return outputLink(cap, {
+ href: href ? href.replace(this.rules.inline._escapes, '$1') : href,
+ title: title ? title.replace(this.rules.inline._escapes, '$1') : title
+ }, cap[0], this.lexer);
+ }
+ }
+
+ reflink(src, links) {
+ let cap;
+ if ((cap = this.rules.inline.reflink.exec(src))
+ || (cap = this.rules.inline.nolink.exec(src))) {
+ let link = (cap[2] || cap[1]).replace(/\s+/g, ' ');
+ link = links[link.toLowerCase()];
+ if (!link || !link.href) {
+ const text = cap[0].charAt(0);
+ return {
+ type: 'text',
+ raw: text,
+ text
+ };
+ }
+ return outputLink(cap, link, cap[0], this.lexer);
+ }
+ }
+
+ emStrong(src, maskedSrc, prevChar = '') {
+ let match = this.rules.inline.emStrong.lDelim.exec(src);
+ if (!match) return;
+
+ // _ can't be between two alphanumerics. \p{L}\p{N} includes non-english alphabet/numbers as well
+ if (match[3] && prevChar.match(/[\p{L}\p{N}]/u)) return;
+
+ const nextChar = match[1] || match[2] || '';
+
+ if (!nextChar || (nextChar && (prevChar === '' || this.rules.inline.punctuation.exec(prevChar)))) {
+ const lLength = match[0].length - 1;
+ let rDelim, rLength, delimTotal = lLength, midDelimTotal = 0;
+
+ const endReg = match[0][0] === '*' ? this.rules.inline.emStrong.rDelimAst : this.rules.inline.emStrong.rDelimUnd;
+ endReg.lastIndex = 0;
+
+ // Clip maskedSrc to same section of string as src (move to lexer?)
+ maskedSrc = maskedSrc.slice(-1 * src.length + lLength);
+
+ while ((match = endReg.exec(maskedSrc)) != null) {
+ rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];
+
+ if (!rDelim) continue; // skip single * in __abc*abc__
+
+ rLength = rDelim.length;
+
+ if (match[3] || match[4]) { // found another Left Delim
+ delimTotal += rLength;
+ continue;
+ } else if (match[5] || match[6]) { // either Left or Right Delim
+ if (lLength % 3 && !((lLength + rLength) % 3)) {
+ midDelimTotal += rLength;
+ continue; // CommonMark Emphasis Rules 9-10
+ }
+ }
+
+ delimTotal -= rLength;
+
+ if (delimTotal > 0) continue; // Haven't found enough closing delimiters
+
+ // Remove extra characters. *a*** -> *a*
+ rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);
+
+ // Create `em` if smallest delimiter has odd char count. *a***
+ if (Math.min(lLength, rLength) % 2) {
+ const text = src.slice(1, lLength + match.index + rLength);
+ return {
+ type: 'em',
+ raw: src.slice(0, lLength + match.index + rLength + 1),
+ text,
+ tokens: this.lexer.inlineTokens(text, [])
+ };
+ }
+
+ // Create 'strong' if smallest delimiter has even char count. **a***
+ const text = src.slice(2, lLength + match.index + rLength - 1);
+ return {
+ type: 'strong',
+ raw: src.slice(0, lLength + match.index + rLength + 1),
+ text,
+ tokens: this.lexer.inlineTokens(text, [])
+ };
+ }
+ }
+ }
+
+ codespan(src) {
+ const cap = this.rules.inline.code.exec(src);
+ if (cap) {
+ let text = cap[2].replace(/\n/g, ' ');
+ const hasNonSpaceChars = /[^ ]/.test(text);
+ const hasSpaceCharsOnBothEnds = /^ /.test(text) && / $/.test(text);
+ if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {
+ text = text.substring(1, text.length - 1);
+ }
+ text = escape(text, true);
+ return {
+ type: 'codespan',
+ raw: cap[0],
+ text
+ };
+ }
+ }
+
+ br(src) {
+ const cap = this.rules.inline.br.exec(src);
+ if (cap) {
+ return {
+ type: 'br',
+ raw: cap[0]
+ };
+ }
+ }
+
+ del(src) {
+ const cap = this.rules.inline.del.exec(src);
+ if (cap) {
+ return {
+ type: 'del',
+ raw: cap[0],
+ text: cap[2],
+ tokens: this.lexer.inlineTokens(cap[2], [])
+ };
+ }
+ }
+
+ autolink(src, mangle) {
+ const cap = this.rules.inline.autolink.exec(src);
+ if (cap) {
+ let text, href;
+ if (cap[2] === '@') {
+ text = escape(this.options.mangle ? mangle(cap[1]) : cap[1]);
+ href = 'mailto:' + text;
+ } else {
+ text = escape(cap[1]);
+ href = text;
+ }
+
+ return {
+ type: 'link',
+ raw: cap[0],
+ text,
+ href,
+ tokens: [
+ {
+ type: 'text',
+ raw: text,
+ text
+ }
+ ]
+ };
+ }
+ }
+
+ url(src, mangle) {
+ let cap;
+ if (cap = this.rules.inline.url.exec(src)) {
+ let text, href;
+ if (cap[2] === '@') {
+ text = escape(this.options.mangle ? mangle(cap[0]) : cap[0]);
+ href = 'mailto:' + text;
+ } else {
+ // do extended autolink path validation
+ let prevCapZero;
+ do {
+ prevCapZero = cap[0];
+ cap[0] = this.rules.inline._backpedal.exec(cap[0])[0];
+ } while (prevCapZero !== cap[0]);
+ text = escape(cap[0]);
+ if (cap[1] === 'www.') {
+ href = 'http://' + text;
+ } else {
+ href = text;
+ }
+ }
+ return {
+ type: 'link',
+ raw: cap[0],
+ text,
+ href,
+ tokens: [
+ {
+ type: 'text',
+ raw: text,
+ text
+ }
+ ]
+ };
+ }
+ }
+
+ inlineText(src, smartypants) {
+ const cap = this.rules.inline.text.exec(src);
+ if (cap) {
+ let text;
+ if (this.lexer.state.inRawBlock) {
+ text = this.options.sanitize ? (this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0])) : cap[0];
+ } else {
+ text = escape(this.options.smartypants ? smartypants(cap[0]) : cap[0]);
+ }
+ return {
+ type: 'text',
+ raw: cap[0],
+ text
+ };
+ }
+ }
+}
+
+/**
+ * Block-Level Grammar
+ */
+const block = {
+ newline: /^(?: *(?:\n|$))+/,
+ code: /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/,
+ fences: /^ {0,3}(`{3,}(?=[^`\n]*\n)|~{3,})([^\n]*)\n(?:|([\s\S]*?)\n)(?: {0,3}\1[~`]* *(?=\n|$)|$)/,
+ hr: /^ {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\* *){3,})(?:\n+|$)/,
+ heading: /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,
+ blockquote: /^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/,
+ list: /^( {0,3}bull)( [^\n]+?)?(?:\n|$)/,
+ html: '^ {0,3}(?:' // optional indentation
+ + '<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:[^\\n]*\\n+|$)' // (1)
+ + '|comment[^\\n]*(\\n+|$)' // (2)
+ + '|<\\?[\\s\\S]*?(?:\\?>\\n*|$)' // (3)
+ + '|\\n*|$)' // (4)
+ + '|\\n*|$)' // (5)
+ + '|)[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (6)
+ + '|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (7) open tag
+ + '|(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (7) closing tag
+ + ')',
+ def: /^ {0,3}\[(label)\]: *(?:\n *)?]+)>?(?:(?: +(?:\n *)?| *\n *)(title))? *(?:\n+|$)/,
+ table: noopTest,
+ lheading: /^([^\n]+)\n {0,3}(=+|-+) *(?:\n+|$)/,
+ // regex template, placeholders will be replaced according to different paragraph
+ // interruption rules of commonmark and the original markdown spec:
+ _paragraph: /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/,
+ text: /^[^\n]+/
+};
+
+block._label = /(?!\s*\])(?:\\.|[^\[\]\\])+/;
+block._title = /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/;
+block.def = edit(block.def)
+ .replace('label', block._label)
+ .replace('title', block._title)
+ .getRegex();
+
+block.bullet = /(?:[*+-]|\d{1,9}[.)])/;
+block.listItemStart = edit(/^( *)(bull) */)
+ .replace('bull', block.bullet)
+ .getRegex();
+
+block.list = edit(block.list)
+ .replace(/bull/g, block.bullet)
+ .replace('hr', '\\n+(?=\\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$))')
+ .replace('def', '\\n+(?=' + block.def.source + ')')
+ .getRegex();
+
+block._tag = 'address|article|aside|base|basefont|blockquote|body|caption'
+ + '|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption'
+ + '|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe'
+ + '|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option'
+ + '|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr'
+ + '|track|ul';
+block._comment = /|$)/;
+block.html = edit(block.html, 'i')
+ .replace('comment', block._comment)
+ .replace('tag', block._tag)
+ .replace('attribute', / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/)
+ .getRegex();
+
+block.paragraph = edit(block._paragraph)
+ .replace('hr', block.hr)
+ .replace('heading', ' {0,3}#{1,6} ')
+ .replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs
+ .replace('|table', '')
+ .replace('blockquote', ' {0,3}>')
+ .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n')
+ .replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
+ .replace('html', ')|<(?:script|pre|style|textarea|!--)')
+ .replace('tag', block._tag) // pars can be interrupted by type (6) html blocks
+ .getRegex();
+
+block.blockquote = edit(block.blockquote)
+ .replace('paragraph', block.paragraph)
+ .getRegex();
+
+/**
+ * Normal Block Grammar
+ */
+
+block.normal = merge({}, block);
+
+/**
+ * GFM Block Grammar
+ */
+
+block.gfm = merge({}, block.normal, {
+ table: '^ *([^\\n ].*\\|.*)\\n' // Header
+ + ' {0,3}(?:\\| *)?(:?-+:? *(?:\\| *:?-+:? *)*)(?:\\| *)?' // Align
+ + '(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)' // Cells
+});
+
+block.gfm.table = edit(block.gfm.table)
+ .replace('hr', block.hr)
+ .replace('heading', ' {0,3}#{1,6} ')
+ .replace('blockquote', ' {0,3}>')
+ .replace('code', ' {4}[^\\n]')
+ .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n')
+ .replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
+ .replace('html', ')|<(?:script|pre|style|textarea|!--)')
+ .replace('tag', block._tag) // tables can be interrupted by type (6) html blocks
+ .getRegex();
+
+block.gfm.paragraph = edit(block._paragraph)
+ .replace('hr', block.hr)
+ .replace('heading', ' {0,3}#{1,6} ')
+ .replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs
+ .replace('table', block.gfm.table) // interrupt paragraphs with table
+ .replace('blockquote', ' {0,3}>')
+ .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n')
+ .replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
+ .replace('html', ')|<(?:script|pre|style|textarea|!--)')
+ .replace('tag', block._tag) // pars can be interrupted by type (6) html blocks
+ .getRegex();
+/**
+ * Pedantic grammar (original John Gruber's loose markdown specification)
+ */
+
+block.pedantic = merge({}, block.normal, {
+ html: edit(
+ '^ *(?:comment *(?:\\n|\\s*$)'
+ + '|<(tag)[\\s\\S]+? *(?:\\n{2,}|\\s*$)' // closed tag
+ + '|'
+ + (escaped ? code : escape(code, true))
+ + '
\n';
+ }
+
+ return ''
+ + (escaped ? code : escape(code, true))
+ + '
\n';
+ }
+
+ blockquote(quote) {
+ return '\n' + quote + '
\n';
+ }
+
+ html(html) {
+ return html;
+ }
+
+ heading(text, level, raw, slugger) {
+ if (this.options.headerIds) {
+ return ''
+ + text
+ + ' \n';
+ }
+ // ignore IDs
+ return '' + text + ' \n';
+ }
+
+ hr() {
+ return this.options.xhtml ? '
\n' : '
\n';
+ }
+
+ list(body, ordered, start) {
+ const type = ordered ? 'ol' : 'ul',
+ startatt = (ordered && start !== 1) ? (' start="' + start + '"') : '';
+ return '<' + type + startatt + '>\n' + body + '\n';
+ }
+
+ listitem(text) {
+ return '- ' + text + '
\n';
+ }
+
+ checkbox(checked) {
+ return ' ';
+ }
+
+ paragraph(text) {
+ return '' + text + '
\n';
+ }
+
+ table(header, body) {
+ if (body) body = '' + body + '';
+
+ return '\n'
+ + '\n'
+ + header
+ + '\n'
+ + body
+ + '
\n';
+ }
+
+ tablerow(content) {
+ return '\n' + content + ' \n';
+ }
+
+ tablecell(content, flags) {
+ const type = flags.header ? 'th' : 'td';
+ const tag = flags.align
+ ? '<' + type + ' align="' + flags.align + '">'
+ : '<' + type + '>';
+ return tag + content + '\n';
+ }
+
+ // span level renderer
+ strong(text) {
+ return '' + text + '';
+ }
+
+ em(text) {
+ return '' + text + '';
+ }
+
+ codespan(text) {
+ return '' + text + '';
+ }
+
+ br() {
+ return this.options.xhtml ? '
' : '
';
+ }
+
+ del(text) {
+ return '' + text + '';
+ }
+
+ link(href, title, text) {
+ href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
+ if (href === null) {
+ return text;
+ }
+ let out = '';
+ return out;
+ }
+
+ image(href, title, text) {
+ href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
+ if (href === null) {
+ return text;
+ }
+
+ let out = '' : '>';
+ return out;
+ }
+
+ text(text) {
+ return text;
+ }
+}
+
+/**
+ * TextRenderer
+ * returns only the textual part of the token
+ */
+class TextRenderer {
+ // no need for block level renderers
+ strong(text) {
+ return text;
+ }
+
+ em(text) {
+ return text;
+ }
+
+ codespan(text) {
+ return text;
+ }
+
+ del(text) {
+ return text;
+ }
+
+ html(text) {
+ return text;
+ }
+
+ text(text) {
+ return text;
+ }
+
+ link(href, title, text) {
+ return '' + text;
+ }
+
+ image(href, title, text) {
+ return '' + text;
+ }
+
+ br() {
+ return '';
+ }
+}
+
+/**
+ * Slugger generates header id
+ */
+class Slugger {
+ constructor() {
+ this.seen = {};
+ }
+
+ serialize(value) {
+ return value
+ .toLowerCase()
+ .trim()
+ // remove html tags
+ .replace(/<[!\/a-z].*?>/ig, '')
+ // remove unwanted chars
+ .replace(/[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g, '')
+ .replace(/\s/g, '-');
+ }
+
+ /**
+ * Finds the next safe (unique) slug to use
+ */
+ getNextSafeSlug(originalSlug, isDryRun) {
+ let slug = originalSlug;
+ let occurenceAccumulator = 0;
+ if (this.seen.hasOwnProperty(slug)) {
+ occurenceAccumulator = this.seen[originalSlug];
+ do {
+ occurenceAccumulator++;
+ slug = originalSlug + '-' + occurenceAccumulator;
+ } while (this.seen.hasOwnProperty(slug));
+ }
+ if (!isDryRun) {
+ this.seen[originalSlug] = occurenceAccumulator;
+ this.seen[slug] = 0;
+ }
+ return slug;
+ }
+
+ /**
+ * Convert string to unique id
+ * @param {object} options
+ * @param {boolean} options.dryrun Generates the next unique slug without updating the internal accumulator.
+ */
+ slug(value, options = {}) {
+ const slug = this.serialize(value);
+ return this.getNextSafeSlug(slug, options.dryrun);
+ }
+}
+
+/**
+ * Parsing & Compiling
+ */
+class Parser {
+ constructor(options) {
+ this.options = options || defaults;
+ this.options.renderer = this.options.renderer || new Renderer();
+ this.renderer = this.options.renderer;
+ this.renderer.options = this.options;
+ this.textRenderer = new TextRenderer();
+ this.slugger = new Slugger();
+ }
+
+ /**
+ * Static Parse Method
+ */
+ static parse(tokens, options) {
+ const parser = new Parser(options);
+ return parser.parse(tokens);
+ }
+
+ /**
+ * Static Parse Inline Method
+ */
+ static parseInline(tokens, options) {
+ const parser = new Parser(options);
+ return parser.parseInline(tokens);
+ }
+
+ /**
+ * Parse Loop
+ */
+ parse(tokens, top = true) {
+ let out = '',
+ i,
+ j,
+ k,
+ l2,
+ l3,
+ row,
+ cell,
+ header,
+ body,
+ token,
+ ordered,
+ start,
+ loose,
+ itemBody,
+ item,
+ checked,
+ task,
+ checkbox,
+ ret;
+
+ const l = tokens.length;
+ for (i = 0; i < l; i++) {
+ token = tokens[i];
+
+ // Run any renderer extensions
+ if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
+ ret = this.options.extensions.renderers[token.type].call({ parser: this }, token);
+ if (ret !== false || !['space', 'hr', 'heading', 'code', 'table', 'blockquote', 'list', 'html', 'paragraph', 'text'].includes(token.type)) {
+ out += ret || '';
+ continue;
+ }
+ }
+
+ switch (token.type) {
+ case 'space': {
+ continue;
+ }
+ case 'hr': {
+ out += this.renderer.hr();
+ continue;
+ }
+ case 'heading': {
+ out += this.renderer.heading(
+ this.parseInline(token.tokens),
+ token.depth,
+ unescape(this.parseInline(token.tokens, this.textRenderer)),
+ this.slugger);
+ continue;
+ }
+ case 'code': {
+ out += this.renderer.code(token.text,
+ token.lang,
+ token.escaped);
+ continue;
+ }
+ case 'table': {
+ header = '';
+
+ // header
+ cell = '';
+ l2 = token.header.length;
+ for (j = 0; j < l2; j++) {
+ cell += this.renderer.tablecell(
+ this.parseInline(token.header[j].tokens),
+ { header: true, align: token.align[j] }
+ );
+ }
+ header += this.renderer.tablerow(cell);
+
+ body = '';
+ l2 = token.rows.length;
+ for (j = 0; j < l2; j++) {
+ row = token.rows[j];
+
+ cell = '';
+ l3 = row.length;
+ for (k = 0; k < l3; k++) {
+ cell += this.renderer.tablecell(
+ this.parseInline(row[k].tokens),
+ { header: false, align: token.align[k] }
+ );
+ }
+
+ body += this.renderer.tablerow(cell);
+ }
+ out += this.renderer.table(header, body);
+ continue;
+ }
+ case 'blockquote': {
+ body = this.parse(token.tokens);
+ out += this.renderer.blockquote(body);
+ continue;
+ }
+ case 'list': {
+ ordered = token.ordered;
+ start = token.start;
+ loose = token.loose;
+ l2 = token.items.length;
+
+ body = '';
+ for (j = 0; j < l2; j++) {
+ item = token.items[j];
+ checked = item.checked;
+ task = item.task;
+
+ itemBody = '';
+ if (item.task) {
+ checkbox = this.renderer.checkbox(checked);
+ if (loose) {
+ if (item.tokens.length > 0 && item.tokens[0].type === 'paragraph') {
+ item.tokens[0].text = checkbox + ' ' + item.tokens[0].text;
+ if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === 'text') {
+ item.tokens[0].tokens[0].text = checkbox + ' ' + item.tokens[0].tokens[0].text;
+ }
+ } else {
+ item.tokens.unshift({
+ type: 'text',
+ text: checkbox
+ });
+ }
+ } else {
+ itemBody += checkbox;
+ }
+ }
+
+ itemBody += this.parse(item.tokens, loose);
+ body += this.renderer.listitem(itemBody, task, checked);
+ }
+
+ out += this.renderer.list(body, ordered, start);
+ continue;
+ }
+ case 'html': {
+ // TODO parse inline content if parameter markdown=1
+ out += this.renderer.html(token.text);
+ continue;
+ }
+ case 'paragraph': {
+ out += this.renderer.paragraph(this.parseInline(token.tokens));
+ continue;
+ }
+ case 'text': {
+ body = token.tokens ? this.parseInline(token.tokens) : token.text;
+ while (i + 1 < l && tokens[i + 1].type === 'text') {
+ token = tokens[++i];
+ body += '\n' + (token.tokens ? this.parseInline(token.tokens) : token.text);
+ }
+ out += top ? this.renderer.paragraph(body) : body;
+ continue;
+ }
+
+ default: {
+ const errMsg = 'Token with "' + token.type + '" type was not found.';
+ if (this.options.silent) {
+ console.error(errMsg);
+ return;
+ } else {
+ throw new Error(errMsg);
+ }
+ }
+ }
+ }
+
+ return out;
+ }
+
+ /**
+ * Parse Inline Tokens
+ */
+ parseInline(tokens, renderer) {
+ renderer = renderer || this.renderer;
+ let out = '',
+ i,
+ token,
+ ret;
+
+ const l = tokens.length;
+ for (i = 0; i < l; i++) {
+ token = tokens[i];
+
+ // Run any renderer extensions
+ if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
+ ret = this.options.extensions.renderers[token.type].call({ parser: this }, token);
+ if (ret !== false || !['escape', 'html', 'link', 'image', 'strong', 'em', 'codespan', 'br', 'del', 'text'].includes(token.type)) {
+ out += ret || '';
+ continue;
+ }
+ }
+
+ switch (token.type) {
+ case 'escape': {
+ out += renderer.text(token.text);
+ break;
+ }
+ case 'html': {
+ out += renderer.html(token.text);
+ break;
+ }
+ case 'link': {
+ out += renderer.link(token.href, token.title, this.parseInline(token.tokens, renderer));
+ break;
+ }
+ case 'image': {
+ out += renderer.image(token.href, token.title, token.text);
+ break;
+ }
+ case 'strong': {
+ out += renderer.strong(this.parseInline(token.tokens, renderer));
+ break;
+ }
+ case 'em': {
+ out += renderer.em(this.parseInline(token.tokens, renderer));
+ break;
+ }
+ case 'codespan': {
+ out += renderer.codespan(token.text);
+ break;
+ }
+ case 'br': {
+ out += renderer.br();
+ break;
+ }
+ case 'del': {
+ out += renderer.del(this.parseInline(token.tokens, renderer));
+ break;
+ }
+ case 'text': {
+ out += renderer.text(token.text);
+ break;
+ }
+ default: {
+ const errMsg = 'Token with "' + token.type + '" type was not found.';
+ if (this.options.silent) {
+ console.error(errMsg);
+ return;
+ } else {
+ throw new Error(errMsg);
+ }
+ }
+ }
+ }
+ return out;
+ }
+}
+
+/**
+ * Marked
+ */
+function marked(src, opt, callback) {
+ // throw error in case of non string input
+ if (typeof src === 'undefined' || src === null) {
+ throw new Error('marked(): input parameter is undefined or null');
+ }
+ if (typeof src !== 'string') {
+ throw new Error('marked(): input parameter is of type '
+ + Object.prototype.toString.call(src) + ', string expected');
+ }
+
+ if (typeof opt === 'function') {
+ callback = opt;
+ opt = null;
+ }
+
+ opt = merge({}, marked.defaults, opt || {});
+ checkSanitizeDeprecation(opt);
+
+ if (callback) {
+ const highlight = opt.highlight;
+ let tokens;
+
+ try {
+ tokens = Lexer.lex(src, opt);
+ } catch (e) {
+ return callback(e);
+ }
+
+ const done = function(err) {
+ let out;
+
+ if (!err) {
+ try {
+ if (opt.walkTokens) {
+ marked.walkTokens(tokens, opt.walkTokens);
+ }
+ out = Parser.parse(tokens, opt);
+ } catch (e) {
+ err = e;
+ }
+ }
+
+ opt.highlight = highlight;
+
+ return err
+ ? callback(err)
+ : callback(null, out);
+ };
+
+ if (!highlight || highlight.length < 3) {
+ return done();
+ }
+
+ delete opt.highlight;
+
+ if (!tokens.length) return done();
+
+ let pending = 0;
+ marked.walkTokens(tokens, function(token) {
+ if (token.type === 'code') {
+ pending++;
+ setTimeout(() => {
+ highlight(token.text, token.lang, function(err, code) {
+ if (err) {
+ return done(err);
+ }
+ if (code != null && code !== token.text) {
+ token.text = code;
+ token.escaped = true;
+ }
+
+ pending--;
+ if (pending === 0) {
+ done();
+ }
+ });
+ }, 0);
+ }
+ });
+
+ if (pending === 0) {
+ done();
+ }
+
+ return;
+ }
+
+ try {
+ const tokens = Lexer.lex(src, opt);
+ if (opt.walkTokens) {
+ marked.walkTokens(tokens, opt.walkTokens);
+ }
+ return Parser.parse(tokens, opt);
+ } catch (e) {
+ e.message += '\nPlease report this to https://github.com/markedjs/marked.';
+ if (opt.silent) {
+ return 'An error occurred:
'
+ + escape(e.message + '', true)
+ + '
';
+ }
+ throw e;
+ }
+}
+
+/**
+ * Options
+ */
+
+marked.options =
+marked.setOptions = function(opt) {
+ merge(marked.defaults, opt);
+ changeDefaults(marked.defaults);
+ return marked;
+};
+
+marked.getDefaults = getDefaults;
+
+marked.defaults = defaults;
+
+/**
+ * Use Extension
+ */
+
+marked.use = function(...args) {
+ const opts = merge({}, ...args);
+ const extensions = marked.defaults.extensions || { renderers: {}, childTokens: {} };
+ let hasExtensions;
+
+ args.forEach((pack) => {
+ // ==-- Parse "addon" extensions --== //
+ if (pack.extensions) {
+ hasExtensions = true;
+ pack.extensions.forEach((ext) => {
+ if (!ext.name) {
+ throw new Error('extension name required');
+ }
+ if (ext.renderer) { // Renderer extensions
+ const prevRenderer = extensions.renderers ? extensions.renderers[ext.name] : null;
+ if (prevRenderer) {
+ // Replace extension with func to run new extension but fall back if false
+ extensions.renderers[ext.name] = function(...args) {
+ let ret = ext.renderer.apply(this, args);
+ if (ret === false) {
+ ret = prevRenderer.apply(this, args);
+ }
+ return ret;
+ };
+ } else {
+ extensions.renderers[ext.name] = ext.renderer;
+ }
+ }
+ if (ext.tokenizer) { // Tokenizer Extensions
+ if (!ext.level || (ext.level !== 'block' && ext.level !== 'inline')) {
+ throw new Error("extension level must be 'block' or 'inline'");
+ }
+ if (extensions[ext.level]) {
+ extensions[ext.level].unshift(ext.tokenizer);
+ } else {
+ extensions[ext.level] = [ext.tokenizer];
+ }
+ if (ext.start) { // Function to check for start of token
+ if (ext.level === 'block') {
+ if (extensions.startBlock) {
+ extensions.startBlock.push(ext.start);
+ } else {
+ extensions.startBlock = [ext.start];
+ }
+ } else if (ext.level === 'inline') {
+ if (extensions.startInline) {
+ extensions.startInline.push(ext.start);
+ } else {
+ extensions.startInline = [ext.start];
+ }
+ }
+ }
+ }
+ if (ext.childTokens) { // Child tokens to be visited by walkTokens
+ extensions.childTokens[ext.name] = ext.childTokens;
+ }
+ });
+ }
+
+ // ==-- Parse "overwrite" extensions --== //
+ if (pack.renderer) {
+ const renderer = marked.defaults.renderer || new Renderer();
+ for (const prop in pack.renderer) {
+ const prevRenderer = renderer[prop];
+ // Replace renderer with func to run extension, but fall back if false
+ renderer[prop] = (...args) => {
+ let ret = pack.renderer[prop].apply(renderer, args);
+ if (ret === false) {
+ ret = prevRenderer.apply(renderer, args);
+ }
+ return ret;
+ };
+ }
+ opts.renderer = renderer;
+ }
+ if (pack.tokenizer) {
+ const tokenizer = marked.defaults.tokenizer || new Tokenizer();
+ for (const prop in pack.tokenizer) {
+ const prevTokenizer = tokenizer[prop];
+ // Replace tokenizer with func to run extension, but fall back if false
+ tokenizer[prop] = (...args) => {
+ let ret = pack.tokenizer[prop].apply(tokenizer, args);
+ if (ret === false) {
+ ret = prevTokenizer.apply(tokenizer, args);
+ }
+ return ret;
+ };
+ }
+ opts.tokenizer = tokenizer;
+ }
+
+ // ==-- Parse WalkTokens extensions --== //
+ if (pack.walkTokens) {
+ const walkTokens = marked.defaults.walkTokens;
+ opts.walkTokens = function(token) {
+ pack.walkTokens.call(this, token);
+ if (walkTokens) {
+ walkTokens.call(this, token);
+ }
+ };
+ }
+
+ if (hasExtensions) {
+ opts.extensions = extensions;
+ }
+
+ marked.setOptions(opts);
+ });
+};
+
+/**
+ * Run callback for every token
+ */
+
+marked.walkTokens = function(tokens, callback) {
+ for (const token of tokens) {
+ callback.call(marked, token);
+ switch (token.type) {
+ case 'table': {
+ for (const cell of token.header) {
+ marked.walkTokens(cell.tokens, callback);
+ }
+ for (const row of token.rows) {
+ for (const cell of row) {
+ marked.walkTokens(cell.tokens, callback);
+ }
+ }
+ break;
+ }
+ case 'list': {
+ marked.walkTokens(token.items, callback);
+ break;
+ }
+ default: {
+ if (marked.defaults.extensions && marked.defaults.extensions.childTokens && marked.defaults.extensions.childTokens[token.type]) { // Walk any extensions
+ marked.defaults.extensions.childTokens[token.type].forEach(function(childTokens) {
+ marked.walkTokens(token[childTokens], callback);
+ });
+ } else if (token.tokens) {
+ marked.walkTokens(token.tokens, callback);
+ }
+ }
+ }
+ }
+};
+
+/**
+ * Parse Inline
+ */
+marked.parseInline = function(src, opt) {
+ // throw error in case of non string input
+ if (typeof src === 'undefined' || src === null) {
+ throw new Error('marked.parseInline(): input parameter is undefined or null');
+ }
+ if (typeof src !== 'string') {
+ throw new Error('marked.parseInline(): input parameter is of type '
+ + Object.prototype.toString.call(src) + ', string expected');
+ }
+
+ opt = merge({}, marked.defaults, opt || {});
+ checkSanitizeDeprecation(opt);
+
+ try {
+ const tokens = Lexer.lexInline(src, opt);
+ if (opt.walkTokens) {
+ marked.walkTokens(tokens, opt.walkTokens);
+ }
+ return Parser.parseInline(tokens, opt);
+ } catch (e) {
+ e.message += '\nPlease report this to https://github.com/markedjs/marked.';
+ if (opt.silent) {
+ return 'An error occurred:
'
+ + escape(e.message + '', true)
+ + '
';
+ }
+ throw e;
+ }
+};
+
+/**
+ * Expose
+ */
+marked.Parser = Parser;
+marked.parser = Parser.parse;
+marked.Renderer = Renderer;
+marked.TextRenderer = TextRenderer;
+marked.Lexer = Lexer;
+marked.lexer = Lexer.lex;
+marked.Tokenizer = Tokenizer;
+marked.Slugger = Slugger;
+marked.parse = marked;
+
+const options = marked.options;
+const setOptions = marked.setOptions;
+const use = marked.use;
+const walkTokens = marked.walkTokens;
+const parseInline = marked.parseInline;
+const parse = marked;
+const parser = Parser.parse;
+const lexer = Lexer.lex;
+
+export { Lexer, Parser, Renderer, Slugger, TextRenderer, Tokenizer, defaults, getDefaults, lexer, marked, options, parse, parseInline, parser, setOptions, use, walkTokens };
diff --git a/lib/marked.js b/lib/marked.js
deleted file mode 100644
index 9f1584bb3b..0000000000
--- a/lib/marked.js
+++ /dev/null
@@ -1,1286 +0,0 @@
-/**
- * marked - a markdown parser
- * Copyright (c) 2011-2014, Christopher Jeffrey. (MIT Licensed)
- * https://github.com/chjj/marked
- */
-
-;(function() {
-
-/**
- * Block-Level Grammar
- */
-
-var block = {
- newline: /^\n+/,
- code: /^( {4}[^\n]+\n*)+/,
- fences: noop,
- hr: /^( *[-*_]){3,} *(?:\n+|$)/,
- heading: /^ *(#{1,6}) *([^\n]+?) *#* *(?:\n+|$)/,
- nptable: noop,
- lheading: /^([^\n]+)\n *(=|-){2,} *(?:\n+|$)/,
- blockquote: /^( *>[^\n]+(\n(?!def)[^\n]+)*\n*)+/,
- list: /^( *)(bull) [\s\S]+?(?:hr|def|\n{2,}(?! )(?!\1bull )\n*|\s*$)/,
- html: /^ *(?:comment *(?:\n|\s*$)|closed *(?:\n{2,}|\s*$)|closing *(?:\n{2,}|\s*$))/,
- def: /^ *\[([^\]]+)\]: *]+)>?(?: +["(]([^\n]+)[")])? *(?:\n+|$)/,
- table: noop,
- paragraph: /^((?:[^\n]+\n?(?!hr|heading|lheading|blockquote|tag|def))+)\n*/,
- text: /^[^\n]+/
-};
-
-block.bullet = /(?:[*+-]|\d+\.)/;
-block.item = /^( *)(bull) [^\n]*(?:\n(?!\1bull )[^\n]*)*/;
-block.item = replace(block.item, 'gm')
- (/bull/g, block.bullet)
- ();
-
-block.list = replace(block.list)
- (/bull/g, block.bullet)
- ('hr', '\\n+(?=\\1?(?:[-*_] *){3,}(?:\\n+|$))')
- ('def', '\\n+(?=' + block.def.source + ')')
- ();
-
-block.blockquote = replace(block.blockquote)
- ('def', block.def)
- ();
-
-block._tag = '(?!(?:'
- + 'a|em|strong|small|s|cite|q|dfn|abbr|data|time|code'
- + '|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo'
- + '|span|br|wbr|ins|del|img)\\b)\\w+(?!:/|[^\\w\\s@]*@)\\b';
-
-block.html = replace(block.html)
- ('comment', //)
- ('closed', /<(tag)[\s\S]+?<\/\1>/)
- ('closing', /])*?>/)
- (/tag/g, block._tag)
- ();
-
-block.paragraph = replace(block.paragraph)
- ('hr', block.hr)
- ('heading', block.heading)
- ('lheading', block.lheading)
- ('blockquote', block.blockquote)
- ('tag', '<' + block._tag)
- ('def', block.def)
- ();
-
-/**
- * Normal Block Grammar
- */
-
-block.normal = merge({}, block);
-
-/**
- * GFM Block Grammar
- */
-
-block.gfm = merge({}, block.normal, {
- fences: /^ *(`{3,}|~{3,})[ \.]*(\S+)? *\n([\s\S]*?)\s*\1 *(?:\n+|$)/,
- paragraph: /^/,
- heading: /^ *(#{1,6}) +([^\n]+?) *#* *(?:\n+|$)/
-});
-
-block.gfm.paragraph = replace(block.paragraph)
- ('(?!', '(?!'
- + block.gfm.fences.source.replace('\\1', '\\2') + '|'
- + block.list.source.replace('\\1', '\\3') + '|')
- ();
-
-/**
- * GFM + Tables Block Grammar
- */
-
-block.tables = merge({}, block.gfm, {
- nptable: /^ *(\S.*\|.*)\n *([-:]+ *\|[-| :]*)\n((?:.*\|.*(?:\n|$))*)\n*/,
- table: /^ *\|(.+)\n *\|( *[-:]+[-| :]*)\n((?: *\|.*(?:\n|$))*)\n*/
-});
-
-/**
- * Block Lexer
- */
-
-function Lexer(options) {
- this.tokens = [];
- this.tokens.links = {};
- this.options = options || marked.defaults;
- this.rules = block.normal;
-
- if (this.options.gfm) {
- if (this.options.tables) {
- this.rules = block.tables;
- } else {
- this.rules = block.gfm;
- }
- }
-}
-
-/**
- * Expose Block Rules
- */
-
-Lexer.rules = block;
-
-/**
- * Static Lex Method
- */
-
-Lexer.lex = function(src, options) {
- var lexer = new Lexer(options);
- return lexer.lex(src);
-};
-
-/**
- * Preprocessing
- */
-
-Lexer.prototype.lex = function(src) {
- src = src
- .replace(/\r\n|\r/g, '\n')
- .replace(/\t/g, ' ')
- .replace(/\u00a0/g, ' ')
- .replace(/\u2424/g, '\n');
-
- return this.token(src, true);
-};
-
-/**
- * Lexing
- */
-
-Lexer.prototype.token = function(src, top, bq) {
- var src = src.replace(/^ +$/gm, '')
- , next
- , loose
- , cap
- , bull
- , b
- , item
- , space
- , i
- , l;
-
- while (src) {
- // newline
- if (cap = this.rules.newline.exec(src)) {
- src = src.substring(cap[0].length);
- if (cap[0].length > 1) {
- this.tokens.push({
- type: 'space'
- });
- }
- }
-
- // code
- if (cap = this.rules.code.exec(src)) {
- src = src.substring(cap[0].length);
- cap = cap[0].replace(/^ {4}/gm, '');
- this.tokens.push({
- type: 'code',
- text: !this.options.pedantic
- ? cap.replace(/\n+$/, '')
- : cap
- });
- continue;
- }
-
- // fences (gfm)
- if (cap = this.rules.fences.exec(src)) {
- src = src.substring(cap[0].length);
- this.tokens.push({
- type: 'code',
- lang: cap[2],
- text: cap[3] || ''
- });
- continue;
- }
-
- // heading
- if (cap = this.rules.heading.exec(src)) {
- src = src.substring(cap[0].length);
- this.tokens.push({
- type: 'heading',
- depth: cap[1].length,
- text: cap[2]
- });
- continue;
- }
-
- // table no leading pipe (gfm)
- if (top && (cap = this.rules.nptable.exec(src))) {
- src = src.substring(cap[0].length);
-
- item = {
- type: 'table',
- header: cap[1].replace(/^ *| *\| *$/g, '').split(/ *\| */),
- align: cap[2].replace(/^ *|\| *$/g, '').split(/ *\| */),
- cells: cap[3].replace(/\n$/, '').split('\n')
- };
-
- for (i = 0; i < item.align.length; i++) {
- if (/^ *-+: *$/.test(item.align[i])) {
- item.align[i] = 'right';
- } else if (/^ *:-+: *$/.test(item.align[i])) {
- item.align[i] = 'center';
- } else if (/^ *:-+ *$/.test(item.align[i])) {
- item.align[i] = 'left';
- } else {
- item.align[i] = null;
- }
- }
-
- for (i = 0; i < item.cells.length; i++) {
- item.cells[i] = item.cells[i].split(/ *\| */);
- }
-
- this.tokens.push(item);
-
- continue;
- }
-
- // lheading
- if (cap = this.rules.lheading.exec(src)) {
- src = src.substring(cap[0].length);
- this.tokens.push({
- type: 'heading',
- depth: cap[2] === '=' ? 1 : 2,
- text: cap[1]
- });
- continue;
- }
-
- // hr
- if (cap = this.rules.hr.exec(src)) {
- src = src.substring(cap[0].length);
- this.tokens.push({
- type: 'hr'
- });
- continue;
- }
-
- // blockquote
- if (cap = this.rules.blockquote.exec(src)) {
- src = src.substring(cap[0].length);
-
- this.tokens.push({
- type: 'blockquote_start'
- });
-
- cap = cap[0].replace(/^ *> ?/gm, '');
-
- // Pass `top` to keep the current
- // "toplevel" state. This is exactly
- // how markdown.pl works.
- this.token(cap, top, true);
-
- this.tokens.push({
- type: 'blockquote_end'
- });
-
- continue;
- }
-
- // list
- if (cap = this.rules.list.exec(src)) {
- src = src.substring(cap[0].length);
- bull = cap[2];
-
- this.tokens.push({
- type: 'list_start',
- ordered: bull.length > 1
- });
-
- // Get each top-level item.
- cap = cap[0].match(this.rules.item);
-
- next = false;
- l = cap.length;
- i = 0;
-
- for (; i < l; i++) {
- item = cap[i];
-
- // Remove the list item's bullet
- // so it is seen as the next token.
- space = item.length;
- item = item.replace(/^ *([*+-]|\d+\.) +/, '');
-
- // Outdent whatever the
- // list item contains. Hacky.
- if (~item.indexOf('\n ')) {
- space -= item.length;
- item = !this.options.pedantic
- ? item.replace(new RegExp('^ {1,' + space + '}', 'gm'), '')
- : item.replace(/^ {1,4}/gm, '');
- }
-
- // Determine whether the next list item belongs here.
- // Backpedal if it does not belong in this list.
- if (this.options.smartLists && i !== l - 1) {
- b = block.bullet.exec(cap[i + 1])[0];
- if (bull !== b && !(bull.length > 1 && b.length > 1)) {
- src = cap.slice(i + 1).join('\n') + src;
- i = l - 1;
- }
- }
-
- // Determine whether item is loose or not.
- // Use: /(^|\n)(?! )[^\n]+\n\n(?!\s*$)/
- // for discount behavior.
- loose = next || /\n\n(?!\s*$)/.test(item);
- if (i !== l - 1) {
- next = item.charAt(item.length - 1) === '\n';
- if (!loose) loose = next;
- }
-
- this.tokens.push({
- type: loose
- ? 'loose_item_start'
- : 'list_item_start'
- });
-
- // Recurse.
- this.token(item, false, bq);
-
- this.tokens.push({
- type: 'list_item_end'
- });
- }
-
- this.tokens.push({
- type: 'list_end'
- });
-
- continue;
- }
-
- // html
- if (cap = this.rules.html.exec(src)) {
- src = src.substring(cap[0].length);
- this.tokens.push({
- type: this.options.sanitize
- ? 'paragraph'
- : 'html',
- pre: !this.options.sanitizer
- && (cap[1] === 'pre' || cap[1] === 'script' || cap[1] === 'style'),
- text: cap[0]
- });
- continue;
- }
-
- // def
- if ((!bq && top) && (cap = this.rules.def.exec(src))) {
- src = src.substring(cap[0].length);
- this.tokens.links[cap[1].toLowerCase()] = {
- href: cap[2],
- title: cap[3]
- };
- continue;
- }
-
- // table (gfm)
- if (top && (cap = this.rules.table.exec(src))) {
- src = src.substring(cap[0].length);
-
- item = {
- type: 'table',
- header: cap[1].replace(/^ *| *\| *$/g, '').split(/ *\| */),
- align: cap[2].replace(/^ *|\| *$/g, '').split(/ *\| */),
- cells: cap[3].replace(/(?: *\| *)?\n$/, '').split('\n')
- };
-
- for (i = 0; i < item.align.length; i++) {
- if (/^ *-+: *$/.test(item.align[i])) {
- item.align[i] = 'right';
- } else if (/^ *:-+: *$/.test(item.align[i])) {
- item.align[i] = 'center';
- } else if (/^ *:-+ *$/.test(item.align[i])) {
- item.align[i] = 'left';
- } else {
- item.align[i] = null;
- }
- }
-
- for (i = 0; i < item.cells.length; i++) {
- item.cells[i] = item.cells[i]
- .replace(/^ *\| *| *\| *$/g, '')
- .split(/ *\| */);
- }
-
- this.tokens.push(item);
-
- continue;
- }
-
- // top-level paragraph
- if (top && (cap = this.rules.paragraph.exec(src))) {
- src = src.substring(cap[0].length);
- this.tokens.push({
- type: 'paragraph',
- text: cap[1].charAt(cap[1].length - 1) === '\n'
- ? cap[1].slice(0, -1)
- : cap[1]
- });
- continue;
- }
-
- // text
- if (cap = this.rules.text.exec(src)) {
- // Top-level should never reach here.
- src = src.substring(cap[0].length);
- this.tokens.push({
- type: 'text',
- text: cap[0]
- });
- continue;
- }
-
- if (src) {
- throw new
- Error('Infinite loop on byte: ' + src.charCodeAt(0));
- }
- }
-
- return this.tokens;
-};
-
-/**
- * Inline-Level Grammar
- */
-
-var inline = {
- escape: /^\\([\\`*{}\[\]()#+\-.!_>])/,
- autolink: /^<([^ >]+(@|:\/)[^ >]+)>/,
- url: noop,
- tag: /^|^<\/?\w+(?:"[^"]*"|'[^']*'|[^'">])*?>/,
- link: /^!?\[(inside)\]\(href\)/,
- reflink: /^!?\[(inside)\]\s*\[([^\]]*)\]/,
- nolink: /^!?\[((?:\[[^\]]*\]|[^\[\]])*)\]/,
- strong: /^__([\s\S]+?)__(?!_)|^\*\*([\s\S]+?)\*\*(?!\*)/,
- em: /^\b_((?:[^_]|__)+?)_\b|^\*((?:\*\*|[\s\S])+?)\*(?!\*)/,
- code: /^(`+)\s*([\s\S]*?[^`])\s*\1(?!`)/,
- br: /^ {2,}\n(?!\s*$)/,
- del: noop,
- text: /^[\s\S]+?(?=[\\?(?:\s+['"]([\s\S]*?)['"])?\s*/;
-
-inline.link = replace(inline.link)
- ('inside', inline._inside)
- ('href', inline._href)
- ();
-
-inline.reflink = replace(inline.reflink)
- ('inside', inline._inside)
- ();
-
-/**
- * Normal Inline Grammar
- */
-
-inline.normal = merge({}, inline);
-
-/**
- * Pedantic Inline Grammar
- */
-
-inline.pedantic = merge({}, inline.normal, {
- strong: /^__(?=\S)([\s\S]*?\S)__(?!_)|^\*\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/,
- em: /^_(?=\S)([\s\S]*?\S)_(?!_)|^\*(?=\S)([\s\S]*?\S)\*(?!\*)/
-});
-
-/**
- * GFM Inline Grammar
- */
-
-inline.gfm = merge({}, inline.normal, {
- escape: replace(inline.escape)('])', '~|])')(),
- url: /^(https?:\/\/[^\s<]+[^<.,:;"')\]\s])/,
- del: /^~~(?=\S)([\s\S]*?\S)~~/,
- text: replace(inline.text)
- (']|', '~]|')
- ('|', '|https?://|')
- ()
-});
-
-/**
- * GFM + Line Breaks Inline Grammar
- */
-
-inline.breaks = merge({}, inline.gfm, {
- br: replace(inline.br)('{2,}', '*')(),
- text: replace(inline.gfm.text)('{2,}', '*')()
-});
-
-/**
- * Inline Lexer & Compiler
- */
-
-function InlineLexer(links, options) {
- this.options = options || marked.defaults;
- this.links = links;
- this.rules = inline.normal;
- this.renderer = this.options.renderer || new Renderer;
- this.renderer.options = this.options;
-
- if (!this.links) {
- throw new
- Error('Tokens array requires a `links` property.');
- }
-
- if (this.options.gfm) {
- if (this.options.breaks) {
- this.rules = inline.breaks;
- } else {
- this.rules = inline.gfm;
- }
- } else if (this.options.pedantic) {
- this.rules = inline.pedantic;
- }
-}
-
-/**
- * Expose Inline Rules
- */
-
-InlineLexer.rules = inline;
-
-/**
- * Static Lexing/Compiling Method
- */
-
-InlineLexer.output = function(src, links, options) {
- var inline = new InlineLexer(links, options);
- return inline.output(src);
-};
-
-/**
- * Lexing/Compiling
- */
-
-InlineLexer.prototype.output = function(src) {
- var out = ''
- , link
- , text
- , href
- , cap;
-
- while (src) {
- // escape
- if (cap = this.rules.escape.exec(src)) {
- src = src.substring(cap[0].length);
- out += cap[1];
- continue;
- }
-
- // autolink
- if (cap = this.rules.autolink.exec(src)) {
- src = src.substring(cap[0].length);
- if (cap[2] === '@') {
- text = cap[1].charAt(6) === ':'
- ? this.mangle(cap[1].substring(7))
- : this.mangle(cap[1]);
- href = this.mangle('mailto:') + text;
- } else {
- text = escape(cap[1]);
- href = text;
- }
- out += this.renderer.link(href, null, text);
- continue;
- }
-
- // url (gfm)
- if (!this.inLink && (cap = this.rules.url.exec(src))) {
- src = src.substring(cap[0].length);
- text = escape(cap[1]);
- href = text;
- out += this.renderer.link(href, null, text);
- continue;
- }
-
- // tag
- if (cap = this.rules.tag.exec(src)) {
- if (!this.inLink && /^/i.test(cap[0])) {
- this.inLink = false;
- }
- src = src.substring(cap[0].length);
- out += this.options.sanitize
- ? this.options.sanitizer
- ? this.options.sanitizer(cap[0])
- : escape(cap[0])
- : cap[0]
- continue;
- }
-
- // link
- if (cap = this.rules.link.exec(src)) {
- src = src.substring(cap[0].length);
- this.inLink = true;
- out += this.outputLink(cap, {
- href: cap[2],
- title: cap[3]
- });
- this.inLink = false;
- continue;
- }
-
- // reflink, nolink
- if ((cap = this.rules.reflink.exec(src))
- || (cap = this.rules.nolink.exec(src))) {
- src = src.substring(cap[0].length);
- link = (cap[2] || cap[1]).replace(/\s+/g, ' ');
- link = this.links[link.toLowerCase()];
- if (!link || !link.href) {
- out += cap[0].charAt(0);
- src = cap[0].substring(1) + src;
- continue;
- }
- this.inLink = true;
- out += this.outputLink(cap, link);
- this.inLink = false;
- continue;
- }
-
- // strong
- if (cap = this.rules.strong.exec(src)) {
- src = src.substring(cap[0].length);
- out += this.renderer.strong(this.output(cap[2] || cap[1]));
- continue;
- }
-
- // em
- if (cap = this.rules.em.exec(src)) {
- src = src.substring(cap[0].length);
- out += this.renderer.em(this.output(cap[2] || cap[1]));
- continue;
- }
-
- // code
- if (cap = this.rules.code.exec(src)) {
- src = src.substring(cap[0].length);
- out += this.renderer.codespan(escape(cap[2], true));
- continue;
- }
-
- // br
- if (cap = this.rules.br.exec(src)) {
- src = src.substring(cap[0].length);
- out += this.renderer.br();
- continue;
- }
-
- // del (gfm)
- if (cap = this.rules.del.exec(src)) {
- src = src.substring(cap[0].length);
- out += this.renderer.del(this.output(cap[1]));
- continue;
- }
-
- // text
- if (cap = this.rules.text.exec(src)) {
- src = src.substring(cap[0].length);
- out += this.renderer.text(escape(this.smartypants(cap[0])));
- continue;
- }
-
- if (src) {
- throw new
- Error('Infinite loop on byte: ' + src.charCodeAt(0));
- }
- }
-
- return out;
-};
-
-/**
- * Compile Link
- */
-
-InlineLexer.prototype.outputLink = function(cap, link) {
- var href = escape(link.href)
- , title = link.title ? escape(link.title) : null;
-
- return cap[0].charAt(0) !== '!'
- ? this.renderer.link(href, title, this.output(cap[1]))
- : this.renderer.image(href, title, escape(cap[1]));
-};
-
-/**
- * Smartypants Transformations
- */
-
-InlineLexer.prototype.smartypants = function(text) {
- if (!this.options.smartypants) return text;
- return text
- // em-dashes
- .replace(/---/g, '\u2014')
- // en-dashes
- .replace(/--/g, '\u2013')
- // opening singles
- .replace(/(^|[-\u2014/(\[{"\s])'/g, '$1\u2018')
- // closing singles & apostrophes
- .replace(/'/g, '\u2019')
- // opening doubles
- .replace(/(^|[-\u2014/(\[{\u2018\s])"/g, '$1\u201c')
- // closing doubles
- .replace(/"/g, '\u201d')
- // ellipses
- .replace(/\.{3}/g, '\u2026');
-};
-
-/**
- * Mangle Links
- */
-
-InlineLexer.prototype.mangle = function(text) {
- if (!this.options.mangle) return text;
- var out = ''
- , l = text.length
- , i = 0
- , ch;
-
- for (; i < l; i++) {
- ch = text.charCodeAt(i);
- if (Math.random() > 0.5) {
- ch = 'x' + ch.toString(16);
- }
- out += '&#' + ch + ';';
- }
-
- return out;
-};
-
-/**
- * Renderer
- */
-
-function Renderer(options) {
- this.options = options || {};
-}
-
-Renderer.prototype.code = function(code, lang, escaped) {
- if (this.options.highlight) {
- var out = this.options.highlight(code, lang);
- if (out != null && out !== code) {
- escaped = true;
- code = out;
- }
- }
-
- if (!lang) {
- return ''
- + (escaped ? code : escape(code, true))
- + '\n
';
- }
-
- return ''
- + (escaped ? code : escape(code, true))
- + '\n
\n';
-};
-
-Renderer.prototype.blockquote = function(quote) {
- return '\n' + quote + '
\n';
-};
-
-Renderer.prototype.html = function(html) {
- return html;
-};
-
-Renderer.prototype.heading = function(text, level, raw) {
- return ''
- + text
- + ' \n';
-};
-
-Renderer.prototype.hr = function() {
- return this.options.xhtml ? '
\n' : '
\n';
-};
-
-Renderer.prototype.list = function(body, ordered) {
- var type = ordered ? 'ol' : 'ul';
- return '<' + type + '>\n' + body + '\n';
-};
-
-Renderer.prototype.listitem = function(text) {
- return '- ' + text + '
\n';
-};
-
-Renderer.prototype.paragraph = function(text) {
- return '' + text + '
\n';
-};
-
-Renderer.prototype.table = function(header, body) {
- return '\n'
- + '\n'
- + header
- + '\n'
- + '\n'
- + body
- + '\n'
- + '
\n';
-};
-
-Renderer.prototype.tablerow = function(content) {
- return '\n' + content + ' \n';
-};
-
-Renderer.prototype.tablecell = function(content, flags) {
- var type = flags.header ? 'th' : 'td';
- var tag = flags.align
- ? '<' + type + ' style="text-align:' + flags.align + '">'
- : '<' + type + '>';
- return tag + content + '\n';
-};
-
-// span level renderer
-Renderer.prototype.strong = function(text) {
- return '' + text + '';
-};
-
-Renderer.prototype.em = function(text) {
- return '' + text + '';
-};
-
-Renderer.prototype.codespan = function(text) {
- return '' + text + '';
-};
-
-Renderer.prototype.br = function() {
- return this.options.xhtml ? '
' : '
';
-};
-
-Renderer.prototype.del = function(text) {
- return '' + text + '';
-};
-
-Renderer.prototype.link = function(href, title, text) {
- if (this.options.sanitize) {
- try {
- var prot = decodeURIComponent(unescape(href))
- .replace(/[^\w:]/g, '')
- .toLowerCase();
- } catch (e) {
- return '';
- }
- if (prot.indexOf('javascript:') === 0 || prot.indexOf('vbscript:') === 0) {
- return '';
- }
- }
- var out = '';
- return out;
-};
-
-Renderer.prototype.image = function(href, title, text) {
- var out = '' : '>';
- return out;
-};
-
-Renderer.prototype.text = function(text) {
- return text;
-};
-
-/**
- * Parsing & Compiling
- */
-
-function Parser(options) {
- this.tokens = [];
- this.token = null;
- this.options = options || marked.defaults;
- this.options.renderer = this.options.renderer || new Renderer;
- this.renderer = this.options.renderer;
- this.renderer.options = this.options;
-}
-
-/**
- * Static Parse Method
- */
-
-Parser.parse = function(src, options, renderer) {
- var parser = new Parser(options, renderer);
- return parser.parse(src);
-};
-
-/**
- * Parse Loop
- */
-
-Parser.prototype.parse = function(src) {
- this.inline = new InlineLexer(src.links, this.options, this.renderer);
- this.tokens = src.reverse();
-
- var out = '';
- while (this.next()) {
- out += this.tok();
- }
-
- return out;
-};
-
-/**
- * Next Token
- */
-
-Parser.prototype.next = function() {
- return this.token = this.tokens.pop();
-};
-
-/**
- * Preview Next Token
- */
-
-Parser.prototype.peek = function() {
- return this.tokens[this.tokens.length - 1] || 0;
-};
-
-/**
- * Parse Text Tokens
- */
-
-Parser.prototype.parseText = function() {
- var body = this.token.text;
-
- while (this.peek().type === 'text') {
- body += '\n' + this.next().text;
- }
-
- return this.inline.output(body);
-};
-
-/**
- * Parse Current Token
- */
-
-Parser.prototype.tok = function() {
- switch (this.token.type) {
- case 'space': {
- return '';
- }
- case 'hr': {
- return this.renderer.hr();
- }
- case 'heading': {
- return this.renderer.heading(
- this.inline.output(this.token.text),
- this.token.depth,
- this.token.text);
- }
- case 'code': {
- return this.renderer.code(this.token.text,
- this.token.lang,
- this.token.escaped);
- }
- case 'table': {
- var header = ''
- , body = ''
- , i
- , row
- , cell
- , flags
- , j;
-
- // header
- cell = '';
- for (i = 0; i < this.token.header.length; i++) {
- flags = { header: true, align: this.token.align[i] };
- cell += this.renderer.tablecell(
- this.inline.output(this.token.header[i]),
- { header: true, align: this.token.align[i] }
- );
- }
- header += this.renderer.tablerow(cell);
-
- for (i = 0; i < this.token.cells.length; i++) {
- row = this.token.cells[i];
-
- cell = '';
- for (j = 0; j < row.length; j++) {
- cell += this.renderer.tablecell(
- this.inline.output(row[j]),
- { header: false, align: this.token.align[j] }
- );
- }
-
- body += this.renderer.tablerow(cell);
- }
- return this.renderer.table(header, body);
- }
- case 'blockquote_start': {
- var body = '';
-
- while (this.next().type !== 'blockquote_end') {
- body += this.tok();
- }
-
- return this.renderer.blockquote(body);
- }
- case 'list_start': {
- var body = ''
- , ordered = this.token.ordered;
-
- while (this.next().type !== 'list_end') {
- body += this.tok();
- }
-
- return this.renderer.list(body, ordered);
- }
- case 'list_item_start': {
- var body = '';
-
- while (this.next().type !== 'list_item_end') {
- body += this.token.type === 'text'
- ? this.parseText()
- : this.tok();
- }
-
- return this.renderer.listitem(body);
- }
- case 'loose_item_start': {
- var body = '';
-
- while (this.next().type !== 'list_item_end') {
- body += this.tok();
- }
-
- return this.renderer.listitem(body);
- }
- case 'html': {
- var html = !this.token.pre && !this.options.pedantic
- ? this.inline.output(this.token.text)
- : this.token.text;
- return this.renderer.html(html);
- }
- case 'paragraph': {
- return this.renderer.paragraph(this.inline.output(this.token.text));
- }
- case 'text': {
- return this.renderer.paragraph(this.parseText());
- }
- }
-};
-
-/**
- * Helpers
- */
-
-function escape(html, encode) {
- return html
- .replace(!encode ? /&(?!#?\w+;)/g : /&/g, '&')
- .replace(//g, '>')
- .replace(/"/g, '"')
- .replace(/'/g, ''');
-}
-
-function unescape(html) {
- // explicitly match decimal, hex, and named HTML entities
- return html.replace(/&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/g, function(_, n) {
- n = n.toLowerCase();
- if (n === 'colon') return ':';
- if (n.charAt(0) === '#') {
- return n.charAt(1) === 'x'
- ? String.fromCharCode(parseInt(n.substring(2), 16))
- : String.fromCharCode(+n.substring(1));
- }
- return '';
- });
-}
-
-function replace(regex, opt) {
- regex = regex.source;
- opt = opt || '';
- return function self(name, val) {
- if (!name) return new RegExp(regex, opt);
- val = val.source || val;
- val = val.replace(/(^|[^\[])\^/g, '$1');
- regex = regex.replace(name, val);
- return self;
- };
-}
-
-function noop() {}
-noop.exec = noop;
-
-function merge(obj) {
- var i = 1
- , target
- , key;
-
- for (; i < arguments.length; i++) {
- target = arguments[i];
- for (key in target) {
- if (Object.prototype.hasOwnProperty.call(target, key)) {
- obj[key] = target[key];
- }
- }
- }
-
- return obj;
-}
-
-
-/**
- * Marked
- */
-
-function marked(src, opt, callback) {
- if (callback || typeof opt === 'function') {
- if (!callback) {
- callback = opt;
- opt = null;
- }
-
- opt = merge({}, marked.defaults, opt || {});
-
- var highlight = opt.highlight
- , tokens
- , pending
- , i = 0;
-
- try {
- tokens = Lexer.lex(src, opt)
- } catch (e) {
- return callback(e);
- }
-
- pending = tokens.length;
-
- var done = function(err) {
- if (err) {
- opt.highlight = highlight;
- return callback(err);
- }
-
- var out;
-
- try {
- out = Parser.parse(tokens, opt);
- } catch (e) {
- err = e;
- }
-
- opt.highlight = highlight;
-
- return err
- ? callback(err)
- : callback(null, out);
- };
-
- if (!highlight || highlight.length < 3) {
- return done();
- }
-
- delete opt.highlight;
-
- if (!pending) return done();
-
- for (; i < tokens.length; i++) {
- (function(token) {
- if (token.type !== 'code') {
- return --pending || done();
- }
- return highlight(token.text, token.lang, function(err, code) {
- if (err) return done(err);
- if (code == null || code === token.text) {
- return --pending || done();
- }
- token.text = code;
- token.escaped = true;
- --pending || done();
- });
- })(tokens[i]);
- }
-
- return;
- }
- try {
- if (opt) opt = merge({}, marked.defaults, opt);
- return Parser.parse(Lexer.lex(src, opt), opt);
- } catch (e) {
- e.message += '\nPlease report this to https://github.com/chjj/marked.';
- if ((opt || marked.defaults).silent) {
- return 'An error occured:
'
- + escape(e.message + '', true)
- + '
';
- }
- throw e;
- }
-}
-
-/**
- * Options
- */
-
-marked.options =
-marked.setOptions = function(opt) {
- merge(marked.defaults, opt);
- return marked;
-};
-
-marked.defaults = {
- gfm: true,
- tables: true,
- breaks: false,
- pedantic: false,
- sanitize: false,
- sanitizer: null,
- mangle: true,
- smartLists: false,
- silent: false,
- highlight: null,
- langPrefix: 'lang-',
- smartypants: false,
- headerPrefix: '',
- renderer: new Renderer,
- xhtml: false
-};
-
-/**
- * Expose
- */
-
-marked.Parser = Parser;
-marked.parser = Parser.parse;
-
-marked.Renderer = Renderer;
-
-marked.Lexer = Lexer;
-marked.lexer = Lexer.lex;
-
-marked.InlineLexer = InlineLexer;
-marked.inlineLexer = InlineLexer.output;
-
-marked.parse = marked;
-
-if (typeof module !== 'undefined' && typeof exports === 'object') {
- module.exports = marked;
-} else if (typeof define === 'function' && define.amd) {
- define(function() { return marked; });
-} else {
- this.marked = marked;
-}
-
-}).call(function() {
- return this || (typeof window !== 'undefined' ? window : global);
-}());
diff --git a/lib/marked.umd.js b/lib/marked.umd.js
new file mode 100644
index 0000000000..db80c91a3e
--- /dev/null
+++ b/lib/marked.umd.js
@@ -0,0 +1,2937 @@
+/**
+ * marked - a markdown parser
+ * Copyright (c) 2011-2022, Christopher Jeffrey. (MIT Licensed)
+ * https://github.com/markedjs/marked
+ */
+
+/**
+ * DO NOT EDIT THIS FILE
+ * The code in this file is generated from files in ./src/
+ */
+
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+ typeof define === 'function' && define.amd ? define(['exports'], factory) :
+ (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.marked = {}));
+})(this, (function (exports) { 'use strict';
+
+ function _defineProperties(target, props) {
+ for (var i = 0; i < props.length; i++) {
+ var descriptor = props[i];
+ descriptor.enumerable = descriptor.enumerable || false;
+ descriptor.configurable = true;
+ if ("value" in descriptor) descriptor.writable = true;
+ Object.defineProperty(target, descriptor.key, descriptor);
+ }
+ }
+
+ function _createClass(Constructor, protoProps, staticProps) {
+ if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+ if (staticProps) _defineProperties(Constructor, staticProps);
+ Object.defineProperty(Constructor, "prototype", {
+ writable: false
+ });
+ return Constructor;
+ }
+
+ function _unsupportedIterableToArray(o, minLen) {
+ if (!o) return;
+ if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+ var n = Object.prototype.toString.call(o).slice(8, -1);
+ if (n === "Object" && o.constructor) n = o.constructor.name;
+ if (n === "Map" || n === "Set") return Array.from(o);
+ if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+ }
+
+ function _arrayLikeToArray(arr, len) {
+ if (len == null || len > arr.length) len = arr.length;
+
+ for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+ return arr2;
+ }
+
+ function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+ var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+ if (it) return (it = it.call(o)).next.bind(it);
+
+ if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+ if (it) o = it;
+ var i = 0;
+ return function () {
+ if (i >= o.length) return {
+ done: true
+ };
+ return {
+ done: false,
+ value: o[i++]
+ };
+ };
+ }
+
+ throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+ }
+
+ function getDefaults() {
+ return {
+ baseUrl: null,
+ breaks: false,
+ extensions: null,
+ gfm: true,
+ headerIds: true,
+ headerPrefix: '',
+ highlight: null,
+ langPrefix: 'language-',
+ mangle: true,
+ pedantic: false,
+ renderer: null,
+ sanitize: false,
+ sanitizer: null,
+ silent: false,
+ smartLists: false,
+ smartypants: false,
+ tokenizer: null,
+ walkTokens: null,
+ xhtml: false
+ };
+ }
+ exports.defaults = getDefaults();
+ function changeDefaults(newDefaults) {
+ exports.defaults = newDefaults;
+ }
+
+ /**
+ * Helpers
+ */
+ var escapeTest = /[&<>"']/;
+ var escapeReplace = /[&<>"']/g;
+ var escapeTestNoEncode = /[<>"']|&(?!#?\w+;)/;
+ var escapeReplaceNoEncode = /[<>"']|&(?!#?\w+;)/g;
+ var escapeReplacements = {
+ '&': '&',
+ '<': '<',
+ '>': '>',
+ '"': '"',
+ "'": '''
+ };
+
+ var getEscapeReplacement = function getEscapeReplacement(ch) {
+ return escapeReplacements[ch];
+ };
+
+ function escape(html, encode) {
+ if (encode) {
+ if (escapeTest.test(html)) {
+ return html.replace(escapeReplace, getEscapeReplacement);
+ }
+ } else {
+ if (escapeTestNoEncode.test(html)) {
+ return html.replace(escapeReplaceNoEncode, getEscapeReplacement);
+ }
+ }
+
+ return html;
+ }
+ var unescapeTest = /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig;
+ function unescape(html) {
+ // explicitly match decimal, hex, and named HTML entities
+ return html.replace(unescapeTest, function (_, n) {
+ n = n.toLowerCase();
+ if (n === 'colon') return ':';
+
+ if (n.charAt(0) === '#') {
+ return n.charAt(1) === 'x' ? String.fromCharCode(parseInt(n.substring(2), 16)) : String.fromCharCode(+n.substring(1));
+ }
+
+ return '';
+ });
+ }
+ var caret = /(^|[^\[])\^/g;
+ function edit(regex, opt) {
+ regex = regex.source || regex;
+ opt = opt || '';
+ var obj = {
+ replace: function replace(name, val) {
+ val = val.source || val;
+ val = val.replace(caret, '$1');
+ regex = regex.replace(name, val);
+ return obj;
+ },
+ getRegex: function getRegex() {
+ return new RegExp(regex, opt);
+ }
+ };
+ return obj;
+ }
+ var nonWordAndColonTest = /[^\w:]/g;
+ var originIndependentUrl = /^$|^[a-z][a-z0-9+.-]*:|^[?#]/i;
+ function cleanUrl(sanitize, base, href) {
+ if (sanitize) {
+ var prot;
+
+ try {
+ prot = decodeURIComponent(unescape(href)).replace(nonWordAndColonTest, '').toLowerCase();
+ } catch (e) {
+ return null;
+ }
+
+ if (prot.indexOf('javascript:') === 0 || prot.indexOf('vbscript:') === 0 || prot.indexOf('data:') === 0) {
+ return null;
+ }
+ }
+
+ if (base && !originIndependentUrl.test(href)) {
+ href = resolveUrl(base, href);
+ }
+
+ try {
+ href = encodeURI(href).replace(/%25/g, '%');
+ } catch (e) {
+ return null;
+ }
+
+ return href;
+ }
+ var baseUrls = {};
+ var justDomain = /^[^:]+:\/*[^/]*$/;
+ var protocol = /^([^:]+:)[\s\S]*$/;
+ var domain = /^([^:]+:\/*[^/]*)[\s\S]*$/;
+ function resolveUrl(base, href) {
+ if (!baseUrls[' ' + base]) {
+ // we can ignore everything in base after the last slash of its path component,
+ // but we might need to add _that_
+ // https://tools.ietf.org/html/rfc3986#section-3
+ if (justDomain.test(base)) {
+ baseUrls[' ' + base] = base + '/';
+ } else {
+ baseUrls[' ' + base] = rtrim(base, '/', true);
+ }
+ }
+
+ base = baseUrls[' ' + base];
+ var relativeBase = base.indexOf(':') === -1;
+
+ if (href.substring(0, 2) === '//') {
+ if (relativeBase) {
+ return href;
+ }
+
+ return base.replace(protocol, '$1') + href;
+ } else if (href.charAt(0) === '/') {
+ if (relativeBase) {
+ return href;
+ }
+
+ return base.replace(domain, '$1') + href;
+ } else {
+ return base + href;
+ }
+ }
+ var noopTest = {
+ exec: function noopTest() {}
+ };
+ function merge(obj) {
+ var i = 1,
+ target,
+ key;
+
+ for (; i < arguments.length; i++) {
+ target = arguments[i];
+
+ for (key in target) {
+ if (Object.prototype.hasOwnProperty.call(target, key)) {
+ obj[key] = target[key];
+ }
+ }
+ }
+
+ return obj;
+ }
+ function splitCells(tableRow, count) {
+ // ensure that every cell-delimiting pipe has a space
+ // before it to distinguish it from an escaped pipe
+ var row = tableRow.replace(/\|/g, function (match, offset, str) {
+ var escaped = false,
+ curr = offset;
+
+ while (--curr >= 0 && str[curr] === '\\') {
+ escaped = !escaped;
+ }
+
+ if (escaped) {
+ // odd number of slashes means | is escaped
+ // so we leave it alone
+ return '|';
+ } else {
+ // add space before unescaped |
+ return ' |';
+ }
+ }),
+ cells = row.split(/ \|/);
+ var i = 0; // First/last cell in a row cannot be empty if it has no leading/trailing pipe
+
+ if (!cells[0].trim()) {
+ cells.shift();
+ }
+
+ if (!cells[cells.length - 1].trim()) {
+ cells.pop();
+ }
+
+ if (cells.length > count) {
+ cells.splice(count);
+ } else {
+ while (cells.length < count) {
+ cells.push('');
+ }
+ }
+
+ for (; i < cells.length; i++) {
+ // leading or trailing whitespace is ignored per the gfm spec
+ cells[i] = cells[i].trim().replace(/\\\|/g, '|');
+ }
+
+ return cells;
+ } // Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').
+ // /c*$/ is vulnerable to REDOS.
+ // invert: Remove suffix of non-c chars instead. Default falsey.
+
+ function rtrim(str, c, invert) {
+ var l = str.length;
+
+ if (l === 0) {
+ return '';
+ } // Length of suffix matching the invert condition.
+
+
+ var suffLen = 0; // Step left until we fail to match the invert condition.
+
+ while (suffLen < l) {
+ var currChar = str.charAt(l - suffLen - 1);
+
+ if (currChar === c && !invert) {
+ suffLen++;
+ } else if (currChar !== c && invert) {
+ suffLen++;
+ } else {
+ break;
+ }
+ }
+
+ return str.substr(0, l - suffLen);
+ }
+ function findClosingBracket(str, b) {
+ if (str.indexOf(b[1]) === -1) {
+ return -1;
+ }
+
+ var l = str.length;
+ var level = 0,
+ i = 0;
+
+ for (; i < l; i++) {
+ if (str[i] === '\\') {
+ i++;
+ } else if (str[i] === b[0]) {
+ level++;
+ } else if (str[i] === b[1]) {
+ level--;
+
+ if (level < 0) {
+ return i;
+ }
+ }
+ }
+
+ return -1;
+ }
+ function checkSanitizeDeprecation(opt) {
+ if (opt && opt.sanitize && !opt.silent) {
+ console.warn('marked(): sanitize and sanitizer parameters are deprecated since version 0.7.0, should not be used and will be removed in the future. Read more here: https://marked.js.org/#/USING_ADVANCED.md#options');
+ }
+ } // copied from https://stackoverflow.com/a/5450113/806777
+
+ function repeatString(pattern, count) {
+ if (count < 1) {
+ return '';
+ }
+
+ var result = '';
+
+ while (count > 1) {
+ if (count & 1) {
+ result += pattern;
+ }
+
+ count >>= 1;
+ pattern += pattern;
+ }
+
+ return result + pattern;
+ }
+
+ function outputLink(cap, link, raw, lexer) {
+ var href = link.href;
+ var title = link.title ? escape(link.title) : null;
+ var text = cap[1].replace(/\\([\[\]])/g, '$1');
+
+ if (cap[0].charAt(0) !== '!') {
+ lexer.state.inLink = true;
+ var token = {
+ type: 'link',
+ raw: raw,
+ href: href,
+ title: title,
+ text: text,
+ tokens: lexer.inlineTokens(text, [])
+ };
+ lexer.state.inLink = false;
+ return token;
+ } else {
+ return {
+ type: 'image',
+ raw: raw,
+ href: href,
+ title: title,
+ text: escape(text)
+ };
+ }
+ }
+
+ function indentCodeCompensation(raw, text) {
+ var matchIndentToCode = raw.match(/^(\s+)(?:```)/);
+
+ if (matchIndentToCode === null) {
+ return text;
+ }
+
+ var indentToCode = matchIndentToCode[1];
+ return text.split('\n').map(function (node) {
+ var matchIndentInNode = node.match(/^\s+/);
+
+ if (matchIndentInNode === null) {
+ return node;
+ }
+
+ var indentInNode = matchIndentInNode[0];
+
+ if (indentInNode.length >= indentToCode.length) {
+ return node.slice(indentToCode.length);
+ }
+
+ return node;
+ }).join('\n');
+ }
+ /**
+ * Tokenizer
+ */
+
+
+ var Tokenizer = /*#__PURE__*/function () {
+ function Tokenizer(options) {
+ this.options = options || exports.defaults;
+ }
+
+ var _proto = Tokenizer.prototype;
+
+ _proto.space = function space(src) {
+ var cap = this.rules.block.newline.exec(src);
+
+ if (cap && cap[0].length > 0) {
+ return {
+ type: 'space',
+ raw: cap[0]
+ };
+ }
+ };
+
+ _proto.code = function code(src) {
+ var cap = this.rules.block.code.exec(src);
+
+ if (cap) {
+ var text = cap[0].replace(/^ {1,4}/gm, '');
+ return {
+ type: 'code',
+ raw: cap[0],
+ codeBlockStyle: 'indented',
+ text: !this.options.pedantic ? rtrim(text, '\n') : text
+ };
+ }
+ };
+
+ _proto.fences = function fences(src) {
+ var cap = this.rules.block.fences.exec(src);
+
+ if (cap) {
+ var raw = cap[0];
+ var text = indentCodeCompensation(raw, cap[3] || '');
+ return {
+ type: 'code',
+ raw: raw,
+ lang: cap[2] ? cap[2].trim() : cap[2],
+ text: text
+ };
+ }
+ };
+
+ _proto.heading = function heading(src) {
+ var cap = this.rules.block.heading.exec(src);
+
+ if (cap) {
+ var text = cap[2].trim(); // remove trailing #s
+
+ if (/#$/.test(text)) {
+ var trimmed = rtrim(text, '#');
+
+ if (this.options.pedantic) {
+ text = trimmed.trim();
+ } else if (!trimmed || / $/.test(trimmed)) {
+ // CommonMark requires space before trailing #s
+ text = trimmed.trim();
+ }
+ }
+
+ var token = {
+ type: 'heading',
+ raw: cap[0],
+ depth: cap[1].length,
+ text: text,
+ tokens: []
+ };
+ this.lexer.inline(token.text, token.tokens);
+ return token;
+ }
+ };
+
+ _proto.hr = function hr(src) {
+ var cap = this.rules.block.hr.exec(src);
+
+ if (cap) {
+ return {
+ type: 'hr',
+ raw: cap[0]
+ };
+ }
+ };
+
+ _proto.blockquote = function blockquote(src) {
+ var cap = this.rules.block.blockquote.exec(src);
+
+ if (cap) {
+ var text = cap[0].replace(/^ *> ?/gm, '');
+ return {
+ type: 'blockquote',
+ raw: cap[0],
+ tokens: this.lexer.blockTokens(text, []),
+ text: text
+ };
+ }
+ };
+
+ _proto.list = function list(src) {
+ var cap = this.rules.block.list.exec(src);
+
+ if (cap) {
+ var raw, istask, ischecked, indent, i, blankLine, endsWithBlankLine, line, nextLine, rawLine, itemContents, endEarly;
+ var bull = cap[1].trim();
+ var isordered = bull.length > 1;
+ var list = {
+ type: 'list',
+ raw: '',
+ ordered: isordered,
+ start: isordered ? +bull.slice(0, -1) : '',
+ loose: false,
+ items: []
+ };
+ bull = isordered ? "\\d{1,9}\\" + bull.slice(-1) : "\\" + bull;
+
+ if (this.options.pedantic) {
+ bull = isordered ? bull : '[*+-]';
+ } // Get next list item
+
+
+ var itemRegex = new RegExp("^( {0,3}" + bull + ")((?: [^\\n]*)?(?:\\n|$))"); // Check if current bullet point can start a new List Item
+
+ while (src) {
+ endEarly = false;
+
+ if (!(cap = itemRegex.exec(src))) {
+ break;
+ }
+
+ if (this.rules.block.hr.test(src)) {
+ // End list if bullet was actually HR (possibly move into itemRegex?)
+ break;
+ }
+
+ raw = cap[0];
+ src = src.substring(raw.length);
+ line = cap[2].split('\n', 1)[0];
+ nextLine = src.split('\n', 1)[0];
+
+ if (this.options.pedantic) {
+ indent = 2;
+ itemContents = line.trimLeft();
+ } else {
+ indent = cap[2].search(/[^ ]/); // Find first non-space char
+
+ indent = indent > 4 ? 1 : indent; // Treat indented code blocks (> 4 spaces) as having only 1 indent
+
+ itemContents = line.slice(indent);
+ indent += cap[1].length;
+ }
+
+ blankLine = false;
+
+ if (!line && /^ *$/.test(nextLine)) {
+ // Items begin with at most one blank line
+ raw += nextLine + '\n';
+ src = src.substring(nextLine.length + 1);
+ endEarly = true;
+ }
+
+ if (!endEarly) {
+ var nextBulletRegex = new RegExp("^ {0," + Math.min(3, indent - 1) + "}(?:[*+-]|\\d{1,9}[.)])"); // Check if following lines should be included in List Item
+
+ while (src) {
+ rawLine = src.split('\n', 1)[0];
+ line = rawLine; // Re-align to follow commonmark nesting rules
+
+ if (this.options.pedantic) {
+ line = line.replace(/^ {1,4}(?=( {4})*[^ ])/g, ' ');
+ } // End list item if found start of new bullet
+
+
+ if (nextBulletRegex.test(line)) {
+ break;
+ }
+
+ if (line.search(/[^ ]/) >= indent || !line.trim()) {
+ // Dedent if possible
+ itemContents += '\n' + line.slice(indent);
+ } else if (!blankLine) {
+ // Until blank line, item doesn't need indentation
+ itemContents += '\n' + line;
+ } else {
+ // Otherwise, improper indentation ends this item
+ break;
+ }
+
+ if (!blankLine && !line.trim()) {
+ // Check if current line is blank
+ blankLine = true;
+ }
+
+ raw += rawLine + '\n';
+ src = src.substring(rawLine.length + 1);
+ }
+ }
+
+ if (!list.loose) {
+ // If the previous item ended with a blank line, the list is loose
+ if (endsWithBlankLine) {
+ list.loose = true;
+ } else if (/\n *\n *$/.test(raw)) {
+ endsWithBlankLine = true;
+ }
+ } // Check for task list items
+
+
+ if (this.options.gfm) {
+ istask = /^\[[ xX]\] /.exec(itemContents);
+
+ if (istask) {
+ ischecked = istask[0] !== '[ ] ';
+ itemContents = itemContents.replace(/^\[[ xX]\] +/, '');
+ }
+ }
+
+ list.items.push({
+ type: 'list_item',
+ raw: raw,
+ task: !!istask,
+ checked: ischecked,
+ loose: false,
+ text: itemContents
+ });
+ list.raw += raw;
+ } // Do not consume newlines at end of final item. Alternatively, make itemRegex *start* with any newlines to simplify/speed up endsWithBlankLine logic
+
+
+ list.items[list.items.length - 1].raw = raw.trimRight();
+ list.items[list.items.length - 1].text = itemContents.trimRight();
+ list.raw = list.raw.trimRight();
+ var l = list.items.length; // Item child tokens handled here at end because we needed to have the final item to trim it first
+
+ for (i = 0; i < l; i++) {
+ this.lexer.state.top = false;
+ list.items[i].tokens = this.lexer.blockTokens(list.items[i].text, []);
+ var spacers = list.items[i].tokens.filter(function (t) {
+ return t.type === 'space';
+ });
+ var hasMultipleLineBreaks = spacers.every(function (t) {
+ var chars = t.raw.split('');
+ var lineBreaks = 0;
+
+ for (var _iterator = _createForOfIteratorHelperLoose(chars), _step; !(_step = _iterator()).done;) {
+ var _char = _step.value;
+
+ if (_char === '\n') {
+ lineBreaks += 1;
+ }
+
+ if (lineBreaks > 1) {
+ return true;
+ }
+ }
+
+ return false;
+ });
+
+ if (!list.loose && spacers.length && hasMultipleLineBreaks) {
+ // Having a single line break doesn't mean a list is loose. A single line break is terminating the last list item
+ list.loose = true;
+ list.items[i].loose = true;
+ }
+ }
+
+ return list;
+ }
+ };
+
+ _proto.html = function html(src) {
+ var cap = this.rules.block.html.exec(src);
+
+ if (cap) {
+ var token = {
+ type: 'html',
+ raw: cap[0],
+ pre: !this.options.sanitizer && (cap[1] === 'pre' || cap[1] === 'script' || cap[1] === 'style'),
+ text: cap[0]
+ };
+
+ if (this.options.sanitize) {
+ token.type = 'paragraph';
+ token.text = this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]);
+ token.tokens = [];
+ this.lexer.inline(token.text, token.tokens);
+ }
+
+ return token;
+ }
+ };
+
+ _proto.def = function def(src) {
+ var cap = this.rules.block.def.exec(src);
+
+ if (cap) {
+ if (cap[3]) cap[3] = cap[3].substring(1, cap[3].length - 1);
+ var tag = cap[1].toLowerCase().replace(/\s+/g, ' ');
+ return {
+ type: 'def',
+ tag: tag,
+ raw: cap[0],
+ href: cap[2],
+ title: cap[3]
+ };
+ }
+ };
+
+ _proto.table = function table(src) {
+ var cap = this.rules.block.table.exec(src);
+
+ if (cap) {
+ var item = {
+ type: 'table',
+ header: splitCells(cap[1]).map(function (c) {
+ return {
+ text: c
+ };
+ }),
+ align: cap[2].replace(/^ *|\| *$/g, '').split(/ *\| */),
+ rows: cap[3] ? cap[3].replace(/\n[ \t]*$/, '').split('\n') : []
+ };
+
+ if (item.header.length === item.align.length) {
+ item.raw = cap[0];
+ var l = item.align.length;
+ var i, j, k, row;
+
+ for (i = 0; i < l; i++) {
+ if (/^ *-+: *$/.test(item.align[i])) {
+ item.align[i] = 'right';
+ } else if (/^ *:-+: *$/.test(item.align[i])) {
+ item.align[i] = 'center';
+ } else if (/^ *:-+ *$/.test(item.align[i])) {
+ item.align[i] = 'left';
+ } else {
+ item.align[i] = null;
+ }
+ }
+
+ l = item.rows.length;
+
+ for (i = 0; i < l; i++) {
+ item.rows[i] = splitCells(item.rows[i], item.header.length).map(function (c) {
+ return {
+ text: c
+ };
+ });
+ } // parse child tokens inside headers and cells
+ // header child tokens
+
+
+ l = item.header.length;
+
+ for (j = 0; j < l; j++) {
+ item.header[j].tokens = [];
+ this.lexer.inlineTokens(item.header[j].text, item.header[j].tokens);
+ } // cell child tokens
+
+
+ l = item.rows.length;
+
+ for (j = 0; j < l; j++) {
+ row = item.rows[j];
+
+ for (k = 0; k < row.length; k++) {
+ row[k].tokens = [];
+ this.lexer.inlineTokens(row[k].text, row[k].tokens);
+ }
+ }
+
+ return item;
+ }
+ }
+ };
+
+ _proto.lheading = function lheading(src) {
+ var cap = this.rules.block.lheading.exec(src);
+
+ if (cap) {
+ var token = {
+ type: 'heading',
+ raw: cap[0],
+ depth: cap[2].charAt(0) === '=' ? 1 : 2,
+ text: cap[1],
+ tokens: []
+ };
+ this.lexer.inline(token.text, token.tokens);
+ return token;
+ }
+ };
+
+ _proto.paragraph = function paragraph(src) {
+ var cap = this.rules.block.paragraph.exec(src);
+
+ if (cap) {
+ var token = {
+ type: 'paragraph',
+ raw: cap[0],
+ text: cap[1].charAt(cap[1].length - 1) === '\n' ? cap[1].slice(0, -1) : cap[1],
+ tokens: []
+ };
+ this.lexer.inline(token.text, token.tokens);
+ return token;
+ }
+ };
+
+ _proto.text = function text(src) {
+ var cap = this.rules.block.text.exec(src);
+
+ if (cap) {
+ var token = {
+ type: 'text',
+ raw: cap[0],
+ text: cap[0],
+ tokens: []
+ };
+ this.lexer.inline(token.text, token.tokens);
+ return token;
+ }
+ };
+
+ _proto.escape = function escape$1(src) {
+ var cap = this.rules.inline.escape.exec(src);
+
+ if (cap) {
+ return {
+ type: 'escape',
+ raw: cap[0],
+ text: escape(cap[1])
+ };
+ }
+ };
+
+ _proto.tag = function tag(src) {
+ var cap = this.rules.inline.tag.exec(src);
+
+ if (cap) {
+ if (!this.lexer.state.inLink && /^/i.test(cap[0])) {
+ this.lexer.state.inLink = false;
+ }
+
+ if (!this.lexer.state.inRawBlock && /^<(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
+ this.lexer.state.inRawBlock = true;
+ } else if (this.lexer.state.inRawBlock && /^<\/(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
+ this.lexer.state.inRawBlock = false;
+ }
+
+ return {
+ type: this.options.sanitize ? 'text' : 'html',
+ raw: cap[0],
+ inLink: this.lexer.state.inLink,
+ inRawBlock: this.lexer.state.inRawBlock,
+ text: this.options.sanitize ? this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]) : cap[0]
+ };
+ }
+ };
+
+ _proto.link = function link(src) {
+ var cap = this.rules.inline.link.exec(src);
+
+ if (cap) {
+ var trimmedUrl = cap[2].trim();
+
+ if (!this.options.pedantic && /^$/.test(trimmedUrl)) {
+ return;
+ } // ending angle bracket cannot be escaped
+
+
+ var rtrimSlash = rtrim(trimmedUrl.slice(0, -1), '\\');
+
+ if ((trimmedUrl.length - rtrimSlash.length) % 2 === 0) {
+ return;
+ }
+ } else {
+ // find closing parenthesis
+ var lastParenIndex = findClosingBracket(cap[2], '()');
+
+ if (lastParenIndex > -1) {
+ var start = cap[0].indexOf('!') === 0 ? 5 : 4;
+ var linkLen = start + cap[1].length + lastParenIndex;
+ cap[2] = cap[2].substring(0, lastParenIndex);
+ cap[0] = cap[0].substring(0, linkLen).trim();
+ cap[3] = '';
+ }
+ }
+
+ var href = cap[2];
+ var title = '';
+
+ if (this.options.pedantic) {
+ // split pedantic href and title
+ var link = /^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(href);
+
+ if (link) {
+ href = link[1];
+ title = link[3];
+ }
+ } else {
+ title = cap[3] ? cap[3].slice(1, -1) : '';
+ }
+
+ href = href.trim();
+
+ if (/^$/.test(trimmedUrl)) {
+ // pedantic allows starting angle bracket without ending angle bracket
+ href = href.slice(1);
+ } else {
+ href = href.slice(1, -1);
+ }
+ }
+
+ return outputLink(cap, {
+ href: href ? href.replace(this.rules.inline._escapes, '$1') : href,
+ title: title ? title.replace(this.rules.inline._escapes, '$1') : title
+ }, cap[0], this.lexer);
+ }
+ };
+
+ _proto.reflink = function reflink(src, links) {
+ var cap;
+
+ if ((cap = this.rules.inline.reflink.exec(src)) || (cap = this.rules.inline.nolink.exec(src))) {
+ var link = (cap[2] || cap[1]).replace(/\s+/g, ' ');
+ link = links[link.toLowerCase()];
+
+ if (!link || !link.href) {
+ var text = cap[0].charAt(0);
+ return {
+ type: 'text',
+ raw: text,
+ text: text
+ };
+ }
+
+ return outputLink(cap, link, cap[0], this.lexer);
+ }
+ };
+
+ _proto.emStrong = function emStrong(src, maskedSrc, prevChar) {
+ if (prevChar === void 0) {
+ prevChar = '';
+ }
+
+ var match = this.rules.inline.emStrong.lDelim.exec(src);
+ if (!match) return; // _ can't be between two alphanumerics. \p{L}\p{N} includes non-english alphabet/numbers as well
+
+ if (match[3] && prevChar.match(/(?:[0-9A-Za-z\xAA\xB2\xB3\xB5\xB9\xBA\xBC-\xBE\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u0660-\u0669\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07C0-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088E\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0966-\u096F\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09E6-\u09F1\u09F4-\u09F9\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A66-\u0A6F\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AE6-\u0AEF\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B66-\u0B6F\u0B71-\u0B77\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0BE6-\u0BF2\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5D\u0C60\u0C61\u0C66-\u0C6F\u0C78-\u0C7E\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDD\u0CDE\u0CE0\u0CE1\u0CE6-\u0CEF\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D58-\u0D61\u0D66-\u0D78\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DE6-\u0DEF\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F20-\u0F33\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F-\u1049\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u1090-\u1099\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1369-\u137C\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u17E0-\u17E9\u17F0-\u17F9\u1810-\u1819\u1820-\u1878\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A16\u1A20-\u1A54\u1A80-\u1A89\u1A90-\u1A99\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B50-\u1B59\u1B83-\u1BA0\u1BAE-\u1BE5\u1C00-\u1C23\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2070\u2071\u2074-\u2079\u207F-\u2089\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2150-\u2189\u2460-\u249B\u24EA-\u24FF\u2776-\u2793\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2CFD\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u3192-\u3195\u31A0-\u31BF\u31F0-\u31FF\u3220-\u3229\u3248-\u324F\u3251-\u325F\u3280-\u3289\u32B1-\u32BF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7CA\uA7D0\uA7D1\uA7D3\uA7D5-\uA7D9\uA7F2-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA830-\uA835\uA840-\uA873\uA882-\uA8B3\uA8D0-\uA8D9\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA900-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF-\uA9D9\uA9E0-\uA9E4\uA9E6-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA50-\uAA59\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD07-\uDD33\uDD40-\uDD78\uDD8A\uDD8B\uDE80-\uDE9C\uDEA0-\uDED0\uDEE1-\uDEFB\uDF00-\uDF23\uDF2D-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDD70-\uDD7A\uDD7C-\uDD8A\uDD8C-\uDD92\uDD94\uDD95\uDD97-\uDDA1\uDDA3-\uDDB1\uDDB3-\uDDB9\uDDBB\uDDBC\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67\uDF80-\uDF85\uDF87-\uDFB0\uDFB2-\uDFBA]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC58-\uDC76\uDC79-\uDC9E\uDCA7-\uDCAF\uDCE0-\uDCF2\uDCF4\uDCF5\uDCFB-\uDD1B\uDD20-\uDD39\uDD80-\uDDB7\uDDBC-\uDDCF\uDDD2-\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE40-\uDE48\uDE60-\uDE7E\uDE80-\uDE9F\uDEC0-\uDEC7\uDEC9-\uDEE4\uDEEB-\uDEEF\uDF00-\uDF35\uDF40-\uDF55\uDF58-\uDF72\uDF78-\uDF91\uDFA9-\uDFAF]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2\uDCFA-\uDD23\uDD30-\uDD39\uDE60-\uDE7E\uDE80-\uDEA9\uDEB0\uDEB1\uDF00-\uDF27\uDF30-\uDF45\uDF51-\uDF54\uDF70-\uDF81\uDFB0-\uDFCB\uDFE0-\uDFF6]|\uD804[\uDC03-\uDC37\uDC52-\uDC6F\uDC71\uDC72\uDC75\uDC83-\uDCAF\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD03-\uDD26\uDD36-\uDD3F\uDD44\uDD47\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDD0-\uDDDA\uDDDC\uDDE1-\uDDF4\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDEF0-\uDEF9\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC50-\uDC59\uDC5F-\uDC61\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE50-\uDE59\uDE80-\uDEAA\uDEB8\uDEC0-\uDEC9\uDF00-\uDF1A\uDF30-\uDF3B\uDF40-\uDF46]|\uD806[\uDC00-\uDC2B\uDCA0-\uDCF2\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD2F\uDD3F\uDD41\uDD50-\uDD59\uDDA0-\uDDA7\uDDAA-\uDDD0\uDDE1\uDDE3\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE89\uDE9D\uDEB0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC50-\uDC6C\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46\uDD50-\uDD59\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD89\uDD98\uDDA0-\uDDA9\uDEE0-\uDEF2\uDFB0\uDFC0-\uDFD4]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|\uD80B[\uDF90-\uDFF0]|[\uD80C\uD81C-\uD820\uD822\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879\uD880-\uD883][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDE70-\uDEBE\uDEC0-\uDEC9\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF50-\uDF59\uDF5B-\uDF61\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDE40-\uDE96\uDF00-\uDF4A\uDF50\uDF93-\uDF9F\uDFE0\uDFE1\uDFE3]|\uD821[\uDC00-\uDFF7]|\uD823[\uDC00-\uDCD5\uDD00-\uDD08]|\uD82B[\uDFF0-\uDFF3\uDFF5-\uDFFB\uDFFD\uDFFE]|\uD82C[\uDC00-\uDD22\uDD50-\uDD52\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD834[\uDEE0-\uDEF3\uDF60-\uDF78]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD837[\uDF00-\uDF1E]|\uD838[\uDD00-\uDD2C\uDD37-\uDD3D\uDD40-\uDD49\uDD4E\uDE90-\uDEAD\uDEC0-\uDEEB\uDEF0-\uDEF9]|\uD839[\uDFE0-\uDFE6\uDFE8-\uDFEB\uDFED\uDFEE\uDFF0-\uDFFE]|\uD83A[\uDC00-\uDCC4\uDCC7-\uDCCF\uDD00-\uDD43\uDD4B\uDD50-\uDD59]|\uD83B[\uDC71-\uDCAB\uDCAD-\uDCAF\uDCB1-\uDCB4\uDD01-\uDD2D\uDD2F-\uDD3D\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD83C[\uDD00-\uDD0C]|\uD83E[\uDFF0-\uDFF9]|\uD869[\uDC00-\uDEDF\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF38\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A])/)) return;
+ var nextChar = match[1] || match[2] || '';
+
+ if (!nextChar || nextChar && (prevChar === '' || this.rules.inline.punctuation.exec(prevChar))) {
+ var lLength = match[0].length - 1;
+ var rDelim,
+ rLength,
+ delimTotal = lLength,
+ midDelimTotal = 0;
+ var endReg = match[0][0] === '*' ? this.rules.inline.emStrong.rDelimAst : this.rules.inline.emStrong.rDelimUnd;
+ endReg.lastIndex = 0; // Clip maskedSrc to same section of string as src (move to lexer?)
+
+ maskedSrc = maskedSrc.slice(-1 * src.length + lLength);
+
+ while ((match = endReg.exec(maskedSrc)) != null) {
+ rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];
+ if (!rDelim) continue; // skip single * in __abc*abc__
+
+ rLength = rDelim.length;
+
+ if (match[3] || match[4]) {
+ // found another Left Delim
+ delimTotal += rLength;
+ continue;
+ } else if (match[5] || match[6]) {
+ // either Left or Right Delim
+ if (lLength % 3 && !((lLength + rLength) % 3)) {
+ midDelimTotal += rLength;
+ continue; // CommonMark Emphasis Rules 9-10
+ }
+ }
+
+ delimTotal -= rLength;
+ if (delimTotal > 0) continue; // Haven't found enough closing delimiters
+ // Remove extra characters. *a*** -> *a*
+
+ rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal); // Create `em` if smallest delimiter has odd char count. *a***
+
+ if (Math.min(lLength, rLength) % 2) {
+ var _text = src.slice(1, lLength + match.index + rLength);
+
+ return {
+ type: 'em',
+ raw: src.slice(0, lLength + match.index + rLength + 1),
+ text: _text,
+ tokens: this.lexer.inlineTokens(_text, [])
+ };
+ } // Create 'strong' if smallest delimiter has even char count. **a***
+
+
+ var text = src.slice(2, lLength + match.index + rLength - 1);
+ return {
+ type: 'strong',
+ raw: src.slice(0, lLength + match.index + rLength + 1),
+ text: text,
+ tokens: this.lexer.inlineTokens(text, [])
+ };
+ }
+ }
+ };
+
+ _proto.codespan = function codespan(src) {
+ var cap = this.rules.inline.code.exec(src);
+
+ if (cap) {
+ var text = cap[2].replace(/\n/g, ' ');
+ var hasNonSpaceChars = /[^ ]/.test(text);
+ var hasSpaceCharsOnBothEnds = /^ /.test(text) && / $/.test(text);
+
+ if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {
+ text = text.substring(1, text.length - 1);
+ }
+
+ text = escape(text, true);
+ return {
+ type: 'codespan',
+ raw: cap[0],
+ text: text
+ };
+ }
+ };
+
+ _proto.br = function br(src) {
+ var cap = this.rules.inline.br.exec(src);
+
+ if (cap) {
+ return {
+ type: 'br',
+ raw: cap[0]
+ };
+ }
+ };
+
+ _proto.del = function del(src) {
+ var cap = this.rules.inline.del.exec(src);
+
+ if (cap) {
+ return {
+ type: 'del',
+ raw: cap[0],
+ text: cap[2],
+ tokens: this.lexer.inlineTokens(cap[2], [])
+ };
+ }
+ };
+
+ _proto.autolink = function autolink(src, mangle) {
+ var cap = this.rules.inline.autolink.exec(src);
+
+ if (cap) {
+ var text, href;
+
+ if (cap[2] === '@') {
+ text = escape(this.options.mangle ? mangle(cap[1]) : cap[1]);
+ href = 'mailto:' + text;
+ } else {
+ text = escape(cap[1]);
+ href = text;
+ }
+
+ return {
+ type: 'link',
+ raw: cap[0],
+ text: text,
+ href: href,
+ tokens: [{
+ type: 'text',
+ raw: text,
+ text: text
+ }]
+ };
+ }
+ };
+
+ _proto.url = function url(src, mangle) {
+ var cap;
+
+ if (cap = this.rules.inline.url.exec(src)) {
+ var text, href;
+
+ if (cap[2] === '@') {
+ text = escape(this.options.mangle ? mangle(cap[0]) : cap[0]);
+ href = 'mailto:' + text;
+ } else {
+ // do extended autolink path validation
+ var prevCapZero;
+
+ do {
+ prevCapZero = cap[0];
+ cap[0] = this.rules.inline._backpedal.exec(cap[0])[0];
+ } while (prevCapZero !== cap[0]);
+
+ text = escape(cap[0]);
+
+ if (cap[1] === 'www.') {
+ href = 'http://' + text;
+ } else {
+ href = text;
+ }
+ }
+
+ return {
+ type: 'link',
+ raw: cap[0],
+ text: text,
+ href: href,
+ tokens: [{
+ type: 'text',
+ raw: text,
+ text: text
+ }]
+ };
+ }
+ };
+
+ _proto.inlineText = function inlineText(src, smartypants) {
+ var cap = this.rules.inline.text.exec(src);
+
+ if (cap) {
+ var text;
+
+ if (this.lexer.state.inRawBlock) {
+ text = this.options.sanitize ? this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]) : cap[0];
+ } else {
+ text = escape(this.options.smartypants ? smartypants(cap[0]) : cap[0]);
+ }
+
+ return {
+ type: 'text',
+ raw: cap[0],
+ text: text
+ };
+ }
+ };
+
+ return Tokenizer;
+ }();
+
+ /**
+ * Block-Level Grammar
+ */
+
+ var block = {
+ newline: /^(?: *(?:\n|$))+/,
+ code: /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/,
+ fences: /^ {0,3}(`{3,}(?=[^`\n]*\n)|~{3,})([^\n]*)\n(?:|([\s\S]*?)\n)(?: {0,3}\1[~`]* *(?=\n|$)|$)/,
+ hr: /^ {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\* *){3,})(?:\n+|$)/,
+ heading: /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,
+ blockquote: /^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/,
+ list: /^( {0,3}bull)( [^\n]+?)?(?:\n|$)/,
+ html: '^ {0,3}(?:' // optional indentation
+ + '<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:[^\\n]*\\n+|$)' // (1)
+ + '|comment[^\\n]*(\\n+|$)' // (2)
+ + '|<\\?[\\s\\S]*?(?:\\?>\\n*|$)' // (3)
+ + '|\\n*|$)' // (4)
+ + '|\\n*|$)' // (5)
+ + '|)[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (6)
+ + '|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (7) open tag
+ + '|(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (7) closing tag
+ + ')',
+ def: /^ {0,3}\[(label)\]: *(?:\n *)?]+)>?(?:(?: +(?:\n *)?| *\n *)(title))? *(?:\n+|$)/,
+ table: noopTest,
+ lheading: /^([^\n]+)\n {0,3}(=+|-+) *(?:\n+|$)/,
+ // regex template, placeholders will be replaced according to different paragraph
+ // interruption rules of commonmark and the original markdown spec:
+ _paragraph: /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/,
+ text: /^[^\n]+/
+ };
+ block._label = /(?!\s*\])(?:\\.|[^\[\]\\])+/;
+ block._title = /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/;
+ block.def = edit(block.def).replace('label', block._label).replace('title', block._title).getRegex();
+ block.bullet = /(?:[*+-]|\d{1,9}[.)])/;
+ block.listItemStart = edit(/^( *)(bull) */).replace('bull', block.bullet).getRegex();
+ block.list = edit(block.list).replace(/bull/g, block.bullet).replace('hr', '\\n+(?=\\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$))').replace('def', '\\n+(?=' + block.def.source + ')').getRegex();
+ block._tag = 'address|article|aside|base|basefont|blockquote|body|caption' + '|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption' + '|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe' + '|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option' + '|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr' + '|track|ul';
+ block._comment = /|$)/;
+ block.html = edit(block.html, 'i').replace('comment', block._comment).replace('tag', block._tag).replace('attribute', / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
+ block.paragraph = edit(block._paragraph).replace('hr', block.hr).replace('heading', ' {0,3}#{1,6} ').replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs
+ .replace('|table', '').replace('blockquote', ' {0,3}>').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
+ .replace('html', ')|<(?:script|pre|style|textarea|!--)').replace('tag', block._tag) // pars can be interrupted by type (6) html blocks
+ .getRegex();
+ block.blockquote = edit(block.blockquote).replace('paragraph', block.paragraph).getRegex();
+ /**
+ * Normal Block Grammar
+ */
+
+ block.normal = merge({}, block);
+ /**
+ * GFM Block Grammar
+ */
+
+ block.gfm = merge({}, block.normal, {
+ table: '^ *([^\\n ].*\\|.*)\\n' // Header
+ + ' {0,3}(?:\\| *)?(:?-+:? *(?:\\| *:?-+:? *)*)(?:\\| *)?' // Align
+ + '(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)' // Cells
+
+ });
+ block.gfm.table = edit(block.gfm.table).replace('hr', block.hr).replace('heading', ' {0,3}#{1,6} ').replace('blockquote', ' {0,3}>').replace('code', ' {4}[^\\n]').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
+ .replace('html', ')|<(?:script|pre|style|textarea|!--)').replace('tag', block._tag) // tables can be interrupted by type (6) html blocks
+ .getRegex();
+ block.gfm.paragraph = edit(block._paragraph).replace('hr', block.hr).replace('heading', ' {0,3}#{1,6} ').replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs
+ .replace('table', block.gfm.table) // interrupt paragraphs with table
+ .replace('blockquote', ' {0,3}>').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
+ .replace('html', ')|<(?:script|pre|style|textarea|!--)').replace('tag', block._tag) // pars can be interrupted by type (6) html blocks
+ .getRegex();
+ /**
+ * Pedantic grammar (original John Gruber's loose markdown specification)
+ */
+
+ block.pedantic = merge({}, block.normal, {
+ html: edit('^ *(?:comment *(?:\\n|\\s*$)' + '|<(tag)[\\s\\S]+? *(?:\\n{2,}|\\s*$)' // closed tag
+ + '|' + (escaped ? _code : escape(_code, true)) + '
\n';
+ }
+
+ return '' + (escaped ? _code : escape(_code, true)) + '
\n';
+ };
+
+ _proto.blockquote = function blockquote(quote) {
+ return '\n' + quote + '
\n';
+ };
+
+ _proto.html = function html(_html) {
+ return _html;
+ };
+
+ _proto.heading = function heading(text, level, raw, slugger) {
+ if (this.options.headerIds) {
+ return '' + text + ' \n';
+ } // ignore IDs
+
+
+ return '' + text + ' \n';
+ };
+
+ _proto.hr = function hr() {
+ return this.options.xhtml ? '
\n' : '
\n';
+ };
+
+ _proto.list = function list(body, ordered, start) {
+ var type = ordered ? 'ol' : 'ul',
+ startatt = ordered && start !== 1 ? ' start="' + start + '"' : '';
+ return '<' + type + startatt + '>\n' + body + '\n';
+ };
+
+ _proto.listitem = function listitem(text) {
+ return '- ' + text + '
\n';
+ };
+
+ _proto.checkbox = function checkbox(checked) {
+ return ' ';
+ };
+
+ _proto.paragraph = function paragraph(text) {
+ return '' + text + '
\n';
+ };
+
+ _proto.table = function table(header, body) {
+ if (body) body = '' + body + '';
+ return '\n' + '\n' + header + '\n' + body + '
\n';
+ };
+
+ _proto.tablerow = function tablerow(content) {
+ return '\n' + content + ' \n';
+ };
+
+ _proto.tablecell = function tablecell(content, flags) {
+ var type = flags.header ? 'th' : 'td';
+ var tag = flags.align ? '<' + type + ' align="' + flags.align + '">' : '<' + type + '>';
+ return tag + content + '\n';
+ } // span level renderer
+ ;
+
+ _proto.strong = function strong(text) {
+ return '' + text + '';
+ };
+
+ _proto.em = function em(text) {
+ return '' + text + '';
+ };
+
+ _proto.codespan = function codespan(text) {
+ return '' + text + '';
+ };
+
+ _proto.br = function br() {
+ return this.options.xhtml ? '
' : '
';
+ };
+
+ _proto.del = function del(text) {
+ return '' + text + '';
+ };
+
+ _proto.link = function link(href, title, text) {
+ href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
+
+ if (href === null) {
+ return text;
+ }
+
+ var out = '';
+ return out;
+ };
+
+ _proto.image = function image(href, title, text) {
+ href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
+
+ if (href === null) {
+ return text;
+ }
+
+ var out = '' : '>';
+ return out;
+ };
+
+ _proto.text = function text(_text) {
+ return _text;
+ };
+
+ return Renderer;
+ }();
+
+ /**
+ * TextRenderer
+ * returns only the textual part of the token
+ */
+ var TextRenderer = /*#__PURE__*/function () {
+ function TextRenderer() {}
+
+ var _proto = TextRenderer.prototype;
+
+ // no need for block level renderers
+ _proto.strong = function strong(text) {
+ return text;
+ };
+
+ _proto.em = function em(text) {
+ return text;
+ };
+
+ _proto.codespan = function codespan(text) {
+ return text;
+ };
+
+ _proto.del = function del(text) {
+ return text;
+ };
+
+ _proto.html = function html(text) {
+ return text;
+ };
+
+ _proto.text = function text(_text) {
+ return _text;
+ };
+
+ _proto.link = function link(href, title, text) {
+ return '' + text;
+ };
+
+ _proto.image = function image(href, title, text) {
+ return '' + text;
+ };
+
+ _proto.br = function br() {
+ return '';
+ };
+
+ return TextRenderer;
+ }();
+
+ /**
+ * Slugger generates header id
+ */
+ var Slugger = /*#__PURE__*/function () {
+ function Slugger() {
+ this.seen = {};
+ }
+
+ var _proto = Slugger.prototype;
+
+ _proto.serialize = function serialize(value) {
+ return value.toLowerCase().trim() // remove html tags
+ .replace(/<[!\/a-z].*?>/ig, '') // remove unwanted chars
+ .replace(/[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g, '').replace(/\s/g, '-');
+ }
+ /**
+ * Finds the next safe (unique) slug to use
+ */
+ ;
+
+ _proto.getNextSafeSlug = function getNextSafeSlug(originalSlug, isDryRun) {
+ var slug = originalSlug;
+ var occurenceAccumulator = 0;
+
+ if (this.seen.hasOwnProperty(slug)) {
+ occurenceAccumulator = this.seen[originalSlug];
+
+ do {
+ occurenceAccumulator++;
+ slug = originalSlug + '-' + occurenceAccumulator;
+ } while (this.seen.hasOwnProperty(slug));
+ }
+
+ if (!isDryRun) {
+ this.seen[originalSlug] = occurenceAccumulator;
+ this.seen[slug] = 0;
+ }
+
+ return slug;
+ }
+ /**
+ * Convert string to unique id
+ * @param {object} options
+ * @param {boolean} options.dryrun Generates the next unique slug without updating the internal accumulator.
+ */
+ ;
+
+ _proto.slug = function slug(value, options) {
+ if (options === void 0) {
+ options = {};
+ }
+
+ var slug = this.serialize(value);
+ return this.getNextSafeSlug(slug, options.dryrun);
+ };
+
+ return Slugger;
+ }();
+
+ /**
+ * Parsing & Compiling
+ */
+
+ var Parser = /*#__PURE__*/function () {
+ function Parser(options) {
+ this.options = options || exports.defaults;
+ this.options.renderer = this.options.renderer || new Renderer();
+ this.renderer = this.options.renderer;
+ this.renderer.options = this.options;
+ this.textRenderer = new TextRenderer();
+ this.slugger = new Slugger();
+ }
+ /**
+ * Static Parse Method
+ */
+
+
+ Parser.parse = function parse(tokens, options) {
+ var parser = new Parser(options);
+ return parser.parse(tokens);
+ }
+ /**
+ * Static Parse Inline Method
+ */
+ ;
+
+ Parser.parseInline = function parseInline(tokens, options) {
+ var parser = new Parser(options);
+ return parser.parseInline(tokens);
+ }
+ /**
+ * Parse Loop
+ */
+ ;
+
+ var _proto = Parser.prototype;
+
+ _proto.parse = function parse(tokens, top) {
+ if (top === void 0) {
+ top = true;
+ }
+
+ var out = '',
+ i,
+ j,
+ k,
+ l2,
+ l3,
+ row,
+ cell,
+ header,
+ body,
+ token,
+ ordered,
+ start,
+ loose,
+ itemBody,
+ item,
+ checked,
+ task,
+ checkbox,
+ ret;
+ var l = tokens.length;
+
+ for (i = 0; i < l; i++) {
+ token = tokens[i]; // Run any renderer extensions
+
+ if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
+ ret = this.options.extensions.renderers[token.type].call({
+ parser: this
+ }, token);
+
+ if (ret !== false || !['space', 'hr', 'heading', 'code', 'table', 'blockquote', 'list', 'html', 'paragraph', 'text'].includes(token.type)) {
+ out += ret || '';
+ continue;
+ }
+ }
+
+ switch (token.type) {
+ case 'space':
+ {
+ continue;
+ }
+
+ case 'hr':
+ {
+ out += this.renderer.hr();
+ continue;
+ }
+
+ case 'heading':
+ {
+ out += this.renderer.heading(this.parseInline(token.tokens), token.depth, unescape(this.parseInline(token.tokens, this.textRenderer)), this.slugger);
+ continue;
+ }
+
+ case 'code':
+ {
+ out += this.renderer.code(token.text, token.lang, token.escaped);
+ continue;
+ }
+
+ case 'table':
+ {
+ header = ''; // header
+
+ cell = '';
+ l2 = token.header.length;
+
+ for (j = 0; j < l2; j++) {
+ cell += this.renderer.tablecell(this.parseInline(token.header[j].tokens), {
+ header: true,
+ align: token.align[j]
+ });
+ }
+
+ header += this.renderer.tablerow(cell);
+ body = '';
+ l2 = token.rows.length;
+
+ for (j = 0; j < l2; j++) {
+ row = token.rows[j];
+ cell = '';
+ l3 = row.length;
+
+ for (k = 0; k < l3; k++) {
+ cell += this.renderer.tablecell(this.parseInline(row[k].tokens), {
+ header: false,
+ align: token.align[k]
+ });
+ }
+
+ body += this.renderer.tablerow(cell);
+ }
+
+ out += this.renderer.table(header, body);
+ continue;
+ }
+
+ case 'blockquote':
+ {
+ body = this.parse(token.tokens);
+ out += this.renderer.blockquote(body);
+ continue;
+ }
+
+ case 'list':
+ {
+ ordered = token.ordered;
+ start = token.start;
+ loose = token.loose;
+ l2 = token.items.length;
+ body = '';
+
+ for (j = 0; j < l2; j++) {
+ item = token.items[j];
+ checked = item.checked;
+ task = item.task;
+ itemBody = '';
+
+ if (item.task) {
+ checkbox = this.renderer.checkbox(checked);
+
+ if (loose) {
+ if (item.tokens.length > 0 && item.tokens[0].type === 'paragraph') {
+ item.tokens[0].text = checkbox + ' ' + item.tokens[0].text;
+
+ if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === 'text') {
+ item.tokens[0].tokens[0].text = checkbox + ' ' + item.tokens[0].tokens[0].text;
+ }
+ } else {
+ item.tokens.unshift({
+ type: 'text',
+ text: checkbox
+ });
+ }
+ } else {
+ itemBody += checkbox;
+ }
+ }
+
+ itemBody += this.parse(item.tokens, loose);
+ body += this.renderer.listitem(itemBody, task, checked);
+ }
+
+ out += this.renderer.list(body, ordered, start);
+ continue;
+ }
+
+ case 'html':
+ {
+ // TODO parse inline content if parameter markdown=1
+ out += this.renderer.html(token.text);
+ continue;
+ }
+
+ case 'paragraph':
+ {
+ out += this.renderer.paragraph(this.parseInline(token.tokens));
+ continue;
+ }
+
+ case 'text':
+ {
+ body = token.tokens ? this.parseInline(token.tokens) : token.text;
+
+ while (i + 1 < l && tokens[i + 1].type === 'text') {
+ token = tokens[++i];
+ body += '\n' + (token.tokens ? this.parseInline(token.tokens) : token.text);
+ }
+
+ out += top ? this.renderer.paragraph(body) : body;
+ continue;
+ }
+
+ default:
+ {
+ var errMsg = 'Token with "' + token.type + '" type was not found.';
+
+ if (this.options.silent) {
+ console.error(errMsg);
+ return;
+ } else {
+ throw new Error(errMsg);
+ }
+ }
+ }
+ }
+
+ return out;
+ }
+ /**
+ * Parse Inline Tokens
+ */
+ ;
+
+ _proto.parseInline = function parseInline(tokens, renderer) {
+ renderer = renderer || this.renderer;
+ var out = '',
+ i,
+ token,
+ ret;
+ var l = tokens.length;
+
+ for (i = 0; i < l; i++) {
+ token = tokens[i]; // Run any renderer extensions
+
+ if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
+ ret = this.options.extensions.renderers[token.type].call({
+ parser: this
+ }, token);
+
+ if (ret !== false || !['escape', 'html', 'link', 'image', 'strong', 'em', 'codespan', 'br', 'del', 'text'].includes(token.type)) {
+ out += ret || '';
+ continue;
+ }
+ }
+
+ switch (token.type) {
+ case 'escape':
+ {
+ out += renderer.text(token.text);
+ break;
+ }
+
+ case 'html':
+ {
+ out += renderer.html(token.text);
+ break;
+ }
+
+ case 'link':
+ {
+ out += renderer.link(token.href, token.title, this.parseInline(token.tokens, renderer));
+ break;
+ }
+
+ case 'image':
+ {
+ out += renderer.image(token.href, token.title, token.text);
+ break;
+ }
+
+ case 'strong':
+ {
+ out += renderer.strong(this.parseInline(token.tokens, renderer));
+ break;
+ }
+
+ case 'em':
+ {
+ out += renderer.em(this.parseInline(token.tokens, renderer));
+ break;
+ }
+
+ case 'codespan':
+ {
+ out += renderer.codespan(token.text);
+ break;
+ }
+
+ case 'br':
+ {
+ out += renderer.br();
+ break;
+ }
+
+ case 'del':
+ {
+ out += renderer.del(this.parseInline(token.tokens, renderer));
+ break;
+ }
+
+ case 'text':
+ {
+ out += renderer.text(token.text);
+ break;
+ }
+
+ default:
+ {
+ var errMsg = 'Token with "' + token.type + '" type was not found.';
+
+ if (this.options.silent) {
+ console.error(errMsg);
+ return;
+ } else {
+ throw new Error(errMsg);
+ }
+ }
+ }
+ }
+
+ return out;
+ };
+
+ return Parser;
+ }();
+
+ /**
+ * Marked
+ */
+
+ function marked(src, opt, callback) {
+ // throw error in case of non string input
+ if (typeof src === 'undefined' || src === null) {
+ throw new Error('marked(): input parameter is undefined or null');
+ }
+
+ if (typeof src !== 'string') {
+ throw new Error('marked(): input parameter is of type ' + Object.prototype.toString.call(src) + ', string expected');
+ }
+
+ if (typeof opt === 'function') {
+ callback = opt;
+ opt = null;
+ }
+
+ opt = merge({}, marked.defaults, opt || {});
+ checkSanitizeDeprecation(opt);
+
+ if (callback) {
+ var highlight = opt.highlight;
+ var tokens;
+
+ try {
+ tokens = Lexer.lex(src, opt);
+ } catch (e) {
+ return callback(e);
+ }
+
+ var done = function done(err) {
+ var out;
+
+ if (!err) {
+ try {
+ if (opt.walkTokens) {
+ marked.walkTokens(tokens, opt.walkTokens);
+ }
+
+ out = Parser.parse(tokens, opt);
+ } catch (e) {
+ err = e;
+ }
+ }
+
+ opt.highlight = highlight;
+ return err ? callback(err) : callback(null, out);
+ };
+
+ if (!highlight || highlight.length < 3) {
+ return done();
+ }
+
+ delete opt.highlight;
+ if (!tokens.length) return done();
+ var pending = 0;
+ marked.walkTokens(tokens, function (token) {
+ if (token.type === 'code') {
+ pending++;
+ setTimeout(function () {
+ highlight(token.text, token.lang, function (err, code) {
+ if (err) {
+ return done(err);
+ }
+
+ if (code != null && code !== token.text) {
+ token.text = code;
+ token.escaped = true;
+ }
+
+ pending--;
+
+ if (pending === 0) {
+ done();
+ }
+ });
+ }, 0);
+ }
+ });
+
+ if (pending === 0) {
+ done();
+ }
+
+ return;
+ }
+
+ try {
+ var _tokens = Lexer.lex(src, opt);
+
+ if (opt.walkTokens) {
+ marked.walkTokens(_tokens, opt.walkTokens);
+ }
+
+ return Parser.parse(_tokens, opt);
+ } catch (e) {
+ e.message += '\nPlease report this to https://github.com/markedjs/marked.';
+
+ if (opt.silent) {
+ return 'An error occurred:
' + escape(e.message + '', true) + '
';
+ }
+
+ throw e;
+ }
+ }
+ /**
+ * Options
+ */
+
+ marked.options = marked.setOptions = function (opt) {
+ merge(marked.defaults, opt);
+ changeDefaults(marked.defaults);
+ return marked;
+ };
+
+ marked.getDefaults = getDefaults;
+ marked.defaults = exports.defaults;
+ /**
+ * Use Extension
+ */
+
+ marked.use = function () {
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ var opts = merge.apply(void 0, [{}].concat(args));
+ var extensions = marked.defaults.extensions || {
+ renderers: {},
+ childTokens: {}
+ };
+ var hasExtensions;
+ args.forEach(function (pack) {
+ // ==-- Parse "addon" extensions --== //
+ if (pack.extensions) {
+ hasExtensions = true;
+ pack.extensions.forEach(function (ext) {
+ if (!ext.name) {
+ throw new Error('extension name required');
+ }
+
+ if (ext.renderer) {
+ // Renderer extensions
+ var prevRenderer = extensions.renderers ? extensions.renderers[ext.name] : null;
+
+ if (prevRenderer) {
+ // Replace extension with func to run new extension but fall back if false
+ extensions.renderers[ext.name] = function () {
+ for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+ args[_key2] = arguments[_key2];
+ }
+
+ var ret = ext.renderer.apply(this, args);
+
+ if (ret === false) {
+ ret = prevRenderer.apply(this, args);
+ }
+
+ return ret;
+ };
+ } else {
+ extensions.renderers[ext.name] = ext.renderer;
+ }
+ }
+
+ if (ext.tokenizer) {
+ // Tokenizer Extensions
+ if (!ext.level || ext.level !== 'block' && ext.level !== 'inline') {
+ throw new Error("extension level must be 'block' or 'inline'");
+ }
+
+ if (extensions[ext.level]) {
+ extensions[ext.level].unshift(ext.tokenizer);
+ } else {
+ extensions[ext.level] = [ext.tokenizer];
+ }
+
+ if (ext.start) {
+ // Function to check for start of token
+ if (ext.level === 'block') {
+ if (extensions.startBlock) {
+ extensions.startBlock.push(ext.start);
+ } else {
+ extensions.startBlock = [ext.start];
+ }
+ } else if (ext.level === 'inline') {
+ if (extensions.startInline) {
+ extensions.startInline.push(ext.start);
+ } else {
+ extensions.startInline = [ext.start];
+ }
+ }
+ }
+ }
+
+ if (ext.childTokens) {
+ // Child tokens to be visited by walkTokens
+ extensions.childTokens[ext.name] = ext.childTokens;
+ }
+ });
+ } // ==-- Parse "overwrite" extensions --== //
+
+
+ if (pack.renderer) {
+ (function () {
+ var renderer = marked.defaults.renderer || new Renderer();
+
+ var _loop = function _loop(prop) {
+ var prevRenderer = renderer[prop]; // Replace renderer with func to run extension, but fall back if false
+
+ renderer[prop] = function () {
+ for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+ args[_key3] = arguments[_key3];
+ }
+
+ var ret = pack.renderer[prop].apply(renderer, args);
+
+ if (ret === false) {
+ ret = prevRenderer.apply(renderer, args);
+ }
+
+ return ret;
+ };
+ };
+
+ for (var prop in pack.renderer) {
+ _loop(prop);
+ }
+
+ opts.renderer = renderer;
+ })();
+ }
+
+ if (pack.tokenizer) {
+ (function () {
+ var tokenizer = marked.defaults.tokenizer || new Tokenizer();
+
+ var _loop2 = function _loop2(prop) {
+ var prevTokenizer = tokenizer[prop]; // Replace tokenizer with func to run extension, but fall back if false
+
+ tokenizer[prop] = function () {
+ for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+ args[_key4] = arguments[_key4];
+ }
+
+ var ret = pack.tokenizer[prop].apply(tokenizer, args);
+
+ if (ret === false) {
+ ret = prevTokenizer.apply(tokenizer, args);
+ }
+
+ return ret;
+ };
+ };
+
+ for (var prop in pack.tokenizer) {
+ _loop2(prop);
+ }
+
+ opts.tokenizer = tokenizer;
+ })();
+ } // ==-- Parse WalkTokens extensions --== //
+
+
+ if (pack.walkTokens) {
+ var _walkTokens = marked.defaults.walkTokens;
+
+ opts.walkTokens = function (token) {
+ pack.walkTokens.call(this, token);
+
+ if (_walkTokens) {
+ _walkTokens.call(this, token);
+ }
+ };
+ }
+
+ if (hasExtensions) {
+ opts.extensions = extensions;
+ }
+
+ marked.setOptions(opts);
+ });
+ };
+ /**
+ * Run callback for every token
+ */
+
+
+ marked.walkTokens = function (tokens, callback) {
+ var _loop3 = function _loop3() {
+ var token = _step.value;
+ callback.call(marked, token);
+
+ switch (token.type) {
+ case 'table':
+ {
+ for (var _iterator2 = _createForOfIteratorHelperLoose(token.header), _step2; !(_step2 = _iterator2()).done;) {
+ var cell = _step2.value;
+ marked.walkTokens(cell.tokens, callback);
+ }
+
+ for (var _iterator3 = _createForOfIteratorHelperLoose(token.rows), _step3; !(_step3 = _iterator3()).done;) {
+ var row = _step3.value;
+
+ for (var _iterator4 = _createForOfIteratorHelperLoose(row), _step4; !(_step4 = _iterator4()).done;) {
+ var _cell = _step4.value;
+ marked.walkTokens(_cell.tokens, callback);
+ }
+ }
+
+ break;
+ }
+
+ case 'list':
+ {
+ marked.walkTokens(token.items, callback);
+ break;
+ }
+
+ default:
+ {
+ if (marked.defaults.extensions && marked.defaults.extensions.childTokens && marked.defaults.extensions.childTokens[token.type]) {
+ // Walk any extensions
+ marked.defaults.extensions.childTokens[token.type].forEach(function (childTokens) {
+ marked.walkTokens(token[childTokens], callback);
+ });
+ } else if (token.tokens) {
+ marked.walkTokens(token.tokens, callback);
+ }
+ }
+ }
+ };
+
+ for (var _iterator = _createForOfIteratorHelperLoose(tokens), _step; !(_step = _iterator()).done;) {
+ _loop3();
+ }
+ };
+ /**
+ * Parse Inline
+ */
+
+
+ marked.parseInline = function (src, opt) {
+ // throw error in case of non string input
+ if (typeof src === 'undefined' || src === null) {
+ throw new Error('marked.parseInline(): input parameter is undefined or null');
+ }
+
+ if (typeof src !== 'string') {
+ throw new Error('marked.parseInline(): input parameter is of type ' + Object.prototype.toString.call(src) + ', string expected');
+ }
+
+ opt = merge({}, marked.defaults, opt || {});
+ checkSanitizeDeprecation(opt);
+
+ try {
+ var tokens = Lexer.lexInline(src, opt);
+
+ if (opt.walkTokens) {
+ marked.walkTokens(tokens, opt.walkTokens);
+ }
+
+ return Parser.parseInline(tokens, opt);
+ } catch (e) {
+ e.message += '\nPlease report this to https://github.com/markedjs/marked.';
+
+ if (opt.silent) {
+ return 'An error occurred:
' + escape(e.message + '', true) + '
';
+ }
+
+ throw e;
+ }
+ };
+ /**
+ * Expose
+ */
+
+
+ marked.Parser = Parser;
+ marked.parser = Parser.parse;
+ marked.Renderer = Renderer;
+ marked.TextRenderer = TextRenderer;
+ marked.Lexer = Lexer;
+ marked.lexer = Lexer.lex;
+ marked.Tokenizer = Tokenizer;
+ marked.Slugger = Slugger;
+ marked.parse = marked;
+ var options = marked.options;
+ var setOptions = marked.setOptions;
+ var use = marked.use;
+ var walkTokens = marked.walkTokens;
+ var parseInline = marked.parseInline;
+ var parse = marked;
+ var parser = Parser.parse;
+ var lexer = Lexer.lex;
+
+ exports.Lexer = Lexer;
+ exports.Parser = Parser;
+ exports.Renderer = Renderer;
+ exports.Slugger = Slugger;
+ exports.TextRenderer = TextRenderer;
+ exports.Tokenizer = Tokenizer;
+ exports.getDefaults = getDefaults;
+ exports.lexer = lexer;
+ exports.marked = marked;
+ exports.options = options;
+ exports.parse = parse;
+ exports.parseInline = parseInline;
+ exports.parser = parser;
+ exports.setOptions = setOptions;
+ exports.use = use;
+ exports.walkTokens = walkTokens;
+
+ Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
diff --git a/man/marked.1 b/man/marked.1
index b9bdc8c212..4dd24fd1d8 100644
--- a/man/marked.1
+++ b/man/marked.1
@@ -1,21 +1,21 @@
.ds q \N'34'
-.TH marked 1 "2014-01-31" "v0.3.1" "marked.js"
+.TH marked 1
.SH NAME
marked \- a javascript markdown parser
.SH SYNOPSIS
.B marked
-[\-o \fI