From 4fdc5b2b845308816e99451d25937065e749c533 Mon Sep 17 00:00:00 2001
From: Siavash Safi
Date: Wed, 9 Aug 2017 15:25:37 +0200
Subject: [PATCH] Initial commit
---
.gitignore | 3 +
LICENSE | 21 +
README.md | 45 +
pom.xml | 177 +
.../java/com/catawiki/jira/prism/Code.java | 55 +
.../java/com/catawiki/jira/prism/Init.java | 39 +
.../META-INF/spring/plugin-context.xml | 10 +
src/main/resources/atlassian-plugin.xml | 56 +
src/main/resources/css/prism.css | 139 +
src/main/resources/images/pluginIcon.png | Bin 0 -> 251 bytes
src/main/resources/images/pluginLogo.png | Bin 0 -> 1096 bytes
src/main/resources/js/prism-init.js | 7 +
src/main/resources/js/prism.js | 6659 +++++++++++++++++
src/main/resources/soy/prism.soy | 9 +
14 files changed, 7220 insertions(+)
create mode 100644 .gitignore
create mode 100644 LICENSE
create mode 100644 README.md
create mode 100644 pom.xml
create mode 100644 src/main/java/com/catawiki/jira/prism/Code.java
create mode 100644 src/main/java/com/catawiki/jira/prism/Init.java
create mode 100644 src/main/resources/META-INF/spring/plugin-context.xml
create mode 100644 src/main/resources/atlassian-plugin.xml
create mode 100644 src/main/resources/css/prism.css
create mode 100644 src/main/resources/images/pluginIcon.png
create mode 100644 src/main/resources/images/pluginLogo.png
create mode 100644 src/main/resources/js/prism-init.js
create mode 100644 src/main/resources/js/prism.js
create mode 100644 src/main/resources/soy/prism.soy
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..6103cc2
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,3 @@
+target/
+.DS_Store
+
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..b34ad2c
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Catawiki B.V.
+
+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/README.md b/README.md
new file mode 100644
index 0000000..490601d
--- /dev/null
+++ b/README.md
@@ -0,0 +1,45 @@
+Prism is a `{code}` macro plugin for Atlassian JIRA.
+
+## Features
+* Support for many programming languages
+* Client side syntax highlighting using [Prism](http://prismjs.com/)
+
+## Build
+Install **Atlassian Plugin SDK** and run `atlas-package`.
+
+## Usage
+Default language is Ruby:
+
+```
+{code}
+class Bar < Foo
+ def initialize(a)
+ @a = a
+ end
+end
+{code}
+```
+
+You can specify another language:
+
+```
+{code:java}
+public class Bar extends Foo {
+ private int a;
+
+ public Bar(int a) {
+ this.a = a;
+ }
+}
+{code}
+```
+
+## Issues
+Visual editing in Rich Text Editor is not supported. While you don't have to disable Rich Text Editor in JIRA, you cannot use the **visual tab** to do code editing.
+
+## Notes
+This plugin uses a slightly modified version of [Prism](http://prismjs.com/) to fix JS compile issues in Atlassian Plugin SDK.
+
+This plugin is released without any support, if you want to add a new feature or fix a bug feel free to submit a PR.
+
+Also check [this JIRA Server issue](https://jira.atlassian.com/browse/JRASERVER-21067) regarding `{code}` macro limitations and why this plugin was developed.
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000..893820d
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,177 @@
+
+
+
+
+ 4.0.0
+ com.catawiki.jira
+ prism
+ 1.0.0
+
+
+ Catawiki B.V.
+ https://www.catawiki.com/
+
+
+ Prism
+ Code syntax highlighting plugin for Atlassian JIRA.
+ atlassian-plugin
+
+
+
+ com.atlassian.jira
+ jira-api
+ ${jira.version}
+ provided
+
+
+ com.atlassian.jira
+ jira-core
+ ${jira.version}
+ provided
+
+
+ junit
+ junit
+ 4.10
+ test
+
+
+
+ com.atlassian.plugin
+ atlassian-spring-scanner-annotation
+ ${atlassian.spring.scanner.version}
+ compile
+
+
+
+ com.atlassian.plugin
+ atlassian-spring-scanner-runtime
+ ${atlassian.spring.scanner.version}
+ runtime
+
+
+
+ javax.inject
+ javax.inject
+ 1
+ provided
+
+
+
+
+ com.atlassian.plugins
+ atlassian-plugins-osgi-testrunner
+ ${plugin.testrunner.version}
+ test
+
+
+ javax.ws.rs
+ jsr311-api
+ 1.1.1
+ provided
+
+
+ com.google.code.gson
+ gson
+ 2.2.2-atlassian-1
+
+
+
+
+
+
+
+
+
+
+ com.atlassian.maven.plugins
+ maven-jira-plugin
+ ${amps.version}
+ true
+
+ ${jira.version}
+ ${jira.version}
+
+
+ true
+ false
+
+
+
+
+
+
+
+
+ com.catawiki.jira.prism,
+
+
+
+
+ org.springframework.osgi.*;resolution:="optional",
+ org.eclipse.gemini.blueprint.*;resolution:="optional",
+ *
+
+
+
+ *
+
+
+
+
+
+ com.atlassian.plugin
+ atlassian-spring-scanner-maven-plugin
+ ${atlassian.spring.scanner.version}
+
+
+
+ atlassian-spring-scanner
+
+ process-classes
+
+
+
+
+
+ com.atlassian.plugin
+ atlassian-spring-scanner-external-jar
+
+
+ false
+
+
+
+
+
+
+ 7.2.2
+ 6.2.11
+ 1.2.3
+ 1.2.13
+
+ ${project.groupId}.${project.artifactId}
+
+ 6.3.11
+
+
+
diff --git a/src/main/java/com/catawiki/jira/prism/Code.java b/src/main/java/com/catawiki/jira/prism/Code.java
new file mode 100644
index 0000000..7d57096
--- /dev/null
+++ b/src/main/java/com/catawiki/jira/prism/Code.java
@@ -0,0 +1,55 @@
+package com.catawiki.jira.prism;
+
+import com.atlassian.jira.template.soy.SoyTemplateRendererProvider;
+import com.atlassian.renderer.RenderContext;
+import com.atlassian.renderer.v2.RenderMode;
+import com.atlassian.renderer.v2.macro.BaseMacro;
+import com.atlassian.renderer.v2.macro.MacroException;
+import com.atlassian.soy.renderer.SoyException;
+import com.atlassian.soy.renderer.SoyTemplateRenderer;
+import com.google.common.collect.ImmutableMap;
+
+import java.util.Map;
+
+public class Code extends BaseMacro {
+
+ private static final String FALLBACK_RENDER_OUTPUT = "{noformat}%s{noformat}";
+
+ private final SoyTemplateRenderer soyTemplateRenderer;
+
+ public Code(final SoyTemplateRendererProvider soyTemplateRendererProvider) {
+ super();
+ this.soyTemplateRenderer = soyTemplateRendererProvider.getRenderer();
+ }
+
+ @Override
+ public boolean hasBody() {
+ return true;
+ }
+
+ @Override
+ public RenderMode getBodyRenderMode() {
+ return RenderMode.allow(RenderMode.F_NONE);
+ }
+
+ @Override
+ public String execute(Map parameters, String body, RenderContext renderContext) throws MacroException {
+
+ ImmutableMap.Builder templateParams = ImmutableMap.builder();
+ templateParams.put("content", body);
+ String language = "ruby";
+ if (parameters.get("0") != null) {
+ language = (String) parameters.get("0");
+ }
+ templateParams.put("language", language);
+
+ try {
+ return this.soyTemplateRenderer.render(
+ "com.catawiki.jira.prism:handler",
+ "Prism.Macros.Code.html",
+ templateParams.build());
+ } catch (SoyException e) {
+ return String.format(FALLBACK_RENDER_OUTPUT, body);
+ }
+ }
+}
diff --git a/src/main/java/com/catawiki/jira/prism/Init.java b/src/main/java/com/catawiki/jira/prism/Init.java
new file mode 100644
index 0000000..c9cc1a1
--- /dev/null
+++ b/src/main/java/com/catawiki/jira/prism/Init.java
@@ -0,0 +1,39 @@
+package com.catawiki.jira.prism;
+
+import org.springframework.beans.factory.DisposableBean;
+import org.springframework.beans.factory.InitializingBean;
+
+import com.atlassian.plugin.PluginController;
+
+public class Init implements InitializingBean, DisposableBean {
+
+ private static final String STANDARD_JIRA_CODE_MACRO = "com.atlassian.jira.plugin.system.renderers.wiki.macros:code";
+ private static final String STANDARD_JIRA_NOFORMAT_MACRO = "com.atlassian.jira.plugin.system.renderers.wiki.macros:noformat";
+
+ private final PluginController pluginController;
+
+ public Init(PluginController pc){
+ this.pluginController = pc;
+ }
+
+ /**
+ * Called when JIRA Syntax Highlighter is being disabled or removed. Enables JIRA standard
+ * Wiki Renderer Macro Plugin for {code}.
+ *
+ * @throws Exception
+ */
+ public void destroy() throws Exception {
+ pluginController.enablePluginModule(STANDARD_JIRA_CODE_MACRO);
+ }
+
+ /**
+ * Called when JIRA Syntax Highlighter has been enabled. Disables JIRA standard Wiki Renderer
+ * Macro Plugin for {code}.
+ *
+ * @throws Exception
+ */
+ public void afterPropertiesSet() throws Exception {
+ pluginController.disablePluginModule(STANDARD_JIRA_CODE_MACRO);
+ }
+
+}
diff --git a/src/main/resources/META-INF/spring/plugin-context.xml b/src/main/resources/META-INF/spring/plugin-context.xml
new file mode 100644
index 0000000..b1f0519
--- /dev/null
+++ b/src/main/resources/META-INF/spring/plugin-context.xml
@@ -0,0 +1,10 @@
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/atlassian-plugin.xml b/src/main/resources/atlassian-plugin.xml
new file mode 100644
index 0000000..f78128f
--- /dev/null
+++ b/src/main/resources/atlassian-plugin.xml
@@ -0,0 +1,56 @@
+
+
+ ${project.description}
+ ${project.version}
+
+ images/pluginIcon.png
+ images/pluginLogo.png
+
+
+
+
+ jira.navigator.advanced
+ jira.navigator.simple
+ jira.view.issue
+ gh-rapid
+
+ ${atlassian.plugin.key}:handler
+
+
+
+
+
+
+ jira.rich.editor
+
+ com.atlassian.jira.plugins.jira-editor-plugin:converter
+
+
+
+
+
+
+
+
+
+ jira.navigator.advanced
+ jira.navigator.simple
+ jira.view.issue
+ gh-rapid
+
+
+
+
+
+ Syntax highlighting for code blocks.
+ code-macro
+ Prism.Macros.Code.convert
+
+
+
+ Helper module to automatic disabling / enabling of JIRA standard code macro on
+ installation or enabling / deinstallation or disabling of Prism Syntax Highlighter plugin
+
+
diff --git a/src/main/resources/css/prism.css b/src/main/resources/css/prism.css
new file mode 100644
index 0000000..e58253b
--- /dev/null
+++ b/src/main/resources/css/prism.css
@@ -0,0 +1,139 @@
+/* http://prismjs.com/download.html?themes=prism&languages=markup+css+clike+javascript+abap+actionscript+ada+apacheconf+apl+applescript+asciidoc+aspnet+autoit+autohotkey+bash+basic+batch+c+brainfuck+bro+bison+csharp+cpp+coffeescript+ruby+css-extras+d+dart+django+diff+docker+eiffel+elixir+erlang+fsharp+fortran+gherkin+git+glsl+go+graphql+groovy+haml+handlebars+haskell+haxe+http+icon+inform7+ini+j+jade+java+jolie+json+julia+keyman+kotlin+latex+less+livescript+lolcode+lua+makefile+markdown+matlab+mel+mizar+monkey+nasm+nginx+nim+nix+nsis+objectivec+ocaml+oz+parigp+parser+pascal+perl+php+php-extras+powershell+processing+prolog+properties+protobuf+puppet+pure+python+q+qore+r+jsx+reason+rest+rip+roboconf+crystal+rust+sas+sass+scss+scala+scheme+smalltalk+smarty+sql+stylus+swift+tcl+textile+twig+typescript+vbnet+verilog+vhdl+vim+wiki+xojo+yaml */
+/**
+ * prism.js default theme for JavaScript, CSS and HTML
+ * Based on dabblet (http://dabblet.com)
+ * @author Lea Verou
+ */
+
+code[class*="language-"],
+pre[class*="language-"] {
+ color: black;
+ background: none;
+ text-shadow: 0 1px white;
+ font-family: Consolas, Monaco, 'Andale Mono', 'Ubuntu Mono', monospace;
+ text-align: left;
+ white-space: pre;
+ word-spacing: normal;
+ word-break: normal;
+ word-wrap: normal;
+ line-height: 1.5;
+
+ -moz-tab-size: 4;
+ -o-tab-size: 4;
+ tab-size: 4;
+
+ -webkit-hyphens: none;
+ -moz-hyphens: none;
+ -ms-hyphens: none;
+ hyphens: none;
+}
+
+pre[class*="language-"]::-moz-selection, pre[class*="language-"] ::-moz-selection,
+code[class*="language-"]::-moz-selection, code[class*="language-"] ::-moz-selection {
+ text-shadow: none;
+ background: #b3d4fc;
+}
+
+pre[class*="language-"]::selection, pre[class*="language-"] ::selection,
+code[class*="language-"]::selection, code[class*="language-"] ::selection {
+ text-shadow: none;
+ background: #b3d4fc;
+}
+
+@media print {
+ code[class*="language-"],
+ pre[class*="language-"] {
+ text-shadow: none;
+ }
+}
+
+/* Code blocks */
+pre[class*="language-"] {
+ padding: 1em;
+ margin: .5em 0;
+ overflow: auto;
+}
+
+:not(pre) > code[class*="language-"],
+pre[class*="language-"] {
+ background: #f5f2f0;
+}
+
+/* Inline code */
+:not(pre) > code[class*="language-"] {
+ padding: .1em;
+ border-radius: .3em;
+ white-space: normal;
+}
+
+.token.comment,
+.token.prolog,
+.token.doctype,
+.token.cdata {
+ color: slategray;
+}
+
+.token.punctuation {
+ color: #999;
+}
+
+.namespace {
+ opacity: .7;
+}
+
+.token.property,
+.token.tag,
+.token.boolean,
+.token.number,
+.token.constant,
+.token.symbol,
+.token.deleted {
+ color: #905;
+}
+
+.token.selector,
+.token.attr-name,
+.token.string,
+.token.char,
+.token.builtin,
+.token.inserted {
+ color: #690;
+}
+
+.token.operator,
+.token.entity,
+.token.url,
+.language-css .token.string,
+.style .token.string {
+ color: #a67f59;
+ background: hsla(0, 0%, 100%, .5);
+}
+
+.token.atrule,
+.token.attr-value,
+.token.keyword {
+ color: #07a;
+}
+
+.token.function {
+ color: #DD4A68;
+}
+
+.token.regex,
+.token.important,
+.token.variable {
+ color: #e90;
+}
+
+.token.important,
+.token.bold {
+ font-weight: bold;
+}
+.token.italic {
+ font-style: italic;
+}
+
+.token.entity {
+ cursor: help;
+}
+
diff --git a/src/main/resources/images/pluginIcon.png b/src/main/resources/images/pluginIcon.png
new file mode 100644
index 0000000000000000000000000000000000000000..1520c5bb0fc9d97bfe10a18bcdad0ff65abc58e9
GIT binary patch
literal 251
zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`hdf;zLoEEKPHyBqWWd96U)q34
znnBpXJb^hZg?STW4}Cf)NDWX!5&+@WdZkiZ{Y!Ejz~*$?J3H|~n)CZv=H
z|6$;M8`~wd;mEzECmK%uV=Q1T*jAb^E6q?Nx9uInlbsq3N$L;y9xybd=iIvWkLdyD
zgH+*J&z;!H>%+^;gpNG2Jh+A@qWJr_vw5QHBR{1T#9)aA?bG
zCqh;^v@LA%!YHFHZP6_&C=|9P$K@z#;C>;lpH_L_04c9%y&qD*Zs_sklN8BtyrRb_ZhPIuX9?~01s
z;lgqQaMax;qe0N@Hf@m4$+;eX?k15bW_YFr?0ae!HT{s6m>lF8H|QNq&IQiONFfpq
z>4t9yT6Da{<@j^DK&D{Bwuj>@buPV{5@ZqA$_S^sTT&m3o5{u2iJXZ*Gy()Da_W&Z
z*s03lBM)Gw0%sN^DY2gr2Gq-O(m;|1>p&g=y$WXx1}m{9gaOoYoRctEgP}+#RI6~t
zK(P|LkI><|9Oon`)?n>OCs
zpmk&4BWjSV#OZ)EHP(m(gIpC(2cY#})kq%9)!;nh9nPHi0-XfY<%|w`fSKxG>FG0x
zM9zr~nUd+v#3eJFPj>wx5=YVZ&~|5dawS74Yl8U?vt_+AtX>3B^~|2>4tC6ua^J5C$uL_
zGDtkppP6rtU9{t6=WqVH-Q^0JU&@dZJkhcMu7-G+E%dzVQv80)o8nfP-|OH$Z+sCs
zF5A2N%YS6yS4`KOsx@cO7M_z)0Jjzn51g(7K3uu3p5@jQZtDljB@#b#Pxf}ivE&M^
zWt%gzn>+@OE3QGGNz{tEio
z>K3aAzm@F26fIW+OF9t_E37NRN}Vf{WKxoolDkE@MY#k3@qGUcPwUN_MJANGVtOqN
z?KABOS{il2QX text.length) {
+ // Something went terribly wrong, ABORT, ABORT!
+ return;
+ }
+
+ if (str instanceof Token) {
+ continue;
+ }
+
+ pattern.lastIndex = 0;
+
+ var match = pattern.exec(str),
+ delNum = 1;
+
+ // Greedy patterns can override/remove up to two previously matched tokens
+ if (!match && greedy && i != strarr.length - 1) {
+ pattern.lastIndex = pos;
+ match = pattern.exec(text);
+ if (!match) {
+ break;
+ }
+
+ var from = match.index + (lookbehind ? match[1].length : 0),
+ to = match.index + match[0].length,
+ k = i,
+ p = pos;
+
+ for (var len = strarr.length; k < len && (p < to || (!strarr[k].type && !strarr[k - 1].greedy)); ++k) {
+ p += strarr[k].length;
+ // Move the index i to the element in strarr that is closest to from
+ if (from >= p) {
+ ++i;
+ pos = p;
+ }
+ }
+
+ /*
+ * If strarr[i] is a Token, then the match starts inside another Token, which is invalid
+ * If strarr[k - 1] is greedy we are in conflict with another greedy pattern
+ */
+ if (strarr[i] instanceof Token || strarr[k - 1].greedy) {
+ continue;
+ }
+
+ // Number of tokens to delete and replace with the new match
+ delNum = k - i;
+ str = text.slice(pos, p);
+ match.index -= pos;
+ }
+
+ if (!match) {
+ if (oneshot) {
+ break;
+ }
+
+ continue;
+ }
+
+ if(lookbehind) {
+ lookbehindLength = match[1].length;
+ }
+
+ var from = match.index + lookbehindLength,
+ match = match[0].slice(lookbehindLength),
+ to = from + match.length,
+ before = str.slice(0, from),
+ after = str.slice(to);
+
+ var args = [i, delNum];
+
+ if (before) {
+ ++i;
+ pos += before.length;
+ args.push(before);
+ }
+
+ var wrapped = new Token(token, inside? _.tokenize(match, inside) : match, alias, match, greedy);
+
+ args.push(wrapped);
+
+ if (after) {
+ args.push(after);
+ }
+
+ Array.prototype.splice.apply(strarr, args);
+
+ if (delNum != 1)
+ _.matchGrammar(text, strarr, grammar, i, pos, true, token);
+
+ if (oneshot)
+ break;
+ }
+ }
+ }
+ },
+
+ tokenize: function(text, grammar, language) {
+ var strarr = [text];
+
+ var rest = grammar.rest;
+
+ if (rest) {
+ for (var token in rest) {
+ grammar[token] = rest[token];
+ }
+
+ delete grammar.rest;
+ }
+
+ _.matchGrammar(text, strarr, grammar, 0, 0, false);
+
+ return strarr;
+ },
+
+ hooks: {
+ all: {},
+
+ add: function (name, callback) {
+ var hooks = _.hooks.all;
+
+ hooks[name] = hooks[name] || [];
+
+ hooks[name].push(callback);
+ },
+
+ run: function (name, env) {
+ var callbacks = _.hooks.all[name];
+
+ if (!callbacks || !callbacks.length) {
+ return;
+ }
+
+ for (var i=0, callback; callback = callbacks[i++];) {
+ callback(env);
+ }
+ }
+ }
+};
+
+var Token = _.Token = function(type, content, alias, matchedStr, greedy) {
+ this.type = type;
+ this.content = content;
+ this.alias = alias;
+ // Copy of the full string this token was created from
+ this.length = (matchedStr || "").length|0;
+ this.greedy = !!greedy;
+};
+
+Token.stringify = function(o, language, parent) {
+ if (typeof o == 'string') {
+ return o;
+ }
+
+ if (_.util.type(o) === 'Array') {
+ return o.map(function(element) {
+ return Token.stringify(element, language, o);
+ }).join('');
+ }
+
+ var env = {
+ type: o.type,
+ content: Token.stringify(o.content, language, parent),
+ tag: 'span',
+ classes: ['token', o.type],
+ attributes: {},
+ language: language,
+ parent: parent
+ };
+
+ if (env.type == 'comment') {
+ env.attributes['spellcheck'] = 'true';
+ }
+
+ if (o.alias) {
+ var aliases = _.util.type(o.alias) === 'Array' ? o.alias : [o.alias];
+ Array.prototype.push.apply(env.classes, aliases);
+ }
+
+ _.hooks.run('wrap', env);
+
+ var attributes = Object.keys(env.attributes).map(function(name) {
+ return name + '="' + (env.attributes[name] || '').replace(/"/g, '"') + '"';
+ }).join(' ');
+
+ return '<' + env.tag + ' class="' + env.classes.join(' ') + '"' + (attributes ? ' ' + attributes : '') + '>' + env.content + '';
+
+};
+
+if (!_self.document) {
+ if (!_self.addEventListener) {
+ // in Node.js
+ return _self.Prism;
+ }
+ // In worker
+ _self.addEventListener('message', function(evt) {
+ var message = JSON.parse(evt.data),
+ lang = message.language,
+ code = message.code,
+ immediateClose = message.immediateClose;
+
+ _self.postMessage(_.highlight(code, _.languages[lang], lang));
+ if (immediateClose) {
+ _self.close();
+ }
+ }, false);
+
+ return _self.Prism;
+}
+
+//Get current script and highlight
+var script = document.currentScript || [].slice.call(document.getElementsByTagName("script")).pop();
+
+if (script) {
+ _.filename = script.src;
+
+ if (document.addEventListener && !_.manual && !script.hasAttribute('data-manual')) {
+ if(document.readyState !== "loading") {
+ if (window.requestAnimationFrame) {
+ window.requestAnimationFrame(_.highlightAll);
+ } else {
+ window.setTimeout(_.highlightAll, 16);
+ }
+ }
+ else {
+ document.addEventListener('DOMContentLoaded', _.highlightAll);
+ }
+ }
+}
+
+return _self.Prism;
+
+})();
+
+if (typeof module !== 'undefined' && module.exports) {
+ module.exports = Prism;
+}
+
+// hack for components to work correctly in node.js
+if (typeof global !== 'undefined') {
+ global.Prism = Prism;
+}
+;
+Prism.languages.markup = {
+ 'comment': //,
+ 'prolog': /<\?[\s\S]+?\?>/,
+ 'doctype': //i,
+ 'cdata': //i,
+ 'tag': {
+ pattern: /<\/?(?!\d)[^\s>\/=$<]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\\1|\\?(?!\1)[\s\S])*\1|[^\s'">=]+))?)*\s*\/?>/i,
+ inside: {
+ 'tag': {
+ pattern: /^<\/?[^\s>\/]+/i,
+ inside: {
+ 'punctuation': /^<\/?/,
+ 'namespace': /^[^\s>\/:]+:/
+ }
+ },
+ 'attr-value': {
+ pattern: /=(?:('|")[\s\S]*?(\1)|[^\s>]+)/i,
+ inside: {
+ 'punctuation': /[=>"']/
+ }
+ },
+ 'punctuation': /\/?>/,
+ 'attr-name': {
+ pattern: /[^\s>\/]+/,
+ inside: {
+ 'namespace': /^[^\s>\/:]+:/
+ }
+ }
+
+ }
+ },
+ 'entity': /&#?[\da-z]{1,8};/i
+};
+
+Prism.languages.markup['tag'].inside['attr-value'].inside['entity'] =
+ Prism.languages.markup['entity'];
+
+// Plugin to make entity title show the real entity, idea by Roman Komarov
+Prism.hooks.add('wrap', function(env) {
+
+ if (env.type === 'entity') {
+ env.attributes['title'] = env.content.replace(/&/, '&');
+ }
+});
+
+Prism.languages.xml = Prism.languages.markup;
+Prism.languages.html = Prism.languages.markup;
+Prism.languages.mathml = Prism.languages.markup;
+Prism.languages.svg = Prism.languages.markup;
+
+Prism.languages.css = {
+ 'comment': /\/\*[\s\S]*?\*\//,
+ 'atrule': {
+ pattern: /@[\w-]+?.*?(;|(?=\s*\{))/i,
+ inside: {
+ 'rule': /@[\w-]+/
+ // See rest below
+ }
+ },
+ 'url': /url\((?:(["'])(\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1|.*?)\)/i,
+ 'selector': /[^\{\}\s][^\{\};]*?(?=\s*\{)/,
+ 'string': {
+ pattern: /("|')(\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+ greedy: true
+ },
+ 'property': /(\b|\B)[\w-]+(?=\s*:)/i,
+ 'important': /\B!important\b/i,
+ 'function': /[-a-z0-9]+(?=\()/i,
+ 'punctuation': /[(){};:]/
+};
+
+Prism.languages.css['atrule'].inside.rest = Prism.util.clone(Prism.languages.css);
+
+if (Prism.languages.markup) {
+ Prism.languages.insertBefore('markup', 'tag', {
+ 'style': {
+ pattern: /()[\s\S]*?(?=<\/style>)/i,
+ lookbehind: true,
+ inside: Prism.languages.css,
+ alias: 'language-css'
+ }
+ });
+
+ Prism.languages.insertBefore('inside', 'attr-value', {
+ 'style-attr': {
+ pattern: /\s*style=("|').*?\1/i,
+ inside: {
+ 'attr-name': {
+ pattern: /^\s*style/i,
+ inside: Prism.languages.markup.tag.inside
+ },
+ 'punctuation': /^\s*=\s*['"]|['"]\s*$/,
+ 'attr-value': {
+ pattern: /.+/i,
+ inside: Prism.languages.css
+ }
+ },
+ alias: 'language-css'
+ }
+ }, Prism.languages.markup.tag);
+};
+Prism.languages.clike = {
+ 'comment': [
+ {
+ pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
+ lookbehind: true
+ },
+ {
+ pattern: /(^|[^\\:])\/\/.*/,
+ lookbehind: true
+ }
+ ],
+ 'string': {
+ pattern: /(["'])(\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+ greedy: true
+ },
+ 'class-name': {
+ pattern: /((?:\b(?:class|interface|extends|implements|trait|instanceof|new)\s+)|(?:catch\s+\())[a-z0-9_\.\\]+/i,
+ lookbehind: true,
+ inside: {
+ punctuation: /(\.|\\)/
+ }
+ },
+ 'keyword': /\b(if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\b/,
+ 'boolean': /\b(true|false)\b/,
+ 'function': /[a-z0-9_]+(?=\()/i,
+ 'number': /\b-?(?:0x[\da-f]+|\d*\.?\d+(?:e[+-]?\d+)?)\b/i,
+ 'operator': /--?|\+\+?|!=?=?|<=?|>=?|==?=?|&&?|\|\|?|\?|\*|\/|~|\^|%/,
+ 'punctuation': /[{}[\];(),.:]/
+};
+
+Prism.languages.javascript = Prism.languages.extend('clike', {
+ 'keyword': /\b(as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|var|void|while|with|yield)\b/,
+ 'number': /\b-?(0[xX][\dA-Fa-f]+|0[bB][01]+|0[oO][0-7]+|\d*\.?\d+([Ee][+-]?\d+)?|NaN|Infinity)\b/,
+ // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
+ 'function': /[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*(?=\()/i,
+ 'operator': /-[-=]?|\+[+=]?|!=?=?|<>?>?=?|=(?:==?|>)?|&[&=]?|\|[|=]?|\*\*?=?|\/=?|~|\^=?|%=?|\?|\.{3}/
+});
+
+Prism.languages.insertBefore('javascript', 'keyword', {
+ 'regex': {
+ pattern: /(^|[^/])\/(?!\/)(\[[^\]\r\n]+]|\\.|[^/\\\[\r\n])+\/[gimyu]{0,5}(?=\s*($|[\r\n,.;})]))/,
+ lookbehind: true,
+ greedy: true
+ }
+});
+
+Prism.languages.insertBefore('javascript', 'string', {
+ 'template-string': {
+ pattern: /`(?:\\\\|\\?[^\\])*?`/,
+ greedy: true,
+ inside: {
+ 'interpolation': {
+ pattern: /\$\{[^}]+\}/,
+ inside: {
+ 'interpolation-punctuation': {
+ pattern: /^\$\{|\}$/,
+ alias: 'punctuation'
+ },
+ rest: Prism.languages.javascript
+ }
+ },
+ 'string': /[\s\S]+/
+ }
+ }
+});
+
+if (Prism.languages.markup) {
+ Prism.languages.insertBefore('markup', 'tag', {
+ 'script': {
+ pattern: /()[\s\S]*?(?=<\/script>)/i,
+ lookbehind: true,
+ inside: Prism.languages.javascript,
+ alias: 'language-javascript'
+ }
+ });
+}
+
+Prism.languages.js = Prism.languages.javascript;
+
+Prism.languages.abap = {
+ 'comment': /^\*.*/m,
+ 'string' : /(`|')(\\?.)*?\1/m,
+ 'string-template': {
+ pattern: /(\||\})(\\?.)*?(?=\||\{)/,
+ lookbehind: true,
+ alias: 'string'
+ },
+ /* End Of Line comments should not interfere with strings when the
+ quote character occurs within them. We assume a string being highlighted
+ inside an EOL comment is more acceptable than the opposite.
+ */
+ 'eol-comment': {
+ pattern: /(^|\s)".*/m,
+ lookbehind: true,
+ alias: 'comment'
+ },
+ 'keyword' : {
+ pattern: /(\s|\.|^)(?:SCIENTIFIC_WITH_LEADING_ZERO|SCALE_PRESERVING_SCIENTIFIC|RMC_COMMUNICATION_FAILURE|END-ENHANCEMENT-SECTION|MULTIPLY-CORRESPONDING|SUBTRACT-CORRESPONDING|VERIFICATION-MESSAGE|DIVIDE-CORRESPONDING|ENHANCEMENT-SECTION|CURRENCY_CONVERSION|RMC_SYSTEM_FAILURE|START-OF-SELECTION|MOVE-CORRESPONDING|RMC_INVALID_STATUS|CUSTOMER-FUNCTION|END-OF-DEFINITION|ENHANCEMENT-POINT|SYSTEM-EXCEPTIONS|ADD-CORRESPONDING|SCALE_PRESERVING|SELECTION-SCREEN|CURSOR-SELECTION|END-OF-SELECTION|LOAD-OF-PROGRAM|SCROLL-BOUNDARY|SELECTION-TABLE|EXCEPTION-TABLE|IMPLEMENTATIONS|PARAMETER-TABLE|RIGHT-JUSTIFIED|UNIT_CONVERSION|AUTHORITY-CHECK|LIST-PROCESSING|SIGN_AS_POSTFIX|COL_BACKGROUND|IMPLEMENTATION|INTERFACE-POOL|TRANSFORMATION|IDENTIFICATION|ENDENHANCEMENT|LINE-SELECTION|INITIALIZATION|LEFT-JUSTIFIED|SELECT-OPTIONS|SELECTION-SETS|COMMUNICATION|CORRESPONDING|DECIMAL_SHIFT|PRINT-CONTROL|VALUE-REQUEST|CHAIN-REQUEST|FUNCTION-POOL|FIELD-SYMBOLS|FUNCTIONALITY|INVERTED-DATE|SELECTION-SET|CLASS-METHODS|OUTPUT-LENGTH|CLASS-CODING|COL_NEGATIVE|ERRORMESSAGE|FIELD-GROUPS|HELP-REQUEST|NO-EXTENSION|NO-TOPOFPAGE|REDEFINITION|DISPLAY-MODE|ENDINTERFACE|EXIT-COMMAND|FIELD-SYMBOL|NO-SCROLLING|SHORTDUMP-ID|ACCESSPOLICY|CLASS-EVENTS|COL_POSITIVE|DECLARATIONS|ENHANCEMENTS|FILTER-TABLE|SWITCHSTATES|SYNTAX-CHECK|TRANSPORTING|ASYNCHRONOUS|SYNTAX-TRACE|TOKENIZATION|USER-COMMAND|WITH-HEADING|ABAP-SOURCE|BREAK-POINT|CHAIN-INPUT|COMPRESSION|FIXED-POINT|NEW-SECTION|NON-UNICODE|OCCURRENCES|RESPONSIBLE|SYSTEM-CALL|TRACE-TABLE|ABBREVIATED|CHAR-TO-HEX|END-OF-FILE|ENDFUNCTION|ENVIRONMENT|ASSOCIATION|COL_HEADING|EDITOR-CALL|END-OF-PAGE|ENGINEERING|IMPLEMENTED|INTENSIFIED|RADIOBUTTON|SYSTEM-EXIT|TOP-OF-PAGE|TRANSACTION|APPLICATION|CONCATENATE|DESTINATION|ENHANCEMENT|IMMEDIATELY|NO-GROUPING|PRECOMPILED|REPLACEMENT|TITLE-LINES|ACTIVATION|BYTE-ORDER|CLASS-POOL|CONNECTION|CONVERSION|DEFINITION|DEPARTMENT|EXPIRATION|INHERITING|MESSAGE-ID|NO-HEADING|PERFORMING|QUEUE-ONLY|RIGHTSPACE|SCIENTIFIC|STATUSINFO|STRUCTURES|SYNCPOINTS|WITH-TITLE|ATTRIBUTES|BOUNDARIES|CLASS-DATA|COL_NORMAL|DD\/MM\/YYYY|DESCENDING|INTERFACES|LINE-COUNT|MM\/DD\/YYYY|NON-UNIQUE|PRESERVING|SELECTIONS|STATEMENTS|SUBROUTINE|TRUNCATION|TYPE-POOLS|ARITHMETIC|BACKGROUND|ENDPROVIDE|EXCEPTIONS|IDENTIFIER|INDEX-LINE|OBLIGATORY|PARAMETERS|PERCENTAGE|PUSHBUTTON|RESOLUTION|COMPONENTS|DEALLOCATE|DISCONNECT|DUPLICATES|FIRST-LINE|HEAD-LINES|NO-DISPLAY|OCCURRENCE|RESPECTING|RETURNCODE|SUBMATCHES|TRACE-FILE|ASCENDING|BYPASSING|ENDMODULE|EXCEPTION|EXCLUDING|EXPORTING|INCREMENT|MATCHCODE|PARAMETER|PARTIALLY|PREFERRED|REFERENCE|REPLACING|RETURNING|SELECTION|SEPARATED|SPECIFIED|STATEMENT|TIMESTAMP|TYPE-POOL|ACCEPTING|APPENDAGE|ASSIGNING|COL_GROUP|COMPARING|CONSTANTS|DANGEROUS|IMPORTING|INSTANCES|LEFTSPACE|LOG-POINT|QUICKINFO|READ-ONLY|SCROLLING|SQLSCRIPT|STEP-LOOP|TOP-LINES|TRANSLATE|APPENDING|AUTHORITY|CHARACTER|COMPONENT|CONDITION|DIRECTORY|DUPLICATE|MESSAGING|RECEIVING|SUBSCREEN|ACCORDING|COL_TOTAL|END-LINES|ENDMETHOD|ENDSELECT|EXPANDING|EXTENSION|INCLUDING|INFOTYPES|INTERFACE|INTERVALS|LINE-SIZE|PF-STATUS|PROCEDURE|PROTECTED|REQUESTED|RESUMABLE|RIGHTPLUS|SAP-SPOOL|SECONDARY|STRUCTURE|SUBSTRING|TABLEVIEW|NUMOFCHAR|ADJACENT|ANALYSIS|ASSIGNED|BACKWARD|CHANNELS|CHECKBOX|CONTINUE|CRITICAL|DATAINFO|DD\/MM\/YY|DURATION|ENCODING|ENDCLASS|FUNCTION|LEFTPLUS|LINEFEED|MM\/DD\/YY|OVERFLOW|RECEIVED|SKIPPING|SORTABLE|STANDARD|SUBTRACT|SUPPRESS|TABSTRIP|TITLEBAR|TRUNCATE|UNASSIGN|WHENEVER|ANALYZER|COALESCE|COMMENTS|CONDENSE|DECIMALS|DEFERRED|ENDWHILE|EXPLICIT|KEYWORDS|MESSAGES|POSITION|PRIORITY|RECEIVER|RENAMING|TIMEZONE|TRAILING|ALLOCATE|CENTERED|CIRCULAR|CONTROLS|CURRENCY|DELETING|DESCRIBE|DISTANCE|ENDCATCH|EXPONENT|EXTENDED|GENERATE|IGNORING|INCLUDES|INTERNAL|MAJOR-ID|MODIFIER|NEW-LINE|OPTIONAL|PROPERTY|ROLLBACK|STARTING|SUPPLIED|ABSTRACT|CHANGING|CONTEXTS|CREATING|CUSTOMER|DATABASE|DAYLIGHT|DEFINING|DISTINCT|DIVISION|ENABLING|ENDCHAIN|ESCAPING|HARMLESS|IMPLICIT|INACTIVE|LANGUAGE|MINOR-ID|MULTIPLY|NEW-PAGE|NO-TITLE|POS_HIGH|SEPARATE|TEXTPOOL|TRANSFER|SELECTOR|DBMAXLEN|ITERATOR|SELECTOR|ARCHIVE|BIT-XOR|BYTE-CO|COLLECT|COMMENT|CURRENT|DEFAULT|DISPLAY|ENDFORM|EXTRACT|LEADING|LISTBOX|LOCATOR|MEMBERS|METHODS|NESTING|POS_LOW|PROCESS|PROVIDE|RAISING|RESERVE|SECONDS|SUMMARY|VISIBLE|BETWEEN|BIT-AND|BYTE-CS|CLEANUP|COMPUTE|CONTROL|CONVERT|DATASET|ENDCASE|FORWARD|HEADERS|HOTSPOT|INCLUDE|INVERSE|KEEPING|NO-ZERO|OBJECTS|OVERLAY|PADDING|PATTERN|PROGRAM|REFRESH|SECTION|SUMMING|TESTING|VERSION|WINDOWS|WITHOUT|BIT-NOT|BYTE-CA|BYTE-NA|CASTING|CONTEXT|COUNTRY|DYNAMIC|ENABLED|ENDLOOP|EXECUTE|FRIENDS|HANDLER|HEADING|INITIAL|\*-INPUT|LOGFILE|MAXIMUM|MINIMUM|NO-GAPS|NO-SIGN|PRAGMAS|PRIMARY|PRIVATE|REDUCED|REPLACE|REQUEST|RESULTS|UNICODE|WARNING|ALIASES|BYTE-CN|BYTE-NS|CALLING|COL_KEY|COLUMNS|CONNECT|ENDEXEC|ENTRIES|EXCLUDE|FILTERS|FURTHER|HELP-ID|LOGICAL|MAPPING|MESSAGE|NAMETAB|OPTIONS|PACKAGE|PERFORM|RECEIVE|STATICS|VARYING|BINDING|CHARLEN|GREATER|XSTRLEN|ACCEPT|APPEND|DETAIL|ELSEIF|ENDING|ENDTRY|FORMAT|FRAMES|GIVING|HASHED|HEADER|IMPORT|INSERT|MARGIN|MODULE|NATIVE|OBJECT|OFFSET|REMOTE|RESUME|SAVING|SIMPLE|SUBMIT|TABBED|TOKENS|UNIQUE|UNPACK|UPDATE|WINDOW|YELLOW|ACTUAL|ASPECT|CENTER|CURSOR|DELETE|DIALOG|DIVIDE|DURING|ERRORS|EVENTS|EXTEND|FILTER|HANDLE|HAVING|IGNORE|LITTLE|MEMORY|NO-GAP|OCCURS|OPTION|PERSON|PLACES|PUBLIC|REDUCE|REPORT|RESULT|SINGLE|SORTED|SWITCH|SYNTAX|TARGET|VALUES|WRITER|ASSERT|BLOCKS|BOUNDS|BUFFER|CHANGE|COLUMN|COMMIT|CONCAT|COPIES|CREATE|DDMMYY|DEFINE|ENDIAN|ESCAPE|EXPAND|KERNEL|LAYOUT|LEGACY|LEVELS|MMDDYY|NUMBER|OUTPUT|RANGES|READER|RETURN|SCREEN|SEARCH|SELECT|SHARED|SOURCE|STABLE|STATIC|SUBKEY|SUFFIX|TABLES|UNWIND|YYMMDD|ASSIGN|BACKUP|BEFORE|BINARY|BIT-OR|BLANKS|CLIENT|CODING|COMMON|DEMAND|DYNPRO|EXCEPT|EXISTS|EXPORT|FIELDS|GLOBAL|GROUPS|LENGTH|LOCALE|MEDIUM|METHOD|MODIFY|NESTED|OTHERS|REJECT|SCROLL|SUPPLY|SYMBOL|ENDFOR|STRLEN|ALIGN|BEGIN|BOUND|ENDAT|ENTRY|EVENT|FINAL|FLUSH|GRANT|INNER|SHORT|USING|WRITE|AFTER|BLACK|BLOCK|CLOCK|COLOR|COUNT|DUMMY|EMPTY|ENDDO|ENDON|GREEN|INDEX|INOUT|LEAVE|LEVEL|LINES|MODIF|ORDER|OUTER|RANGE|RESET|RETRY|RIGHT|SMART|SPLIT|STYLE|TABLE|THROW|UNDER|UNTIL|UPPER|UTF-8|WHERE|ALIAS|BLANK|CLEAR|CLOSE|EXACT|FETCH|FIRST|FOUND|GROUP|LLANG|LOCAL|OTHER|REGEX|SPOOL|TITLE|TYPES|VALID|WHILE|ALPHA|BOXED|CATCH|CHAIN|CHECK|CLASS|COVER|ENDIF|EQUIV|FIELD|FLOOR|FRAME|INPUT|LOWER|MATCH|NODES|PAGES|PRINT|RAISE|ROUND|SHIFT|SPACE|SPOTS|STAMP|STATE|TASKS|TIMES|TRMAC|ULINE|UNION|VALUE|WIDTH|EQUAL|LOG10|TRUNC|BLOB|CASE|CEIL|CLOB|COND|EXIT|FILE|GAPS|HOLD|INCL|INTO|KEEP|KEYS|LAST|LINE|LONG|LPAD|MAIL|MODE|OPEN|PINK|READ|ROWS|TEST|THEN|ZERO|AREA|BACK|BADI|BYTE|CAST|EDIT|EXEC|FAIL|FIND|FKEQ|FONT|FREE|GKEQ|HIDE|INIT|ITNO|LATE|LOOP|MAIN|MARK|MOVE|NEXT|NULL|RISK|ROLE|UNIT|WAIT|ZONE|BASE|CALL|CODE|DATA|DATE|FKGE|GKGE|HIGH|KIND|LEFT|LIST|MASK|MESH|NAME|NODE|PACK|PAGE|POOL|SEND|SIGN|SIZE|SOME|STOP|TASK|TEXT|TIME|USER|VARY|WITH|WORD|BLUE|CONV|COPY|DEEP|ELSE|FORM|FROM|HINT|ICON|JOIN|LIKE|LOAD|ONLY|PART|SCAN|SKIP|SORT|TYPE|UNIX|VIEW|WHEN|WORK|ACOS|ASIN|ATAN|COSH|EACH|FRAC|LESS|RTTI|SINH|SQRT|TANH|AVG|BIT|DIV|ISO|LET|OUT|PAD|SQL|ALL|CI_|CPI|END|LOB|LPI|MAX|MIN|NEW|OLE|RUN|SET|\?TO|YES|ABS|ADD|AND|BIG|FOR|HDB|JOB|LOW|NOT|SAP|TRY|VIA|XML|ANY|GET|IDS|KEY|MOD|OFF|PUT|RAW|RED|REF|SUM|TAB|XSD|CNT|COS|EXP|LOG|SIN|TAN|XOR|AT|CO|CP|DO|GT|ID|IF|NS|OR|BT|CA|CS|GE|NA|NB|EQ|IN|LT|NE|NO|OF|ON|PF|TO|AS|BY|CN|IS|LE|NP|UP|E|I|M|O|Z|C|X)\b/i,
+ lookbehind: true
+ },
+ /* Numbers can be only integers. Decimal or Hex appear only as strings */
+ 'number' : /\b\d+\b/,
+ /* Operators must always be surrounded by whitespace, they cannot be put
+ adjacent to operands.
+ */
+ 'operator' : {
+ pattern: /(\s)(?:\*\*?|<[=>]?|>=?|\?=|[-+\/=])(?=\s)/,
+ lookbehind: true
+ },
+ 'string-operator' : {
+ pattern: /(\s)&&?(?=\s)/,
+ lookbehind: true,
+ /* The official editor highlights */
+ alias: "keyword"
+ },
+ 'token-operator' : [{
+ /* Special operators used to access structure components, class methods/attributes, etc. */
+ pattern: /(\w)(?:->?|=>|[~|{}])(?=\w)/,
+ lookbehind: true,
+ alias: "punctuation"
+ }, {
+ /* Special tokens used do delimit string templates */
+ pattern: /[|{}]/,
+ alias: "punctuation"
+ }],
+ 'punctuation' : /[,.:()]/
+};
+Prism.languages.actionscript = Prism.languages.extend('javascript', {
+ 'keyword': /\b(?:as|break|case|catch|class|const|default|delete|do|else|extends|finally|for|function|if|implements|import|in|instanceof|interface|internal|is|native|new|null|package|private|protected|public|return|super|switch|this|throw|try|typeof|use|var|void|while|with|dynamic|each|final|get|include|namespace|native|override|set|static)\b/,
+ 'operator': /\+\+|--|(?:[+\-*\/%^]|&&?|\|\|?|<>?>?|[!=]=?)=?|[~?@]/
+});
+Prism.languages.actionscript['class-name'].alias = 'function';
+
+if (Prism.languages.markup) {
+ Prism.languages.insertBefore('actionscript', 'string', {
+ 'xml': {
+ pattern: /(^|[^.])<\/?\w+(?:\s+[^\s>\/=]+=("|')(?:\\\1|\\?(?!\1)[\s\S])*\2)*\s*\/?>/,
+ lookbehind: true,
+ inside: {
+ rest: Prism.languages.markup
+ }
+ }
+ });
+};
+Prism.languages.ada = {
+ 'comment': /--.*/,
+ 'string': /"(?:""|[^"\r\f\n])*"/i,
+ 'number': [
+ {
+ pattern: /\b\d(?:_?\d)*#[0-9A-F](?:_?[0-9A-F])*(?:\.[0-9A-F](?:_?[0-9A-F])*)?#(?:E[+-]?\d(?:_?\d)*)?/i
+ },
+ {
+ pattern: /\b\d(?:_?\d)*(?:\.\d(?:_?\d)*)?(?:E[+-]?\d(?:_?\d)*)?\b/i
+ }
+ ],
+ 'attr-name': /\b'\w+/i,
+ 'keyword': /\b(?:abort|abs|abstract|accept|access|aliased|all|and|array|at|begin|body|case|constant|declare|delay|delta|digits|do|else|new|return|elsif|end|entry|exception|exit|for|function|generic|goto|if|in|interface|is|limited|loop|mod|not|null|of|others|out|overriding|package|pragma|private|procedure|protected|raise|range|record|rem|renames|requeue|reverse|select|separate|some|subtype|synchronized|tagged|task|terminate|then|type|until|use|when|while|with|xor)\b/i,
+ 'boolean': /\b(?:true|false)\b/i,
+ 'operator': /<[=>]?|>=?|=>?|:=|\/=?|\*\*?|[&+-]/,
+ 'punctuation': /\.\.?|[,;():]/,
+ 'char': /'.'/,
+ 'variable': /\b[a-z](?:[_a-z\d])*\b/i
+};
+Prism.languages.apacheconf = {
+ 'comment': /#.*/,
+ 'directive-inline': {
+ pattern: /^(\s*)\b(AcceptFilter|AcceptPathInfo|AccessFileName|Action|AddAlt|AddAltByEncoding|AddAltByType|AddCharset|AddDefaultCharset|AddDescription|AddEncoding|AddHandler|AddIcon|AddIconByEncoding|AddIconByType|AddInputFilter|AddLanguage|AddModuleInfo|AddOutputFilter|AddOutputFilterByType|AddType|Alias|AliasMatch|Allow|AllowCONNECT|AllowEncodedSlashes|AllowMethods|AllowOverride|AllowOverrideList|Anonymous|Anonymous_LogEmail|Anonymous_MustGiveEmail|Anonymous_NoUserID|Anonymous_VerifyEmail|AsyncRequestWorkerFactor|AuthBasicAuthoritative|AuthBasicFake|AuthBasicProvider|AuthBasicUseDigestAlgorithm|AuthDBDUserPWQuery|AuthDBDUserRealmQuery|AuthDBMGroupFile|AuthDBMType|AuthDBMUserFile|AuthDigestAlgorithm|AuthDigestDomain|AuthDigestNonceLifetime|AuthDigestProvider|AuthDigestQop|AuthDigestShmemSize|AuthFormAuthoritative|AuthFormBody|AuthFormDisableNoStore|AuthFormFakeBasicAuth|AuthFormLocation|AuthFormLoginRequiredLocation|AuthFormLoginSuccessLocation|AuthFormLogoutLocation|AuthFormMethod|AuthFormMimetype|AuthFormPassword|AuthFormProvider|AuthFormSitePassphrase|AuthFormSize|AuthFormUsername|AuthGroupFile|AuthLDAPAuthorizePrefix|AuthLDAPBindAuthoritative|AuthLDAPBindDN|AuthLDAPBindPassword|AuthLDAPCharsetConfig|AuthLDAPCompareAsUser|AuthLDAPCompareDNOnServer|AuthLDAPDereferenceAliases|AuthLDAPGroupAttribute|AuthLDAPGroupAttributeIsDN|AuthLDAPInitialBindAsUser|AuthLDAPInitialBindPattern|AuthLDAPMaxSubGroupDepth|AuthLDAPRemoteUserAttribute|AuthLDAPRemoteUserIsDN|AuthLDAPSearchAsUser|AuthLDAPSubGroupAttribute|AuthLDAPSubGroupClass|AuthLDAPUrl|AuthMerging|AuthName|AuthnCacheContext|AuthnCacheEnable|AuthnCacheProvideFor|AuthnCacheSOCache|AuthnCacheTimeout|AuthnzFcgiCheckAuthnProvider|AuthnzFcgiDefineProvider|AuthType|AuthUserFile|AuthzDBDLoginToReferer|AuthzDBDQuery|AuthzDBDRedirectQuery|AuthzDBMType|AuthzSendForbiddenOnFailure|BalancerGrowth|BalancerInherit|BalancerMember|BalancerPersist|BrowserMatch|BrowserMatchNoCase|BufferedLogs|BufferSize|CacheDefaultExpire|CacheDetailHeader|CacheDirLength|CacheDirLevels|CacheDisable|CacheEnable|CacheFile|CacheHeader|CacheIgnoreCacheControl|CacheIgnoreHeaders|CacheIgnoreNoLastMod|CacheIgnoreQueryString|CacheIgnoreURLSessionIdentifiers|CacheKeyBaseURL|CacheLastModifiedFactor|CacheLock|CacheLockMaxAge|CacheLockPath|CacheMaxExpire|CacheMaxFileSize|CacheMinExpire|CacheMinFileSize|CacheNegotiatedDocs|CacheQuickHandler|CacheReadSize|CacheReadTime|CacheRoot|CacheSocache|CacheSocacheMaxSize|CacheSocacheMaxTime|CacheSocacheMinTime|CacheSocacheReadSize|CacheSocacheReadTime|CacheStaleOnError|CacheStoreExpired|CacheStoreNoStore|CacheStorePrivate|CGIDScriptTimeout|CGIMapExtension|CharsetDefault|CharsetOptions|CharsetSourceEnc|CheckCaseOnly|CheckSpelling|ChrootDir|ContentDigest|CookieDomain|CookieExpires|CookieName|CookieStyle|CookieTracking|CoreDumpDirectory|CustomLog|Dav|DavDepthInfinity|DavGenericLockDB|DavLockDB|DavMinTimeout|DBDExptime|DBDInitSQL|DBDKeep|DBDMax|DBDMin|DBDParams|DBDPersist|DBDPrepareSQL|DBDriver|DefaultIcon|DefaultLanguage|DefaultRuntimeDir|DefaultType|Define|DeflateBufferSize|DeflateCompressionLevel|DeflateFilterNote|DeflateInflateLimitRequestBody|DeflateInflateRatioBurst|DeflateInflateRatioLimit|DeflateMemLevel|DeflateWindowSize|Deny|DirectoryCheckHandler|DirectoryIndex|DirectoryIndexRedirect|DirectorySlash|DocumentRoot|DTracePrivileges|DumpIOInput|DumpIOOutput|EnableExceptionHook|EnableMMAP|EnableSendfile|Error|ErrorDocument|ErrorLog|ErrorLogFormat|Example|ExpiresActive|ExpiresByType|ExpiresDefault|ExtendedStatus|ExtFilterDefine|ExtFilterOptions|FallbackResource|FileETag|FilterChain|FilterDeclare|FilterProtocol|FilterProvider|FilterTrace|ForceLanguagePriority|ForceType|ForensicLog|GprofDir|GracefulShutdownTimeout|Group|Header|HeaderName|HeartbeatAddress|HeartbeatListen|HeartbeatMaxServers|HeartbeatStorage|HeartbeatStorage|HostnameLookups|IdentityCheck|IdentityCheckTimeout|ImapBase|ImapDefault|ImapMenu|Include|IncludeOptional|IndexHeadInsert|IndexIgnore|IndexIgnoreReset|IndexOptions|IndexOrderDefault|IndexStyleSheet|InputSed|ISAPIAppendLogToErrors|ISAPIAppendLogToQuery|ISAPICacheFile|ISAPIFakeAsync|ISAPILogNotSupported|ISAPIReadAheadBuffer|KeepAlive|KeepAliveTimeout|KeptBodySize|LanguagePriority|LDAPCacheEntries|LDAPCacheTTL|LDAPConnectionPoolTTL|LDAPConnectionTimeout|LDAPLibraryDebug|LDAPOpCacheEntries|LDAPOpCacheTTL|LDAPReferralHopLimit|LDAPReferrals|LDAPRetries|LDAPRetryDelay|LDAPSharedCacheFile|LDAPSharedCacheSize|LDAPTimeout|LDAPTrustedClientCert|LDAPTrustedGlobalCert|LDAPTrustedMode|LDAPVerifyServerCert|LimitInternalRecursion|LimitRequestBody|LimitRequestFields|LimitRequestFieldSize|LimitRequestLine|LimitXMLRequestBody|Listen|ListenBackLog|LoadFile|LoadModule|LogFormat|LogLevel|LogMessage|LuaAuthzProvider|LuaCodeCache|LuaHookAccessChecker|LuaHookAuthChecker|LuaHookCheckUserID|LuaHookFixups|LuaHookInsertFilter|LuaHookLog|LuaHookMapToStorage|LuaHookTranslateName|LuaHookTypeChecker|LuaInherit|LuaInputFilter|LuaMapHandler|LuaOutputFilter|LuaPackageCPath|LuaPackagePath|LuaQuickHandler|LuaRoot|LuaScope|MaxConnectionsPerChild|MaxKeepAliveRequests|MaxMemFree|MaxRangeOverlaps|MaxRangeReversals|MaxRanges|MaxRequestWorkers|MaxSpareServers|MaxSpareThreads|MaxThreads|MergeTrailers|MetaDir|MetaFiles|MetaSuffix|MimeMagicFile|MinSpareServers|MinSpareThreads|MMapFile|ModemStandard|ModMimeUsePathInfo|MultiviewsMatch|Mutex|NameVirtualHost|NoProxy|NWSSLTrustedCerts|NWSSLUpgradeable|Options|Order|OutputSed|PassEnv|PidFile|PrivilegesMode|Protocol|ProtocolEcho|ProxyAddHeaders|ProxyBadHeader|ProxyBlock|ProxyDomain|ProxyErrorOverride|ProxyExpressDBMFile|ProxyExpressDBMType|ProxyExpressEnable|ProxyFtpDirCharset|ProxyFtpEscapeWildcards|ProxyFtpListOnWildcard|ProxyHTMLBufSize|ProxyHTMLCharsetOut|ProxyHTMLDocType|ProxyHTMLEnable|ProxyHTMLEvents|ProxyHTMLExtended|ProxyHTMLFixups|ProxyHTMLInterp|ProxyHTMLLinks|ProxyHTMLMeta|ProxyHTMLStripComments|ProxyHTMLURLMap|ProxyIOBufferSize|ProxyMaxForwards|ProxyPass|ProxyPassInherit|ProxyPassInterpolateEnv|ProxyPassMatch|ProxyPassReverse|ProxyPassReverseCookieDomain|ProxyPassReverseCookiePath|ProxyPreserveHost|ProxyReceiveBufferSize|ProxyRemote|ProxyRemoteMatch|ProxyRequests|ProxySCGIInternalRedirect|ProxySCGISendfile|ProxySet|ProxySourceAddress|ProxyStatus|ProxyTimeout|ProxyVia|ReadmeName|ReceiveBufferSize|Redirect|RedirectMatch|RedirectPermanent|RedirectTemp|ReflectorHeader|RemoteIPHeader|RemoteIPInternalProxy|RemoteIPInternalProxyList|RemoteIPProxiesHeader|RemoteIPTrustedProxy|RemoteIPTrustedProxyList|RemoveCharset|RemoveEncoding|RemoveHandler|RemoveInputFilter|RemoveLanguage|RemoveOutputFilter|RemoveType|RequestHeader|RequestReadTimeout|Require|RewriteBase|RewriteCond|RewriteEngine|RewriteMap|RewriteOptions|RewriteRule|RLimitCPU|RLimitMEM|RLimitNPROC|Satisfy|ScoreBoardFile|Script|ScriptAlias|ScriptAliasMatch|ScriptInterpreterSource|ScriptLog|ScriptLogBuffer|ScriptLogLength|ScriptSock|SecureListen|SeeRequestTail|SendBufferSize|ServerAdmin|ServerAlias|ServerLimit|ServerName|ServerPath|ServerRoot|ServerSignature|ServerTokens|Session|SessionCookieName|SessionCookieName2|SessionCookieRemove|SessionCryptoCipher|SessionCryptoDriver|SessionCryptoPassphrase|SessionCryptoPassphraseFile|SessionDBDCookieName|SessionDBDCookieName2|SessionDBDCookieRemove|SessionDBDDeleteLabel|SessionDBDInsertLabel|SessionDBDPerUser|SessionDBDSelectLabel|SessionDBDUpdateLabel|SessionEnv|SessionExclude|SessionHeader|SessionInclude|SessionMaxAge|SetEnv|SetEnvIf|SetEnvIfExpr|SetEnvIfNoCase|SetHandler|SetInputFilter|SetOutputFilter|SSIEndTag|SSIErrorMsg|SSIETag|SSILastModified|SSILegacyExprParser|SSIStartTag|SSITimeFormat|SSIUndefinedEcho|SSLCACertificateFile|SSLCACertificatePath|SSLCADNRequestFile|SSLCADNRequestPath|SSLCARevocationCheck|SSLCARevocationFile|SSLCARevocationPath|SSLCertificateChainFile|SSLCertificateFile|SSLCertificateKeyFile|SSLCipherSuite|SSLCompression|SSLCryptoDevice|SSLEngine|SSLFIPS|SSLHonorCipherOrder|SSLInsecureRenegotiation|SSLOCSPDefaultResponder|SSLOCSPEnable|SSLOCSPOverrideResponder|SSLOCSPResponderTimeout|SSLOCSPResponseMaxAge|SSLOCSPResponseTimeSkew|SSLOCSPUseRequestNonce|SSLOpenSSLConfCmd|SSLOptions|SSLPassPhraseDialog|SSLProtocol|SSLProxyCACertificateFile|SSLProxyCACertificatePath|SSLProxyCARevocationCheck|SSLProxyCARevocationFile|SSLProxyCARevocationPath|SSLProxyCheckPeerCN|SSLProxyCheckPeerExpire|SSLProxyCheckPeerName|SSLProxyCipherSuite|SSLProxyEngine|SSLProxyMachineCertificateChainFile|SSLProxyMachineCertificateFile|SSLProxyMachineCertificatePath|SSLProxyProtocol|SSLProxyVerify|SSLProxyVerifyDepth|SSLRandomSeed|SSLRenegBufferSize|SSLRequire|SSLRequireSSL|SSLSessionCache|SSLSessionCacheTimeout|SSLSessionTicketKeyFile|SSLSRPUnknownUserSeed|SSLSRPVerifierFile|SSLStaplingCache|SSLStaplingErrorCacheTimeout|SSLStaplingFakeTryLater|SSLStaplingForceURL|SSLStaplingResponderTimeout|SSLStaplingResponseMaxAge|SSLStaplingResponseTimeSkew|SSLStaplingReturnResponderErrors|SSLStaplingStandardCacheTimeout|SSLStrictSNIVHostCheck|SSLUserName|SSLUseStapling|SSLVerifyClient|SSLVerifyDepth|StartServers|StartThreads|Substitute|Suexec|SuexecUserGroup|ThreadLimit|ThreadsPerChild|ThreadStackSize|TimeOut|TraceEnable|TransferLog|TypesConfig|UnDefine|UndefMacro|UnsetEnv|Use|UseCanonicalName|UseCanonicalPhysicalPort|User|UserDir|VHostCGIMode|VHostCGIPrivs|VHostGroup|VHostPrivs|VHostSecure|VHostUser|VirtualDocumentRoot|VirtualDocumentRootIP|VirtualScriptAlias|VirtualScriptAliasIP|WatchdogInterval|XBitHack|xml2EncAlias|xml2EncDefault|xml2StartParse)\b/mi,
+ lookbehind: true,
+ alias: 'property'
+ },
+ 'directive-block': {
+ pattern: /<\/?\b(AuthnProviderAlias|AuthzProviderAlias|Directory|DirectoryMatch|Else|ElseIf|Files|FilesMatch|If|IfDefine|IfModule|IfVersion|Limit|LimitExcept|Location|LocationMatch|Macro|Proxy|RequireAll|RequireAny|RequireNone|VirtualHost)\b *.*>/i,
+ inside: {
+ 'directive-block': {
+ pattern: /^<\/?\w+/,
+ inside: {
+ 'punctuation': /^<\/?/
+ },
+ alias: 'tag'
+ },
+ 'directive-block-parameter': {
+ pattern: /.*[^>]/,
+ inside: {
+ 'punctuation': /:/,
+ 'string': {
+ pattern: /("|').*\1/,
+ inside: {
+ 'variable': /(\$|%)\{?(\w\.?(\+|\-|:)?)+\}?/
+ }
+ }
+ },
+ alias: 'attr-value'
+ },
+ 'punctuation': />/
+ },
+ alias: 'tag'
+ },
+ 'directive-flags': {
+ pattern: /\[(\w,?)+\]/,
+ alias: 'keyword'
+ },
+ 'string': {
+ pattern: /("|').*\1/,
+ inside: {
+ 'variable': /(\$|%)\{?(\w\.?(\+|\-|:)?)+\}?/
+ }
+ },
+ 'variable': /(\$|%)\{?(\w\.?(\+|\-|:)?)+\}?/,
+ 'regex': /\^?.*\$|\^.*\$?/
+};
+
+Prism.languages.apl = {
+ 'comment': /(?:â|#[! ]).*$/m,
+ 'string': {
+ pattern: /'(?:[^'\r\n]|'')*'/,
+ greedy: true
+ },
+ 'number': /¯?(?:\d*\.?\d+(?:e[+¯]?\d+)?|¯|∞)(?:j¯?(?:\d*\.?\d+(?:e[\+¯]?\d+)?|¯|∞))?/i,
+ 'statement': /:[A-Z][a-z][A-Za-z]*\b/,
+ 'system-function': {
+ pattern: /⎕[A-Z]+/i,
+ alias: 'function'
+ },
+ 'constant': /[â¬âŒ¾#⎕âž]/,
+ 'function': /[-+×÷⌈⌊∣|â³â¸?*âŸâ—‹!⌹<≤=>≥≠≡≢∊â·âˆªâˆ©~∨∧â±â²â´,âªâŒ½âŠ–â‰â†‘↓⊂⊃⊆⊇⌷â‹â’⊤⊥â•âŽâŠ£âŠ¢ââ‚≈â¯â†—¤→]/,
+ 'monadic-operator': {
+ pattern: /[\\\/⌿â€Â¨â¨âŒ¶&∥]/,
+ alias: 'operator'
+ },
+ 'dyadic-operator': {
+ pattern: /[.â£â â¤âˆ˜âŒ¸@⌺]/,
+ alias: 'operator'
+ },
+ 'assignment': {
+ pattern: /â†/,
+ alias: 'keyword'
+ },
+ 'punctuation': /[\[;\]()◇⋄]/,
+ 'dfn': {
+ pattern: /[{}âºâµâ¶â¹âˆ‡â«:]/,
+ alias: 'builtin'
+ }
+};
+
+Prism.languages.applescript = {
+ 'comment': [
+ // Allow one level of nesting
+ /\(\*(?:\(\*[\s\S]*?\*\)|[\s\S])*?\*\)/,
+ /--.+/,
+ /#.+/
+ ],
+ 'string': /"(?:\\?.)*?"/,
+ 'number': /\b-?\d*\.?\d+([Ee]-?\d+)?\b/,
+ 'operator': [
+ /[&=≠≤≥*+\-\/÷^]|[<>]=?/,
+ /\b(?:(?:start|begin|end)s? with|(?:(?:does not|doesn't) contain|contains?)|(?:is|isn't|is not) (?:in|contained by)|(?:(?:is|isn't|is not) )?(?:greater|less) than(?: or equal)?(?: to)?|(?:(?:does not|doesn't) come|comes) (?:before|after)|(?:is|isn't|is not) equal(?: to)?|(?:(?:does not|doesn't) equal|equals|equal to|isn't|is not)|(?:a )?(?:ref(?: to)?|reference to)|(?:and|or|div|mod|as|not))\b/
+ ],
+ 'keyword': /\b(?:about|above|after|against|apart from|around|aside from|at|back|before|beginning|behind|below|beneath|beside|between|but|by|considering|continue|copy|does|eighth|else|end|equal|error|every|exit|false|fifth|first|for|fourth|from|front|get|given|global|if|ignoring|in|instead of|into|is|it|its|last|local|me|middle|my|ninth|of|on|onto|out of|over|prop|property|put|repeat|return|returning|second|set|seventh|since|sixth|some|tell|tenth|that|the|then|third|through|thru|timeout|times|to|transaction|true|try|until|where|while|whose|with|without)\b/,
+ 'class': {
+ pattern: /\b(?:alias|application|boolean|class|constant|date|file|integer|list|number|POSIX file|real|record|reference|RGB color|script|text|centimetres|centimeters|feet|inches|kilometres|kilometers|metres|meters|miles|yards|square feet|square kilometres|square kilometers|square metres|square meters|square miles|square yards|cubic centimetres|cubic centimeters|cubic feet|cubic inches|cubic metres|cubic meters|cubic yards|gallons|litres|liters|quarts|grams|kilograms|ounces|pounds|degrees Celsius|degrees Fahrenheit|degrees Kelvin)\b/,
+ alias: 'builtin'
+ },
+ 'punctuation': /[{}():,¬«»《》]/
+};
+(function (Prism) {
+
+ var attributes = {
+ pattern: /(^[ \t]*)\[(?!\[)(?:(["'$`])(?:(?!\2)[^\\]|\\.)*\2|\[(?:[^\]\\]|\\.)*\]|[^\]\\]|\\.)*\]/m,
+ lookbehind: true,
+ inside: {
+ 'quoted': {
+ pattern: /([$`])(?:(?!\1)[^\\]|\\.)*\1/,
+ inside: {
+ 'punctuation': /^[$`]|[$`]$/
+ }
+ },
+ 'interpreted': {
+ pattern: /'(?:[^'\\]|\\.)*'/,
+ inside: {
+ 'punctuation': /^'|'$/
+ // See rest below
+ }
+ },
+ 'string': /"(?:[^"\\]|\\.)*"/,
+ 'variable': /\w+(?==)/,
+ 'punctuation': /^\[|\]$|,/,
+ 'operator': /=/,
+ // The negative look-ahead prevents blank matches
+ 'attr-value': /(?!^\s+$).+/
+ }
+ };
+ Prism.languages.asciidoc = {
+ 'comment-block': {
+ pattern: /^(\/{4,})(?:\r?\n|\r)(?:[\s\S]*(?:\r?\n|\r))??\1/m,
+ alias: 'comment'
+ },
+ 'table': {
+ pattern: /^\|={3,}(?:(?:\r?\n|\r).*)*?(?:\r?\n|\r)\|={3,}$/m,
+ inside: {
+ 'specifiers': {
+ pattern: /(?!\|)(?:(?:(?:\d+(?:\.\d+)?|\.\d+)[+*])?(?:[<^>](?:\.[<^>])?|\.[<^>])?[a-z]*)(?=\|)/,
+ alias: 'attr-value'
+ },
+ 'punctuation': {
+ pattern: /(^|[^\\])[|!]=*/,
+ lookbehind: true
+ }
+ // See rest below
+ }
+ },
+
+ 'passthrough-block': {
+ pattern: /^(\+{4,})(?:\r?\n|\r)(?:[\s\S]*(?:\r?\n|\r))??\1$/m,
+ inside: {
+ 'punctuation': /^\++|\++$/
+ // See rest below
+ }
+ },
+ // Literal blocks and listing blocks
+ 'literal-block': {
+ pattern: /^(-{4,}|\.{4,})(?:\r?\n|\r)(?:[\s\S]*(?:\r?\n|\r))??\1$/m,
+ inside: {
+ 'punctuation': /^(?:-+|\.+)|(?:-+|\.+)$/
+ // See rest below
+ }
+ },
+ // Sidebar blocks, quote blocks, example blocks and open blocks
+ 'other-block': {
+ pattern: /^(--|\*{4,}|_{4,}|={4,})(?:\r?\n|\r)(?:[\s\S]*(?:\r?\n|\r))??\1$/m,
+ inside: {
+ 'punctuation': /^(?:-+|\*+|_+|=+)|(?:-+|\*+|_+|=+)$/
+ // See rest below
+ }
+ },
+
+ // list-punctuation and list-label must appear before indented-block
+ 'list-punctuation': {
+ pattern: /(^[ \t]*)(?:-|\*{1,5}|\.{1,5}|(?:[a-z]|\d+)\.|[xvi]+\))(?= )/im,
+ lookbehind: true,
+ alias: 'punctuation'
+ },
+ 'list-label': {
+ pattern: /(^[ \t]*)[a-z\d].+(?::{2,4}|;;)(?=\s)/im,
+ lookbehind: true,
+ alias: 'symbol'
+ },
+ 'indented-block': {
+ pattern: /((\r?\n|\r)\2)([ \t]+)\S.*(?:(?:\r?\n|\r)\3.+)*(?=\2{2}|$)/,
+ lookbehind: true
+ },
+
+ 'comment': /^\/\/.*/m,
+ 'title': {
+ pattern: /^.+(?:\r?\n|\r)(?:={3,}|-{3,}|~{3,}|\^{3,}|\+{3,})$|^={1,5} +.+|^\.(?![\s.]).*/m,
+ alias: 'important',
+ inside: {
+ 'punctuation': /^(?:\.|=+)|(?:=+|-+|~+|\^+|\++)$/
+ // See rest below
+ }
+ },
+ 'attribute-entry': {
+ pattern: /^:[^:\r\n]+:(?: .*?(?: \+(?:\r?\n|\r).*?)*)?$/m,
+ alias: 'tag'
+ },
+ 'attributes': attributes,
+ 'hr': {
+ pattern: /^'{3,}$/m,
+ alias: 'punctuation'
+ },
+ 'page-break': {
+ pattern: /^<{3,}$/m,
+ alias: 'punctuation'
+ },
+ 'admonition': {
+ pattern: /^(?:TIP|NOTE|IMPORTANT|WARNING|CAUTION):/m,
+ alias: 'keyword'
+ },
+ 'callout': [
+ {
+ pattern: /(^[ \t]*)/m,
+ lookbehind: true,
+ alias: 'symbol'
+ },
+ {
+ pattern: /<\d+>/,
+ alias: 'symbol'
+ }
+ ],
+ 'macro': {
+ pattern: /\b[a-z\d][a-z\d-]*::?(?:(?:\S+)??\[(?:[^\]\\"]|(["'])(?:(?!\1)[^\\]|\\.)*\1|\\.)*\])/,
+ inside: {
+ 'function': /^[a-z\d-]+(?=:)/,
+ 'punctuation': /^::?/,
+ 'attributes': {
+ pattern: /(?:\[(?:[^\]\\"]|(["'])(?:(?!\1)[^\\]|\\.)*\1|\\.)*\])/,
+ inside: attributes.inside
+ }
+ }
+ },
+ 'inline': {
+ /*
+ The initial look-behind prevents the highlighting of escaped quoted text.
+
+ Quoted text can be multi-line but cannot span an empty line.
+ All quoted text can have attributes before [foobar, 'foobar', baz="bar"].
+
+ First, we handle the constrained quotes.
+ Those must be bounded by non-word chars and cannot have spaces between the delimiter and the first char.
+ They are, in order: _emphasis_, ``double quotes'', `single quotes', `monospace`, 'emphasis', *strong*, +monospace+ and #unquoted#
+
+ Then we handle the unconstrained quotes.
+ Those do not have the restrictions of the constrained quotes.
+ They are, in order: __emphasis__, **strong**, ++monospace++, +++passthrough+++, ##unquoted##, $$passthrough$$, ~subscript~, ^superscript^, {attribute-reference}, [[anchor]], [[[bibliography anchor]]], <>, (((indexes))) and ((indexes))
+ */
+ pattern: /(^|[^\\])(?:(?:\B\[(?:[^\]\\"]|(["'])(?:(?!\2)[^\\]|\\.)*\2|\\.)*\])?(?:\b_(?!\s)(?: _|[^_\\\r\n]|\\.)+(?:(?:\r?\n|\r)(?: _|[^_\\\r\n]|\\.)+)*_\b|\B``(?!\s).+?(?:(?:\r?\n|\r).+?)*''\B|\B`(?!\s)(?: ['`]|.)+?(?:(?:\r?\n|\r)(?: ['`]|.)+?)*['`]\B|\B(['*+#])(?!\s)(?: \3|(?!\3)[^\\\r\n]|\\.)+(?:(?:\r?\n|\r)(?: \3|(?!\3)[^\\\r\n]|\\.)+)*\3\B)|(?:\[(?:[^\]\\"]|(["'])(?:(?!\4)[^\\]|\\.)*\4|\\.)*\])?(?:(__|\*\*|\+\+\+?|##|\$\$|[~^]).+?(?:(?:\r?\n|\r).+?)*\5|\{[^}\r\n]+\}|\[\[\[?.+?(?:(?:\r?\n|\r).+?)*\]?\]\]|<<.+?(?:(?:\r?\n|\r).+?)*>>|\(\(\(?.+?(?:(?:\r?\n|\r).+?)*\)?\)\)))/m,
+ lookbehind: true,
+ inside: {
+ 'attributes': attributes,
+ 'url': {
+ pattern: /^(?:\[\[\[?.+?\]?\]\]|<<.+?>>)$/,
+ inside: {
+ 'punctuation': /^(?:\[\[\[?|<<)|(?:\]\]\]?|>>)$/
+ }
+ },
+ 'attribute-ref': {
+ pattern: /^\{.+\}$/,
+ inside: {
+ 'variable': {
+ pattern: /(^\{)[a-z\d,+_-]+/,
+ lookbehind: true
+ },
+ 'operator': /^[=?!#%@$]|!(?=[:}])/,
+ 'punctuation': /^\{|\}$|::?/
+ }
+ },
+ 'italic': {
+ pattern: /^(['_])[\s\S]+\1$/,
+ inside: {
+ 'punctuation': /^(?:''?|__?)|(?:''?|__?)$/
+ }
+ },
+ 'bold': {
+ pattern: /^\*[\s\S]+\*$/,
+ inside: {
+ punctuation: /^\*\*?|\*\*?$/
+ }
+ },
+ 'punctuation': /^(?:``?|\+{1,3}|##?|\$\$|[~^]|\(\(\(?)|(?:''?|\+{1,3}|##?|\$\$|[~^`]|\)?\)\))$/
+ }
+ },
+ 'replacement': {
+ pattern: /\((?:C|TM|R)\)/,
+ alias: 'builtin'
+ },
+ 'entity': /&#?[\da-z]{1,8};/i,
+ 'line-continuation': {
+ pattern: /(^| )\+$/m,
+ lookbehind: true,
+ alias: 'punctuation'
+ }
+ };
+
+
+ // Allow some nesting. There is no recursion though, so cloning should not be needed.
+
+ attributes.inside['interpreted'].inside.rest = {
+ 'macro': Prism.languages.asciidoc['macro'],
+ 'inline': Prism.languages.asciidoc['inline'],
+ 'replacement': Prism.languages.asciidoc['replacement'],
+ 'entity': Prism.languages.asciidoc['entity']
+ };
+
+ Prism.languages.asciidoc['passthrough-block'].inside.rest = {
+ 'macro': Prism.languages.asciidoc['macro']
+ };
+
+ Prism.languages.asciidoc['literal-block'].inside.rest = {
+ 'callout': Prism.languages.asciidoc['callout']
+ };
+
+ Prism.languages.asciidoc['table'].inside.rest = {
+ 'comment-block': Prism.languages.asciidoc['comment-block'],
+ 'passthrough-block': Prism.languages.asciidoc['passthrough-block'],
+ 'literal-block': Prism.languages.asciidoc['literal-block'],
+ 'other-block': Prism.languages.asciidoc['other-block'],
+ 'list-punctuation': Prism.languages.asciidoc['list-punctuation'],
+ 'indented-block': Prism.languages.asciidoc['indented-block'],
+ 'comment': Prism.languages.asciidoc['comment'],
+ 'title': Prism.languages.asciidoc['title'],
+ 'attribute-entry': Prism.languages.asciidoc['attribute-entry'],
+ 'attributes': Prism.languages.asciidoc['attributes'],
+ 'hr': Prism.languages.asciidoc['hr'],
+ 'page-break': Prism.languages.asciidoc['page-break'],
+ 'admonition': Prism.languages.asciidoc['admonition'],
+ 'list-label': Prism.languages.asciidoc['list-label'],
+ 'callout': Prism.languages.asciidoc['callout'],
+ 'macro': Prism.languages.asciidoc['macro'],
+ 'inline': Prism.languages.asciidoc['inline'],
+ 'replacement': Prism.languages.asciidoc['replacement'],
+ 'entity': Prism.languages.asciidoc['entity'],
+ 'line-continuation': Prism.languages.asciidoc['line-continuation']
+ };
+
+ Prism.languages.asciidoc['other-block'].inside.rest = {
+ 'table': Prism.languages.asciidoc['table'],
+ 'list-punctuation': Prism.languages.asciidoc['list-punctuation'],
+ 'indented-block': Prism.languages.asciidoc['indented-block'],
+ 'comment': Prism.languages.asciidoc['comment'],
+ 'attribute-entry': Prism.languages.asciidoc['attribute-entry'],
+ 'attributes': Prism.languages.asciidoc['attributes'],
+ 'hr': Prism.languages.asciidoc['hr'],
+ 'page-break': Prism.languages.asciidoc['page-break'],
+ 'admonition': Prism.languages.asciidoc['admonition'],
+ 'list-label': Prism.languages.asciidoc['list-label'],
+ 'macro': Prism.languages.asciidoc['macro'],
+ 'inline': Prism.languages.asciidoc['inline'],
+ 'replacement': Prism.languages.asciidoc['replacement'],
+ 'entity': Prism.languages.asciidoc['entity'],
+ 'line-continuation': Prism.languages.asciidoc['line-continuation']
+ };
+
+ Prism.languages.asciidoc['title'].inside.rest = {
+ 'macro': Prism.languages.asciidoc['macro'],
+ 'inline': Prism.languages.asciidoc['inline'],
+ 'replacement': Prism.languages.asciidoc['replacement'],
+ 'entity': Prism.languages.asciidoc['entity']
+ };
+
+ // Plugin to make entity title show the real entity, idea by Roman Komarov
+ Prism.hooks.add('wrap', function(env) {
+ if (env.type === 'entity') {
+ env.attributes['title'] = env.content.replace(/&/, '&');
+ }
+ });
+}(Prism));
+Prism.languages.aspnet = Prism.languages.extend('markup', {
+ 'page-directive tag': {
+ pattern: /<%\s*@.*%>/i,
+ inside: {
+ 'page-directive tag': /<%\s*@\s*(?:Assembly|Control|Implements|Import|Master(?:Type)?|OutputCache|Page|PreviousPageType|Reference|Register)?|%>/i,
+ rest: Prism.languages.markup.tag.inside
+ }
+ },
+ 'directive tag': {
+ pattern: /<%.*%>/i,
+ inside: {
+ 'directive tag': /<%\s*?[$=%#:]{0,2}|%>/i,
+ rest: Prism.languages.csharp
+ }
+ }
+});
+// Regexp copied from prism-markup, with a negative look-ahead added
+Prism.languages.aspnet.tag.pattern = /<(?!%)\/?[^\s>\/]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\\1|\\?(?!\1)[\s\S])*\1|[^\s'">=]+))?)*\s*\/?>/i;
+
+// match directives of attribute value foo="<% Bar %>"
+Prism.languages.insertBefore('inside', 'punctuation', {
+ 'directive tag': Prism.languages.aspnet['directive tag']
+}, Prism.languages.aspnet.tag.inside["attr-value"]);
+
+Prism.languages.insertBefore('aspnet', 'comment', {
+ 'asp comment': /<%--[\s\S]*?--%>/
+});
+
+// script runat="server" contains csharp, not javascript
+Prism.languages.insertBefore('aspnet', Prism.languages.javascript ? 'script' : 'tag', {
+ 'asp script': {
+ pattern: /()[\s\S]*?(?=<\/script>)/i,
+ lookbehind: true,
+ inside: Prism.languages.csharp || {}
+ }
+});
+Prism.languages.autoit = {
+ "comment": [
+ /;.*/,
+ {
+ // The multi-line comments delimiters can actually be commented out with ";"
+ pattern: /(^\s*)#(?:comments-start|cs)[\s\S]*?^\s*#(?:comments-end|ce)/m,
+ lookbehind: true
+ }
+ ],
+ "url": {
+ pattern: /(^\s*#include\s+)(?:<[^\r\n>]+>|"[^\r\n"]+")/m,
+ lookbehind: true
+ },
+ "string": {
+ pattern: /(["'])(?:\1\1|(?!\1)[^\r\n])*\1/,
+ greedy: true,
+ inside: {
+ "variable": /([%$@])\w+\1/
+ }
+ },
+ "directive": {
+ pattern: /(^\s*)#\w+/m,
+ lookbehind: true,
+ alias: 'keyword'
+ },
+ "function": /\b\w+(?=\()/,
+ // Variables and macros
+ "variable": /[$@]\w+/,
+ "keyword": /\b(?:Case|Const|Continue(?:Case|Loop)|Default|Dim|Do|Else(?:If)?|End(?:Func|If|Select|Switch|With)|Enum|Exit(?:Loop)?|For|Func|Global|If|In|Local|Next|Null|ReDim|Select|Static|Step|Switch|Then|To|Until|Volatile|WEnd|While|With)\b/i,
+ "number": /\b(?:0x[\da-f]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/i,
+ "boolean": /\b(?:True|False)\b/i,
+ "operator": /<[=>]?|[-+*\/=&>]=?|[?^]|\b(?:And|Or|Not)\b/i,
+ "punctuation": /[\[\]().,:]/
+};
+// NOTES - follows first-first highlight method, block is locked after highlight, different from SyntaxHl
+Prism.languages.autohotkey= {
+ 'comment': {
+ pattern: /(^[^";\n]*("[^"\n]*?"[^"\n]*?)*)(;.*$|^\s*\/\*[\s\S]*\n\*\/)/m,
+ lookbehind: true
+ },
+ 'string': /"(([^"\n\r]|"")*)"/m,
+ 'function': /[^\(\); \t,\n\+\*\-=\?>:\\\/<&%\[\]]+?(?=\()/m, //function - don't use .*\) in the end bcoz string locks it
+ 'tag': /^[ \t]*[^\s:]+?(?=:(?:[^:]|$))/m, //labels
+ 'variable': /%\w+%/,
+ 'number': /\b-?(0x[\dA-Fa-f]+|\d*\.?\d+([Ee]-?\d+)?)\b/,
+ 'operator': /\?|\/\/?=?|:=|\|[=|]?|&[=&]?|\+[=+]?|-[=-]?|\*[=*]?|<(?:<=?|>|=)?|>>?=?|[.^!=~]=?|\b(?:AND|NOT|OR)\b/,
+ 'punctuation': /[\{}[\]\(\):,]/,
+ 'boolean': /\b(true|false)\b/,
+
+ 'selector': /\b(AutoTrim|BlockInput|Break|Click|ClipWait|Continue|Control|ControlClick|ControlFocus|ControlGet|ControlGetFocus|ControlGetPos|ControlGetText|ControlMove|ControlSend|ControlSendRaw|ControlSetText|CoordMode|Critical|DetectHiddenText|DetectHiddenWindows|Drive|DriveGet|DriveSpaceFree|EnvAdd|EnvDiv|EnvGet|EnvMult|EnvSet|EnvSub|EnvUpdate|Exit|ExitApp|FileAppend|FileCopy|FileCopyDir|FileCreateDir|FileCreateShortcut|FileDelete|FileEncoding|FileGetAttrib|FileGetShortcut|FileGetSize|FileGetTime|FileGetVersion|FileInstall|FileMove|FileMoveDir|FileRead|FileReadLine|FileRecycle|FileRecycleEmpty|FileRemoveDir|FileSelectFile|FileSelectFolder|FileSetAttrib|FileSetTime|FormatTime|GetKeyState|Gosub|Goto|GroupActivate|GroupAdd|GroupClose|GroupDeactivate|Gui|GuiControl|GuiControlGet|Hotkey|ImageSearch|IniDelete|IniRead|IniWrite|Input|InputBox|KeyWait|ListHotkeys|ListLines|ListVars|Loop|Menu|MouseClick|MouseClickDrag|MouseGetPos|MouseMove|MsgBox|OnExit|OutputDebug|Pause|PixelGetColor|PixelSearch|PostMessage|Process|Progress|Random|RegDelete|RegRead|RegWrite|Reload|Repeat|Return|Run|RunAs|RunWait|Send|SendEvent|SendInput|SendMessage|SendMode|SendPlay|SendRaw|SetBatchLines|SetCapslockState|SetControlDelay|SetDefaultMouseSpeed|SetEnv|SetFormat|SetKeyDelay|SetMouseDelay|SetNumlockState|SetScrollLockState|SetStoreCapslockMode|SetTimer|SetTitleMatchMode|SetWinDelay|SetWorkingDir|Shutdown|Sleep|Sort|SoundBeep|SoundGet|SoundGetWaveVolume|SoundPlay|SoundSet|SoundSetWaveVolume|SplashImage|SplashTextOff|SplashTextOn|SplitPath|StatusBarGetText|StatusBarWait|StringCaseSense|StringGetPos|StringLeft|StringLen|StringLower|StringMid|StringReplace|StringRight|StringSplit|StringTrimLeft|StringTrimRight|StringUpper|Suspend|SysGet|Thread|ToolTip|Transform|TrayTip|URLDownloadToFile|WinActivate|WinActivateBottom|WinClose|WinGet|WinGetActiveStats|WinGetActiveTitle|WinGetClass|WinGetPos|WinGetText|WinGetTitle|WinHide|WinKill|WinMaximize|WinMenuSelectItem|WinMinimize|WinMinimizeAll|WinMinimizeAllUndo|WinMove|WinRestore|WinSet|WinSetTitle|WinShow|WinWait|WinWaitActive|WinWaitClose|WinWaitNotActive)\b/i,
+
+ 'constant': /\b(a_ahkpath|a_ahkversion|a_appdata|a_appdatacommon|a_autotrim|a_batchlines|a_caretx|a_carety|a_computername|a_controldelay|a_cursor|a_dd|a_ddd|a_dddd|a_defaultmousespeed|a_desktop|a_desktopcommon|a_detecthiddentext|a_detecthiddenwindows|a_endchar|a_eventinfo|a_exitreason|a_formatfloat|a_formatinteger|a_gui|a_guievent|a_guicontrol|a_guicontrolevent|a_guiheight|a_guiwidth|a_guix|a_guiy|a_hour|a_iconfile|a_iconhidden|a_iconnumber|a_icontip|a_index|a_ipaddress1|a_ipaddress2|a_ipaddress3|a_ipaddress4|a_isadmin|a_iscompiled|a_iscritical|a_ispaused|a_issuspended|a_isunicode|a_keydelay|a_language|a_lasterror|a_linefile|a_linenumber|a_loopfield|a_loopfileattrib|a_loopfiledir|a_loopfileext|a_loopfilefullpath|a_loopfilelongpath|a_loopfilename|a_loopfileshortname|a_loopfileshortpath|a_loopfilesize|a_loopfilesizekb|a_loopfilesizemb|a_loopfiletimeaccessed|a_loopfiletimecreated|a_loopfiletimemodified|a_loopreadline|a_loopregkey|a_loopregname|a_loopregsubkey|a_loopregtimemodified|a_loopregtype|a_mday|a_min|a_mm|a_mmm|a_mmmm|a_mon|a_mousedelay|a_msec|a_mydocuments|a_now|a_nowutc|a_numbatchlines|a_ostype|a_osversion|a_priorhotkey|programfiles|a_programfiles|a_programs|a_programscommon|a_screenheight|a_screenwidth|a_scriptdir|a_scriptfullpath|a_scriptname|a_sec|a_space|a_startmenu|a_startmenucommon|a_startup|a_startupcommon|a_stringcasesense|a_tab|a_temp|a_thisfunc|a_thishotkey|a_thislabel|a_thismenu|a_thismenuitem|a_thismenuitempos|a_tickcount|a_timeidle|a_timeidlephysical|a_timesincepriorhotkey|a_timesincethishotkey|a_titlematchmode|a_titlematchmodespeed|a_username|a_wday|a_windelay|a_windir|a_workingdir|a_yday|a_year|a_yweek|a_yyyy|clipboard|clipboardall|comspec|errorlevel)\b/i,
+
+ 'builtin': /\b(abs|acos|asc|asin|atan|ceil|chr|class|cos|dllcall|exp|fileexist|Fileopen|floor|il_add|il_create|il_destroy|instr|substr|isfunc|islabel|IsObject|ln|log|lv_add|lv_delete|lv_deletecol|lv_getcount|lv_getnext|lv_gettext|lv_insert|lv_insertcol|lv_modify|lv_modifycol|lv_setimagelist|mod|onmessage|numget|numput|registercallback|regexmatch|regexreplace|round|sin|tan|sqrt|strlen|sb_seticon|sb_setparts|sb_settext|strsplit|tv_add|tv_delete|tv_getchild|tv_getcount|tv_getnext|tv_get|tv_getparent|tv_getprev|tv_getselection|tv_gettext|tv_modify|varsetcapacity|winactive|winexist|__New|__Call|__Get|__Set)\b/i,
+
+ 'symbol': /\b(alt|altdown|altup|appskey|backspace|browser_back|browser_favorites|browser_forward|browser_home|browser_refresh|browser_search|browser_stop|bs|capslock|ctrl|ctrlbreak|ctrldown|ctrlup|del|delete|down|end|enter|esc|escape|f1|f10|f11|f12|f13|f14|f15|f16|f17|f18|f19|f2|f20|f21|f22|f23|f24|f3|f4|f5|f6|f7|f8|f9|home|ins|insert|joy1|joy10|joy11|joy12|joy13|joy14|joy15|joy16|joy17|joy18|joy19|joy2|joy20|joy21|joy22|joy23|joy24|joy25|joy26|joy27|joy28|joy29|joy3|joy30|joy31|joy32|joy4|joy5|joy6|joy7|joy8|joy9|joyaxes|joybuttons|joyinfo|joyname|joypov|joyr|joyu|joyv|joyx|joyy|joyz|lalt|launch_app1|launch_app2|launch_mail|launch_media|lbutton|lcontrol|lctrl|left|lshift|lwin|lwindown|lwinup|mbutton|media_next|media_play_pause|media_prev|media_stop|numlock|numpad0|numpad1|numpad2|numpad3|numpad4|numpad5|numpad6|numpad7|numpad8|numpad9|numpadadd|numpadclear|numpaddel|numpaddiv|numpaddot|numpaddown|numpadend|numpadenter|numpadhome|numpadins|numpadleft|numpadmult|numpadpgdn|numpadpgup|numpadright|numpadsub|numpadup|pgdn|pgup|printscreen|ralt|rbutton|rcontrol|rctrl|right|rshift|rwin|rwindown|rwinup|scrolllock|shift|shiftdown|shiftup|space|tab|up|volume_down|volume_mute|volume_up|wheeldown|wheelleft|wheelright|wheelup|xbutton1|xbutton2)\b/i,
+
+ 'important': /#\b(AllowSameLineComments|ClipboardTimeout|CommentFlag|ErrorStdOut|EscapeChar|HotkeyInterval|HotkeyModifierTimeout|Hotstring|IfWinActive|IfWinExist|IfWinNotActive|IfWinNotExist|Include|IncludeAgain|InstallKeybdHook|InstallMouseHook|KeyHistory|LTrim|MaxHotkeysPerInterval|MaxMem|MaxThreads|MaxThreadsBuffer|MaxThreadsPerHotkey|NoEnv|NoTrayIcon|Persistent|SingleInstance|UseHook|WinActivateForce)\b/i,
+
+ 'keyword': /\b(Abort|AboveNormal|Add|ahk_class|ahk_group|ahk_id|ahk_pid|All|Alnum|Alpha|AltSubmit|AltTab|AltTabAndMenu|AltTabMenu|AltTabMenuDismiss|AlwaysOnTop|AutoSize|Background|BackgroundTrans|BelowNormal|between|BitAnd|BitNot|BitOr|BitShiftLeft|BitShiftRight|BitXOr|Bold|Border|Button|ByRef|Checkbox|Checked|CheckedGray|Choose|ChooseString|Close|Color|ComboBox|Contains|ControlList|Count|Date|DateTime|Days|DDL|Default|DeleteAll|Delimiter|Deref|Destroy|Digit|Disable|Disabled|DropDownList|Edit|Eject|Else|Enable|Enabled|Error|Exist|Expand|ExStyle|FileSystem|First|Flash|Float|FloatFast|Focus|Font|for|global|Grid|Group|GroupBox|GuiClose|GuiContextMenu|GuiDropFiles|GuiEscape|GuiSize|Hdr|Hidden|Hide|High|HKCC|HKCR|HKCU|HKEY_CLASSES_ROOT|HKEY_CURRENT_CONFIG|HKEY_CURRENT_USER|HKEY_LOCAL_MACHINE|HKEY_USERS|HKLM|HKU|Hours|HScroll|Icon|IconSmall|ID|IDLast|If|IfEqual|IfExist|IfGreater|IfGreaterOrEqual|IfInString|IfLess|IfLessOrEqual|IfMsgBox|IfNotEqual|IfNotExist|IfNotInString|IfWinActive|IfWinExist|IfWinNotActive|IfWinNotExist|Ignore|ImageList|in|Integer|IntegerFast|Interrupt|is|italic|Join|Label|LastFound|LastFoundExist|Limit|Lines|List|ListBox|ListView|local|Lock|Logoff|Low|Lower|Lowercase|MainWindow|Margin|Maximize|MaximizeBox|MaxSize|Minimize|MinimizeBox|MinMax|MinSize|Minutes|MonthCal|Mouse|Move|Multi|NA|No|NoActivate|NoDefault|NoHide|NoIcon|NoMainWindow|norm|Normal|NoSort|NoSortHdr|NoStandard|Not|NoTab|NoTimers|Number|Off|Ok|On|OwnDialogs|Owner|Parse|Password|Picture|Pixel|Pos|Pow|Priority|ProcessName|Radio|Range|Read|ReadOnly|Realtime|Redraw|REG_BINARY|REG_DWORD|REG_EXPAND_SZ|REG_MULTI_SZ|REG_SZ|Region|Relative|Rename|Report|Resize|Restore|Retry|RGB|Screen|Seconds|Section|Serial|SetLabel|ShiftAltTab|Show|Single|Slider|SortDesc|Standard|static|Status|StatusBar|StatusCD|strike|Style|Submit|SysMenu|Tab2|TabStop|Text|Theme|Tile|ToggleCheck|ToggleEnable|ToolWindow|Top|Topmost|TransColor|Transparent|Tray|TreeView|TryAgain|Type|UnCheck|underline|Unicode|Unlock|UpDown|Upper|Uppercase|UseErrorLevel|Vis|VisFirst|Visible|VScroll|Wait|WaitClose|WantCtrlA|WantF2|WantReturn|While|Wrap|Xdigit|xm|xp|xs|Yes|ym|yp|ys)\b/i
+};
+(function(Prism) {
+ var insideString = {
+ variable: [
+ // Arithmetic Environment
+ {
+ pattern: /\$?\(\([\s\S]+?\)\)/,
+ inside: {
+ // If there is a $ sign at the beginning highlight $(( and )) as variable
+ variable: [{
+ pattern: /(^\$\(\([\s\S]+)\)\)/,
+ lookbehind: true
+ },
+ /^\$\(\(/,
+ ],
+ number: /\b-?(?:0x[\dA-Fa-f]+|\d*\.?\d+(?:[Ee]-?\d+)?)\b/,
+ // Operators according to https://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic
+ operator: /--?|-=|\+\+?|\+=|!=?|~|\*\*?|\*=|\/=?|%=?|<<=?|>>=?|<=?|>=?|==?|&&?|&=|\^=?|\|\|?|\|=|\?|:/,
+ // If there is no $ sign at the beginning highlight (( and )) as punctuation
+ punctuation: /\(\(?|\)\)?|,|;/
+ }
+ },
+ // Command Substitution
+ {
+ pattern: /\$\([^)]+\)|`[^`]+`/,
+ inside: {
+ variable: /^\$\(|^`|\)$|`$/
+ }
+ },
+ /\$(?:[a-z0-9_#\?\*!@]+|\{[^}]+\})/i
+ ],
+ };
+
+ Prism.languages.bash = {
+ 'shebang': {
+ pattern: /^#!\s*\/bin\/bash|^#!\s*\/bin\/sh/,
+ alias: 'important'
+ },
+ 'comment': {
+ pattern: /(^|[^"{\\])#.*/,
+ lookbehind: true
+ },
+ 'string': [
+ //Support for Here-Documents https://en.wikipedia.org/wiki/Here_document
+ {
+ pattern: /((?:^|[^<])<<\s*)(?:"|')?(\w+?)(?:"|')?\s*\r?\n(?:[\s\S])*?\r?\n\2/g,
+ lookbehind: true,
+ greedy: true,
+ inside: insideString
+ },
+ {
+ pattern: /(["'])(?:\\\\|\\?[^\\])*?\1/g,
+ greedy: true,
+ inside: insideString
+ }
+ ],
+ 'variable': insideString.variable,
+ // Originally based on http://ss64.com/bash/
+ 'function': {
+ pattern: /(^|\s|;|\||&)(?:alias|apropos|apt-get|aptitude|aspell|awk|basename|bash|bc|bg|builtin|bzip2|cal|cat|cd|cfdisk|chgrp|chmod|chown|chroot|chkconfig|cksum|clear|cmp|comm|command|cp|cron|crontab|csplit|cut|date|dc|dd|ddrescue|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|du|egrep|eject|enable|env|ethtool|eval|exec|expand|expect|export|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|getopts|git|grep|groupadd|groupdel|groupmod|groups|gzip|hash|head|help|hg|history|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|jobs|join|kill|killall|less|link|ln|locate|logname|logout|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|make|man|mkdir|mkfifo|mkisofs|mknod|more|most|mount|mtools|mtr|mv|mmv|nano|netstat|nice|nl|nohup|notify-send|npm|nslookup|open|op|passwd|paste|pathchk|ping|pkill|popd|pr|printcap|printenv|printf|ps|pushd|pv|pwd|quota|quotacheck|quotactl|ram|rar|rcp|read|readarray|readonly|reboot|rename|renice|remsync|rev|rm|rmdir|rsync|screen|scp|sdiff|sed|seq|service|sftp|shift|shopt|shutdown|sleep|slocate|sort|source|split|ssh|stat|strace|su|sudo|sum|suspend|sync|tail|tar|tee|test|time|timeout|times|touch|top|traceroute|trap|tr|tsort|tty|type|ulimit|umask|umount|unalias|uname|unexpand|uniq|units|unrar|unshar|uptime|useradd|userdel|usermod|users|uuencode|uudecode|v|vdir|vi|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yes|zip)(?=$|\s|;|\||&)/,
+ lookbehind: true
+ },
+ 'keyword': {
+ pattern: /(^|\s|;|\||&)(?:let|:|\.|if|then|else|elif|fi|for|break|continue|while|in|case|function|select|do|done|until|echo|exit|return|set|declare)(?=$|\s|;|\||&)/,
+ lookbehind: true
+ },
+ 'boolean': {
+ pattern: /(^|\s|;|\||&)(?:true|false)(?=$|\s|;|\||&)/,
+ lookbehind: true
+ },
+ 'operator': /&&?|\|\|?|==?|!=?|<<>|<=?|>=?|=~/,
+ 'punctuation': /\$?\(\(?|\)\)?|\.\.|[{}[\];]/
+ };
+
+ var inside = insideString.variable[1].inside;
+ inside['function'] = Prism.languages.bash['function'];
+ inside.keyword = Prism.languages.bash.keyword;
+ inside['boolean'] = Prism.languages.bash['boolean'];
+ inside.operator = Prism.languages.bash.operator;
+ inside.punctuation = Prism.languages.bash.punctuation;
+})(Prism);
+
+Prism.languages.basic = {
+ 'string': /"(?:""|[!#$%&'()*,\/:;<=>?^_ +\-.A-Z\d])*"/i,
+ 'comment': {
+ pattern: /(?:!|REM\b).+/i,
+ inside: {
+ 'keyword': /^REM/i
+ }
+ },
+ 'number': /(?:\b|\B[.-])(?:\d+\.?\d*)(?:E[+-]?\d+)?/i,
+ 'keyword': /\b(?:AS|BEEP|BLOAD|BSAVE|CALL(?: ABSOLUTE)?|CASE|CHAIN|CHDIR|CLEAR|CLOSE|CLS|COM|COMMON|CONST|DATA|DECLARE|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|DIM|DO|DOUBLE|ELSE|ELSEIF|END|ENVIRON|ERASE|ERROR|EXIT|FIELD|FILES|FOR|FUNCTION|GET|GOSUB|GOTO|IF|INPUT|INTEGER|IOCTL|KEY|KILL|LINE INPUT|LOCATE|LOCK|LONG|LOOP|LSET|MKDIR|NAME|NEXT|OFF|ON(?: COM| ERROR| KEY| TIMER)?|OPEN|OPTION BASE|OUT|POKE|PUT|READ|REDIM|REM|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SHARED|SINGLE|SELECT CASE|SHELL|SLEEP|STATIC|STEP|STOP|STRING|SUB|SWAP|SYSTEM|THEN|TIMER|TO|TROFF|TRON|TYPE|UNLOCK|UNTIL|USING|VIEW PRINT|WAIT|WEND|WHILE|WRITE)(?:\$|\b)/i,
+ 'function': /\b(?:ABS|ACCESS|ACOS|ANGLE|AREA|ARITHMETIC|ARRAY|ASIN|ASK|AT|ATN|BASE|BEGIN|BREAK|CAUSE|CEIL|CHR|CLIP|COLLATE|COLOR|CON|COS|COSH|COT|CSC|DATE|DATUM|DEBUG|DECIMAL|DEF|DEG|DEGREES|DELETE|DET|DEVICE|DISPLAY|DOT|ELAPSED|EPS|ERASABLE|EXLINE|EXP|EXTERNAL|EXTYPE|FILETYPE|FIXED|FP|GO|GRAPH|HANDLER|IDN|IMAGE|IN|INT|INTERNAL|IP|IS|KEYED|LBOUND|LCASE|LEFT|LEN|LENGTH|LET|LINE|LINES|LOG|LOG10|LOG2|LTRIM|MARGIN|MAT|MAX|MAXNUM|MID|MIN|MISSING|MOD|NATIVE|NUL|NUMERIC|OF|OPTION|ORD|ORGANIZATION|OUTIN|OUTPUT|PI|POINT|POINTER|POINTS|POS|PRINT|PROGRAM|PROMPT|RAD|RADIANS|RANDOMIZE|RECORD|RECSIZE|RECTYPE|RELATIVE|REMAINDER|REPEAT|REST|RETRY|REWRITE|RIGHT|RND|ROUND|RTRIM|SAME|SEC|SELECT|SEQUENTIAL|SET|SETTER|SGN|SIN|SINH|SIZE|SKIP|SQR|STANDARD|STATUS|STR|STREAM|STYLE|TAB|TAN|TANH|TEMPLATE|TEXT|THERE|TIME|TIMEOUT|TRACE|TRANSFORM|TRUNCATE|UBOUND|UCASE|USE|VAL|VARIABLE|VIEWPORT|WHEN|WINDOW|WITH|ZER|ZONEWIDTH)(?:\$|\b)/i,
+ 'operator': /<[=>]?|>=?|[+\-*\/^=&]|\b(?:AND|EQV|IMP|NOT|OR|XOR)\b/i,
+ 'punctuation': /[,;:()]/
+};
+(function (Prism) {
+ var variable = /%%?[~:\w]+%?|!\S+!/;
+ var parameter = {
+ pattern: /\/[a-z?]+(?=[ :]|$):?|-[a-z]\b|--[a-z-]+\b/im,
+ alias: 'attr-name',
+ inside: {
+ 'punctuation': /:/
+ }
+ };
+ var string = /"[^"]*"/;
+ var number = /(?:\b|-)\d+\b/;
+
+ Prism.languages.batch = {
+ 'comment': [
+ /^::.*/m,
+ {
+ pattern: /((?:^|[&(])[ \t]*)rem\b(?:[^^&)\r\n]|\^(?:\r\n|[\s\S]))*/im,
+ lookbehind: true
+ }
+ ],
+ 'label': {
+ pattern: /^:.*/m,
+ alias: 'property'
+ },
+ 'command': [
+ {
+ // FOR command
+ pattern: /((?:^|[&(])[ \t]*)for(?: ?\/[a-z?](?:[ :](?:"[^"]*"|\S+))?)* \S+ in \([^)]+\) do/im,
+ lookbehind: true,
+ inside: {
+ 'keyword': /^for\b|\b(?:in|do)\b/i,
+ 'string': string,
+ 'parameter': parameter,
+ 'variable': variable,
+ 'number': number,
+ 'punctuation': /[()',]/
+ }
+ },
+ {
+ // IF command
+ pattern: /((?:^|[&(])[ \t]*)if(?: ?\/[a-z?](?:[ :](?:"[^"]*"|\S+))?)* (?:not )?(?:cmdextversion \d+|defined \w+|errorlevel \d+|exist \S+|(?:"[^"]*"|\S+)?(?:==| (?:equ|neq|lss|leq|gtr|geq) )(?:"[^"]*"|\S+))/im,
+ lookbehind: true,
+ inside: {
+ 'keyword': /^if\b|\b(?:not|cmdextversion|defined|errorlevel|exist)\b/i,
+ 'string': string,
+ 'parameter': parameter,
+ 'variable': variable,
+ 'number': number,
+ 'operator': /\^|==|\b(?:equ|neq|lss|leq|gtr|geq)\b/i
+ }
+ },
+ {
+ // ELSE command
+ pattern: /((?:^|[&()])[ \t]*)else\b/im,
+ lookbehind: true,
+ inside: {
+ 'keyword': /^else\b/i
+ }
+ },
+ {
+ // SET command
+ pattern: /((?:^|[&(])[ \t]*)set(?: ?\/[a-z](?:[ :](?:"[^"]*"|\S+))?)* (?:[^^&)\r\n]|\^(?:\r\n|[\s\S]))*/im,
+ lookbehind: true,
+ inside: {
+ 'keyword': /^set\b/i,
+ 'string': string,
+ 'parameter': parameter,
+ 'variable': [
+ variable,
+ /\w+(?=(?:[*\/%+\-&^|]|<<|>>)?=)/
+ ],
+ 'number': number,
+ 'operator': /[*\/%+\-&^|]=?|<<=?|>>=?|[!~_=]/,
+ 'punctuation': /[()',]/
+ }
+ },
+ {
+ // Other commands
+ pattern: /((?:^|[&(])[ \t]*@?)\w+\b(?:[^^&)\r\n]|\^(?:\r\n|[\s\S]))*/im,
+ lookbehind: true,
+ inside: {
+ 'keyword': /^\w+\b/i,
+ 'string': string,
+ 'parameter': parameter,
+ 'label': {
+ pattern: /(^\s*):\S+/m,
+ lookbehind: true,
+ alias: 'property'
+ },
+ 'variable': variable,
+ 'number': number,
+ 'operator': /\^/
+ }
+ }
+ ],
+ 'operator': /[&@]/,
+ 'punctuation': /[()']/
+ };
+}(Prism));
+Prism.languages.c = Prism.languages.extend('clike', {
+ 'keyword': /\b(asm|typeof|inline|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|union|unsigned|void|volatile|while)\b/,
+ 'operator': /\-[>-]?|\+\+?|!=?|<>?=?|==?|&&?|\|?\||[~^%?*\/]/,
+ 'number': /\b-?(?:0x[\da-f]+|\d*\.?\d+(?:e[+-]?\d+)?)[ful]*\b/i
+});
+
+Prism.languages.insertBefore('c', 'string', {
+ 'macro': {
+ // allow for multiline macro definitions
+ // spaces after the # character compile fine with gcc
+ pattern: /(^\s*)#\s*[a-z]+([^\r\n\\]|\\.|\\(?:\r\n?|\n))*/im,
+ lookbehind: true,
+ alias: 'property',
+ inside: {
+ // highlight the path of the include statement as a string
+ 'string': {
+ pattern: /(#\s*include\s*)(<.+?>|("|')(\\?.)+?\3)/,
+ lookbehind: true
+ },
+ // highlight macro directives as keywords
+ 'directive': {
+ pattern: /(#\s*)\b(define|elif|else|endif|error|ifdef|ifndef|if|import|include|line|pragma|undef|using)\b/,
+ lookbehind: true,
+ alias: 'keyword'
+ }
+ }
+ },
+ // highlight predefined macros as constants
+ 'constant': /\b(__FILE__|__LINE__|__DATE__|__TIME__|__TIMESTAMP__|__func__|EOF|NULL|stdin|stdout|stderr)\b/
+});
+
+delete Prism.languages.c['class-name'];
+delete Prism.languages.c['boolean'];
+
+Prism.languages.brainfuck = {
+ 'pointer': {
+ pattern: /<|>/,
+ alias: 'keyword'
+ },
+ 'increment': {
+ pattern: /\+/,
+ alias: 'inserted'
+ },
+ 'decrement': {
+ pattern: /-/,
+ alias: 'deleted'
+ },
+ 'branching': {
+ pattern: /\[|\]/,
+ alias: 'important'
+ },
+ 'operator': /[.,]/,
+ 'comment': /\S+/
+};
+Prism.languages.bro = {
+
+ 'comment': {
+ pattern: /(^|[^\\$])#.*/,
+ lookbehind: true,
+ inside: {
+ 'italic': /\b(TODO|FIXME|XXX)\b/
+ }
+ },
+
+ 'string': {
+ pattern: /(["'])(\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+ greedy: true
+ },
+
+ 'boolean': /\b(T|F)\b/,
+
+ 'function': {
+ pattern: /(?:function|hook|event) [a-zA-Z0-9_]+(::[a-zA-Z0-9_]+)?/,
+ inside: {
+ keyword: /^(?:function|hook|event)/
+ }
+ },
+
+ 'variable': {
+ pattern: /(?:global|local) [a-zA-Z0-9_]+/i,
+ inside: {
+ keyword: /(?:global|local)/
+ }
+ },
+
+ 'builtin':
+ /(@(load(-(sigs|plugin))?|unload|prefixes|ifn?def|else|(end)?if|DIR|FILENAME))|(&?(redef|priority|log|optional|default|add_func|delete_func|expire_func|read_expire|write_expire|create_expire|synchronized|persistent|rotate_interval|rotate_size|encrypt|raw_output|mergeable|group|error_handler|type_column))/,
+
+ 'constant': {
+ pattern: /const [a-zA-Z0-9_]+/i,
+ inside: {
+ keyword: /const/
+ }
+ },
+
+ 'keyword':
+ /\b(break|next|continue|alarm|using|of|add|delete|export|print|return|schedule|when|timeout|addr|any|bool|count|double|enum|file|int|interval|pattern|opaque|port|record|set|string|subnet|table|time|vector|for|if|else|in|module|function)\b/,
+
+ 'operator': /--?|\+\+?|!=?=?|<=?|>=?|==?=?|&&|\|\|?|\?|\*|\/|~|\^|%/,
+
+ 'number': /\b-?(?:0x[\da-f]+|\d*\.?\d+(?:e[+-]?\d+)?)\b/i,
+
+ 'punctuation': /[{}[\];(),.:]/
+};
+
+Prism.languages.bison = Prism.languages.extend('c', {});
+
+Prism.languages.insertBefore('bison', 'comment', {
+ 'bison': {
+ // This should match all the beginning of the file
+ // including the prologue(s), the bison declarations and
+ // the grammar rules.
+ pattern: /^[\s\S]*?%%[\s\S]*?%%/,
+ inside: {
+ 'c': {
+ // Allow for one level of nested braces
+ pattern: /%\{[\s\S]*?%\}|\{(?:\{[^}]*\}|[^{}])*\}/,
+ inside: {
+ 'delimiter': {
+ pattern: /^%?\{|%?\}$/,
+ alias: 'punctuation'
+ },
+ 'bison-variable': {
+ pattern: /[$@](?:<[^\s>]+>)?[\w$]+/,
+ alias: 'variable',
+ inside: {
+ 'punctuation': /<|>/
+ }
+ },
+ rest: Prism.languages.c
+ }
+ },
+ 'comment': Prism.languages.c.comment,
+ 'string': Prism.languages.c.string,
+ 'property': /\S+(?=:)/,
+ 'keyword': /%\w+/,
+ 'number': {
+ pattern: /(^|[^@])\b(?:0x[\da-f]+|\d+)/i,
+ lookbehind: true
+ },
+ 'punctuation': /%[%?]|[|:;\[\]<>]/
+ }
+ }
+});
+Prism.languages.csharp = Prism.languages.extend('clike', {
+ 'keyword': /\b(abstract|as|async|await|base|bool|break|byte|case|catch|char|checked|class|const|continue|decimal|default|delegate|do|double|else|enum|event|explicit|extern|false|finally|fixed|float|for|foreach|goto|if|implicit|in|int|interface|internal|is|lock|long|namespace|new|null|object|operator|out|override|params|private|protected|public|readonly|ref|return|sbyte|sealed|short|sizeof|stackalloc|static|string|struct|switch|this|throw|true|try|typeof|uint|ulong|unchecked|unsafe|ushort|using|virtual|void|volatile|while|add|alias|ascending|async|await|descending|dynamic|from|get|global|group|into|join|let|orderby|partial|remove|select|set|value|var|where|yield)\b/,
+ 'string': [
+ {
+ pattern: /@("|')(\1\1|\\\1|\\?(?!\1)[\s\S])*\1/,
+ greedy: true
+ },
+ {
+ pattern: /("|')(\\?.)*?\1/,
+ greedy: true
+ }
+ ],
+ 'number': /\b-?(0x[\da-f]+|\d*\.?\d+f?)\b/i
+});
+
+Prism.languages.insertBefore('csharp', 'keyword', {
+ 'generic-method': {
+ pattern: /[a-z0-9_]+\s*<[^>\r\n]+?>\s*(?=\()/i,
+ alias: 'function',
+ inside: {
+ keyword: Prism.languages.csharp.keyword,
+ punctuation: /[<>(),.:]/
+ }
+ },
+ 'preprocessor': {
+ pattern: /(^\s*)#.*/m,
+ lookbehind: true,
+ alias: 'property',
+ inside: {
+ // highlight preprocessor directives as keywords
+ 'directive': {
+ pattern: /(\s*#)\b(define|elif|else|endif|endregion|error|if|line|pragma|region|undef|warning)\b/,
+ lookbehind: true,
+ alias: 'keyword'
+ }
+ }
+ }
+});
+
+Prism.languages.cpp = Prism.languages.extend('c', {
+ 'keyword': /\b(alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|class|compl|const|constexpr|const_cast|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|float|for|friend|goto|if|inline|int|long|mutable|namespace|new|noexcept|nullptr|operator|private|protected|public|register|reinterpret_cast|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/,
+ 'boolean': /\b(true|false)\b/,
+ 'operator': /[-+]{1,2}|!=?|<{1,2}=?|>{1,2}=?|\->|:{1,2}|={1,2}|\^|~|%|&{1,2}|\|?\||\?|\*|\/|\b(and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/
+});
+
+Prism.languages.insertBefore('cpp', 'keyword', {
+ 'class-name': {
+ pattern: /(class\s+)[a-z0-9_]+/i,
+ lookbehind: true
+ }
+});
+(function(Prism) {
+
+// Ignore comments starting with { to privilege string interpolation highlighting
+var comment = /#(?!\{).+/,
+ interpolation = {
+ pattern: /#\{[^}]+\}/,
+ alias: 'variable'
+ };
+
+Prism.languages.coffeescript = Prism.languages.extend('javascript', {
+ 'comment': comment,
+ 'string': [
+
+ // Strings are multiline
+ {
+ pattern: /'(?:\\?[^\\])*?'/,
+ greedy: true
+ },
+
+ {
+ // Strings are multiline
+ pattern: /"(?:\\?[^\\])*?"/,
+ greedy: true,
+ inside: {
+ 'interpolation': interpolation
+ }
+ }
+ ],
+ 'keyword': /\b(and|break|by|catch|class|continue|debugger|delete|do|each|else|extend|extends|false|finally|for|if|in|instanceof|is|isnt|let|loop|namespace|new|no|not|null|of|off|on|or|own|return|super|switch|then|this|throw|true|try|typeof|undefined|unless|until|when|while|window|with|yes|yield)\b/,
+ 'class-member': {
+ pattern: /@(?!\d)\w+/,
+ alias: 'variable'
+ }
+});
+
+Prism.languages.insertBefore('coffeescript', 'comment', {
+ 'multiline-comment': {
+ pattern: /###[\s\S]+?###/,
+ alias: 'comment'
+ },
+
+ // Block regexp can contain comments and interpolation
+ 'block-regex': {
+ pattern: /\/{3}[\s\S]*?\/{3}/,
+ alias: 'regex',
+ inside: {
+ 'comment': comment,
+ 'interpolation': interpolation
+ }
+ }
+});
+
+Prism.languages.insertBefore('coffeescript', 'string', {
+ 'inline-javascript': {
+ pattern: /`(?:\\?[\s\S])*?`/,
+ inside: {
+ 'delimiter': {
+ pattern: /^`|`$/,
+ alias: 'punctuation'
+ },
+ rest: Prism.languages.javascript
+ }
+ },
+
+ // Block strings
+ 'multiline-string': [
+ {
+ pattern: /'''[\s\S]*?'''/,
+ greedy: true,
+ alias: 'string'
+ },
+ {
+ pattern: /"""[\s\S]*?"""/,
+ greedy: true,
+ alias: 'string',
+ inside: {
+ interpolation: interpolation
+ }
+ }
+ ]
+
+});
+
+Prism.languages.insertBefore('coffeescript', 'keyword', {
+ // Object property
+ 'property': /(?!\d)\w+(?=\s*:(?!:))/
+});
+
+delete Prism.languages.coffeescript['template-string'];
+
+}(Prism));
+/**
+ * Original by Samuel Flores
+ *
+ * Adds the following new token classes:
+ * constant, builtin, variable, symbol, regex
+ */
+(function(Prism) {
+ Prism.languages.ruby = Prism.languages.extend('clike', {
+ 'comment': [
+ /#(?!\{[^\r\n]*?\}).*/,
+ /^=begin(?:\r?\n|\r)(?:.*(?:\r?\n|\r))*?=end/m
+ ],
+ 'keyword': /\b(alias|and|BEGIN|begin|break|case|class|def|define_method|defined|do|each|else|elsif|END|end|ensure|false|for|if|in|module|new|next|nil|not|or|raise|redo|require|rescue|retry|return|self|super|then|throw|true|undef|unless|until|when|while|yield)\b/
+ });
+
+ var interpolation = {
+ pattern: /#\{[^}]+\}/,
+ inside: {
+ 'delimiter': {
+ pattern: /^#\{|\}$/,
+ alias: 'tag'
+ },
+ rest: Prism.util.clone(Prism.languages.ruby)
+ }
+ };
+
+ Prism.languages.insertBefore('ruby', 'keyword', {
+ 'regex': [
+ {
+ pattern: /%r([^a-zA-Z0-9\s\{\(\[<])(?:[^\\]|\\[\s\S])*?\1[gim]{0,3}/,
+ greedy: true,
+ inside: {
+ 'interpolation': interpolation
+ }
+ },
+ {
+ pattern: /%r\((?:[^()\\]|\\[\s\S])*\)[gim]{0,3}/,
+ greedy: true,
+ inside: {
+ 'interpolation': interpolation
+ }
+ },
+ {
+ // Here we need to specifically allow interpolation
+ pattern: /%r\{(?:[^#{}\\]|#(?:\{[^}]+\})?|\\[\s\S])*\}[gim]{0,3}/,
+ greedy: true,
+ inside: {
+ 'interpolation': interpolation
+ }
+ },
+ {
+ pattern: /%r\[(?:[^\[\]\\]|\\[\s\S])*\][gim]{0,3}/,
+ greedy: true,
+ inside: {
+ 'interpolation': interpolation
+ }
+ },
+ {
+ pattern: /%r<(?:[^<>\\]|\\[\s\S])*>[gim]{0,3}/,
+ greedy: true,
+ inside: {
+ 'interpolation': interpolation
+ }
+ },
+ {
+ pattern: /(^|[^/])\/(?!\/)(\[.+?]|\\.|[^/\\\r\n])+\/[gim]{0,3}(?=\s*($|[\r\n,.;})]))/,
+ lookbehind: true,
+ greedy: true
+ }
+ ],
+ 'variable': /[@$]+[a-zA-Z_][a-zA-Z_0-9]*(?:[?!]|\b)/,
+ 'symbol': /:[a-zA-Z_][a-zA-Z_0-9]*(?:[?!]|\b)/
+ });
+
+ Prism.languages.insertBefore('ruby', 'number', {
+ 'builtin': /\b(Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Stat|File|Fixnum|Float|Hash|Integer|IO|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|String|Struct|TMS|Symbol|ThreadGroup|Thread|Time|TrueClass)\b/,
+ 'constant': /\b[A-Z][a-zA-Z_0-9]*(?:[?!]|\b)/
+ });
+
+ Prism.languages.ruby.string = [
+ {
+ pattern: /%[qQiIwWxs]?([^a-zA-Z0-9\s\{\(\[<])(?:[^\\]|\\[\s\S])*?\1/,
+ greedy: true,
+ inside: {
+ 'interpolation': interpolation
+ }
+ },
+ {
+ pattern: /%[qQiIwWxs]?\((?:[^()\\]|\\[\s\S])*\)/,
+ greedy: true,
+ inside: {
+ 'interpolation': interpolation
+ }
+ },
+ {
+ // Here we need to specifically allow interpolation
+ pattern: /%[qQiIwWxs]?\{(?:[^#{}\\]|#(?:\{[^}]+\})?|\\[\s\S])*\}/,
+ greedy: true,
+ inside: {
+ 'interpolation': interpolation
+ }
+ },
+ {
+ pattern: /%[qQiIwWxs]?\[(?:[^\[\]\\]|\\[\s\S])*\]/,
+ greedy: true,
+ inside: {
+ 'interpolation': interpolation
+ }
+ },
+ {
+ pattern: /%[qQiIwWxs]?<(?:[^<>\\]|\\[\s\S])*>/,
+ greedy: true,
+ inside: {
+ 'interpolation': interpolation
+ }
+ },
+ {
+ pattern: /("|')(#\{[^}]+\}|\\(?:\r?\n|\r)|\\?.)*?\1/,
+ greedy: true,
+ inside: {
+ 'interpolation': interpolation
+ }
+ }
+ ];
+}(Prism));
+Prism.languages.css.selector = {
+ pattern: /[^\{\}\s][^\{\}]*(?=\s*\{)/,
+ inside: {
+ 'pseudo-element': /:(?:after|before|first-letter|first-line|selection)|::[-\w]+/,
+ 'pseudo-class': /:[-\w]+(?:\(.*\))?/,
+ 'class': /\.[-:\.\w]+/,
+ 'id': /#[-:\.\w]+/,
+ 'attribute': /\[[^\]]+\]/
+ }
+};
+
+Prism.languages.insertBefore('css', 'function', {
+ 'hexcode': /#[\da-f]{3,8}/i,
+ 'entity': /\\[\da-f]{1,8}/i,
+ 'number': /[\d%\.]+/
+});
+Prism.languages.d = Prism.languages.extend('clike', {
+ 'string': [
+ // r"", x""
+ /\b[rx]"(\\.|[^\\"])*"[cwd]?/,
+ // q"[]", q"()", q"<>", q"{}"
+ /\bq"(?:\[[\s\S]*?\]|\([\s\S]*?\)|<[\s\S]*?>|\{[\s\S]*?\})"/,
+ // q"IDENT
+ // ...
+ // IDENT"
+ /\bq"([_a-zA-Z][_a-zA-Z\d]*)(?:\r?\n|\r)[\s\S]*?(?:\r?\n|\r)\1"/,
+ // q"//", q"||", etc.
+ /\bq"(.)[\s\S]*?\1"/,
+ // Characters
+ /'(?:\\'|\\?[^']+)'/,
+
+ /(["`])(\\.|(?!\1)[^\\])*\1[cwd]?/
+ ],
+
+ 'number': [
+ // The lookbehind and the negative look-ahead try to prevent bad highlighting of the .. operator
+ // Hexadecimal numbers must be handled separately to avoid problems with exponent "e"
+ /\b0x\.?[a-f\d_]+(?:(?!\.\.)\.[a-f\d_]*)?(?:p[+-]?[a-f\d_]+)?[ulfi]*/i,
+ {
+ pattern: /((?:\.\.)?)(?:\b0b\.?|\b|\.)\d[\d_]*(?:(?!\.\.)\.[\d_]*)?(?:e[+-]?\d[\d_]*)?[ulfi]*/i,
+ lookbehind: true
+ }
+ ],
+
+ // In order: $, keywords and special tokens, globally defined symbols
+ 'keyword': /\$|\b(?:abstract|alias|align|asm|assert|auto|body|bool|break|byte|case|cast|catch|cdouble|cent|cfloat|char|class|const|continue|creal|dchar|debug|default|delegate|delete|deprecated|do|double|else|enum|export|extern|false|final|finally|float|for|foreach|foreach_reverse|function|goto|idouble|if|ifloat|immutable|import|inout|int|interface|invariant|ireal|lazy|long|macro|mixin|module|new|nothrow|null|out|override|package|pragma|private|protected|public|pure|real|ref|return|scope|shared|short|static|struct|super|switch|synchronized|template|this|throw|true|try|typedef|typeid|typeof|ubyte|ucent|uint|ulong|union|unittest|ushort|version|void|volatile|wchar|while|with|__(?:(?:FILE|MODULE|LINE|FUNCTION|PRETTY_FUNCTION|DATE|EOF|TIME|TIMESTAMP|VENDOR|VERSION)__|gshared|traits|vector|parameters)|string|wstring|dstring|size_t|ptrdiff_t)\b/,
+ 'operator': /\|[|=]?|&[&=]?|\+[+=]?|-[-=]?|\.?\.\.|=[>=]?|!(?:i[ns]\b|<>?=?|>=?|=)?|\bi[ns]\b|(?:<[<>]?|>>?>?|\^\^|[*\/%^~])=?/
+});
+
+
+Prism.languages.d.comment = [
+ // Shebang
+ /^\s*#!.+/,
+ // /+ +/
+ {
+ // Allow one level of nesting
+ pattern: /(^|[^\\])\/\+(?:\/\+[\s\S]*?\+\/|[\s\S])*?\+\//,
+ lookbehind: true
+ }
+].concat(Prism.languages.d.comment);
+
+Prism.languages.insertBefore('d', 'comment', {
+ 'token-string': {
+ // Allow one level of nesting
+ pattern: /\bq\{(?:|\{[^}]*\}|[^}])*\}/,
+ alias: 'string'
+ }
+});
+
+Prism.languages.insertBefore('d', 'keyword', {
+ 'property': /\B@\w*/
+});
+
+Prism.languages.insertBefore('d', 'function', {
+ 'register': {
+ // Iasm registers
+ pattern: /\b(?:[ABCD][LHX]|E[ABCD]X|E?(?:BP|SP|DI|SI)|[ECSDGF]S|CR[0234]|DR[012367]|TR[3-7]|X?MM[0-7]|R[ABCD]X|[BS]PL|R[BS]P|[DS]IL|R[DS]I|R(?:[89]|1[0-5])[BWD]?|XMM(?:[89]|1[0-5])|YMM(?:1[0-5]|\d))\b|\bST(?:\([0-7]\)|\b)/,
+ alias: 'variable'
+ }
+});
+Prism.languages.dart = Prism.languages.extend('clike', {
+ 'string': [
+ {
+ pattern: /r?("""|''')[\s\S]*?\1/,
+ greedy: true
+ },
+ {
+ pattern: /r?("|')(\\?.)*?\1/,
+ greedy: true
+ }
+ ],
+ 'keyword': [
+ /\b(?:async|sync|yield)\*/,
+ /\b(?:abstract|assert|async|await|break|case|catch|class|const|continue|default|deferred|do|dynamic|else|enum|export|external|extends|factory|final|finally|for|get|if|implements|import|in|library|new|null|operator|part|rethrow|return|set|static|super|switch|this|throw|try|typedef|var|void|while|with|yield)\b/
+ ],
+ 'operator': /\bis!|\b(?:as|is)\b|\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?/
+});
+
+Prism.languages.insertBefore('dart','function',{
+ 'metadata': {
+ pattern: /@\w+/,
+ alias: 'symbol'
+ }
+});
+// Django/Jinja2 syntax definition for Prism.js syntax highlighter.
+// Mostly it works OK but can paint code incorrectly on complex html/template tag combinations.
+
+var _django_template = {
+ 'property': {
+ pattern: /(?:{{|{%)[\s\S]*?(?:%}|}})/g,
+ greedy: true,
+ inside: {
+ 'string': {
+ pattern: /("|')(?:\\\\|\\?[^\\\r\n])*?\1/,
+ greedy: true
+ },
+ 'keyword': /\b(?:\||load|verbatim|widthratio|ssi|firstof|for|url|ifchanged|csrf_token|lorem|ifnotequal|autoescape|now|templatetag|debug|cycle|ifequal|regroup|comment|filter|endfilter|if|spaceless|with|extends|block|include|else|empty|endif|endfor|as|endblock|endautoescape|endverbatim|trans|endtrans|[Tt]rue|[Ff]alse|[Nn]one|in|is|static|macro|endmacro|call|endcall|set|endset|raw|endraw)\b/,
+ 'operator' : /[-+=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]|\b(?:or|and|not)\b/,
+ 'function': /\b(?:_|abs|add|addslashes|attr|batch|callable|capfirst|capitalize|center|count|cut|d|date|default|default_if_none|defined|dictsort|dictsortreversed|divisibleby|e|equalto|escape|escaped|escapejs|even|filesizeformat|first|float|floatformat|force_escape|forceescape|format|get_digit|groupby|indent|int|iriencode|iterable|join|last|length|length_is|linebreaks|linebreaksbr|linenumbers|list|ljust|lower|make_list|map|mapping|number|odd|phone2numeric|pluralize|pprint|random|reject|rejectattr|removetags|replace|reverse|rjust|round|safe|safeseq|sameas|select|selectattr|sequence|slice|slugify|sort|string|stringformat|striptags|sum|time|timesince|timeuntil|title|trim|truncate|truncatechars|truncatechars_html|truncatewords|truncatewords_html|undefined|unordered_list|upper|urlencode|urlize|urlizetrunc|wordcount|wordwrap|xmlattr|yesno)\b/,
+ 'important': /\b-?\d+(?:\.\d+)?\b/,
+ 'variable': /\b\w+?\b/,
+ 'punctuation' : /[[\];(),.:]/
+ }
+ }
+};
+
+Prism.languages.django = Prism.languages.extend('markup', {'comment': /(?:)/});
+// Updated html tag pattern to allow template tags inside html tags
+Prism.languages.django.tag.pattern = /<\/?(?!\d)[^\s>\/=$<]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\\1|\\?(?!\1)[\s\S])*\1|[^>=]+))?)*\s*\/?>/i;
+Prism.languages.insertBefore('django', 'entity', _django_template);
+Prism.languages.insertBefore('inside', 'tag', _django_template, Prism.languages.django.tag);
+
+if (Prism.languages.javascript) {
+ // Combine js code and template tags painting inside