-
+
- two
+
- three
- +
-
+ ```
+
+ After (output):
+ ```html
+
- one +
- two
+
- three
+ - a
-
+
hello world! + +**Actual Output:** + +
hello **world**!
+ + + +# Want a Feature? +You can request a new feature by submitting an issue. If you would like to implement a new feature feel free to issue a +Pull Request. + + +# Pull requests (PRs) +PRs are awesome. However, before you submit your pull request consider the following guidelines: + + - Search GitHub for an open or closed Pull Request that relates to your submission. You don't want to duplicate effort. + - When issuing PRs that change code, make your changes in a new git branch based on develop: + + ```bash + git checkout -b my-fix-branch develop + ``` + + - Run the full test suite before submitting and make sure all tests pass (obviously =P). + - Try to follow our [**coding style rules**](https://github.com/showdownjs/code-style/blob/master/README.md). + Breaking them prevents the PR to pass the tests. + - Refrain from fixing multiple issues in the same pull request. It's preferable to open multiple small PRs instead of one + hard to review big one. Also, don't reuse old forks (or PRs) to fix new issues. + - If the PR introduces a new feature or fixes an issue, please add the appropriate test case. + - We use commit notes to generate the changelog. It's extremely helpful if your commit messages adhere to the + [**AngularJS Git Commit Guidelines**](https://github.com/showdownjs/code-style/blob/master/README.md#commit-message-convention). + - If we suggest changes then: + - Make the required updates. + - Re-run the Angular test suite to ensure tests are still passing. + - Rebase your branch and force push to your GitHub repository (this will update your Pull Request): + + ```bash + git rebase develop -i + git push origin my-fix-branch -f + ``` + - After your pull request is merged, you can safely delete your branch. + +If you have time to contribute to this project, we feel obliged that you get credit for it. +These rules enable us to review your PR faster and will give you appropriate credit in your GitHub profile. +We thank you in advance for your contribution! + + +# Joining the team +We're looking for members to help maintaining Showdown. +Please see [this issue](https://github.com/showdownjs/showdown/issues/114) to express interest or comment on this note. diff --git a/CodeShowWeb/Pub/showdown-master/CREDITS.md b/CodeShowWeb/Pub/showdown-master/CREDITS.md new file mode 100644 index 0000000..af4005c --- /dev/null +++ b/CodeShowWeb/Pub/showdown-master/CREDITS.md @@ -0,0 +1,52 @@ +Credits +======= + + - Showdown v2 + * [Estevão Santos](https://github.com/tivie) + + - Showdown v1 + * [Estevão Santos](https://github.com/tivie) + * [Pascal Deschênes](https://github.com/pdeschen) + + - Showdown v0 + * [Corey Innis](http://github.com/coreyti):+ Original GitHub project maintainer + * [Remy Sharp](https://github.com/remy/):
+ CommonJS-compatibility and more + * [Konstantin Käfer](https://github.com/kkaefer/):
+ CommonJS packaging + * [Roger Braun](https://github.com/rogerbraun):
+ Github-style code blocks + * [Dominic Tarr](https://github.com/dominictarr):
+ Documentation + * [Cat Chen](https://github.com/CatChen):
+ Export fix + * [Titus Stone](https://github.com/tstone):
+ Mocha tests, extension mechanism, and bug fixes + * [Rob Sutherland](https://github.com/roberocity):
+ The idea that lead to extensions + * [Pavel Lang](https://github.com/langpavel):
+ Code cleanup + * [Ben Combee](https://github.com/unwiredben):
+ Regex optimization + * [Adam Backstrom](https://github.com/abackstrom):
+ WebKit bugfix + * [Pascal Deschênes](https://github.com/pdeschen):
+ Grunt support, extension fixes + additions, packaging improvements, documentation + * [Estevão Santos](https://github.com/tivie)
+ Bug fixing and late maintainer + * [Hannah Wolfe](https://github.com/ErisDS)
+ Bug fixes + * [Alexandre Courtiol](https://github.com/acourtiol)
+ Bug fixes and build optimization + * [Karthik Balakrishnan](https://github.com/torcellite)
+ Support for table alignment + * [rheber](https://github.com/rheber)
+ Cli + + + - Original Project + * [John Gruber](http://daringfireball.net/projects/markdown/)
+ Author of Markdown + * [John Fraser](http://attacklab.net/)
+ Author of Showdown diff --git a/CodeShowWeb/Pub/showdown-master/DONATIONS.md b/CodeShowWeb/Pub/showdown-master/DONATIONS.md new file mode 100644 index 0000000..a69c50c --- /dev/null +++ b/CodeShowWeb/Pub/showdown-master/DONATIONS.md @@ -0,0 +1,30 @@ +We would like to thank everyone that contributed to this library. If you find our library useful and wish to donate as well, you can do so directly [through paypal](https://www.paypal.me/tiviesantos)!! Your contribution will be greatly appreciated. + + +# Donors + +- [**Learn on demand Systems**](http://www.learnondemandsystems.com/) (1000$) + +- **Nothing AG** (25€) + + > Thank you for developing Showdown :) + +- **Sam Huffman** (15$) + + > Thanks for the great work on showdown.js! I've been looking for a good solution to serve wiki-like text to a browser and render as + HTML but nearly gave up after mixed success with wikitext. Your library gets me very close to where I want to be. + +- **Maya Lekova** (10$) + + > Great work with the showdown library! I just used it and it worked exactly the way I expected + (given a complex inline HTML inside the Markdown, which renders fine with other viewers). + The other libraries I've tried (markdown-it and marked) produced a lot of bogus output. Y + our library saved me at least half a day, thanks! Good luck :) + +- **Lin Wang** (10$) + +- **Walter Schnell** (10$) + +- **ivanhjc** (5$) + +- **Juan Marcelo Russo** (1$) diff --git a/CodeShowWeb/Pub/showdown-master/LICENSE b/CodeShowWeb/Pub/showdown-master/LICENSE new file mode 100644 index 0000000..10acb8e --- /dev/null +++ b/CodeShowWeb/Pub/showdown-master/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 ShowdownJS + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/CodeShowWeb/Pub/showdown-master/README.md b/CodeShowWeb/Pub/showdown-master/README.md new file mode 100644 index 0000000..68ca034 --- /dev/null +++ b/CodeShowWeb/Pub/showdown-master/README.md @@ -0,0 +1,518 @@ +![Showdown][sd-logo] + +[](https://travis-ci.org/showdownjs/showdown) +[](https://ci.appveyor.com/project/tivie/showdown/branch/master) +[](http://badge.fury.io/js/showdown) +[](http://badge.fury.io/bo/showdown) +[](https://gitter.im/showdownjs/showdown?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) +[](https://greenkeeper.io/) +[](https://www.paypal.me/tiviesantos) + +------ + +Showdown is a Javascript Markdown to HTML converter, based on the original works by John Gruber. +Showdown can be used client side (in the browser) or server side (with NodeJs). + +## Live DEMO + +Check a live Demo here http://demo.showdownjs.com/ + + +## Who uses Showdown (or a fork) + + - [GoogleCloudPlatform](https://github.com/GoogleCloudPlatform) + - [Ghost](https://ghost.org/) + - [Meteor](https://www.meteor.com/) + - [Stackexchange](http://stackexchange.com/) - forked as [PageDown](https://code.google.com/p/pagedown/) + - [docular](https://github.com/Vertafore/docular) + - [and some others...](https://www.npmjs.com/browse/depended/showdown) + +## Donate [](https://www.paypal.me/tiviesantos) + +As you know, ShowdownJS is a free library and it will remain free forever. However, maintaining and improving the library costs time and money. + +If you like our work and find our library useful, please donate ~~[through Pledgie](https://pledgie.com/campaigns/35166) or~~ directly [through paypal](https://www.paypal.me/tiviesantos)!! Your contribution will be greatly appreciated and help us continue to develop this awesome library. + +## License + +ShowdownJS v 2.0 is release under the MIT version. +Previous versions are release under GPL 2.0 + +## Installation + +### Download tarball + +You can download the latest release tarball directly from [releases][releases] + +### Bower + + bower install showdown + +### npm (server-side) + + npm install showdown + +### NuGet package + + PM> Install-Package showdownjs + +The NuGet Packages can be [found here](https://www.nuget.org/packages/showdownjs/). + +### CDN + +You can also use one of several CDNs available: + +* github CDN + + https://cdn.rawgit.com/showdownjs/showdown/
hello, markdown!
+``` + +## Options + +You can change some of showdown's default behavior through options. + +### Setting options + +Options can be set: + +#### Globally + +Setting a "global" option affects all instances of showdown + +```js +showdown.setOption('optionKey', 'value'); +``` + +#### Locally +Setting a "local" option only affects the specified Converter object. +Local options can be set: + + * **through the constructor** + ```js + var converter = new showdown.Converter({optionKey: 'value'}); + ``` + + * **through the setOption() method** + ```js + var converter = new showdown.Converter(); + converter.setOption('optionKey', 'value'); + ``` + +### Getting an option + +Showdown provides 2 methods (both local and global) to retrieve previous set options. + +#### getOption() + +```js +// Global +var myOption = showdown.getOption('optionKey'); + +//Local +var myOption = converter.getOption('optionKey'); +``` + +#### getOptions() + +```js +// Global +var showdownGlobalOptions = showdown.getOptions(); + +//Local +var thisConverterSpecificOptions = converter.getOptions(); +``` + +### Retrieve the default options + +You can get showdown's default options with: +```js +var defaultOptions = showdown.getDefaultOptions(); +``` + +### Valid Options + + * **omitExtraWLInCodeBlocks**: (boolean) [default false] Omit the trailing newline in a code block. Ex: + + This: + ```html +var foo = 'bar';
+
var foo = 'bar';
foo
+ ``` + + * **parseImgDimensions**: (boolean) [default false] Enable support for setting image dimensions from within markdown syntax. + Examples: + ``` +  simple, assumes units are in px +  sets the height to "auto" +  Image with width of 80% and height of 5em + ``` + + * **simplifiedAutoLink**: (boolean) [default false] Turning this option on will enable automatic linking to urls. + This means that: + + ```md + some text www.google.com + ``` + will be parsed as + ```html +some text www.google.com
+ ```
+
+ * ~~**excludeTrailingPunctuationFromURLs**: (boolean) [default false] This option excludes trailing punctuation from autolinking urls.
+ Punctuation excluded: `. ! ? ( )`. Only applies if **simplifiedAutoLink** option is set to `true`.~~
+
+ * **literalMidWordUnderscores**: (boolean) [default false] Turning this on will stop showdown from interpreting
+ underscores in the middle of words as `` and `` and instead treat them as literal underscores.
+
+ Example:
+
+ ```md
+ some text with__underscores__in middle
+ ```
+ will be parsed as
+ ```html
+ some text with__underscores__in middle a line tags around block-level tags.
+ text = showdown.subParser('makehtml.hashHTMLBlocks')(text, options, globals);
+ text = showdown.subParser('makehtml.paragraphs')(text, options, globals);
+
+ text = globals.converter._dispatch('makehtml.blockGamut.after', text, options, globals).getText();
+
+ return text;
+});
+
+showdown.subParser('makehtml.blockQuotes', function (text, options, globals) {
+ 'use strict';
+
+ text = globals.converter._dispatch('makehtml.blockQuotes.before', text, options, globals).getText();
+
+ // add a couple extra lines after the text and endtext mark
+ text = text + '\n\n';
+
+ var rgx = /(^ {0,3}>[ \t]?.+\n(.+\n)*\n*)+/gm;
+
+ if (options.splitAdjacentBlockquotes) {
+ rgx = /^ {0,3}>[\s\S]*?(?:\n\n)/gm;
+ }
+
+ text = text.replace(rgx, function (bq) {
+ // attacklab: hack around Konqueror 3.5.4 bug:
+ // "----------bug".replace(/^-/g,"") == "bug"
+ bq = bq.replace(/^[ \t]*>[ \t]?/gm, ''); // trim one level of quoting
+
+ // attacklab: clean up hack
+ bq = bq.replace(/¨0/g, '');
+
+ bq = bq.replace(/^[ \t]+$/gm, ''); // trim whitespace-only lines
+ bq = showdown.subParser('makehtml.githubCodeBlocks')(bq, options, globals);
+ bq = showdown.subParser('makehtml.blockGamut')(bq, options, globals); // recurse
+
+ bq = bq.replace(/(^|\n)/g, '$1 ');
+ // These leading spaces screw with Just type strikethrough`
+
+ * **tables**: (boolean) [default false] Enable support for tables syntax. Example:
+
+ ```md
+ | h1 | h2 | h3 |
+ |:------|:-------:|--------:|
+ | 100 | [a][1] | ![b][2] |
+ | *foo* | **bar** | ~~baz~~ |
+ ```
+
+ See the wiki for more info
+
+ * **tablesHeaderId**: (boolean) [default false] If enabled adds an id property to table headers tags.
+
+ * **ghCodeBlocks**: (boolean) [default true] Enable support for GFM code block style.
+
+ * **tasklists**:(boolean) [default false] Enable support for GFM tasklists. Example:
+
+ ```md
+ - [x] This task is done
+ - [ ] This is still pending
+ ```
+ * **smoothLivePreview**: (boolean) [default false] Prevents weird effects in live previews due to incomplete input
+
+ * **smartIndentationFix**: (boolean) [default false] Tries to smartly fix indentation problems related to es6 template
+ strings in the midst of indented code.
+
+ * **disableForced4SpacesIndentedSublists**: (boolean) [default false] Disables the requirement of indenting sublists
+ by 4 spaces for them to be nested, effectively reverting to the old behavior where 2 or 3 spaces were enough.
+ **(since v1.5.0)**
+
+ * **simpleLineBreaks**: (boolean) [default false] Parses line breaks as
, without
+ needing 2 spaces at the end of the line **(since v1.5.1)**
+
+ ```md
+ a line
+ wrapped in two
+ ```
+
+ turns into:
+
+ ```html
+
+ wrapped in two
+[](https://www.jetbrains.com/webstorm/)
+
+
+
+[sd-logo]: https://raw.githubusercontent.com/showdownjs/logo/master/dist/logo.readme.png
+[legacy-branch]: https://github.com/showdownjs/showdown/tree/legacy
+[releases]: https://github.com/showdownjs/showdown/releases
+[changelog]: https://github.com/showdownjs/showdown/blob/master/CHANGELOG.md
+[wiki]: https://github.com/showdownjs/showdown/wiki
+[cli-wiki]: https://github.com/showdownjs/showdown/wiki/CLI-tool
+[definitely-typed]: https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/showdown
+[xss-wiki]: https://github.com/showdownjs/showdown/wiki/Markdown's-XSS-Vulnerability-(and-how-to-mitigate-it)
+[ext-wiki]: https://github.com/showdownjs/showdown/wiki/extensions
+[coding-rules]: https://github.com/showdownjs/code-style/blob/master/README.md
+[ng-commit-guide]: https://github.com/showdownjs/code-style/blob/master/README.md#commit-message-convention
+[boilerplate-repo]: https://github.com/showdownjs/extension-boilerplate
diff --git a/CodeShowWeb/Pub/showdown-master/TASKS.TODO.md b/CodeShowWeb/Pub/showdown-master/TASKS.TODO.md
new file mode 100644
index 0000000..4934896
--- /dev/null
+++ b/CodeShowWeb/Pub/showdown-master/TASKS.TODO.md
@@ -0,0 +1,140 @@
+# ROADMAP TO VERSION 2.0
+
+
+## Options
+
+- [ ] **ghCompatibleHeaderId** (removal)
+
+ Will be removed and **will become the default behavior**.
+
+- [ ] **customizedHeaderId** (removal)
+
+ This option introduced non compliant syntax so it really belongs in an extension.
+ The new **listener extension system** allows users to directly modify and customize
+ the HTML and add any attributes they wish.
+
+- [ ] **rawPrefixHeaderId** (removal)
+
+ This option will be superseeded by the option `rawHeaderId`. So basically activating `rawHeaderId` will make
+ showdown only to replace spaces, ', ", > and < with dashes (-) from generated header ids, including prefixes.
+
+- [X] **literalMidWordAsterisks** (removal)
+
+ This option is weird, hard to maintain and really... makes little sense.
+
+- [X] **excludeTrailingPunctuationFromURLs** (removal)
+
+ This option will be removed and will be the default behavior from now on.
+
+- [ ] **strikethrough** (change)
+
+ Will be enabled by default
+
+- [ ] **disableForced4SpacesIndentedSublists** (to think/postpone)
+
+ This was only a temporary option for backwards compatibility reason. However, most flavours support lists indented
+ with 2 spaces, so it puts us in a tight spot, specially since some markdown beautifiers out there insist in
+ indenting lists with 2 spaces, probably in a misguided try to follow the CommonMark spec.
+
+ The CommonMark spec is, IMHO, a bit confusing for users regarding this, since list sub-blocks (and lists)
+ are determined by the spaces from the start of the line and the first character after the list mark. And the proof
+ are the MD beautifiers out there, which misinterpreted the spec and made a mess
+
+ Showdown syntax is actually easier (and fully compliant with the original spec): if you indent something 4 spaces,
+ it becomes a sub-block. Since lists are blocks, you must indent it 4 spaces for it to become a sub-block.
+
+ Regardless, we kinda have 2 solutions:
+
+ - Drop support for 2 space indentation (and make a lot of users confused since GFM, CommonMark and others allow this)
+ - Create a new list subparser that can be turned on with an option, like gfmListStyle
+ (but postpones even more the alpha 2.0 release since the list subparser is probably the hardest thing to rewrite)
+
+ Tough choices...
+
+- [ ] **simpleLineBreaks** (change)
+
+ Will be removed from Github Flavor since github only does this in comments (which is weird...)
+
+- [ ] **openLinksInNewWindow** (removal)
+
+ Will be removed in favor of the new listener extension, which will allow users to manipulate HTML tags attributes
+ directly.
+
+- [ ] Revamp the option system
+
+ Revamp the option system so that it becomes more simple. Right now, it's really confusing. And option names are weird
+ too. The idea is to pass options to the constructor under an option object, that can have hierarchical structure.
+ Ex:
+
+ ```js
+ var conv = new showdown.Converter({
+ options: {
+ links: {
+ autoLinks: true
+ },
+ headings: {
+ startLevel: 2
+ }
+ }
+ });
+ ```
+
+## Legacy Code Removal
+- [ ] Legacy extension support
+
+ Old extensions that inject directly into extensions object property will no longer be supported
+
+- [ ] HTML and OUTPUT extensions
+
+ HTML and OTP extensions will be dropped in favor of Listener Extensions. We might even give them a new name
+
+## Subparsers
+- [X] **Anchors**: Revamp the anchors subparser so it calls strikethrough, bold, italic and underline directly
+- [X] **autoLinks**: Fix some lingering bugs and issues with autolinks
+
+## Priority Bugs
+- [X] **#355**: *simplifiedAutoLink URLs inside parenthesis followed by another character are not parsed correctly*
+- [X] **#534**: *Multiple parentheses () in url link is not parsed correctly*
+- [ ] **#367**: *sublists rendering with 2 spaces* - related to disableForced4SpacesIndentedSublists option...
+- [ ] **#537**: *master branch doesn't work in a web worker*
+
+## CLI
+- [ ] Refactor the CLI
+- [ ] **#381**: *Support for src and dst directories in showdown cli*
+- [ ] **#584**: *Fails to read from stdin*
+- [ ] **#554**: *CLI not working with jsdom v10*
+
+## Other stuff
+- [X] Regexp rewrite for more performance oompf
+- [ ] Full unit testing
+- [ ] Better error reporting
+
+## Stuff that probably won't make it to v2.0
+- [ ] **#486**: *A backslash at the end of the line is a hard line break*
+- [ ] **#548**: *anchors and images of subParser are errors when they are specific strings*
+- [ ] **#549**: *Strange parsing issue with ``*
+- [ ] Rethink the global variable
+
+## NEW Features
+
+### Event system
+- [X] Listener system revamp
+- [ ] Standardize events for all event types
+- [ ] Unit testing
+- [ ] Functional testing
+
+This should address:
+- **#567**: Allow not making header ids lowercase
+- **#540**: Add complete class to the tasklist list element
+
+### MD to HTML conversion
+- [X] Basic support
+- [X] Basic functional testcase
+- [ ] Advanced support for all showdown MD features
+- [ ] Advanced functional testcase
+- [ ] Unit testing
+
+## Documentation (for v2.0)
+- [ ] Options
+- [ ] Extensions (and the new event system)
+- [ ] Cookbook (with stuff for backwards compatibility, specially regarding removed options)
diff --git a/CodeShowWeb/Pub/showdown-master/bower.json b/CodeShowWeb/Pub/showdown-master/bower.json
new file mode 100644
index 0000000..34698b2
--- /dev/null
+++ b/CodeShowWeb/Pub/showdown-master/bower.json
@@ -0,0 +1,32 @@
+{
+ "name": "showdown",
+ "description": "A Markdown to HTML converter written in Javascript",
+ "homepage": "https://github.com/showdownjs/showdown",
+ "authors": [
+ "Estevão Santos (https://github.com/tivie)",
+ "Pascal Deschênes (https://github.com/pdeschen)"
+ ],
+ "main": ["dist/showdown.js"],
+ "ignore": [
+ ".editorconfig",
+ ".gitattributes",
+ ".gitignore",
+ ".jscs.json",
+ ".jshintignore",
+ ".jshintrc",
+ ".travis.yml",
+ "Gruntfile.js",
+ "package.json",
+ "test/*"
+ ],
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/showdownjs/showdown.git"
+ },
+ "keywords": [
+ "markdown",
+ "md",
+ "mdown"
+ ],
+ "license": "https://github.com/showdownjs/showdown/blob/master/license.txt"
+}
diff --git a/CodeShowWeb/Pub/showdown-master/dist/showdown.js b/CodeShowWeb/Pub/showdown-master/dist/showdown.js
new file mode 100644
index 0000000..e69c44d
--- /dev/null
+++ b/CodeShowWeb/Pub/showdown-master/dist/showdown.js
@@ -0,0 +1,5451 @@
+;/*! showdown v 2.0.0-alpha1 - 25-09-2018 */
+(function(){
+/**
+ * Created by Tivie on 13-07-2015.
+ */
+
+function getDefaultOpts (simple) {
+ 'use strict';
+
+ var defaultOptions = {
+ omitExtraWLInCodeBlocks: {
+ defaultValue: false,
+ describe: 'Omit the default extra whiteline added to code blocks',
+ type: 'boolean'
+ },
+ noHeaderId: {
+ defaultValue: false,
+ describe: 'Turn on/off generated header id',
+ type: 'boolean'
+ },
+ prefixHeaderId: {
+ defaultValue: false,
+ describe: 'Add a prefix to the generated header ids. Passing a string will prefix that string to the header id. Setting to true will add a generic \'section-\' prefix',
+ type: 'string'
+ },
+ rawPrefixHeaderId: {
+ defaultValue: false,
+ describe: 'Setting this option to true will prevent showdown from modifying the prefix. This might result in malformed IDs (if, for instance, the " char is used in the prefix)',
+ type: 'boolean'
+ },
+ ghCompatibleHeaderId: {
+ defaultValue: false,
+ describe: 'Generate header ids compatible with github style (spaces are replaced with dashes, a bunch of non alphanumeric chars are removed)',
+ type: 'boolean'
+ },
+ rawHeaderId: {
+ defaultValue: false,
+ describe: 'Remove only spaces, \' and " from generated header ids (including prefixes), replacing them with dashes (-). WARNING: This might result in malformed ids',
+ type: 'boolean'
+ },
+ headerLevelStart: {
+ defaultValue: false,
+ describe: 'The header blocks level start',
+ type: 'integer'
+ },
+ parseImgDimensions: {
+ defaultValue: false,
+ describe: 'Turn on/off image dimension parsing',
+ type: 'boolean'
+ },
+ simplifiedAutoLink: {
+ defaultValue: false,
+ describe: 'Turn on/off GFM autolink style',
+ type: 'boolean'
+ },
+ literalMidWordUnderscores: {
+ defaultValue: false,
+ describe: 'Parse midword underscores as literal underscores',
+ type: 'boolean'
+ },
+ literalMidWordAsterisks: {
+ defaultValue: false,
+ describe: 'Parse midword asterisks as literal asterisks',
+ type: 'boolean'
+ },
+ strikethrough: {
+ defaultValue: false,
+ describe: 'Turn on/off strikethrough support',
+ type: 'boolean'
+ },
+ tables: {
+ defaultValue: false,
+ describe: 'Turn on/off tables support',
+ type: 'boolean'
+ },
+ tablesHeaderId: {
+ defaultValue: false,
+ describe: 'Add an id to table headers',
+ type: 'boolean'
+ },
+ ghCodeBlocks: {
+ defaultValue: true,
+ describe: 'Turn on/off GFM fenced code blocks support',
+ type: 'boolean'
+ },
+ tasklists: {
+ defaultValue: false,
+ describe: 'Turn on/off GFM tasklist support',
+ type: 'boolean'
+ },
+ smoothLivePreview: {
+ defaultValue: false,
+ describe: 'Prevents weird effects in live previews due to incomplete input',
+ type: 'boolean'
+ },
+ smartIndentationFix: {
+ defaultValue: false,
+ description: 'Tries to smartly fix indentation in es6 strings',
+ type: 'boolean'
+ },
+ disableForced4SpacesIndentedSublists: {
+ defaultValue: false,
+ description: 'Disables the requirement of indenting nested sublists by 4 spaces',
+ type: 'boolean'
+ },
+ simpleLineBreaks: {
+ defaultValue: false,
+ description: 'Parses simple line breaks as
(GFM Style)',
+ type: 'boolean'
+ },
+ requireSpaceBeforeHeadingText: {
+ defaultValue: false,
+ description: 'Makes adding a space between `#` and the header text mandatory (GFM Style)',
+ type: 'boolean'
+ },
+ ghMentions: {
+ defaultValue: false,
+ description: 'Enables github @mentions',
+ type: 'boolean'
+ },
+ ghMentionsLink: {
+ defaultValue: 'https://github.com/{u}',
+ description: 'Changes the link generated by @mentions. Only applies if ghMentions option is enabled.',
+ type: 'string'
+ },
+ encodeEmails: {
+ defaultValue: true,
+ description: 'Encode e-mail addresses through the use of Character Entities, transforming ASCII e-mail addresses into its equivalent decimal entities',
+ type: 'boolean'
+ },
+ openLinksInNewWindow: {
+ defaultValue: false,
+ description: 'Open all links in new windows',
+ type: 'boolean'
+ },
+ backslashEscapesHTMLTags: {
+ defaultValue: false,
+ description: 'Support for HTML Tag escaping. ex: \>t<>", "<", ">", "g")
+ * returns: ["t<", ""]
+ * matchRecursiveRegExp("
',
+ 'showdown': '
'
+};
+
+/**
+ * These are all the transformations that form block-level
+ * tags like paragraphs, headers, and list items.
+ */
+showdown.subParser('makehtml.blockGamut', function (text, options, globals) {
+ 'use strict';
+
+ text = globals.converter._dispatch('makehtml.blockGamut.before', text, options, globals).getText();
+
+ // we parse blockquotes first so that we can have headings and hrs
+ // inside blockquotes
+ text = showdown.subParser('makehtml.blockQuotes')(text, options, globals);
+ text = showdown.subParser('makehtml.headers')(text, options, globals);
+
+ // Do Horizontal Rules:
+ text = showdown.subParser('makehtml.horizontalRule')(text, options, globals);
+
+ text = showdown.subParser('makehtml.lists')(text, options, globals);
+ text = showdown.subParser('makehtml.codeBlocks')(text, options, globals);
+ text = showdown.subParser('makehtml.tables')(text, options, globals);
+
+ // We already ran _HashHTMLBlocks() before, in Markdown(), but that
+ // was to escape raw HTML in the original Markdown source. This time,
+ // we're escaping the markup we've just created, so that we don't wrap
+ // content, so we need to fix that:
+ bq = bq.replace(/(\s*
[^\r]+?<\/pre>)/gm, function (wholeMatch, m1) {
+ var pre = m1;
+ // attacklab: hack around Konqueror 3.5.4 bug:
+ pre = pre.replace(/^ /mg, '¨0');
+ pre = pre.replace(/¨0/g, '');
+ return pre;
+ });
+
+ return showdown.subParser('makehtml.hashBlock')('\n' + bq + '\n
', options, globals);
+ });
+
+ text = globals.converter._dispatch('makehtml.blockQuotes.after', text, options, globals).getText();
+ return text;
+});
+
+/**
+ * Process Markdown `
';
+
+ codeblock = showdown.subParser('makehtml.hashBlock')(codeblock, options, globals);
+
+ // Since GHCodeblocks can be false positives, we need to
+ // store the primitive text and the parsed text in a global var,
+ // and then return a token
+ return '\n\n¨G' + (globals.ghCodeBlocks.push({text: wholeMatch, codeblock: codeblock}) - 1) + 'G\n\n';
+ });
+
+ // attacklab: strip sentinel
+ text = text.replace(/¨0/, '');
+
+ return globals.converter._dispatch('makehtml.githubCodeBlocks.after', text, options, globals).getText();
+});
+
+showdown.subParser('makehtml.hashBlock', function (text, options, globals) {
+ 'use strict';
+ text = globals.converter._dispatch('makehtml.hashBlock.before', text, options, globals).getText();
+ text = text.replace(/(^\n+|\n+$)/g, '');
+ text = '\n\n¨K' + (globals.gHtmlBlocks.push(text) - 1) + 'K\n\n';
+ text = globals.converter._dispatch('makehtml.hashBlock.after', text, options, globals).getText();
+ return text;
+});
+
+/**
+ * Hash and escape ` blocks.
+ */
+showdown.subParser('makehtml.codeBlocks', function (text, options, globals) {
+ 'use strict';
+
+ text = globals.converter._dispatch('makehtml.codeBlocks.before', text, options, globals).getText();
+
+ // sentinel workarounds for lack of \A and \Z, safari\khtml bug
+ text += '¨0';
+
+ var pattern = /(?:\n\n|^)((?:(?:[ ]{4}|\t).*\n+)+)(\n*[ ]{0,3}[^ \t\n]|(?=¨0))/g;
+ text = text.replace(pattern, function (wholeMatch, m1, m2) {
+ var codeblock = m1,
+ nextChar = m2,
+ end = '\n';
+
+ codeblock = showdown.subParser('makehtml.outdent')(codeblock, options, globals);
+ codeblock = showdown.subParser('makehtml.encodeCode')(codeblock, options, globals);
+ codeblock = showdown.subParser('makehtml.detab')(codeblock, options, globals);
+ codeblock = codeblock.replace(/^\n+/g, ''); // trim leading newlines
+ codeblock = codeblock.replace(/\n+$/g, ''); // trim trailing newlines
+
+ if (options.omitExtraWLInCodeBlocks) {
+ end = '';
+ }
+
+ codeblock = '
';
+
+ return showdown.subParser('makehtml.hashBlock')(codeblock, options, globals) + nextChar;
+ });
+
+ // strip sentinel
+ text = text.replace(/¨0/, '');
+
+ text = globals.converter._dispatch('makehtml.codeBlocks.after', text, options, globals).getText();
+ return text;
+});
+
+/**
+ *
+ * * Backtick quotes are used for ' + codeblock + end + ' spans.
+ *
+ * * You can use multiple backticks as the delimiters if you want to
+ * include literal backticks in the code span. So, this input:
+ *
+ * Just type ``foo `bar` baz`` at the prompt.
+ *
+ * Will translate to:
+ *
+ * foo `bar` baz at the prompt.`bar` ...
+ */
+showdown.subParser('makehtml.codeSpans', function (text, options, globals) {
+ 'use strict';
+
+ text = globals.converter._dispatch('makehtml.codeSpans.before', text, options, globals).getText();
+
+ if (typeof(text) === 'undefined') {
+ text = '';
+ }
+ text = text.replace(/(^|[^\\])(`+)([^\r]*?[^`])\2(?!`)/gm,
+ function (wholeMatch, m1, m2, m3) {
+ var c = m3;
+ c = c.replace(/^([ \t]*)/g, ''); // leading whitespace
+ c = c.replace(/[ \t]*$/g, ''); // trailing whitespace
+ c = showdown.subParser('makehtml.encodeCode')(c, options, globals);
+ c = m1 + '' + c + '';
+ c = showdown.subParser('makehtml.hashHTMLSpans')(c, options, globals);
+ return c;
+ }
+ );
+
+ text = globals.converter._dispatch('makehtml.codeSpans.after', text, options, globals).getText();
+ return text;
+});
+
+/**
+ * Turn Markdown link shortcuts into XHTML tags.
+ */
+showdown.subParser('makehtml.completeHTMLDocument', function (text, options, globals) {
+ 'use strict';
+
+ if (!options.completeHTMLDocument) {
+ return text;
+ }
+
+ text = globals.converter._dispatch('makehtml.completeHTMLDocument.before', text, options, globals).getText();
+
+ var doctype = 'html',
+ doctypeParsed = '\n',
+ title = '',
+ charset = '\n',
+ lang = '',
+ metadata = '';
+
+ if (typeof globals.metadata.parsed.doctype !== 'undefined') {
+ doctypeParsed = '\n';
+ doctype = globals.metadata.parsed.doctype.toString().toLowerCase();
+ if (doctype === 'html' || doctype === 'html5') {
+ charset = '';
+ }
+ }
+
+ for (var meta in globals.metadata.parsed) {
+ if (globals.metadata.parsed.hasOwnProperty(meta)) {
+ switch (meta.toLowerCase()) {
+ case 'doctype':
+ break;
+
+ case 'title':
+ title = ' elements that should not be parsed as markdown
+ */
+showdown.subParser('makehtml.hashCodeTags', function (text, options, globals) {
+ 'use strict';
+ text = globals.converter._dispatch('makehtml.hashCodeTags.before', text, options, globals).getText();
+
+ var repFunc = function (wholeMatch, match, left, right) {
+ var codeblock = left + showdown.subParser('makehtml.encodeCode')(match, options, globals) + right;
+ return '¨C' + (globals.gHtmlSpans.push(codeblock) - 1) + 'C';
+ };
+
+ // Hash naked
+ text = showdown.helper.replaceRecursiveRegExp(text, repFunc, '', 'gim');
+
+ text = globals.converter._dispatch('makehtml.hashCodeTags.after', text, options, globals).getText();
+ return text;
+});
+
+showdown.subParser('makehtml.hashElement', function (text, options, globals) {
+ 'use strict';
+
+ return function (wholeMatch, m1) {
+ var blockText = m1;
+
+ // Undo double lines
+ blockText = blockText.replace(/\n\n/g, '\n');
+ blockText = blockText.replace(/^\n/, '');
+
+ // strip trailing blank lines
+ blockText = blockText.replace(/\n+$/g, '');
+
+ // Replace the element text with a marker ("¨KxK" where x is its key)
+ blockText = '\n\n¨K' + (globals.gHtmlBlocks.push(blockText) - 1) + 'K\n\n';
+
+ return blockText;
+ };
+});
+
+showdown.subParser('makehtml.hashHTMLBlocks', function (text, options, globals) {
+ 'use strict';
+ text = globals.converter._dispatch('makehtml.hashHTMLBlocks.before', text, options, globals).getText();
+
+ var blockTags = [
+ 'pre',
+ 'div',
+ 'h1',
+ 'h2',
+ 'h3',
+ 'h4',
+ 'h5',
+ 'h6',
+ 'blockquote',
+ 'table',
+ 'dl',
+ 'ol',
+ 'ul',
+ 'script',
+ 'noscript',
+ 'form',
+ 'fieldset',
+ 'iframe',
+ 'math',
+ 'style',
+ 'section',
+ 'header',
+ 'footer',
+ 'nav',
+ 'article',
+ 'aside',
+ 'address',
+ 'audio',
+ 'canvas',
+ 'figure',
+ 'hgroup',
+ 'output',
+ 'video',
+ 'p'
+ ],
+ repFunc = function (wholeMatch, match, left, right) {
+ var txt = wholeMatch;
+ // check if this html element is marked as markdown
+ // if so, it's contents should be parsed as markdown
+ if (left.search(/\bmarkdown\b/) !== -1) {
+ txt = left + globals.converter.makeHtml(match) + right;
+ }
+ return '\n\n¨K' + (globals.gHtmlBlocks.push(txt) - 1) + 'K\n\n';
+ };
+
+ if (options.backslashEscapesHTMLTags) {
+ // encode backslash escaped HTML tags
+ text = text.replace(/\\<(\/?[^>]+?)>/g, function (wm, inside) {
+ return '<' + inside + '>';
+ });
+ }
+
+ // hash HTML Blocks
+ for (var i = 0; i < blockTags.length; ++i) {
+
+ var opTagPos,
+ rgx1 = new RegExp('^ {0,3}(<' + blockTags[i] + '\\b[^>]*>)', 'im'),
+ patLeft = '<' + blockTags[i] + '\\b[^>]*>',
+ patRight = '';
+ // 1. Look for the first position of the first opening HTML tag in the text
+ while ((opTagPos = showdown.helper.regexIndexOf(text, rgx1)) !== -1) {
+
+ // if the HTML tag is \ escaped, we need to escape it and break
+
+
+ //2. Split the text in that position
+ var subTexts = showdown.helper.splitAtIndex(text, opTagPos),
+ //3. Match recursively
+ newSubText1 = showdown.helper.replaceRecursiveRegExp(subTexts[1], repFunc, patLeft, patRight, 'im');
+
+ // prevent an infinite loop
+ if (newSubText1 === subTexts[1]) {
+ break;
+ }
+ text = subTexts[0].concat(newSubText1);
+ }
+ }
+ // HR SPECIAL CASE
+ text = text.replace(/(\n {0,3}(<(hr)\b([^<>])*?\/?>)[ \t]*(?=\n{2,}))/g,
+ showdown.subParser('makehtml.hashElement')(text, options, globals));
+
+ // Special case for standalone HTML comments
+ text = showdown.helper.replaceRecursiveRegExp(text, function (txt) {
+ return '\n\n¨K' + (globals.gHtmlBlocks.push(txt) - 1) + 'K\n\n';
+ }, '^ {0,3}', 'gm');
+
+ // PHP and ASP-style processor instructions ( and <%...%>)
+ text = text.replace(/(?:\n\n)( {0,3}(?:<([?%])[^\r]*?\2>)[ \t]*(?=\n{2,}))/g,
+ showdown.subParser('makehtml.hashElement')(text, options, globals));
+
+ text = globals.converter._dispatch('makehtml.hashHTMLBlocks.after', text, options, globals).getText();
+ return text;
+});
+
+/**
+ * Hash span elements that should not be parsed as markdown
+ */
+showdown.subParser('makehtml.hashHTMLSpans', function (text, options, globals) {
+ 'use strict';
+ text = globals.converter._dispatch('makehtml.hashHTMLSpans.before', text, options, globals).getText();
+
+ // Hash Self Closing tags
+ text = text.replace(/<[^>]+?\/>/gi, function (wm) {
+ return showdown.helper._hashHTMLSpan(wm, globals);
+ });
+
+ // Hash tags without properties
+ text = text.replace(/<([^>]+?)>[\s\S]*?<\/\1>/g, function (wm) {
+ return showdown.helper._hashHTMLSpan(wm, globals);
+ });
+
+ // Hash tags with properties
+ text = text.replace(/<([^>]+?)\s[^>]+?>[\s\S]*?<\/\1>/g, function (wm) {
+ return showdown.helper._hashHTMLSpan(wm, globals);
+ });
+
+ // Hash self closing tags without />
+ text = text.replace(/<[^>]+?>/gi, function (wm) {
+ return showdown.helper._hashHTMLSpan(wm, globals);
+ });
+
+ text = globals.converter._dispatch('makehtml.hashHTMLSpans.after', text, options, globals).getText();
+ return text;
+});
+
+/**
+ * Unhash HTML spans
+ */
+showdown.subParser('makehtml.unhashHTMLSpans', function (text, options, globals) {
+ 'use strict';
+ text = globals.converter._dispatch('makehtml.unhashHTMLSpans.before', text, options, globals).getText();
+
+ for (var i = 0; i < globals.gHtmlSpans.length; ++i) {
+ var repText = globals.gHtmlSpans[i],
+ // limiter to prevent infinite loop (assume 10 as limit for recurse)
+ limit = 0;
+
+ while (/¨C(\d+)C/.test(repText)) {
+ var num = RegExp.$1;
+ repText = repText.replace('¨C' + num + 'C', globals.gHtmlSpans[num]);
+ if (limit === 10) {
+ console.error('maximum nesting of 10 spans reached!!!');
+ break;
+ }
+ ++limit;
+ }
+ text = text.replace('¨C' + i + 'C', repText);
+ }
+
+ text = globals.converter._dispatch('makehtml.unhashHTMLSpans.after', text, options, globals).getText();
+ return text;
+});
+
+/**
+ * Hash and escape elements that should not be parsed as markdown
+ */
+showdown.subParser('makehtml.hashPreCodeTags', function (text, options, globals) {
+ 'use strict';
+ text = globals.converter._dispatch('makehtml.hashPreCodeTags.before', text, options, globals).getText();
+
+ var repFunc = function (wholeMatch, match, left, right) {
+ // encode html entities
+ var codeblock = left + showdown.subParser('makehtml.encodeCode')(match, options, globals) + right;
+ return '\n\n¨G' + (globals.ghCodeBlocks.push({text: wholeMatch, codeblock: codeblock}) - 1) + 'G\n\n';
+ };
+
+ // Hash
', 'gim');
+
+ text = globals.converter._dispatch('makehtml.hashPreCodeTags.after', text, options, globals).getText();
+ return text;
+});
+
+showdown.subParser('makehtml.headers', function (text, options, globals) {
+ 'use strict';
+
+ text = globals.converter._dispatch('makehtml.headers.before', text, options, globals).getText();
+
+ var headerLevelStart = (isNaN(parseInt(options.headerLevelStart))) ? 1 : parseInt(options.headerLevelStart),
+
+ // Set text-style headers:
+ // Header 1
+ // ========
+ //
+ // Header 2
+ // --------
+ //
+ setextRegexH1 = (options.smoothLivePreview) ? /^(.+)[ \t]*\n={2,}[ \t]*\n+/gm : /^(.+)[ \t]*\n=+[ \t]*\n+/gm,
+ setextRegexH2 = (options.smoothLivePreview) ? /^(.+)[ \t]*\n-{2,}[ \t]*\n+/gm : /^(.+)[ \t]*\n-+[ \t]*\n+/gm;
+
+ text = text.replace(setextRegexH1, function (wholeMatch, m1) {
+
+ var spanGamut = showdown.subParser('makehtml.spanGamut')(m1, options, globals),
+ hID = (options.noHeaderId) ? '' : ' id="' + headerId(m1) + '"',
+ hLevel = headerLevelStart,
+ hashBlock = '
+ text = showdown.helper.replaceRecursiveRegExp(text, repFunc, '^ {0,3}\\s*
', options, globals);
+ text = text.replace(/^ {0,2}( ?-){3,}[ \t]*$/gm, key);
+ text = text.replace(/^ {0,2}( ?\*){3,}[ \t]*$/gm, key);
+ text = text.replace(/^ {0,2}( ?_){3,}[ \t]*$/gm, key);
+
+ text = globals.converter._dispatch('makehtml.horizontalRule.after', text, options, globals).getText();
+ return text;
+});
+
+/**
+ * Turn Markdown image shortcuts into tags.
+ */
+showdown.subParser('makehtml.images', function (text, options, globals) {
+ 'use strict';
+
+ text = globals.converter._dispatch('makehtml.images.before', text, options, globals).getText();
+
+ var inlineRegExp = /!\[([^\]]*?)][ \t]*()\([ \t]??(?: =([*\d]+[A-Za-z%]{0,4})x([*\d]+[A-Za-z%]{0,4}))?[ \t]*(?:(["'])([^"]*?)\6)?[ \t]?\)/g,
+ crazyRegExp = /!\[([^\]]*?)][ \t]*()\([ \t]?<([^>]*)>(?: =([*\d]+[A-Za-z%]{0,4})x([*\d]+[A-Za-z%]{0,4}))?[ \t]*(?:(?:(["'])([^"]*?)\6))?[ \t]?\)/g,
+ base64RegExp = /!\[([^\]]*?)][ \t]*()\([ \t]??(?: =([*\d]+[A-Za-z%]{0,4})x([*\d]+[A-Za-z%]{0,4}))?[ \t]*(?:(["'])([^"]*?)\6)?[ \t]?\)/g,
+ referenceRegExp = /!\[([^\]]*?)] ?(?:\n *)?\[([\s\S]*?)]()()()()()/g,
+ refShortcutRegExp = /!\[([^\[\]]+)]()()()()()/g;
+
+ function writeImageTagBase64 (wholeMatch, altText, linkId, url, width, height, m5, title) {
+ url = url.replace(/\s/g, '');
+ return writeImageTag (wholeMatch, altText, linkId, url, width, height, m5, title);
+ }
+
+ function writeImageTag (wholeMatch, altText, linkId, url, width, height, m5, title) {
+
+ var gUrls = globals.gUrls,
+ gTitles = globals.gTitles,
+ gDims = globals.gDimensions;
+
+ linkId = linkId.toLowerCase();
+
+ if (!title) {
+ title = '';
+ }
+ // Special case for explicit empty url
+ if (wholeMatch.search(/\(? ?(['"].*['"])?\)$/m) > -1) {
+ url = '';
+
+ } else if (url === '' || url === null) {
+ if (linkId === '' || linkId === null) {
+ // lower-case and turn embedded newlines into spaces
+ linkId = altText.toLowerCase().replace(/ ?\n/g, ' ');
+ }
+ url = '#' + linkId;
+
+ if (!showdown.helper.isUndefined(gUrls[linkId])) {
+ url = gUrls[linkId];
+ if (!showdown.helper.isUndefined(gTitles[linkId])) {
+ title = gTitles[linkId];
+ }
+ if (!showdown.helper.isUndefined(gDims[linkId])) {
+ width = gDims[linkId].width;
+ height = gDims[linkId].height;
+ }
+ } else {
+ return wholeMatch;
+ }
+ }
+
+ altText = altText
+ .replace(/"/g, '"')
+ //altText = showdown.helper.escapeCharacters(altText, '*_', false);
+ .replace(showdown.helper.regexes.asteriskDashTildeAndColon, showdown.helper.escapeCharactersCallback);
+ //url = showdown.helper.escapeCharacters(url, '*_', false);
+ url = url.replace(showdown.helper.regexes.asteriskDashTildeAndColon, showdown.helper.escapeCharactersCallback);
+ var result = '
x
- - - a
tags + + for (var i = 0; i < end; i++) { + var str = grafs[i]; + // if this is an HTML marker, copy it + if (str.search(/¨(K|G)(\d+)\1/g) >= 0) { + grafsOut.push(str); + + // test for presence of characters to prevent empty lines being parsed + // as paragraphs (resulting in undesired extra empty paragraphs) + } else if (str.search(/\S/) >= 0) { + str = showdown.subParser('makehtml.spanGamut')(str, options, globals); + str = str.replace(/^([ \t]*)/g, '
'); + str += '
'; + grafsOut.push(str); + } + } + + /** Unhashify HTML blocks */ + end = grafsOut.length; + for (i = 0; i < end; i++) { + var blockText = '', + grafsOutIt = grafsOut[i], + codeFlag = false; + // if this is a marker for an html block... + // use RegExp.test instead of string.search because of QML bug + while (/¨(K|G)(\d+)\1/.test(grafsOutIt)) { + var delim = RegExp.$1, + num = RegExp.$2; + + if (delim === 'K') { + blockText = globals.gHtmlBlocks[num]; + } else { + // we need to check if ghBlock is a false positive + if (codeFlag) { + // use encoded version of all text + blockText = showdown.subParser('makehtml.encodeCode')(globals.ghCodeBlocks[num].text, options, globals); + } else { + blockText = globals.ghCodeBlocks[num].codeblock; + } + } + blockText = blockText.replace(/\$/g, '$$$$'); // Escape any dollar signs + + grafsOutIt = grafsOutIt.replace(/(\n\n)?¨(K|G)\d+\2(\n\n)?/, blockText); + // Check if grafsOutIt is a pre->code + if (/^\n'); + } + } else { + // Vanilla hard breaks + text = text.replace(/ +\n/g, '
\n'); + } + + text = globals.converter._dispatch('makehtml.spanGamut.after', text, options, globals).getText(); + return text; +}); + +showdown.subParser('makehtml.strikethrough', function (text, options, globals) { + 'use strict'; + + if (options.strikethrough) { + text = globals.converter._dispatch('makehtml.strikethrough.before', text, options, globals).getText(); + text = text.replace(/(?:~){2}([\s\S]+?)(?:~){2}/g, function (wm, txt) { return '
' + globals.preList[num] + ''; +}); + +showdown.subParser('makeMarkdown.strikethrough', function (node, globals) { + 'use strict'; + + var txt = ''; + if (node.hasChildNodes()) { + txt += '~~'; + var children = node.childNodes, + childrenLength = children.length; + for (var i = 0; i < childrenLength; ++i) { + txt += showdown.subParser('makeMarkdown.node')(children[i], globals); + } + txt += '~~'; + } + return txt; +}); + +showdown.subParser('makeMarkdown.strong', function (node, globals) { + 'use strict'; + + var txt = ''; + if (node.hasChildNodes()) { + txt += '**'; + var children = node.childNodes, + childrenLength = children.length; + for (var i = 0; i < childrenLength; ++i) { + txt += showdown.subParser('makeMarkdown.node')(children[i], globals); + } + txt += '**'; + } + return txt; +}); + +showdown.subParser('makeMarkdown.table', function (node, globals) { + 'use strict'; + + var txt = '', + tableArray = [[], []], + headings = node.querySelectorAll('thead>tr>th'), + rows = node.querySelectorAll('tbody>tr'), + i, ii; + for (i = 0; i < headings.length; ++i) { + var headContent = showdown.subParser('makeMarkdown.tableCell')(headings[i], globals), + allign = '---'; + + if (headings[i].hasAttribute('style')) { + var style = headings[i].getAttribute('style').toLowerCase().replace(/\s/g, ''); + switch (style) { + case 'text-align:left;': + allign = ':---'; + break; + case 'text-align:right;': + allign = '---:'; + break; + case 'text-align:center;': + allign = ':---:'; + break; + } + } + tableArray[0][i] = headContent.trim(); + tableArray[1][i] = allign; + } + + for (i = 0; i < rows.length; ++i) { + var r = tableArray.push([]) - 1, + cols = rows[i].getElementsByTagName('td'); + + for (ii = 0; ii < headings.length; ++ii) { + var cellContent = ' '; + if (typeof cols[ii] !== 'undefined') { + cellContent = showdown.subParser('makeMarkdown.tableCell')(cols[ii], globals); + } + tableArray[r].push(cellContent); + } + } + + var cellSpacesCount = 3; + for (i = 0; i < tableArray.length; ++i) { + for (ii = 0; ii < tableArray[i].length; ++ii) { + var strLen = tableArray[i][ii].length; + if (strLen > cellSpacesCount) { + cellSpacesCount = strLen; + } + } + } + + for (i = 0; i < tableArray.length; ++i) { + for (ii = 0; ii < tableArray[i].length; ++ii) { + if (i === 1) { + if (tableArray[i][ii].slice(-1) === ':') { + tableArray[i][ii] = showdown.helper.padEnd(tableArray[i][ii].slice(-1), cellSpacesCount - 1, '-') + ':'; + } else { + tableArray[i][ii] = showdown.helper.padEnd(tableArray[i][ii], cellSpacesCount, '-'); + } + } else { + tableArray[i][ii] = showdown.helper.padEnd(tableArray[i][ii], cellSpacesCount); + } + } + txt += '| ' + tableArray[i].join(' | ') + ' |\n'; + } + + return txt.trim(); +}); + +showdown.subParser('makeMarkdown.tableCell', function (node, globals) { + 'use strict'; + + var txt = ''; + if (!node.hasChildNodes()) { + return ''; + } + var children = node.childNodes, + childrenLength = children.length; + + for (var i = 0; i < childrenLength; ++i) { + txt += showdown.subParser('makeMarkdown.node')(children[i], globals, true); + } + return txt.trim(); +}); + +showdown.subParser('makeMarkdown.txt', function (node) { + 'use strict'; + + var txt = node.nodeValue; + + // multiple spaces are collapsed + txt = txt.replace(/ +/g, ' '); + + // replace the custom ¨NBSP; with a space + txt = txt.replace(/¨NBSP;/g, ' '); + + // ", <, > and & should replace escaped html entities + txt = showdown.helper.unescapeHTMLEntities(txt); + + // escape markdown magic characters + // emphasis, strong and strikethrough - can appear everywhere + // we also escape pipe (|) because of tables + // and escape ` because of code blocks and spans + txt = txt.replace(/([*_~|`])/g, '\\$1'); + + // escape > because of blockquotes + txt = txt.replace(/^(\s*)>/g, '\\$1>'); + + // hash character, only troublesome at the beginning of a line because of headers + txt = txt.replace(/^#/gm, '\\#'); + + // horizontal rules + txt = txt.replace(/^(\s*)([-=]{3,})(\s*)$/, '$1\\$2$3'); + + // dot, because of ordered lists, only troublesome at the beginning of a line when preceded by an integer + txt = txt.replace(/^( {0,3}\d+)\./gm, '$1\\.'); + + // +, * and -, at the beginning of a line becomes a list, so we need to escape them also (asterisk was already escaped) + txt = txt.replace(/^( {0,3})([+-])/gm, '$1\\$2'); + + // images and links, ] followed by ( is problematic, so we escape it + txt = txt.replace(/]([\s]*)\(/g, '\\]$1\\('); + + // reference URIs must also be escaped + txt = txt.replace(/^ {0,3}\[([\S \t]*?)]:/gm, '\\[$1]:'); + + return txt; +}); + +/** + * Created by Estevao on 31-05-2015. + */ + +/** + * Showdown Converter class + * @class + * @param {object} [converterOptions] + * @returns {Converter} + */ +showdown.Converter = function (converterOptions) { + 'use strict'; + + var + /** + * Options used by this converter + * @private + * @type {{}} + */ + options = {}, + + /** + * Language extensions used by this converter + * @private + * @type {Array} + */ + langExtensions = [], + + /** + * Output modifiers extensions used by this converter + * @private + * @type {Array} + */ + outputModifiers = [], + + /** + * Event listeners + * @private + * @type {{}} + */ + listeners = {}, + + /** + * The flavor set in this converter + */ + setConvFlavor = setFlavor, + + /** + * Metadata of the document + * @type {{parsed: {}, raw: string, format: string}} + */ + metadata = { + parsed: {}, + raw: '', + format: '' + }; + + _constructor(); + + /** + * Converter constructor + * @private + */ + function _constructor () { + converterOptions = converterOptions || {}; + + for (var gOpt in globalOptions) { + if (globalOptions.hasOwnProperty(gOpt)) { + options[gOpt] = globalOptions[gOpt]; + } + } + + // Merge options + if (typeof converterOptions === 'object') { + for (var opt in converterOptions) { + if (converterOptions.hasOwnProperty(opt)) { + options[opt] = converterOptions[opt]; + } + } + } else { + throw Error('Converter expects the passed parameter to be an object, but ' + typeof converterOptions + + ' was passed instead.'); + } + + if (options.extensions) { + showdown.helper.forEach(options.extensions, _parseExtension); + } + } + + /** + * Parse extension + * @param {*} ext + * @param {string} [name=''] + * @private + */ + function _parseExtension (ext, name) { + + name = name || null; + // If it's a string, the extension was previously loaded + if (showdown.helper.isString(ext)) { + ext = showdown.helper.stdExtName(ext); + name = ext; + + // LEGACY_SUPPORT CODE + if (showdown.extensions[ext]) { + console.warn('DEPRECATION WARNING: ' + ext + ' is an old extension that uses a deprecated loading method.' + + 'Please inform the developer that the extension should be updated!'); + legacyExtensionLoading(showdown.extensions[ext], ext); + return; + // END LEGACY SUPPORT CODE + + } else if (!showdown.helper.isUndefined(extensions[ext])) { + ext = extensions[ext]; + + } else { + throw Error('Extension "' + ext + '" could not be loaded. It was either not found or is not a valid extension.'); + } + } + + if (typeof ext === 'function') { + ext = ext(); + } + + if (!showdown.helper.isArray(ext)) { + ext = [ext]; + } + + var validExt = validate(ext, name); + if (!validExt.valid) { + throw Error(validExt.error); + } + + for (var i = 0; i < ext.length; ++i) { + switch (ext[i].type) { + + case 'lang': + langExtensions.push(ext[i]); + break; + + case 'output': + outputModifiers.push(ext[i]); + break; + } + if (ext[i].hasOwnProperty('listeners')) { + for (var ln in ext[i].listeners) { + if (ext[i].listeners.hasOwnProperty(ln)) { + listen(ln, ext[i].listeners[ln]); + } + } + } + } + + } + + /** + * LEGACY_SUPPORT + * @param {*} ext + * @param {string} name + */ + function legacyExtensionLoading (ext, name) { + if (typeof ext === 'function') { + ext = ext(new showdown.Converter()); + } + if (!showdown.helper.isArray(ext)) { + ext = [ext]; + } + var valid = validate(ext, name); + + if (!valid.valid) { + throw Error(valid.error); + } + + for (var i = 0; i < ext.length; ++i) { + switch (ext[i].type) { + case 'lang': + langExtensions.push(ext[i]); + break; + case 'output': + outputModifiers.push(ext[i]); + break; + default:// should never reach here + throw Error('Extension loader error: Type unrecognized!!!'); + } + } + } + + /** + * Listen to an event + * @param {string} name + * @param {function} callback + */ + function listen (name, callback) { + if (!showdown.helper.isString(name)) { + throw Error('Invalid argument in converter.listen() method: name must be a string, but ' + typeof name + ' given'); + } + + if (typeof callback !== 'function') { + throw Error('Invalid argument in converter.listen() method: callback must be a function, but ' + typeof callback + ' given'); + } + name = name.toLowerCase(); + if (!listeners.hasOwnProperty(name)) { + listeners[name] = []; + } + listeners[name].push(callback); + } + + function rTrimInputText (text) { + var rsp = text.match(/^\s*/)[0].length, + rgx = new RegExp('^\\s{0,' + rsp + '}', 'gm'); + return text.replace(rgx, ''); + } + + /** + * + * @param {string} evtName Event name + * @param {string} text Text + * @param {{}} options Converter Options + * @param {{}} globals Converter globals + * @param {{}} pParams extra params for event + * @returns showdown.helper.Event + * @private + */ + this._dispatch = function dispatch (evtName, text, options, globals, pParams) { + evtName = evtName.toLowerCase(); + var params = pParams || {}; + params.converter = this; + params.text = text; + params.options = options; + params.globals = globals; + var event = new showdown.helper.Event(evtName, text, params); + + if (listeners.hasOwnProperty(evtName)) { + for (var ei = 0; ei < listeners[evtName].length; ++ei) { + var nText = listeners[evtName][ei](event); + if (nText && typeof nText !== 'undefined') { + event.setText(nText); + } + } + } + return event; + }; + + /** + * Listen to an event + * @param {string} name + * @param {function} callback + * @returns {showdown.Converter} + */ + this.listen = function (name, callback) { + listen(name, callback); + return this; + }; + + /** + * Converts a markdown string into HTML string + * @param {string} text + * @returns {*} + */ + this.makeHtml = function (text) { + //check if text is not falsy + if (!text) { + return text; + } + + var globals = { + gHtmlBlocks: [], + gHtmlMdBlocks: [], + gHtmlSpans: [], + gUrls: {}, + gTitles: {}, + gDimensions: {}, + gListLevel: 0, + hashLinkCounts: {}, + langExtensions: langExtensions, + outputModifiers: outputModifiers, + converter: this, + ghCodeBlocks: [], + metadata: { + parsed: {}, + raw: '', + format: '' + } + }; + + // This lets us use ¨ trema as an escape char to avoid md5 hashes + // The choice of character is arbitrary; anything that isn't + // magic in Markdown will work. + text = text.replace(/¨/g, '¨T'); + + // Replace $ with ¨D + // RegExp interprets $ as a special character + // when it's in a replacement string + text = text.replace(/\$/g, '¨D'); + + // Standardize line endings + text = text.replace(/\r\n/g, '\n'); // DOS to Unix + text = text.replace(/\r/g, '\n'); // Mac to Unix + + // Stardardize line spaces + text = text.replace(/\u00A0/g, ' '); + + if (options.smartIndentationFix) { + text = rTrimInputText(text); + } + + // Make sure text begins and ends with a couple of newlines: + text = '\n\n' + text + '\n\n'; + + // detab + text = showdown.subParser('makehtml.detab')(text, options, globals); + + /** + * Strip any lines consisting only of spaces and tabs. + * This makes subsequent regexs easier to write, because we can + * match consecutive blank lines with /\n+/ instead of something + * contorted like /[ \t]*\n+/ + */ + text = text.replace(/^[ \t]+$/mg, ''); + + //run languageExtensions + showdown.helper.forEach(langExtensions, function (ext) { + text = showdown.subParser('makehtml.runExtension')(ext, text, options, globals); + }); + + // run the sub parsers + text = showdown.subParser('makehtml.metadata')(text, options, globals); + text = showdown.subParser('makehtml.hashPreCodeTags')(text, options, globals); + text = showdown.subParser('makehtml.githubCodeBlocks')(text, options, globals); + text = showdown.subParser('makehtml.hashHTMLBlocks')(text, options, globals); + text = showdown.subParser('makehtml.hashCodeTags')(text, options, globals); + text = showdown.subParser('makehtml.stripLinkDefinitions')(text, options, globals); + text = showdown.subParser('makehtml.blockGamut')(text, options, globals); + text = showdown.subParser('makehtml.unhashHTMLSpans')(text, options, globals); + text = showdown.subParser('makehtml.unescapeSpecialChars')(text, options, globals); + + // attacklab: Restore dollar signs + text = text.replace(/¨D/g, '$$'); + + // attacklab: Restore tremas + text = text.replace(/¨T/g, '¨'); + + // render a complete html document instead of a partial if the option is enabled + text = showdown.subParser('makehtml.completeHTMLDocument')(text, options, globals); + + // Run output modifiers + showdown.helper.forEach(outputModifiers, function (ext) { + text = showdown.subParser('makehtml.runExtension')(ext, text, options, globals); + }); + + // update metadata + metadata = globals.metadata; + return text; + }; + + /** + * Converts an HTML string into a markdown string + * @param src + * @returns {string} + */ + this.makeMarkdown = function (src) { + + // replace \r\n with \n + src = src.replace(/\r\n/g, '\n'); + src = src.replace(/\r/g, '\n'); // old macs + + // due to an edge case, we need to find this: > < + // to prevent removing of non silent white spaces + // ex: this is sparta + src = src.replace(/>[ \t]+¨NBSP;<'); + + var doc = showdown.helper.document.createElement('div'); + doc.innerHTML = src; + + var globals = { + preList: substitutePreCodeTags(doc) + }; + + // remove all newlines and collapse spaces + clean(doc); + + // some stuff, like accidental reference links must now be escaped + // TODO + // doc.innerHTML = doc.innerHTML.replace(/\[[\S\t ]]/); + + var nodes = doc.childNodes, + mdDoc = ''; + + for (var i = 0; i < nodes.length; i++) { + mdDoc += showdown.subParser('makeMarkdown.node')(nodes[i], globals); + } + + function clean (node) { + for (var n = 0; n < node.childNodes.length; ++n) { + var child = node.childNodes[n]; + if (child.nodeType === 3) { + if (!/\S/.test(child.nodeValue)) { + node.removeChild(child); + --n; + } else { + child.nodeValue = child.nodeValue.split('\n').join(' '); + child.nodeValue = child.nodeValue.replace(/(\s)+/g, '$1'); + } + } else if (child.nodeType === 1) { + clean(child); + } + } + } + + // find all pre tags and replace contents with placeholder + // we need this so that we can remove all indentation from html + // to ease up parsing + function substitutePreCodeTags (doc) { + + var pres = doc.querySelectorAll('pre'), + presPH = []; + + for (var i = 0; i < pres.length; ++i) { + + if (pres[i].childElementCount === 1 && pres[i].firstChild.tagName.toLowerCase() === 'code') { + var content = pres[i].firstChild.innerHTML.trim(), + language = pres[i].firstChild.getAttribute('data-language') || ''; + + // if data-language attribute is not defined, then we look for class language-* + if (language === '') { + var classes = pres[i].firstChild.className.split(' '); + for (var c = 0; c < classes.length; ++c) { + var matches = classes[c].match(/^language-(.+)$/); + if (matches !== null) { + language = matches[1]; + break; + } + } + } + + // unescape html entities in content + content = showdown.helper.unescapeHTMLEntities(content); + + presPH.push(content); + pres[i].outerHTML = '
(GFM Style)',\n type: 'boolean'\n },\n requireSpaceBeforeHeadingText: {\n defaultValue: false,\n description: 'Makes adding a space between `#` and the header text mandatory (GFM Style)',\n type: 'boolean'\n },\n ghMentions: {\n defaultValue: false,\n description: 'Enables github @mentions',\n type: 'boolean'\n },\n ghMentionsLink: {\n defaultValue: 'https://github.com/{u}',\n description: 'Changes the link generated by @mentions. Only applies if ghMentions option is enabled.',\n type: 'string'\n },\n encodeEmails: {\n defaultValue: true,\n description: 'Encode e-mail addresses through the use of Character Entities, transforming ASCII e-mail addresses into its equivalent decimal entities',\n type: 'boolean'\n },\n openLinksInNewWindow: {\n defaultValue: false,\n description: 'Open all links in new windows',\n type: 'boolean'\n },\n backslashEscapesHTMLTags: {\n defaultValue: false,\n description: 'Support for HTML Tag escaping. ex: \\
![](\"https://assets-cdn.github.com/images/icons/emoji/octocat.png\"){kind=icon}
',\n 'showdown': 'tags around block-level tags.\n text = showdown.subParser('makehtml.hashHTMLBlocks')(text, options, globals);\n text = showdown.subParser('makehtml.paragraphs')(text, options, globals);\n\n text = globals.converter._dispatch('makehtml.blockGamut.after', text, options, globals).getText();\n\n return text;\n});\n","showdown.subParser('makehtml.blockQuotes', function (text, options, globals) {\n 'use strict';\n\n text = globals.converter._dispatch('makehtml.blockQuotes.before', text, options, globals).getText();\n\n // add a couple extra lines after the text and endtext mark\n text = text + '\\n\\n';\n\n var rgx = /(^ {0,3}>[ \\t]?.+\\n(.+\\n)*\\n*)+/gm;\n\n if (options.splitAdjacentBlockquotes) {\n rgx = /^ {0,3}>[\\s\\S]*?(?:\\n\\n)/gm;\n }\n\n text = text.replace(rgx, function (bq) {\n // attacklab: hack around Konqueror 3.5.4 bug:\n // \"----------bug\".replace(/^-/g,\"\") == \"bug\"\n bq = bq.replace(/^[ \\t]*>[ \\t]?/gm, ''); // trim one level of quoting\n\n // attacklab: clean up hack\n bq = bq.replace(/¨0/g, '');\n\n bq = bq.replace(/^[ \\t]+$/gm, ''); // trim whitespace-only lines\n bq = showdown.subParser('makehtml.githubCodeBlocks')(bq, options, globals);\n bq = showdown.subParser('makehtml.blockGamut')(bq, options, globals); // recurse\n\n bq = bq.replace(/(^|\\n)/g, '$1 ');\n // These leading spaces screw with
content, so we need to fix that:\n bq = bq.replace(/(\\s*[^\\r]+?<\\/pre>)/gm, function (wholeMatch, m1) {\n var pre = m1;\n // attacklab: hack around Konqueror 3.5.4 bug:\n pre = pre.replace(/^ /mg, '¨0');\n pre = pre.replace(/¨0/g, '');\n return pre;\n });\n\n return showdown.subParser('makehtml.hashBlock')('\\n' + bq + '\\n
', options, globals);\n });\n\n text = globals.converter._dispatch('makehtml.blockQuotes.after', text, options, globals).getText();\n return text;\n});\n","/**\n * Process Markdown `` blocks.\n */\nshowdown.subParser('makehtml.codeBlocks', function (text, options, globals) {\n 'use strict';\n\n text = globals.converter._dispatch('makehtml.codeBlocks.before', text, options, globals).getText();\n\n // sentinel workarounds for lack of \\A and \\Z, safari\\khtml bug\n text += '¨0';\n\n var pattern = /(?:\\n\\n|^)((?:(?:[ ]{4}|\\t).*\\n+)+)(\\n*[ ]{0,3}[^ \\t\\n]|(?=¨0))/g;\n text = text.replace(pattern, function (wholeMatch, m1, m2) {\n var codeblock = m1,\n nextChar = m2,\n end = '\\n';\n\n codeblock = showdown.subParser('makehtml.outdent')(codeblock, options, globals);\n codeblock = showdown.subParser('makehtml.encodeCode')(codeblock, options, globals);\n codeblock = showdown.subParser('makehtml.detab')(codeblock, options, globals);\n codeblock = codeblock.replace(/^\\n+/g, ''); // trim leading newlines\n codeblock = codeblock.replace(/\\n+$/g, ''); // trim trailing newlines\n\n if (options.omitExtraWLInCodeBlocks) {\n end = '';\n }\n\n codeblock = '' + codeblock + end + '
';\n\n return showdown.subParser('makehtml.hashBlock')(codeblock, options, globals) + nextChar;\n });\n\n // strip sentinel\n text = text.replace(/¨0/, '');\n\n text = globals.converter._dispatch('makehtml.codeBlocks.after', text, options, globals).getText();\n return text;\n});\n","/**\n *\n * * Backtick quotes are used for Just type foo `bar` baz at the prompt.
\n *\n * There's no arbitrary limit to the number of backticks you\n * can use as delimters. If you need three consecutive backticks\n * in your code, use four for delimiters, etc.\n *\n * * You can use spaces to get literal backticks at the edges:\n *\n * ... type `` `bar` `` ...\n *\n * Turns to:\n *\n * ... type `bar` ...\n */\nshowdown.subParser('makehtml.codeSpans', function (text, options, globals) {\n 'use strict';\n\n text = globals.converter._dispatch('makehtml.codeSpans.before', text, options, globals).getText();\n\n if (typeof(text) === 'undefined') {\n text = '';\n }\n text = text.replace(/(^|[^\\\\])(`+)([^\\r]*?[^`])\\2(?!`)/gm,\n function (wholeMatch, m1, m2, m3) {\n var c = m3;\n c = c.replace(/^([ \\t]*)/g, '');\t// leading whitespace\n c = c.replace(/[ \\t]*$/g, '');\t// trailing whitespace\n c = showdown.subParser('makehtml.encodeCode')(c, options, globals);\n c = m1 + '' + c + '';\n c = showdown.subParser('makehtml.hashHTMLSpans')(c, options, globals);\n return c;\n }\n );\n\n text = globals.converter._dispatch('makehtml.codeSpans.after', text, options, globals).getText();\n return text;\n});\n","/**\n * Turn Markdown link shortcuts into XHTML tags.\n */\nshowdown.subParser('makehtml.completeHTMLDocument', function (text, options, globals) {\n 'use strict';\n\n if (!options.completeHTMLDocument) {\n return text;\n }\n\n text = globals.converter._dispatch('makehtml.completeHTMLDocument.before', text, options, globals).getText();\n\n var doctype = 'html',\n doctypeParsed = '\\n',\n title = '',\n charset = '\\n',\n lang = '',\n metadata = '';\n\n if (typeof globals.metadata.parsed.doctype !== 'undefined') {\n doctypeParsed = '\\n';\n doctype = globals.metadata.parsed.doctype.toString().toLowerCase();\n if (doctype === 'html' || doctype === 'html5') {\n charset = '';\n }\n }\n\n for (var meta in globals.metadata.parsed) {\n if (globals.metadata.parsed.hasOwnProperty(meta)) {\n switch (meta.toLowerCase()) {\n case 'doctype':\n break;\n\n case 'title':\n title = '' + globals.metadata.parsed.title + ' \\n';\n break;\n\n case 'charset':\n if (doctype === 'html' || doctype === 'html5') {\n charset = '\\n';\n } else {\n charset = '\\n';\n }\n break;\n\n case 'language':\n case 'lang':\n lang = ' lang=\"' + globals.metadata.parsed[meta] + '\"';\n metadata += '\\n';\n break;\n\n default:\n metadata += '\\n';\n }\n }\n }\n\n text = doctypeParsed + '\\n\\n' + title + charset + metadata + '\\n\\n' + text.trim() + '\\n\\n';\n\n text = globals.converter._dispatch('makehtml.completeHTMLDocument.after', text, options, globals).getText();\n return text;\n});\n","/**\n * Convert all tabs to spaces\n */\nshowdown.subParser('makehtml.detab', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('makehtml.detab.before', text, options, globals).getText();\n\n // expand first n-1 tabs\n text = text.replace(/\\t(?=\\t)/g, ' '); // g_tab_width\n\n // replace the nth with two sentinels\n text = text.replace(/\\t/g, '¨A¨B');\n\n // use the sentinel to anchor our regex so it doesn't explode\n text = text.replace(/¨B(.+?)¨A/g, function (wholeMatch, m1) {\n var leadingText = m1,\n numSpaces = 4 - leadingText.length % 4; // g_tab_width\n\n // there *must* be a better way to do this:\n for (var i = 0; i < numSpaces; i++) {\n leadingText += ' ';\n }\n\n return leadingText;\n });\n\n // clean up sentinels\n text = text.replace(/¨A/g, ' '); // g_tab_width\n text = text.replace(/¨B/g, '');\n\n text = globals.converter._dispatch('makehtml.detab.after', text, options, globals).getText();\n return text;\n});\n","showdown.subParser('makehtml.ellipsis', function (text, options, globals) {\n 'use strict';\n\n text = globals.converter._dispatch('makehtml.ellipsis.before', text, options, globals).getText();\n\n text = text.replace(/\\.\\.\\./g, '…');\n\n text = globals.converter._dispatch('makehtml.ellipsis.after', text, options, globals).getText();\n\n return text;\n});\n","/**\n * These are all the transformations that occur *within* block-level\n * tags like paragraphs, headers, and list items.\n */\nshowdown.subParser('makehtml.emoji', function (text, options, globals) {\n 'use strict';\n\n if (!options.emoji) {\n return text;\n }\n\n text = globals.converter._dispatch('makehtml.emoji.before', text, options, globals).getText();\n\n var emojiRgx = /:([\\S]+?):/g;\n\n text = text.replace(emojiRgx, function (wm, emojiCode) {\n if (showdown.helper.emojis.hasOwnProperty(emojiCode)) {\n return showdown.helper.emojis[emojiCode];\n }\n return wm;\n });\n\n text = globals.converter._dispatch('makehtml.emoji.after', text, options, globals).getText();\n\n return text;\n});\n","/**\n * Smart processing for ampersands and angle brackets that need to be encoded.\n */\nshowdown.subParser('makehtml.encodeAmpsAndAngles', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('makehtml.encodeAmpsAndAngles.before', text, options, globals).getText();\n\n // Ampersand-encoding based entirely on Nat Irons's Amputator MT plugin:\n // http://bumppo.net/projects/amputator/\n text = text.replace(/&(?!#?[xX]?(?:[0-9a-fA-F]+|\\w+);)/g, '&');\n\n // Encode naked <'s\n text = text.replace(/<(?![a-z\\/?$!])/gi, '<');\n\n // Encode <\n text = text.replace(/\n text = text.replace(/>/g, '>');\n\n text = globals.converter._dispatch('makehtml.encodeAmpsAndAngles.after', text, options, globals).getText();\n return text;\n});\n","/**\n * Returns the string, with after processing the following backslash escape sequences.\n *\n * attacklab: The polite way to do this is with the new escapeCharacters() function:\n *\n * text = escapeCharacters(text,\"\\\\\",true);\n * text = escapeCharacters(text,\"`*_{}[]()>#+-.!\",true);\n *\n * ...but we're sidestepping its use of the (slow) RegExp constructor\n * as an optimization for Firefox. This function gets called a LOT.\n */\nshowdown.subParser('makehtml.encodeBackslashEscapes', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('makehtml.encodeBackslashEscapes.before', text, options, globals).getText();\n\n text = text.replace(/\\\\(\\\\)/g, showdown.helper.escapeCharactersCallback);\n text = text.replace(/\\\\([`*_{}\\[\\]()>#+.!~=|:-])/g, showdown.helper.escapeCharactersCallback);\n\n text = globals.converter._dispatch('makehtml.encodeBackslashEscapes.after', text, options, globals).getText();\n return text;\n});\n","/**\n * Encode/escape certain characters inside Markdown code runs.\n * The point is that in code, these characters are literals,\n * and lose their special Markdown meanings.\n */\nshowdown.subParser('makehtml.encodeCode', function (text, options, globals) {\n 'use strict';\n\n text = globals.converter._dispatch('makehtml.encodeCode.before', text, options, globals).getText();\n\n // Encode all ampersands; HTML entities are not\n // entities within a Markdown code span.\n text = text\n .replace(/&/g, '&')\n // Do the angle bracket song and dance:\n .replace(//g, '>')\n // Now, escape characters that are magic in Markdown:\n .replace(/([*_{}\\[\\]\\\\=~-])/g, showdown.helper.escapeCharactersCallback);\n\n text = globals.converter._dispatch('makehtml.encodeCode.after', text, options, globals).getText();\n return text;\n});\n","/**\n * Within tags -- meaning between < and > -- encode [\\ ` * _ ~ =] so they\n * don't conflict with their use in Markdown for code, italics and strong.\n */\nshowdown.subParser('makehtml.escapeSpecialCharsWithinTagAttributes', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('makehtml.escapeSpecialCharsWithinTagAttributes.before', text, options, globals).getText();\n\n // Build a regex to find HTML tags.\n var tags = /<\\/?[a-z\\d_:-]+(?:[\\s]+[\\s\\S]+?)?>/gi,\n comments = /-]|-[^>])(?:[^-]|-[^-])*)--)>/gi;\n\n text = text.replace(tags, function (wholeMatch) {\n return wholeMatch\n .replace(/(.)<\\/?code>(?=.)/g, '$1`')\n .replace(/([\\\\`*_~=|])/g, showdown.helper.escapeCharactersCallback);\n });\n\n text = text.replace(comments, function (wholeMatch) {\n return wholeMatch\n .replace(/([\\\\`*_~=|])/g, showdown.helper.escapeCharactersCallback);\n });\n\n text = globals.converter._dispatch('makehtml.escapeSpecialCharsWithinTagAttributes.after', text, options, globals).getText();\n return text;\n});\n","/**\n * Handle github codeblocks prior to running HashHTML so that\n * HTML contained within the codeblock gets escaped properly\n * Example:\n * ```ruby\n * def hello_world(x)\n * puts \"Hello, #{x}\"\n * end\n * ```\n */\nshowdown.subParser('makehtml.githubCodeBlocks', function (text, options, globals) {\n 'use strict';\n\n // early exit if option is not enabled\n if (!options.ghCodeBlocks) {\n return text;\n }\n\n text = globals.converter._dispatch('makehtml.githubCodeBlocks.before', text, options, globals).getText();\n\n text += '¨0';\n\n text = text.replace(/(?:^|\\n)(?: {0,3})(```+|~~~+)(?: *)([^\\s`~]*)\\n([\\s\\S]*?)\\n(?: {0,3})\\1/g, function (wholeMatch, delim, language, codeblock) {\n var end = (options.omitExtraWLInCodeBlocks) ? '' : '\\n';\n\n // First parse the github code block\n codeblock = showdown.subParser('makehtml.encodeCode')(codeblock, options, globals);\n codeblock = showdown.subParser('makehtml.detab')(codeblock, options, globals);\n codeblock = codeblock.replace(/^\\n+/g, ''); // trim leading newlines\n codeblock = codeblock.replace(/\\n+$/g, ''); // trim trailing whitespace\n\n codeblock = '' + codeblock + end + '
';\n\n codeblock = showdown.subParser('makehtml.hashBlock')(codeblock, options, globals);\n\n // Since GHCodeblocks can be false positives, we need to\n // store the primitive text and the parsed text in a global var,\n // and then return a token\n return '\\n\\n¨G' + (globals.ghCodeBlocks.push({text: wholeMatch, codeblock: codeblock}) - 1) + 'G\\n\\n';\n });\n\n // attacklab: strip sentinel\n text = text.replace(/¨0/, '');\n\n return globals.converter._dispatch('makehtml.githubCodeBlocks.after', text, options, globals).getText();\n});\n","showdown.subParser('makehtml.hashBlock', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('makehtml.hashBlock.before', text, options, globals).getText();\n text = text.replace(/(^\\n+|\\n+$)/g, '');\n text = '\\n\\n¨K' + (globals.gHtmlBlocks.push(text) - 1) + 'K\\n\\n';\n text = globals.converter._dispatch('makehtml.hashBlock.after', text, options, globals).getText();\n return text;\n});\n","/**\n * Hash and escape elements that should not be parsed as markdown\n */\nshowdown.subParser('makehtml.hashCodeTags', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('makehtml.hashCodeTags.before', text, options, globals).getText();\n\n var repFunc = function (wholeMatch, match, left, right) {\n var codeblock = left + showdown.subParser('makehtml.encodeCode')(match, options, globals) + right;\n return '¨C' + (globals.gHtmlSpans.push(codeblock) - 1) + 'C';\n };\n\n // Hash naked \n text = showdown.helper.replaceRecursiveRegExp(text, repFunc, ']*>', ' ', 'gim');\n\n text = globals.converter._dispatch('makehtml.hashCodeTags.after', text, options, globals).getText();\n return text;\n});\n","showdown.subParser('makehtml.hashElement', function (text, options, globals) {\n 'use strict';\n\n return function (wholeMatch, m1) {\n var blockText = m1;\n\n // Undo double lines\n blockText = blockText.replace(/\\n\\n/g, '\\n');\n blockText = blockText.replace(/^\\n/, '');\n\n // strip trailing blank lines\n blockText = blockText.replace(/\\n+$/g, '');\n\n // Replace the element text with a marker (\"¨KxK\" where x is its key)\n blockText = '\\n\\n¨K' + (globals.gHtmlBlocks.push(blockText) - 1) + 'K\\n\\n';\n\n return blockText;\n };\n});\n","showdown.subParser('makehtml.hashHTMLBlocks', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('makehtml.hashHTMLBlocks.before', text, options, globals).getText();\n\n var blockTags = [\n 'pre',\n 'div',\n 'h1',\n 'h2',\n 'h3',\n 'h4',\n 'h5',\n 'h6',\n 'blockquote',\n 'table',\n 'dl',\n 'ol',\n 'ul',\n 'script',\n 'noscript',\n 'form',\n 'fieldset',\n 'iframe',\n 'math',\n 'style',\n 'section',\n 'header',\n 'footer',\n 'nav',\n 'article',\n 'aside',\n 'address',\n 'audio',\n 'canvas',\n 'figure',\n 'hgroup',\n 'output',\n 'video',\n 'p'\n ],\n repFunc = function (wholeMatch, match, left, right) {\n var txt = wholeMatch;\n // check if this html element is marked as markdown\n // if so, it's contents should be parsed as markdown\n if (left.search(/\\bmarkdown\\b/) !== -1) {\n txt = left + globals.converter.makeHtml(match) + right;\n }\n return '\\n\\n¨K' + (globals.gHtmlBlocks.push(txt) - 1) + 'K\\n\\n';\n };\n\n if (options.backslashEscapesHTMLTags) {\n // encode backslash escaped HTML tags\n text = text.replace(/\\\\<(\\/?[^>]+?)>/g, function (wm, inside) {\n return '<' + inside + '>';\n });\n }\n\n // hash HTML Blocks\n for (var i = 0; i < blockTags.length; ++i) {\n\n var opTagPos,\n rgx1 = new RegExp('^ {0,3}(<' + blockTags[i] + '\\\\b[^>]*>)', 'im'),\n patLeft = '<' + blockTags[i] + '\\\\b[^>]*>',\n patRight = '';\n // 1. Look for the first position of the first opening HTML tag in the text\n while ((opTagPos = showdown.helper.regexIndexOf(text, rgx1)) !== -1) {\n\n // if the HTML tag is \\ escaped, we need to escape it and break\n\n\n //2. Split the text in that position\n var subTexts = showdown.helper.splitAtIndex(text, opTagPos),\n //3. Match recursively\n newSubText1 = showdown.helper.replaceRecursiveRegExp(subTexts[1], repFunc, patLeft, patRight, 'im');\n\n // prevent an infinite loop\n if (newSubText1 === subTexts[1]) {\n break;\n }\n text = subTexts[0].concat(newSubText1);\n }\n }\n // HR SPECIAL CASE\n text = text.replace(/(\\n {0,3}(<(hr)\\b([^<>])*?\\/?>)[ \\t]*(?=\\n{2,}))/g,\n showdown.subParser('makehtml.hashElement')(text, options, globals));\n\n // Special case for standalone HTML comments\n text = showdown.helper.replaceRecursiveRegExp(text, function (txt) {\n return '\\n\\n¨K' + (globals.gHtmlBlocks.push(txt) - 1) + 'K\\n\\n';\n }, '^ {0,3}', 'gm');\n\n // PHP and ASP-style processor instructions ( and <%...%>)\n text = text.replace(/(?:\\n\\n)( {0,3}(?:<([?%])[^\\r]*?\\2>)[ \\t]*(?=\\n{2,}))/g,\n showdown.subParser('makehtml.hashElement')(text, options, globals));\n\n text = globals.converter._dispatch('makehtml.hashHTMLBlocks.after', text, options, globals).getText();\n return text;\n});\n","/**\n * Hash span elements that should not be parsed as markdown\n */\nshowdown.subParser('makehtml.hashHTMLSpans', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('makehtml.hashHTMLSpans.before', text, options, globals).getText();\n\n // Hash Self Closing tags\n text = text.replace(/<[^>]+?\\/>/gi, function (wm) {\n return showdown.helper._hashHTMLSpan(wm, globals);\n });\n\n // Hash tags without properties\n text = text.replace(/<([^>]+?)>[\\s\\S]*?<\\/\\1>/g, function (wm) {\n return showdown.helper._hashHTMLSpan(wm, globals);\n });\n\n // Hash tags with properties\n text = text.replace(/<([^>]+?)\\s[^>]+?>[\\s\\S]*?<\\/\\1>/g, function (wm) {\n return showdown.helper._hashHTMLSpan(wm, globals);\n });\n\n // Hash self closing tags without />\n text = text.replace(/<[^>]+?>/gi, function (wm) {\n return showdown.helper._hashHTMLSpan(wm, globals);\n });\n\n text = globals.converter._dispatch('makehtml.hashHTMLSpans.after', text, options, globals).getText();\n return text;\n});\n\n/**\n * Unhash HTML spans\n */\nshowdown.subParser('makehtml.unhashHTMLSpans', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('makehtml.unhashHTMLSpans.before', text, options, globals).getText();\n\n for (var i = 0; i < globals.gHtmlSpans.length; ++i) {\n var repText = globals.gHtmlSpans[i],\n // limiter to prevent infinite loop (assume 10 as limit for recurse)\n limit = 0;\n\n while (/¨C(\\d+)C/.test(repText)) {\n var num = RegExp.$1;\n repText = repText.replace('¨C' + num + 'C', globals.gHtmlSpans[num]);\n if (limit === 10) {\n console.error('maximum nesting of 10 spans reached!!!');\n break;\n }\n ++limit;\n }\n text = text.replace('¨C' + i + 'C', repText);\n }\n\n text = globals.converter._dispatch('makehtml.unhashHTMLSpans.after', text, options, globals).getText();\n return text;\n});\n","/**\n * Hash and escape elements that should not be parsed as markdown\n */\nshowdown.subParser('makehtml.hashPreCodeTags', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('makehtml.hashPreCodeTags.before', text, options, globals).getText();\n\n var repFunc = function (wholeMatch, match, left, right) {\n // encode html entities\n var codeblock = left + showdown.subParser('makehtml.encodeCode')(match, options, globals) + right;\n return '\\n\\n¨G' + (globals.ghCodeBlocks.push({text: wholeMatch, codeblock: codeblock}) - 1) + 'G\\n\\n';\n };\n\n // Hash \n text = showdown.helper.replaceRecursiveRegExp(text, repFunc, '^ {0,3}]*>\\\\s*]*>', '^ {0,3} \\\\s*
', 'gim');\n\n text = globals.converter._dispatch('makehtml.hashPreCodeTags.after', text, options, globals).getText();\n return text;\n});\n","showdown.subParser('makehtml.headers', function (text, options, globals) {\n 'use strict';\n\n text = globals.converter._dispatch('makehtml.headers.before', text, options, globals).getText();\n\n var headerLevelStart = (isNaN(parseInt(options.headerLevelStart))) ? 1 : parseInt(options.headerLevelStart),\n\n // Set text-style headers:\n //\tHeader 1\n //\t========\n //\n //\tHeader 2\n //\t--------\n //\n setextRegexH1 = (options.smoothLivePreview) ? /^(.+)[ \\t]*\\n={2,}[ \\t]*\\n+/gm : /^(.+)[ \\t]*\\n=+[ \\t]*\\n+/gm,\n setextRegexH2 = (options.smoothLivePreview) ? /^(.+)[ \\t]*\\n-{2,}[ \\t]*\\n+/gm : /^(.+)[ \\t]*\\n-+[ \\t]*\\n+/gm;\n\n text = text.replace(setextRegexH1, function (wholeMatch, m1) {\n\n var spanGamut = showdown.subParser('makehtml.spanGamut')(m1, options, globals),\n hID = (options.noHeaderId) ? '' : ' id=\"' + headerId(m1) + '\"',\n hLevel = headerLevelStart,\n hashBlock = '' + spanGamut + ' ';\n return showdown.subParser('makehtml.hashBlock')(hashBlock, options, globals);\n });\n\n text = text.replace(setextRegexH2, function (matchFound, m1) {\n var spanGamut = showdown.subParser('makehtml.spanGamut')(m1, options, globals),\n hID = (options.noHeaderId) ? '' : ' id=\"' + headerId(m1) + '\"',\n hLevel = headerLevelStart + 1,\n hashBlock = '' + spanGamut + ' ';\n return showdown.subParser('makehtml.hashBlock')(hashBlock, options, globals);\n });\n\n // atx-style headers:\n // # Header 1\n // ## Header 2\n // ## Header 2 with closing hashes ##\n // ...\n // ###### Header 6\n //\n var atxStyle = (options.requireSpaceBeforeHeadingText) ? /^(#{1,6})[ \\t]+(.+?)[ \\t]*#*\\n+/gm : /^(#{1,6})[ \\t]*(.+?)[ \\t]*#*\\n+/gm;\n\n text = text.replace(atxStyle, function (wholeMatch, m1, m2) {\n var hText = m2;\n if (options.customizedHeaderId) {\n hText = m2.replace(/\\s?\\{([^{]+?)}\\s*$/, '');\n }\n\n var span = showdown.subParser('makehtml.spanGamut')(hText, options, globals),\n hID = (options.noHeaderId) ? '' : ' id=\"' + headerId(m2) + '\"',\n hLevel = headerLevelStart - 1 + m1.length,\n header = '' + span + ' ';\n\n return showdown.subParser('makehtml.hashBlock')(header, options, globals);\n });\n\n function headerId (m) {\n var title,\n prefix;\n\n // It is separate from other options to allow combining prefix and customized\n if (options.customizedHeaderId) {\n var match = m.match(/\\{([^{]+?)}\\s*$/);\n if (match && match[1]) {\n m = match[1];\n }\n }\n\n title = m;\n\n // Prefix id to prevent causing inadvertent pre-existing style matches.\n if (showdown.helper.isString(options.prefixHeaderId)) {\n prefix = options.prefixHeaderId;\n } else if (options.prefixHeaderId === true) {\n prefix = 'section-';\n } else {\n prefix = '';\n }\n\n if (!options.rawPrefixHeaderId) {\n title = prefix + title;\n }\n\n if (options.ghCompatibleHeaderId) {\n title = title\n .replace(/ /g, '-')\n // replace previously escaped chars (&, ¨ and $)\n .replace(/&/g, '')\n .replace(/¨T/g, '')\n .replace(/¨D/g, '')\n // replace rest of the chars (&~$ are repeated as they might have been escaped)\n // borrowed from github's redcarpet (some they should produce similar results)\n .replace(/[&+$,\\/:;=?@\"#{}|^¨~\\[\\]`\\\\*)(%.!'<>]/g, '')\n .toLowerCase();\n } else if (options.rawHeaderId) {\n title = title\n .replace(/ /g, '-')\n // replace previously escaped chars (&, ¨ and $)\n .replace(/&/g, '&')\n .replace(/¨T/g, '¨')\n .replace(/¨D/g, '$')\n // replace \" and '\n .replace(/[\"']/g, '-')\n .toLowerCase();\n } else {\n title = title\n .replace(/[^\\w]/g, '')\n .toLowerCase();\n }\n\n if (options.rawPrefixHeaderId) {\n title = prefix + title;\n }\n\n if (globals.hashLinkCounts[title]) {\n title = title + '-' + (globals.hashLinkCounts[title]++);\n } else {\n globals.hashLinkCounts[title] = 1;\n }\n return title;\n }\n\n text = globals.converter._dispatch('makehtml.headers.after', text, options, globals).getText();\n return text;\n});\n","/**\n * Turn Markdown link shortcuts into XHTML tags.\n */\nshowdown.subParser('makehtml.horizontalRule', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('makehtml.horizontalRule.before', text, options, globals).getText();\n\n var key = showdown.subParser('makehtml.hashBlock')('
', options, globals);\n text = text.replace(/^ {0,2}( ?-){3,}[ \\t]*$/gm, key);\n text = text.replace(/^ {0,2}( ?\\*){3,}[ \\t]*$/gm, key);\n text = text.replace(/^ {0,2}( ?_){3,}[ \\t]*$/gm, key);\n\n text = globals.converter._dispatch('makehtml.horizontalRule.after', text, options, globals).getText();\n return text;\n});\n","/**\n * Turn Markdown image shortcuts into ![]()
tags.\n */\nshowdown.subParser('makehtml.images', function (text, options, globals) {\n 'use strict';\n\n text = globals.converter._dispatch('makehtml.images.before', text, options, globals).getText();\n\n var inlineRegExp = /!\\[([^\\]]*?)][ \\t]*()\\([ \\t]??(?: =([*\\d]+[A-Za-z%]{0,4})x([*\\d]+[A-Za-z%]{0,4}))?[ \\t]*(?:([\"'])([^\"]*?)\\6)?[ \\t]?\\)/g,\n crazyRegExp = /!\\[([^\\]]*?)][ \\t]*()\\([ \\t]?<([^>]*)>(?: =([*\\d]+[A-Za-z%]{0,4})x([*\\d]+[A-Za-z%]{0,4}))?[ \\t]*(?:(?:([\"'])([^\"]*?)\\6))?[ \\t]?\\)/g,\n base64RegExp = /!\\[([^\\]]*?)][ \\t]*()\\([ \\t]??(?: =([*\\d]+[A-Za-z%]{0,4})x([*\\d]+[A-Za-z%]{0,4}))?[ \\t]*(?:([\"'])([^\"]*?)\\6)?[ \\t]?\\)/g,\n referenceRegExp = /!\\[([^\\]]*?)] ?(?:\\n *)?\\[([\\s\\S]*?)]()()()()()/g,\n refShortcutRegExp = /!\\[([^\\[\\]]+)]()()()()()/g;\n\n function writeImageTagBase64 (wholeMatch, altText, linkId, url, width, height, m5, title) {\n url = url.replace(/\\s/g, '');\n return writeImageTag (wholeMatch, altText, linkId, url, width, height, m5, title);\n }\n\n function writeImageTag (wholeMatch, altText, linkId, url, width, height, m5, title) {\n\n var gUrls = globals.gUrls,\n gTitles = globals.gTitles,\n gDims = globals.gDimensions;\n\n linkId = linkId.toLowerCase();\n\n if (!title) {\n title = '';\n }\n // Special case for explicit empty url\n if (wholeMatch.search(/\\(? ?(['\"].*['\"])?\\)$/m) > -1) {\n url = '';\n\n } else if (url === '' || url === null) {\n if (linkId === '' || linkId === null) {\n // lower-case and turn embedded newlines into spaces\n linkId = altText.toLowerCase().replace(/ ?\\n/g, ' ');\n }\n url = '#' + linkId;\n\n if (!showdown.helper.isUndefined(gUrls[linkId])) {\n url = gUrls[linkId];\n if (!showdown.helper.isUndefined(gTitles[linkId])) {\n title = gTitles[linkId];\n }\n if (!showdown.helper.isUndefined(gDims[linkId])) {\n width = gDims[linkId].width;\n height = gDims[linkId].height;\n }\n } else {\n return wholeMatch;\n }\n }\n\n altText = altText\n .replace(/\"/g, '"')\n //altText = showdown.helper.escapeCharacters(altText, '*_', false);\n .replace(showdown.helper.regexes.asteriskDashTildeAndColon, showdown.helper.escapeCharactersCallback);\n //url = showdown.helper.escapeCharacters(url, '*_', false);\n url = url.replace(showdown.helper.regexes.asteriskDashTildeAndColon, showdown.helper.escapeCharactersCallback);\n var result = '![\"'](\"' "title\n")
x \"optional title\")\n\n // base64 encoded images\n text = text.replace(base64RegExp, writeImageTagBase64);\n\n // cases with crazy urls like ./image/cat1).png\n text = text.replace(crazyRegExp, writeImageTag);\n\n // normal cases\n text = text.replace(inlineRegExp, writeImageTag);\n\n // handle reference-style shortcuts: ![img text]\n text = text.replace(refShortcutRegExp, writeImageTag);\n\n text = globals.converter._dispatch('makehtml.images.after', text, options, globals).getText();\n return text;\n});\n","showdown.subParser('makehtml.italicsAndBold', function (text, options, globals) {\n 'use strict';\n\n text = globals.converter._dispatch('makehtml.italicsAndBold.before', text, options, globals).getText();\n\n // it's faster to have 3 separate regexes for each case than have just one\n // because of backtracing, in some cases, it could lead to an exponential effect\n // called \"catastrophic backtrace\". Ominous!\n\n function parseInside (txt, left, right) {\n return left + txt + right;\n }\n\n // Parse underscores\n if (options.literalMidWordUnderscores) {\n text = text.replace(/\\b___(\\S[\\s\\S]*)___\\b/g, function (wm, txt) {\n return parseInside (txt, '', '');\n });\n text = text.replace(/\\b__(\\S[\\s\\S]*)__\\b/g, function (wm, txt) {\n return parseInside (txt, '', '');\n });\n text = text.replace(/\\b_(\\S[\\s\\S]*?)_\\b/g, function (wm, txt) {\n return parseInside (txt, '', '');\n });\n } else {\n text = text.replace(/___(\\S[\\s\\S]*?)___/g, function (wm, m) {\n return (/\\S$/.test(m)) ? parseInside (m, '', '') : wm;\n });\n text = text.replace(/__(\\S[\\s\\S]*?)__/g, function (wm, m) {\n return (/\\S$/.test(m)) ? parseInside (m, '', '') : wm;\n });\n text = text.replace(/_([^\\s_][\\s\\S]*?)_/g, function (wm, m) {\n // !/^_[^_]/.test(m) - test if it doesn't start with __ (since it seems redundant, we removed it)\n return (/\\S$/.test(m)) ? parseInside (m, '', '') : wm;\n });\n }\n\n // Now parse asterisks\n /*\n if (options.literalMidWordAsterisks) {\n text = text.replace(/([^*]|^)\\B\\*\\*\\*(\\S[\\s\\S]+?)\\*\\*\\*\\B(?!\\*)/g, function (wm, lead, txt) {\n return parseInside (txt, lead + '', '');\n });\n text = text.replace(/([^*]|^)\\B\\*\\*(\\S[\\s\\S]+?)\\*\\*\\B(?!\\*)/g, function (wm, lead, txt) {\n return parseInside (txt, lead + '', '');\n });\n text = text.replace(/([^*]|^)\\B\\*(\\S[\\s\\S]+?)\\*\\B(?!\\*)/g, function (wm, lead, txt) {\n return parseInside (txt, lead + '', '');\n });\n } else {\n */\n text = text.replace(/\\*\\*\\*(\\S[\\s\\S]*?)\\*\\*\\*/g, function (wm, m) {\n return (/\\S$/.test(m)) ? parseInside (m, '', '') : wm;\n });\n text = text.replace(/\\*\\*(\\S[\\s\\S]*?)\\*\\*/g, function (wm, m) {\n return (/\\S$/.test(m)) ? parseInside (m, '', '') : wm;\n });\n text = text.replace(/\\*([^\\s*][\\s\\S]*?)\\*/g, function (wm, m) {\n // !/^\\*[^*]/.test(m) - test if it doesn't start with ** (since it seems redundant, we removed it)\n return (/\\S$/.test(m)) ? parseInside (m, '', '') : wm;\n });\n //}\n\n text = globals.converter._dispatch('makehtml.italicsAndBold.after', text, options, globals).getText();\n return text;\n});\n","////\n// makehtml/links.js\n// Copyright (c) 2018 ShowdownJS\n//\n// Transforms MD links into `` html anchors\n//\n// A link contains link text (the visible text), a link destination (the URI that is the link destination), and\n// optionally a link title. There are two basic kinds of links in Markdown.\n// In inline links the destination and title are given immediately after the link text.\n// In reference links the destination and title are defined elsewhere in the document.\n//\n// ***Author:***\n// - Estevão Soares dos Santos (Tivie) \n////\n\n(function () {\n /**\n * Helper function: Wrapper function to pass as second replace parameter\n *\n * @param {RegExp} rgx\n * @param {string} evtRootName\n * @param {{}} options\n * @param {{}} globals\n * @returns {Function}\n */\n function replaceAnchorTag (rgx, evtRootName, options, globals, emptyCase) {\n emptyCase = !!emptyCase;\n return function (wholeMatch, text, id, url, m5, m6, title) {\n // bail we we find 2 newlines somewhere\n if (/\\n\\n/.test(wholeMatch)) {\n return wholeMatch;\n }\n\n var evt = createEvent(rgx, evtRootName + '.captureStart', wholeMatch, text, id, url, title, options, globals);\n return writeAnchorTag(evt, options, globals, emptyCase);\n };\n }\n\n /**\n * TODO Normalize this\n * Helper function: Create a capture event\n * @param {RegExp} rgx\n * @param {String} evtName Event name\n * @param {String} wholeMatch\n * @param {String} text\n * @param {String} id\n * @param {String} url\n * @param {String} title\n * @param {{}} options\n * @param {{}} globals\n * @returns {showdown.helper.Event|*}\n */\n function createEvent (rgx, evtName, wholeMatch, text, id, url, title, options, globals) {\n return globals.converter._dispatch(evtName, wholeMatch, options, globals, {\n regexp: rgx,\n matches: {\n wholeMatch: wholeMatch,\n text: text,\n id: id,\n url: url,\n title: title\n }\n });\n }\n\n /**\n * Helper Function: Normalize and write an anchor tag based on passed parameters\n * @param evt\n * @param options\n * @param globals\n * @param {boolean} emptyCase\n * @returns {string}\n */\n function writeAnchorTag (evt, options, globals, emptyCase) {\n\n var wholeMatch = evt.getMatches().wholeMatch;\n var text = evt.getMatches().text;\n var id = evt.getMatches().id;\n var url = evt.getMatches().url;\n var title = evt.getMatches().title;\n var target = '';\n\n if (!title) {\n title = '';\n }\n id = (id) ? id.toLowerCase() : '';\n\n if (emptyCase) {\n url = '';\n } else if (!url) {\n if (!id) {\n // lower-case and turn embedded newlines into spaces\n id = text.toLowerCase().replace(/ ?\\n/g, ' ');\n }\n url = '#' + id;\n\n if (!showdown.helper.isUndefined(globals.gUrls[id])) {\n url = globals.gUrls[id];\n if (!showdown.helper.isUndefined(globals.gTitles[id])) {\n title = globals.gTitles[id];\n }\n } else {\n return wholeMatch;\n }\n }\n //url = showdown.helper.escapeCharacters(url, '*_:~', false); // replaced line to improve performance\n url = url.replace(showdown.helper.regexes.asteriskDashTildeAndColon, showdown.helper.escapeCharactersCallback);\n\n if (title !== '' && title !== null) {\n title = title.replace(/\"/g, '"');\n //title = showdown.helper.escapeCharacters(title, '*_', false); // replaced line to improve performance\n title = title.replace(showdown.helper.regexes.asteriskDashTildeAndColon, showdown.helper.escapeCharactersCallback);\n title = ' title=\"' + title + '\"';\n }\n\n // optionLinksInNewWindow only applies\n // to external links. Hash links (#) open in same page\n if (options.openLinksInNewWindow && !/^#/.test(url)) {\n // escaped _\n target = ' target=\"¨E95Eblank\"';\n }\n\n // Text can be a markdown element, so we run through the appropriate parsers\n text = showdown.subParser('makehtml.codeSpans')(text, options, globals);\n text = showdown.subParser('makehtml.emoji')(text, options, globals);\n text = showdown.subParser('makehtml.underline')(text, options, globals);\n text = showdown.subParser('makehtml.italicsAndBold')(text, options, globals);\n text = showdown.subParser('makehtml.strikethrough')(text, options, globals);\n text = showdown.subParser('makehtml.ellipsis')(text, options, globals);\n text = showdown.subParser('makehtml.hashHTMLSpans')(text, options, globals);\n\n //evt = createEvent(rgx, evtRootName + '.captureEnd', wholeMatch, text, id, url, title, options, globals);\n\n var result = '' + text + '';\n\n //evt = createEvent(rgx, evtRootName + '.beforeHash', wholeMatch, text, id, url, title, options, globals);\n\n result = showdown.subParser('makehtml.hashHTMLSpans')(result, options, globals);\n\n return result;\n }\n\n var evtRootName = 'makehtml.links';\n\n /**\n * Turn Markdown link shortcuts into XHTML tags.\n */\n showdown.subParser('makehtml.links', function (text, options, globals) {\n\n text = globals.converter._dispatch(evtRootName + '.start', text, options, globals).getText();\n\n // 1. Handle reference-style links: [link text] [id]\n text = showdown.subParser('makehtml.links.reference')(text, options, globals);\n\n // 2. Handle inline-style links: [link text](url \"optional title\")\n text = showdown.subParser('makehtml.links.inline')(text, options, globals);\n\n // 3. Handle reference-style shortcuts: [link text]\n // These must come last in case there's a [link text][1] or [link text](/foo)\n text = showdown.subParser('makehtml.links.referenceShortcut')(text, options, globals);\n\n // 4. Handle angle brackets links -> `).\n text = showdown.subParser('makehtml.links.angleBrackets')(text, options, globals);\n\n // 5. Handle GithubMentions (if option is enabled)\n text = showdown.subParser('makehtml.links.ghMentions')(text, options, globals);\n\n // 6. Handle tags and img tags\n text = text.replace(/]*>[\\s\\S]*<\\/a>/g, function (wholeMatch) {\n return showdown.helper._hashHTMLSpan(wholeMatch, globals);\n });\n\n text = text.replace(/]*\\/?>/g, function (wholeMatch) {\n return showdown.helper._hashHTMLSpan(wholeMatch, globals);\n });\n\n // 7. Handle naked links (if option is enabled)\n text = showdown.subParser('makehtml.links.naked')(text, options, globals);\n\n text = globals.converter._dispatch(evtRootName + '.end', text, options, globals).getText();\n return text;\n });\n\n /**\n * TODO WRITE THIS DOCUMENTATION\n */\n showdown.subParser('makehtml.links.inline', function (text, options, globals) {\n var evtRootName = evtRootName + '.inline';\n\n text = globals.converter._dispatch(evtRootName + '.start', text, options, globals).getText();\n\n // 1. Look for empty cases: []() and [empty]() and [](\"title\")\n var rgxEmpty = /\\[(.*?)]()()()()\\(? ?(?:[\"'](.*)[\"'])?\\)/g;\n text = text.replace(rgxEmpty, replaceAnchorTag(rgxEmpty, evtRootName, options, globals, true));\n\n // 2. Look for cases with crazy urls like ./image/cat1).png\n var rgxCrazy = /\\[((?:\\[[^\\]]*]|[^\\[\\]])*)]()\\s?\\([ \\t]?<([^>]*)>(?:[ \\t]*(([\"'])([^\"]*?)\\5))?[ \\t]?\\)/g;\n text = text.replace(rgxCrazy, replaceAnchorTag(rgxCrazy, evtRootName, options, globals));\n\n // 3. inline links with no title or titles wrapped in ' or \":\n // [text](url.com) || [text]() || [text](url.com \"title\") || [text]( \"title\")\n //var rgx2 = /\\[[ ]*[\\s]?[ ]*([^\\n\\[\\]]*?)[ ]*[\\s]?[ ]*] ?()\\(?(?:[ ]*[\\n]?[ ]*()(['\"])(.*?)\\5)?[ ]*[\\s]?[ ]*\\)/; // this regex is too slow!!!\n var rgx2 = /\\[([\\S ]*?)]\\s?()\\( *?\\s*(?:()(['\"])(.*?)\\5)? *\\)/g;\n text = text.replace(rgx2, replaceAnchorTag(rgx2, evtRootName, options, globals));\n\n // 4. inline links with titles wrapped in (): [foo](bar.com (title))\n var rgx3 = /\\[([\\S ]*?)]\\s?()\\( *?\\s+()()\\((.*?)\\) *\\)/g;\n text = text.replace(rgx3, replaceAnchorTag(rgx3, evtRootName, options, globals));\n\n text = globals.converter._dispatch(evtRootName + '.end', text, options, globals).getText();\n\n return text;\n });\n\n /**\n * TODO WRITE THIS DOCUMENTATION\n */\n showdown.subParser('makehtml.links.reference', function (text, options, globals) {\n var evtRootName = evtRootName + '.reference';\n\n text = globals.converter._dispatch(evtRootName + '.start', text, options, globals).getText();\n\n var rgx = /\\[((?:\\[[^\\]]*]|[^\\[\\]])*)] ?(?:\\n *)?\\[(.*?)]()()()()/g;\n text = text.replace(rgx, replaceAnchorTag(rgx, evtRootName, options, globals));\n\n text = globals.converter._dispatch(evtRootName + '.end', text, options, globals).getText();\n\n return text;\n });\n\n /**\n * TODO WRITE THIS DOCUMENTATION\n */\n showdown.subParser('makehtml.links.referenceShortcut', function (text, options, globals) {\n var evtRootName = evtRootName + '.referenceShortcut';\n\n text = globals.converter._dispatch(evtRootName + '.start', text, options, globals).getText();\n\n var rgx = /\\[([^\\[\\]]+)]()()()()()/g;\n text = text.replace(rgx, replaceAnchorTag(rgx, evtRootName, options, globals));\n\n text = globals.converter._dispatch(evtRootName + '.end', text, options, globals).getText();\n\n return text;\n });\n\n /**\n * TODO WRITE THIS DOCUMENTATION\n */\n showdown.subParser('makehtml.links.ghMentions', function (text, options, globals) {\n var evtRootName = evtRootName + 'ghMentions';\n\n if (!options.ghMentions) {\n return text;\n }\n\n text = globals.converter._dispatch(evtRootName + '.start', text, options, globals).getText();\n\n var rgx = /(^|\\s)(\\\\)?(@([a-z\\d]+(?:[a-z\\d._-]+?[a-z\\d]+)*))/gi;\n\n text = text.replace(rgx, function (wholeMatch, st, escape, mentions, username) {\n // bail if the mentions was escaped\n if (escape === '\\\\') {\n return st + mentions;\n }\n\n // check if options.ghMentionsLink is a string\n // TODO Validation should be done at initialization not at runtime\n if (!showdown.helper.isString(options.ghMentionsLink)) {\n throw new Error('ghMentionsLink option must be a string');\n }\n var url = options.ghMentionsLink.replace(/{u}/g, username);\n var evt = createEvent(rgx, evtRootName + '.captureStart', wholeMatch, mentions, null, url, null, options, globals);\n // captureEnd Event is triggered inside writeAnchorTag function\n return st + writeAnchorTag(evt, options, globals);\n });\n\n text = globals.converter._dispatch(evtRootName + '.end', text, options, globals).getText();\n\n return text;\n });\n\n /**\n * TODO WRITE THIS DOCUMENTATION\n */\n showdown.subParser('makehtml.links.angleBrackets', function (text, options, globals) {\n var evtRootName = 'makehtml.links.angleBrackets';\n\n text = globals.converter._dispatch(evtRootName + '.start', text, options, globals).getText();\n\n // 1. Parse links first\n var urlRgx = /<(((?:https?|ftp):\\/\\/|www\\.)[^'\">\\s]+)>/gi;\n text = text.replace(urlRgx, function (wholeMatch, url, urlStart) {\n var text = url;\n url = (urlStart === 'www.') ? 'http://' + url : url;\n var evt = createEvent(urlRgx, evtRootName + '.captureStart', wholeMatch, text, null, url, null, options, globals);\n return writeAnchorTag(evt, options, globals);\n });\n\n // 2. Then Mail Addresses\n var mailRgx = /<(?:mailto:)?([-.\\w]+@[-a-z0-9]+(\\.[-a-z0-9]+)*\\.[a-z]+)>/gi;\n text = text.replace(mailRgx, function (wholeMatch, mail) {\n var url = 'mailto:';\n mail = showdown.subParser('makehtml.unescapeSpecialChars')(mail, options, globals);\n if (options.encodeEmails) {\n url = showdown.helper.encodeEmailAddress(url + mail);\n mail = showdown.helper.encodeEmailAddress(mail);\n } else {\n url = url + mail;\n }\n var evt = createEvent(mailRgx, evtRootName + '.captureStart', wholeMatch, mail, null, url, null, options, globals);\n return writeAnchorTag(evt, options, globals);\n });\n\n text = globals.converter._dispatch(evtRootName + '.end', text, options, globals).getText();\n return text;\n });\n\n /**\n * TODO MAKE THIS WORK (IT'S NOT ACTIVATED)\n * TODO WRITE THIS DOCUMENTATION\n */\n showdown.subParser('makehtml.links.naked', function (text, options, globals) {\n if (!options.simplifiedAutoLink) {\n return text;\n }\n\n var evtRootName = 'makehtml.links.naked';\n\n text = globals.converter._dispatch(evtRootName + '.start', text, options, globals).getText();\n\n // 2. Now we check for\n // we also include leading markdown magic chars [_*~] for cases like __https://www.google.com/foobar__\n var urlRgx = /([_*~]*?)(((?:https?|ftp):\\/\\/|www\\.)[^\\s<>\"'`´.-][^\\s<>\"'`´]*?\\.[a-z\\d.]+[^\\s<>\"']*)\\1/gi;\n text = text.replace(urlRgx, function (wholeMatch, leadingMDChars, url, urlPrefix) {\n\n // we now will start traversing the url from the front to back, looking for punctuation chars [_*~,;:.!?\\)\\]]\n var len = url.length;\n var suffix = '';\n for (var i = len - 1; i >= 0; --i) {\n var char = url.charAt(i);\n\n if (/[_*~,;:.!?]/.test(char)) {\n // it's a punctuation char\n // we remove it from the url\n url = url.slice(0, -1);\n // and prepend it to the suffix\n suffix = char + suffix;\n } else if (/\\)/.test(char)) {\n var opPar = url.match(/\\(/g) || [];\n var clPar = url.match(/\\)/g);\n\n // it's a curved parenthesis so we need to check for \"balance\" (kinda)\n if (opPar.length < clPar.length) {\n // there are more closing Parenthesis than opening so chop it!!!!!\n url = url.slice(0, -1);\n // and prepend it to the suffix\n suffix = char + suffix;\n } else {\n // it's (kinda) balanced so our work is done\n break;\n }\n } else if (/]/.test(char)) {\n var opPar2 = url.match(/\\[/g) || [];\n var clPar2 = url.match(/\\]/g);\n // it's a squared parenthesis so we need to check for \"balance\" (kinda)\n if (opPar2.length < clPar2.length) {\n // there are more closing Parenthesis than opening so chop it!!!!!\n url = url.slice(0, -1);\n // and prepend it to the suffix\n suffix = char + suffix;\n } else {\n // it's (kinda) balanced so our work is done\n break;\n }\n } else {\n // it's not a punctuation or a parenthesis so our work is done\n break;\n }\n }\n\n // we copy the treated url to the text variable\n var text = url;\n // finally, if it's a www shortcut, we prepend http\n url = (urlPrefix === 'www.') ? 'http://' + url : url;\n\n // url part is done so let's take care of text now\n // we need to escape the text (because of links such as www.example.com/foo__bar__baz)\n text = text.replace(showdown.helper.regexes.asteriskDashTildeAndColon, showdown.helper.escapeCharactersCallback);\n\n // finally we dispatch the event\n var evt = createEvent(urlRgx, evtRootName + '.captureStart', wholeMatch, text, null, url, null, options, globals);\n\n // and return the link tag, with the leadingMDChars and suffix. The leadingMDChars are added at the end too because\n // we consumed those characters in the regexp\n return leadingMDChars + writeAnchorTag(evt, options, globals) + suffix + leadingMDChars;\n });\n\n // 2. Then mails\n var mailRgx = /(^|\\s)(?:mailto:)?([A-Za-z0-9!#$%&'*+-/=?^_`{|}~.]+@[-a-z0-9]+(\\.[-a-z0-9]+)*\\.[a-z]+)(?=$|\\s)/gmi;\n text = text.replace(mailRgx, function (wholeMatch, leadingChar, mail) {\n var url = 'mailto:';\n mail = showdown.subParser('makehtml.unescapeSpecialChars')(mail, options, globals);\n if (options.encodeEmails) {\n url = showdown.helper.encodeEmailAddress(url + mail);\n mail = showdown.helper.encodeEmailAddress(mail);\n } else {\n url = url + mail;\n }\n var evt = createEvent(mailRgx, evtRootName + '.captureStart', wholeMatch, mail, null, url, null, options, globals);\n return leadingChar + writeAnchorTag(evt, options, globals);\n });\n\n\n text = globals.converter._dispatch(evtRootName + '.end', text, options, globals).getText();\n return text;\n });\n})();\n","/**\n * Form HTML ordered (numbered) and unordered (bulleted) lists.\n */\nshowdown.subParser('makehtml.lists', function (text, options, globals) {\n 'use strict';\n\n /**\n * Process the contents of a single ordered or unordered list, splitting it\n * into individual list items.\n * @param {string} listStr\n * @param {boolean} trimTrailing\n * @returns {string}\n */\n function processListItems (listStr, trimTrailing) {\n // The $g_list_level global keeps track of when we're inside a list.\n // Each time we enter a list, we increment it; when we leave a list,\n // we decrement. If it's zero, we're not in a list anymore.\n //\n // We do this because when we're not inside a list, we want to treat\n // something like this:\n //\n // I recommend upgrading to version\n // 8. Oops, now this line is treated\n // as a sub-list.\n //\n // As a single paragraph, despite the fact that the second line starts\n // with a digit-period-space sequence.\n //\n // Whereas when we're inside a list (or sub-list), that line will be\n // treated as the start of a sub-list. What a kludge, huh? This is\n // an aspect of Markdown's syntax that's hard to parse perfectly\n // without resorting to mind-reading. Perhaps the solution is to\n // change the syntax rules such that sub-lists must start with a\n // starting cardinal number; e.g. \"1.\" or \"a.\".\n globals.gListLevel++;\n\n // trim trailing blank lines:\n listStr = listStr.replace(/\\n{2,}$/, '\\n');\n\n // attacklab: add sentinel to emulate \\z\n listStr += '¨0';\n\n var rgx = /(\\n)?(^ {0,3})([*+-]|\\d+[.])[ \\t]+((\\[(x|X| )?])?[ \\t]*[^\\r]+?(\\n{1,2}))(?=\\n*(¨0| {0,3}([*+-]|\\d+[.])[ \\t]+))/gm,\n isParagraphed = (/\\n[ \\t]*\\n(?!¨0)/.test(listStr));\n\n // Since version 1.5, nesting sublists requires 4 spaces (or 1 tab) indentation,\n // which is a syntax breaking change\n // activating this option reverts to old behavior\n // This will be removed in version 2.0\n if (options.disableForced4SpacesIndentedSublists) {\n rgx = /(\\n)?(^ {0,3})([*+-]|\\d+[.])[ \\t]+((\\[(x|X| )?])?[ \\t]*[^\\r]+?(\\n{1,2}))(?=\\n*(¨0|\\2([*+-]|\\d+[.])[ \\t]+))/gm;\n }\n\n listStr = listStr.replace(rgx, function (wholeMatch, m1, m2, m3, m4, taskbtn, checked) {\n checked = (checked && checked.trim() !== '');\n\n var item = showdown.subParser('makehtml.outdent')(m4, options, globals),\n bulletStyle = '';\n\n // Support for github tasklists\n if (taskbtn && options.tasklists) {\n bulletStyle = ' class=\"task-list-item\" style=\"list-style-type: none;\"';\n item = item.replace(/^[ \\t]*\\[(x|X| )?]/m, function () {\n var otp = '- a