Subversion Repositories oidplus

Rev

Rev 1422 | View as "text/javascript" | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1. /**
  2.  * Copyright (c) Tiny Technologies, Inc. All rights reserved.
  3.  * Licensed under the LGPL or a commercial license.
  4.  * For LGPL see License.txt in the project root for license information.
  5.  * For commercial licenses see https://www.tiny.cloud/
  6.  *
  7.  * Version: 5.10.9 (2023-11-15)
  8.  */
  9. (function () {
  10.     'use strict';
  11.  
  12.     var global$2 = tinymce.util.Tools.resolve('tinymce.PluginManager');
  13.  
  14.     var noop = function () {
  15.     };
  16.     var constant = function (value) {
  17.       return function () {
  18.         return value;
  19.       };
  20.     };
  21.     var identity = function (x) {
  22.       return x;
  23.     };
  24.     var never = constant(false);
  25.     var always = constant(true);
  26.  
  27.     var none = function () {
  28.       return NONE;
  29.     };
  30.     var NONE = function () {
  31.       var call = function (thunk) {
  32.         return thunk();
  33.       };
  34.       var id = identity;
  35.       var me = {
  36.         fold: function (n, _s) {
  37.           return n();
  38.         },
  39.         isSome: never,
  40.         isNone: always,
  41.         getOr: id,
  42.         getOrThunk: call,
  43.         getOrDie: function (msg) {
  44.           throw new Error(msg || 'error: getOrDie called on none.');
  45.         },
  46.         getOrNull: constant(null),
  47.         getOrUndefined: constant(undefined),
  48.         or: id,
  49.         orThunk: call,
  50.         map: none,
  51.         each: noop,
  52.         bind: none,
  53.         exists: never,
  54.         forall: always,
  55.         filter: function () {
  56.           return none();
  57.         },
  58.         toArray: function () {
  59.           return [];
  60.         },
  61.         toString: constant('none()')
  62.       };
  63.       return me;
  64.     }();
  65.     var some = function (a) {
  66.       var constant_a = constant(a);
  67.       var self = function () {
  68.         return me;
  69.       };
  70.       var bind = function (f) {
  71.         return f(a);
  72.       };
  73.       var me = {
  74.         fold: function (n, s) {
  75.           return s(a);
  76.         },
  77.         isSome: always,
  78.         isNone: never,
  79.         getOr: constant_a,
  80.         getOrThunk: constant_a,
  81.         getOrDie: constant_a,
  82.         getOrNull: constant_a,
  83.         getOrUndefined: constant_a,
  84.         or: self,
  85.         orThunk: self,
  86.         map: function (f) {
  87.           return some(f(a));
  88.         },
  89.         each: function (f) {
  90.           f(a);
  91.         },
  92.         bind: bind,
  93.         exists: bind,
  94.         forall: bind,
  95.         filter: function (f) {
  96.           return f(a) ? me : NONE;
  97.         },
  98.         toArray: function () {
  99.           return [a];
  100.         },
  101.         toString: function () {
  102.           return 'some(' + a + ')';
  103.         }
  104.       };
  105.       return me;
  106.     };
  107.     var from = function (value) {
  108.       return value === null || value === undefined ? NONE : some(value);
  109.     };
  110.     var Optional = {
  111.       some: some,
  112.       none: none,
  113.       from: from
  114.     };
  115.  
  116.     var get$1 = function (xs, i) {
  117.       return i >= 0 && i < xs.length ? Optional.some(xs[i]) : Optional.none();
  118.     };
  119.     var head = function (xs) {
  120.       return get$1(xs, 0);
  121.     };
  122.  
  123.     var someIf = function (b, a) {
  124.       return b ? Optional.some(a) : Optional.none();
  125.     };
  126.  
  127.     var global$1 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');
  128.  
  129.     var isCodeSample = function (elm) {
  130.       return elm && elm.nodeName === 'PRE' && elm.className.indexOf('language-') !== -1;
  131.     };
  132.     var trimArg = function (predicateFn) {
  133.       return function (arg1, arg2) {
  134.         return predicateFn(arg2);
  135.       };
  136.     };
  137.  
  138.     var Global = typeof window !== 'undefined' ? window : Function('return this;')();
  139.  
  140.     var exports$1 = {}, module = { exports: exports$1 }, global = {};
  141.     (function (define, exports, module, require) {
  142.       var oldprism = window.Prism;
  143.       window.Prism = { manual: true };
  144.       (function (global, factory) {
  145.         typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.EphoxContactWrapper = factory());
  146.       }(this, function () {
  147.         var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
  148.         var prismCore = { exports: {} };
  149.         (function (module) {
  150.           var _self = typeof window !== 'undefined' ? window : typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope ? self : {};
  151.           var Prism = function (_self) {
  152.             var lang = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i;
  153.             var uniqueId = 0;
  154.             var plainTextGrammar = {};
  155.             var _ = {
  156.               manual: _self.Prism && _self.Prism.manual,
  157.               disableWorkerMessageHandler: _self.Prism && _self.Prism.disableWorkerMessageHandler,
  158.               util: {
  159.                 encode: function encode(tokens) {
  160.                   if (tokens instanceof Token) {
  161.                     return new Token(tokens.type, encode(tokens.content), tokens.alias);
  162.                   } else if (Array.isArray(tokens)) {
  163.                     return tokens.map(encode);
  164.                   } else {
  165.                     return tokens.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/\u00a0/g, ' ');
  166.                   }
  167.                 },
  168.                 type: function (o) {
  169.                   return Object.prototype.toString.call(o).slice(8, -1);
  170.                 },
  171.                 objId: function (obj) {
  172.                   if (!obj['__id']) {
  173.                     Object.defineProperty(obj, '__id', { value: ++uniqueId });
  174.                   }
  175.                   return obj['__id'];
  176.                 },
  177.                 clone: function deepClone(o, visited) {
  178.                   visited = visited || {};
  179.                   var clone;
  180.                   var id;
  181.                   switch (_.util.type(o)) {
  182.                   case 'Object':
  183.                     id = _.util.objId(o);
  184.                     if (visited[id]) {
  185.                       return visited[id];
  186.                     }
  187.                     clone = {};
  188.                     visited[id] = clone;
  189.                     for (var key in o) {
  190.                       if (o.hasOwnProperty(key)) {
  191.                         clone[key] = deepClone(o[key], visited);
  192.                       }
  193.                     }
  194.                     return clone;
  195.                   case 'Array':
  196.                     id = _.util.objId(o);
  197.                     if (visited[id]) {
  198.                       return visited[id];
  199.                     }
  200.                     clone = [];
  201.                     visited[id] = clone;
  202.                     o.forEach(function (v, i) {
  203.                       clone[i] = deepClone(v, visited);
  204.                     });
  205.                     return clone;
  206.                   default:
  207.                     return o;
  208.                   }
  209.                 },
  210.                 getLanguage: function (element) {
  211.                   while (element) {
  212.                     var m = lang.exec(element.className);
  213.                     if (m) {
  214.                       return m[1].toLowerCase();
  215.                     }
  216.                     element = element.parentElement;
  217.                   }
  218.                   return 'none';
  219.                 },
  220.                 setLanguage: function (element, language) {
  221.                   element.className = element.className.replace(RegExp(lang.source, 'gi'), '');
  222.                   element.classList.add('language-' + language);
  223.                 },
  224.                 currentScript: function () {
  225.                   if (typeof document === 'undefined') {
  226.                     return null;
  227.                   }
  228.                   if ('currentScript' in document && 1 < 2) {
  229.                     return document.currentScript;
  230.                   }
  231.                   try {
  232.                     throw new Error();
  233.                   } catch (err) {
  234.                     var src = (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(err.stack) || [])[1];
  235.                     if (src) {
  236.                       var scripts = document.getElementsByTagName('script');
  237.                       for (var i in scripts) {
  238.                         if (scripts[i].src == src) {
  239.                           return scripts[i];
  240.                         }
  241.                       }
  242.                     }
  243.                     return null;
  244.                   }
  245.                 },
  246.                 isActive: function (element, className, defaultActivation) {
  247.                   var no = 'no-' + className;
  248.                   while (element) {
  249.                     var classList = element.classList;
  250.                     if (classList.contains(className)) {
  251.                       return true;
  252.                     }
  253.                     if (classList.contains(no)) {
  254.                       return false;
  255.                     }
  256.                     element = element.parentElement;
  257.                   }
  258.                   return !!defaultActivation;
  259.                 }
  260.               },
  261.               languages: {
  262.                 plain: plainTextGrammar,
  263.                 plaintext: plainTextGrammar,
  264.                 text: plainTextGrammar,
  265.                 txt: plainTextGrammar,
  266.                 extend: function (id, redef) {
  267.                   var lang = _.util.clone(_.languages[id]);
  268.                   for (var key in redef) {
  269.                     lang[key] = redef[key];
  270.                   }
  271.                   return lang;
  272.                 },
  273.                 insertBefore: function (inside, before, insert, root) {
  274.                   root = root || _.languages;
  275.                   var grammar = root[inside];
  276.                   var ret = {};
  277.                   for (var token in grammar) {
  278.                     if (grammar.hasOwnProperty(token)) {
  279.                       if (token == before) {
  280.                         for (var newToken in insert) {
  281.                           if (insert.hasOwnProperty(newToken)) {
  282.                             ret[newToken] = insert[newToken];
  283.                           }
  284.                         }
  285.                       }
  286.                       if (!insert.hasOwnProperty(token)) {
  287.                         ret[token] = grammar[token];
  288.                       }
  289.                     }
  290.                   }
  291.                   var old = root[inside];
  292.                   root[inside] = ret;
  293.                   _.languages.DFS(_.languages, function (key, value) {
  294.                     if (value === old && key != inside) {
  295.                       this[key] = ret;
  296.                     }
  297.                   });
  298.                   return ret;
  299.                 },
  300.                 DFS: function DFS(o, callback, type, visited) {
  301.                   visited = visited || {};
  302.                   var objId = _.util.objId;
  303.                   for (var i in o) {
  304.                     if (o.hasOwnProperty(i)) {
  305.                       callback.call(o, i, o[i], type || i);
  306.                       var property = o[i];
  307.                       var propertyType = _.util.type(property);
  308.                       if (propertyType === 'Object' && !visited[objId(property)]) {
  309.                         visited[objId(property)] = true;
  310.                         DFS(property, callback, null, visited);
  311.                       } else if (propertyType === 'Array' && !visited[objId(property)]) {
  312.                         visited[objId(property)] = true;
  313.                         DFS(property, callback, i, visited);
  314.                       }
  315.                     }
  316.                   }
  317.                 }
  318.               },
  319.               plugins: {},
  320.               highlightAll: function (async, callback) {
  321.                 _.highlightAllUnder(document, async, callback);
  322.               },
  323.               highlightAllUnder: function (container, async, callback) {
  324.                 var env = {
  325.                   callback: callback,
  326.                   container: container,
  327.                   selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
  328.                 };
  329.                 _.hooks.run('before-highlightall', env);
  330.                 env.elements = Array.prototype.slice.apply(env.container.querySelectorAll(env.selector));
  331.                 _.hooks.run('before-all-elements-highlight', env);
  332.                 for (var i = 0, element; element = env.elements[i++];) {
  333.                   _.highlightElement(element, async === true, env.callback);
  334.                 }
  335.               },
  336.               highlightElement: function (element, async, callback) {
  337.                 var language = _.util.getLanguage(element);
  338.                 var grammar = _.languages[language];
  339.                 _.util.setLanguage(element, language);
  340.                 var parent = element.parentElement;
  341.                 if (parent && parent.nodeName.toLowerCase() === 'pre') {
  342.                   _.util.setLanguage(parent, language);
  343.                 }
  344.                 var code = element.textContent;
  345.                 var env = {
  346.                   element: element,
  347.                   language: language,
  348.                   grammar: grammar,
  349.                   code: code
  350.                 };
  351.                 function insertHighlightedCode(highlightedCode) {
  352.                   env.highlightedCode = highlightedCode;
  353.                   _.hooks.run('before-insert', env);
  354.                   env.element.innerHTML = env.highlightedCode;
  355.                   _.hooks.run('after-highlight', env);
  356.                   _.hooks.run('complete', env);
  357.                   callback && callback.call(env.element);
  358.                 }
  359.                 _.hooks.run('before-sanity-check', env);
  360.                 parent = env.element.parentElement;
  361.                 if (parent && parent.nodeName.toLowerCase() === 'pre' && !parent.hasAttribute('tabindex')) {
  362.                   parent.setAttribute('tabindex', '0');
  363.                 }
  364.                 if (!env.code) {
  365.                   _.hooks.run('complete', env);
  366.                   callback && callback.call(env.element);
  367.                   return;
  368.                 }
  369.                 _.hooks.run('before-highlight', env);
  370.                 if (!env.grammar) {
  371.                   insertHighlightedCode(_.util.encode(env.code));
  372.                   return;
  373.                 }
  374.                 if (async && _self.Worker) {
  375.                   var worker = new Worker(_.filename);
  376.                   worker.onmessage = function (evt) {
  377.                     insertHighlightedCode(evt.data);
  378.                   };
  379.                   worker.postMessage(JSON.stringify({
  380.                     language: env.language,
  381.                     code: env.code,
  382.                     immediateClose: true
  383.                   }));
  384.                 } else {
  385.                   insertHighlightedCode(_.highlight(env.code, env.grammar, env.language));
  386.                 }
  387.               },
  388.               highlight: function (text, grammar, language) {
  389.                 var env = {
  390.                   code: text,
  391.                   grammar: grammar,
  392.                   language: language
  393.                 };
  394.                 _.hooks.run('before-tokenize', env);
  395.                 if (!env.grammar) {
  396.                   throw new Error('The language "' + env.language + '" has no grammar.');
  397.                 }
  398.                 env.tokens = _.tokenize(env.code, env.grammar);
  399.                 _.hooks.run('after-tokenize', env);
  400.                 return Token.stringify(_.util.encode(env.tokens), env.language);
  401.               },
  402.               tokenize: function (text, grammar) {
  403.                 var rest = grammar.rest;
  404.                 if (rest) {
  405.                   for (var token in rest) {
  406.                     grammar[token] = rest[token];
  407.                   }
  408.                   delete grammar.rest;
  409.                 }
  410.                 var tokenList = new LinkedList();
  411.                 addAfter(tokenList, tokenList.head, text);
  412.                 matchGrammar(text, tokenList, grammar, tokenList.head, 0);
  413.                 return toArray(tokenList);
  414.               },
  415.               hooks: {
  416.                 all: {},
  417.                 add: function (name, callback) {
  418.                   var hooks = _.hooks.all;
  419.                   hooks[name] = hooks[name] || [];
  420.                   hooks[name].push(callback);
  421.                 },
  422.                 run: function (name, env) {
  423.                   var callbacks = _.hooks.all[name];
  424.                   if (!callbacks || !callbacks.length) {
  425.                     return;
  426.                   }
  427.                   for (var i = 0, callback; callback = callbacks[i++];) {
  428.                     callback(env);
  429.                   }
  430.                 }
  431.               },
  432.               Token: Token
  433.             };
  434.             _self.Prism = _;
  435.             function Token(type, content, alias, matchedStr) {
  436.               this.type = type;
  437.               this.content = content;
  438.               this.alias = alias;
  439.               this.length = (matchedStr || '').length | 0;
  440.             }
  441.             Token.stringify = function stringify(o, language) {
  442.               if (typeof o == 'string') {
  443.                 return o;
  444.               }
  445.               if (Array.isArray(o)) {
  446.                 var s = '';
  447.                 o.forEach(function (e) {
  448.                   s += stringify(e, language);
  449.                 });
  450.                 return s;
  451.               }
  452.               var env = {
  453.                 type: o.type,
  454.                 content: stringify(o.content, language),
  455.                 tag: 'span',
  456.                 classes: [
  457.                   'token',
  458.                   o.type
  459.                 ],
  460.                 attributes: {},
  461.                 language: language
  462.               };
  463.               var aliases = o.alias;
  464.               if (aliases) {
  465.                 if (Array.isArray(aliases)) {
  466.                   Array.prototype.push.apply(env.classes, aliases);
  467.                 } else {
  468.                   env.classes.push(aliases);
  469.                 }
  470.               }
  471.               _.hooks.run('wrap', env);
  472.               var attributes = '';
  473.               for (var name in env.attributes) {
  474.                 attributes += ' ' + name + '="' + (env.attributes[name] || '').replace(/"/g, '&quot;') + '"';
  475.               }
  476.               return '<' + env.tag + ' class="' + env.classes.join(' ') + '"' + attributes + '>' + env.content + '</' + env.tag + '>';
  477.             };
  478.             function matchPattern(pattern, pos, text, lookbehind) {
  479.               pattern.lastIndex = pos;
  480.               var match = pattern.exec(text);
  481.               if (match && lookbehind && match[1]) {
  482.                 var lookbehindLength = match[1].length;
  483.                 match.index += lookbehindLength;
  484.                 match[0] = match[0].slice(lookbehindLength);
  485.               }
  486.               return match;
  487.             }
  488.             function matchGrammar(text, tokenList, grammar, startNode, startPos, rematch) {
  489.               for (var token in grammar) {
  490.                 if (!grammar.hasOwnProperty(token) || !grammar[token]) {
  491.                   continue;
  492.                 }
  493.                 var patterns = grammar[token];
  494.                 patterns = Array.isArray(patterns) ? patterns : [patterns];
  495.                 for (var j = 0; j < patterns.length; ++j) {
  496.                   if (rematch && rematch.cause == token + ',' + j) {
  497.                     return;
  498.                   }
  499.                   var patternObj = patterns[j];
  500.                   var inside = patternObj.inside;
  501.                   var lookbehind = !!patternObj.lookbehind;
  502.                   var greedy = !!patternObj.greedy;
  503.                   var alias = patternObj.alias;
  504.                   if (greedy && !patternObj.pattern.global) {
  505.                     var flags = patternObj.pattern.toString().match(/[imsuy]*$/)[0];
  506.                     patternObj.pattern = RegExp(patternObj.pattern.source, flags + 'g');
  507.                   }
  508.                   var pattern = patternObj.pattern || patternObj;
  509.                   for (var currentNode = startNode.next, pos = startPos; currentNode !== tokenList.tail; pos += currentNode.value.length, currentNode = currentNode.next) {
  510.                     if (rematch && pos >= rematch.reach) {
  511.                       break;
  512.                     }
  513.                     var str = currentNode.value;
  514.                     if (tokenList.length > text.length) {
  515.                       return;
  516.                     }
  517.                     if (str instanceof Token) {
  518.                       continue;
  519.                     }
  520.                     var removeCount = 1;
  521.                     var match;
  522.                     if (greedy) {
  523.                       match = matchPattern(pattern, pos, text, lookbehind);
  524.                       if (!match || match.index >= text.length) {
  525.                         break;
  526.                       }
  527.                       var from = match.index;
  528.                       var to = match.index + match[0].length;
  529.                       var p = pos;
  530.                       p += currentNode.value.length;
  531.                       while (from >= p) {
  532.                         currentNode = currentNode.next;
  533.                         p += currentNode.value.length;
  534.                       }
  535.                       p -= currentNode.value.length;
  536.                       pos = p;
  537.                       if (currentNode.value instanceof Token) {
  538.                         continue;
  539.                       }
  540.                       for (var k = currentNode; k !== tokenList.tail && (p < to || typeof k.value === 'string'); k = k.next) {
  541.                         removeCount++;
  542.                         p += k.value.length;
  543.                       }
  544.                       removeCount--;
  545.                       str = text.slice(pos, p);
  546.                       match.index -= pos;
  547.                     } else {
  548.                       match = matchPattern(pattern, 0, str, lookbehind);
  549.                       if (!match) {
  550.                         continue;
  551.                       }
  552.                     }
  553.                     var from = match.index;
  554.                     var matchStr = match[0];
  555.                     var before = str.slice(0, from);
  556.                     var after = str.slice(from + matchStr.length);
  557.                     var reach = pos + str.length;
  558.                     if (rematch && reach > rematch.reach) {
  559.                       rematch.reach = reach;
  560.                     }
  561.                     var removeFrom = currentNode.prev;
  562.                     if (before) {
  563.                       removeFrom = addAfter(tokenList, removeFrom, before);
  564.                       pos += before.length;
  565.                     }
  566.                     removeRange(tokenList, removeFrom, removeCount);
  567.                     var wrapped = new Token(token, inside ? _.tokenize(matchStr, inside) : matchStr, alias, matchStr);
  568.                     currentNode = addAfter(tokenList, removeFrom, wrapped);
  569.                     if (after) {
  570.                       addAfter(tokenList, currentNode, after);
  571.                     }
  572.                     if (removeCount > 1) {
  573.                       var nestedRematch = {
  574.                         cause: token + ',' + j,
  575.                         reach: reach
  576.                       };
  577.                       matchGrammar(text, tokenList, grammar, currentNode.prev, pos, nestedRematch);
  578.                       if (rematch && nestedRematch.reach > rematch.reach) {
  579.                         rematch.reach = nestedRematch.reach;
  580.                       }
  581.                     }
  582.                   }
  583.                 }
  584.               }
  585.             }
  586.             function LinkedList() {
  587.               var head = {
  588.                 value: null,
  589.                 prev: null,
  590.                 next: null
  591.               };
  592.               var tail = {
  593.                 value: null,
  594.                 prev: head,
  595.                 next: null
  596.               };
  597.               head.next = tail;
  598.               this.head = head;
  599.               this.tail = tail;
  600.               this.length = 0;
  601.             }
  602.             function addAfter(list, node, value) {
  603.               var next = node.next;
  604.               var newNode = {
  605.                 value: value,
  606.                 prev: node,
  607.                 next: next
  608.               };
  609.               node.next = newNode;
  610.               next.prev = newNode;
  611.               list.length++;
  612.               return newNode;
  613.             }
  614.             function removeRange(list, node, count) {
  615.               var next = node.next;
  616.               for (var i = 0; i < count && next !== list.tail; i++) {
  617.                 next = next.next;
  618.               }
  619.               node.next = next;
  620.               next.prev = node;
  621.               list.length -= i;
  622.             }
  623.             function toArray(list) {
  624.               var array = [];
  625.               var node = list.head.next;
  626.               while (node !== list.tail) {
  627.                 array.push(node.value);
  628.                 node = node.next;
  629.               }
  630.               return array;
  631.             }
  632.             if (!_self.document) {
  633.               if (!_self.addEventListener) {
  634.                 return _;
  635.               }
  636.               if (!_.disableWorkerMessageHandler) {
  637.                 _self.addEventListener('message', function (evt) {
  638.                   var message = JSON.parse(evt.data);
  639.                   var lang = message.language;
  640.                   var code = message.code;
  641.                   var immediateClose = message.immediateClose;
  642.                   _self.postMessage(_.highlight(code, _.languages[lang], lang));
  643.                   if (immediateClose) {
  644.                     _self.close();
  645.                   }
  646.                 }, false);
  647.               }
  648.               return _;
  649.             }
  650.             var script = _.util.currentScript();
  651.             if (script) {
  652.               _.filename = script.src;
  653.               if (script.hasAttribute('data-manual')) {
  654.                 _.manual = true;
  655.               }
  656.             }
  657.             function highlightAutomaticallyCallback() {
  658.               if (!_.manual) {
  659.                 _.highlightAll();
  660.               }
  661.             }
  662.             if (!_.manual) {
  663.               var readyState = document.readyState;
  664.               if (readyState === 'loading' || readyState === 'interactive' && script && script.defer) {
  665.                 document.addEventListener('DOMContentLoaded', highlightAutomaticallyCallback);
  666.               } else {
  667.                 if (window.requestAnimationFrame) {
  668.                   window.requestAnimationFrame(highlightAutomaticallyCallback);
  669.                 } else {
  670.                   window.setTimeout(highlightAutomaticallyCallback, 16);
  671.                 }
  672.               }
  673.             }
  674.             return _;
  675.           }(_self);
  676.           if (module.exports) {
  677.             module.exports = Prism;
  678.           }
  679.           if (typeof commonjsGlobal !== 'undefined') {
  680.             commonjsGlobal.Prism = Prism;
  681.           }
  682.         }(prismCore));
  683.         Prism.languages.clike = {
  684.           'comment': [
  685.             {
  686.               pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
  687.               lookbehind: true,
  688.               greedy: true
  689.             },
  690.             {
  691.               pattern: /(^|[^\\:])\/\/.*/,
  692.               lookbehind: true,
  693.               greedy: true
  694.             }
  695.           ],
  696.           'string': {
  697.             pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
  698.             greedy: true
  699.           },
  700.           'class-name': {
  701.             pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
  702.             lookbehind: true,
  703.             inside: { 'punctuation': /[.\\]/ }
  704.           },
  705.           'keyword': /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
  706.           'boolean': /\b(?:false|true)\b/,
  707.           'function': /\b\w+(?=\()/,
  708.           'number': /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
  709.           'operator': /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
  710.           'punctuation': /[{}[\];(),.:]/
  711.         };
  712.         (function (Prism) {
  713.           function getPlaceholder(language, index) {
  714.             return '___' + language.toUpperCase() + index + '___';
  715.           }
  716.           Object.defineProperties(Prism.languages['markup-templating'] = {}, {
  717.             buildPlaceholders: {
  718.               value: function (env, language, placeholderPattern, replaceFilter) {
  719.                 if (env.language !== language) {
  720.                   return;
  721.                 }
  722.                 var tokenStack = env.tokenStack = [];
  723.                 env.code = env.code.replace(placeholderPattern, function (match) {
  724.                   if (typeof replaceFilter === 'function' && !replaceFilter(match)) {
  725.                     return match;
  726.                   }
  727.                   var i = tokenStack.length;
  728.                   var placeholder;
  729.                   while (env.code.indexOf(placeholder = getPlaceholder(language, i)) !== -1) {
  730.                     ++i;
  731.                   }
  732.                   tokenStack[i] = match;
  733.                   return placeholder;
  734.                 });
  735.                 env.grammar = Prism.languages.markup;
  736.               }
  737.             },
  738.             tokenizePlaceholders: {
  739.               value: function (env, language) {
  740.                 if (env.language !== language || !env.tokenStack) {
  741.                   return;
  742.                 }
  743.                 env.grammar = Prism.languages[language];
  744.                 var j = 0;
  745.                 var keys = Object.keys(env.tokenStack);
  746.                 function walkTokens(tokens) {
  747.                   for (var i = 0; i < tokens.length; i++) {
  748.                     if (j >= keys.length) {
  749.                       break;
  750.                     }
  751.                     var token = tokens[i];
  752.                     if (typeof token === 'string' || token.content && typeof token.content === 'string') {
  753.                       var k = keys[j];
  754.                       var t = env.tokenStack[k];
  755.                       var s = typeof token === 'string' ? token : token.content;
  756.                       var placeholder = getPlaceholder(language, k);
  757.                       var index = s.indexOf(placeholder);
  758.                       if (index > -1) {
  759.                         ++j;
  760.                         var before = s.substring(0, index);
  761.                         var middle = new Prism.Token(language, Prism.tokenize(t, env.grammar), 'language-' + language, t);
  762.                         var after = s.substring(index + placeholder.length);
  763.                         var replacement = [];
  764.                         if (before) {
  765.                           replacement.push.apply(replacement, walkTokens([before]));
  766.                         }
  767.                         replacement.push(middle);
  768.                         if (after) {
  769.                           replacement.push.apply(replacement, walkTokens([after]));
  770.                         }
  771.                         if (typeof token === 'string') {
  772.                           tokens.splice.apply(tokens, [
  773.                             i,
  774.                             1
  775.                           ].concat(replacement));
  776.                         } else {
  777.                           token.content = replacement;
  778.                         }
  779.                       }
  780.                     } else if (token.content) {
  781.                       walkTokens(token.content);
  782.                     }
  783.                   }
  784.                   return tokens;
  785.                 }
  786.                 walkTokens(env.tokens);
  787.               }
  788.             }
  789.           });
  790.         }(Prism));
  791.         Prism.languages.c = Prism.languages.extend('clike', {
  792.           'comment': {
  793.             pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
  794.             greedy: true
  795.           },
  796.           'string': {
  797.             pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
  798.             greedy: true
  799.           },
  800.           'class-name': {
  801.             pattern: /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
  802.             lookbehind: true
  803.           },
  804.           'keyword': /\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\b/,
  805.           'function': /\b[a-z_]\w*(?=\s*\()/i,
  806.           'number': /(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i,
  807.           'operator': />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/
  808.         });
  809.         Prism.languages.insertBefore('c', 'string', {
  810.           'char': {
  811.             pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/,
  812.             greedy: true
  813.           }
  814.         });
  815.         Prism.languages.insertBefore('c', 'string', {
  816.           'macro': {
  817.             pattern: /(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im,
  818.             lookbehind: true,
  819.             greedy: true,
  820.             alias: 'property',
  821.             inside: {
  822.               'string': [
  823.                 {
  824.                   pattern: /^(#\s*include\s*)<[^>]+>/,
  825.                   lookbehind: true
  826.                 },
  827.                 Prism.languages.c['string']
  828.               ],
  829.               'char': Prism.languages.c['char'],
  830.               'comment': Prism.languages.c['comment'],
  831.               'macro-name': [
  832.                 {
  833.                   pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
  834.                   lookbehind: true
  835.                 },
  836.                 {
  837.                   pattern: /(^#\s*define\s+)\w+\b(?=\()/i,
  838.                   lookbehind: true,
  839.                   alias: 'function'
  840.                 }
  841.               ],
  842.               'directive': {
  843.                 pattern: /^(#\s*)[a-z]+/,
  844.                 lookbehind: true,
  845.                 alias: 'keyword'
  846.               },
  847.               'directive-hash': /^#/,
  848.               'punctuation': /##|\\(?=[\r\n])/,
  849.               'expression': {
  850.                 pattern: /\S[\s\S]*/,
  851.                 inside: Prism.languages.c
  852.               }
  853.             }
  854.           }
  855.         });
  856.         Prism.languages.insertBefore('c', 'function', { 'constant': /\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/ });
  857.         delete Prism.languages.c['boolean'];
  858.         (function (Prism) {
  859.           var keyword = /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/;
  860.           var modName = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(/<keyword>/g, function () {
  861.             return keyword.source;
  862.           });
  863.           Prism.languages.cpp = Prism.languages.extend('c', {
  864.             'class-name': [
  865.               {
  866.                 pattern: RegExp(/(\b(?:class|concept|enum|struct|typename)\s+)(?!<keyword>)\w+/.source.replace(/<keyword>/g, function () {
  867.                   return keyword.source;
  868.                 })),
  869.                 lookbehind: true
  870.               },
  871.               /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/,
  872.               /\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i,
  873.               /\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/
  874.             ],
  875.             'keyword': keyword,
  876.             'number': {
  877.               pattern: /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i,
  878.               greedy: true
  879.             },
  880.             'operator': />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/,
  881.             'boolean': /\b(?:false|true)\b/
  882.           });
  883.           Prism.languages.insertBefore('cpp', 'string', {
  884.             'module': {
  885.               pattern: RegExp(/(\b(?:import|module)\s+)/.source + '(?:' + /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source + '|' + /<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(/<mod-name>/g, function () {
  886.                 return modName;
  887.               }) + ')'),
  888.               lookbehind: true,
  889.               greedy: true,
  890.               inside: {
  891.                 'string': /^[<"][\s\S]+/,
  892.                 'operator': /:/,
  893.                 'punctuation': /\./
  894.               }
  895.             },
  896.             'raw-string': {
  897.               pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
  898.               alias: 'string',
  899.               greedy: true
  900.             }
  901.           });
  902.           Prism.languages.insertBefore('cpp', 'keyword', {
  903.             'generic-function': {
  904.               pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i,
  905.               inside: {
  906.                 'function': /^\w+/,
  907.                 'generic': {
  908.                   pattern: /<[\s\S]+/,
  909.                   alias: 'class-name',
  910.                   inside: Prism.languages.cpp
  911.                 }
  912.               }
  913.             }
  914.           });
  915.           Prism.languages.insertBefore('cpp', 'operator', {
  916.             'double-colon': {
  917.               pattern: /::/,
  918.               alias: 'punctuation'
  919.             }
  920.           });
  921.           Prism.languages.insertBefore('cpp', 'class-name', {
  922.             'base-clause': {
  923.               pattern: /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,
  924.               lookbehind: true,
  925.               greedy: true,
  926.               inside: Prism.languages.extend('cpp', {})
  927.             }
  928.           });
  929.           Prism.languages.insertBefore('inside', 'double-colon', { 'class-name': /\b[a-z_]\w*\b(?!\s*::)/i }, Prism.languages.cpp['base-clause']);
  930.         }(Prism));
  931.         (function (Prism) {
  932.           function replace(pattern, replacements) {
  933.             return pattern.replace(/<<(\d+)>>/g, function (m, index) {
  934.               return '(?:' + replacements[+index] + ')';
  935.             });
  936.           }
  937.           function re(pattern, replacements, flags) {
  938.             return RegExp(replace(pattern, replacements), flags || '');
  939.           }
  940.           function nested(pattern, depthLog2) {
  941.             for (var i = 0; i < depthLog2; i++) {
  942.               pattern = pattern.replace(/<<self>>/g, function () {
  943.                 return '(?:' + pattern + ')';
  944.               });
  945.             }
  946.             return pattern.replace(/<<self>>/g, '[^\\s\\S]');
  947.           }
  948.           var keywordKinds = {
  949.             type: 'bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void',
  950.             typeDeclaration: 'class enum interface record struct',
  951.             contextual: 'add alias and ascending async await by descending from(?=\\s*(?:\\w|$)) get global group into init(?=\\s*;) join let nameof not notnull on or orderby partial remove select set unmanaged value when where with(?=\\s*{)',
  952.             other: 'abstract as base break case catch checked const continue default delegate do else event explicit extern finally fixed for foreach goto if implicit in internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static switch this throw try typeof unchecked unsafe using virtual volatile while yield'
  953.           };
  954.           function keywordsToPattern(words) {
  955.             return '\\b(?:' + words.trim().replace(/ /g, '|') + ')\\b';
  956.           }
  957.           var typeDeclarationKeywords = keywordsToPattern(keywordKinds.typeDeclaration);
  958.           var keywords = RegExp(keywordsToPattern(keywordKinds.type + ' ' + keywordKinds.typeDeclaration + ' ' + keywordKinds.contextual + ' ' + keywordKinds.other));
  959.           var nonTypeKeywords = keywordsToPattern(keywordKinds.typeDeclaration + ' ' + keywordKinds.contextual + ' ' + keywordKinds.other);
  960.           var nonContextualKeywords = keywordsToPattern(keywordKinds.type + ' ' + keywordKinds.typeDeclaration + ' ' + keywordKinds.other);
  961.           var generic = nested(/<(?:[^<>;=+\-*/%&|^]|<<self>>)*>/.source, 2);
  962.           var nestedRound = nested(/\((?:[^()]|<<self>>)*\)/.source, 2);
  963.           var name = /@?\b[A-Za-z_]\w*\b/.source;
  964.           var genericName = replace(/<<0>>(?:\s*<<1>>)?/.source, [
  965.             name,
  966.             generic
  967.           ]);
  968.           var identifier = replace(/(?!<<0>>)<<1>>(?:\s*\.\s*<<1>>)*/.source, [
  969.             nonTypeKeywords,
  970.             genericName
  971.           ]);
  972.           var array = /\[\s*(?:,\s*)*\]/.source;
  973.           var typeExpressionWithoutTuple = replace(/<<0>>(?:\s*(?:\?\s*)?<<1>>)*(?:\s*\?)?/.source, [
  974.             identifier,
  975.             array
  976.           ]);
  977.           var tupleElement = replace(/[^,()<>[\];=+\-*/%&|^]|<<0>>|<<1>>|<<2>>/.source, [
  978.             generic,
  979.             nestedRound,
  980.             array
  981.           ]);
  982.           var tuple = replace(/\(<<0>>+(?:,<<0>>+)+\)/.source, [tupleElement]);
  983.           var typeExpression = replace(/(?:<<0>>|<<1>>)(?:\s*(?:\?\s*)?<<2>>)*(?:\s*\?)?/.source, [
  984.             tuple,
  985.             identifier,
  986.             array
  987.           ]);
  988.           var typeInside = {
  989.             'keyword': keywords,
  990.             'punctuation': /[<>()?,.:[\]]/
  991.           };
  992.           var character = /'(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'/.source;
  993.           var regularString = /"(?:\\.|[^\\"\r\n])*"/.source;
  994.           var verbatimString = /@"(?:""|\\[\s\S]|[^\\"])*"(?!")/.source;
  995.           Prism.languages.csharp = Prism.languages.extend('clike', {
  996.             'string': [
  997.               {
  998.                 pattern: re(/(^|[^$\\])<<0>>/.source, [verbatimString]),
  999.                 lookbehind: true,
  1000.                 greedy: true
  1001.               },
  1002.               {
  1003.                 pattern: re(/(^|[^@$\\])<<0>>/.source, [regularString]),
  1004.                 lookbehind: true,
  1005.                 greedy: true
  1006.               }
  1007.             ],
  1008.             'class-name': [
  1009.               {
  1010.                 pattern: re(/(\busing\s+static\s+)<<0>>(?=\s*;)/.source, [identifier]),
  1011.                 lookbehind: true,
  1012.                 inside: typeInside
  1013.               },
  1014.               {
  1015.                 pattern: re(/(\busing\s+<<0>>\s*=\s*)<<1>>(?=\s*;)/.source, [
  1016.                   name,
  1017.                   typeExpression
  1018.                 ]),
  1019.                 lookbehind: true,
  1020.                 inside: typeInside
  1021.               },
  1022.               {
  1023.                 pattern: re(/(\busing\s+)<<0>>(?=\s*=)/.source, [name]),
  1024.                 lookbehind: true
  1025.               },
  1026.               {
  1027.                 pattern: re(/(\b<<0>>\s+)<<1>>/.source, [
  1028.                   typeDeclarationKeywords,
  1029.                   genericName
  1030.                 ]),
  1031.                 lookbehind: true,
  1032.                 inside: typeInside
  1033.               },
  1034.               {
  1035.                 pattern: re(/(\bcatch\s*\(\s*)<<0>>/.source, [identifier]),
  1036.                 lookbehind: true,
  1037.                 inside: typeInside
  1038.               },
  1039.               {
  1040.                 pattern: re(/(\bwhere\s+)<<0>>/.source, [name]),
  1041.                 lookbehind: true
  1042.               },
  1043.               {
  1044.                 pattern: re(/(\b(?:is(?:\s+not)?|as)\s+)<<0>>/.source, [typeExpressionWithoutTuple]),
  1045.                 lookbehind: true,
  1046.                 inside: typeInside
  1047.               },
  1048.               {
  1049.                 pattern: re(/\b<<0>>(?=\s+(?!<<1>>|with\s*\{)<<2>>(?:\s*[=,;:{)\]]|\s+(?:in|when)\b))/.source, [
  1050.                   typeExpression,
  1051.                   nonContextualKeywords,
  1052.                   name
  1053.                 ]),
  1054.                 inside: typeInside
  1055.               }
  1056.             ],
  1057.             'keyword': keywords,
  1058.             'number': /(?:\b0(?:x[\da-f_]*[\da-f]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[-+]?\d+(?:_+\d+)*)?)(?:[dflmu]|lu|ul)?\b/i,
  1059.             'operator': />>=?|<<=?|[-=]>|([-+&|])\1|~|\?\?=?|[-+*/%&|^!=<>]=?/,
  1060.             'punctuation': /\?\.?|::|[{}[\];(),.:]/
  1061.           });
  1062.           Prism.languages.insertBefore('csharp', 'number', {
  1063.             'range': {
  1064.               pattern: /\.\./,
  1065.               alias: 'operator'
  1066.             }
  1067.           });
  1068.           Prism.languages.insertBefore('csharp', 'punctuation', {
  1069.             'named-parameter': {
  1070.               pattern: re(/([(,]\s*)<<0>>(?=\s*:)/.source, [name]),
  1071.               lookbehind: true,
  1072.               alias: 'punctuation'
  1073.             }
  1074.           });
  1075.           Prism.languages.insertBefore('csharp', 'class-name', {
  1076.             'namespace': {
  1077.               pattern: re(/(\b(?:namespace|using)\s+)<<0>>(?:\s*\.\s*<<0>>)*(?=\s*[;{])/.source, [name]),
  1078.               lookbehind: true,
  1079.               inside: { 'punctuation': /\./ }
  1080.             },
  1081.             'type-expression': {
  1082.               pattern: re(/(\b(?:default|sizeof|typeof)\s*\(\s*(?!\s))(?:[^()\s]|\s(?!\s)|<<0>>)*(?=\s*\))/.source, [nestedRound]),
  1083.               lookbehind: true,
  1084.               alias: 'class-name',
  1085.               inside: typeInside
  1086.             },
  1087.             'return-type': {
  1088.               pattern: re(/<<0>>(?=\s+(?:<<1>>\s*(?:=>|[({]|\.\s*this\s*\[)|this\s*\[))/.source, [
  1089.                 typeExpression,
  1090.                 identifier
  1091.               ]),
  1092.               inside: typeInside,
  1093.               alias: 'class-name'
  1094.             },
  1095.             'constructor-invocation': {
  1096.               pattern: re(/(\bnew\s+)<<0>>(?=\s*[[({])/.source, [typeExpression]),
  1097.               lookbehind: true,
  1098.               inside: typeInside,
  1099.               alias: 'class-name'
  1100.             },
  1101.             'generic-method': {
  1102.               pattern: re(/<<0>>\s*<<1>>(?=\s*\()/.source, [
  1103.                 name,
  1104.                 generic
  1105.               ]),
  1106.               inside: {
  1107.                 'function': re(/^<<0>>/.source, [name]),
  1108.                 'generic': {
  1109.                   pattern: RegExp(generic),
  1110.                   alias: 'class-name',
  1111.                   inside: typeInside
  1112.                 }
  1113.               }
  1114.             },
  1115.             'type-list': {
  1116.               pattern: re(/\b((?:<<0>>\s+<<1>>|record\s+<<1>>\s*<<5>>|where\s+<<2>>)\s*:\s*)(?:<<3>>|<<4>>|<<1>>\s*<<5>>|<<6>>)(?:\s*,\s*(?:<<3>>|<<4>>|<<6>>))*(?=\s*(?:where|[{;]|=>|$))/.source, [
  1117.                 typeDeclarationKeywords,
  1118.                 genericName,
  1119.                 name,
  1120.                 typeExpression,
  1121.                 keywords.source,
  1122.                 nestedRound,
  1123.                 /\bnew\s*\(\s*\)/.source
  1124.               ]),
  1125.               lookbehind: true,
  1126.               inside: {
  1127.                 'record-arguments': {
  1128.                   pattern: re(/(^(?!new\s*\()<<0>>\s*)<<1>>/.source, [
  1129.                     genericName,
  1130.                     nestedRound
  1131.                   ]),
  1132.                   lookbehind: true,
  1133.                   greedy: true,
  1134.                   inside: Prism.languages.csharp
  1135.                 },
  1136.                 'keyword': keywords,
  1137.                 'class-name': {
  1138.                   pattern: RegExp(typeExpression),
  1139.                   greedy: true,
  1140.                   inside: typeInside
  1141.                 },
  1142.                 'punctuation': /[,()]/
  1143.               }
  1144.             },
  1145.             'preprocessor': {
  1146.               pattern: /(^[\t ]*)#.*/m,
  1147.               lookbehind: true,
  1148.               alias: 'property',
  1149.               inside: {
  1150.                 'directive': {
  1151.                   pattern: /(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/,
  1152.                   lookbehind: true,
  1153.                   alias: 'keyword'
  1154.                 }
  1155.               }
  1156.             }
  1157.           });
  1158.           var regularStringOrCharacter = regularString + '|' + character;
  1159.           var regularStringCharacterOrComment = replace(/\/(?![*/])|\/\/[^\r\n]*[\r\n]|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>/.source, [regularStringOrCharacter]);
  1160.           var roundExpression = nested(replace(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [regularStringCharacterOrComment]), 2);
  1161.          var attrTarget = /\b(?:assembly|event|field|method|module|param|property|return|type)\b/.source;
  1162.          var attr = replace(/<<0>>(?:\s*\(<<1>>*\))?/.source, [
  1163.            identifier,
  1164.            roundExpression
  1165.          ]);
  1166.          Prism.languages.insertBefore('csharp', 'class-name', {
  1167.            'attribute': {
  1168.              pattern: re(/((?:^|[^\s\w>)?])\s*\[\s*)(?:<<0>>\s*:\s*)?<<1>>(?:\s*,\s*<<1>>)*(?=\s*\])/.source, [
  1169.                attrTarget,
  1170.                attr
  1171.              ]),
  1172.              lookbehind: true,
  1173.              greedy: true,
  1174.              inside: {
  1175.                'target': {
  1176.                  pattern: re(/^<<0>>(?=\s*:)/.source, [attrTarget]),
  1177.                  alias: 'keyword'
  1178.                },
  1179.                'attribute-arguments': {
  1180.                  pattern: re(/\(<<0>>*\)/.source, [roundExpression]),
  1181.                  inside: Prism.languages.csharp
  1182.                },
  1183.                'class-name': {
  1184.                  pattern: RegExp(identifier),
  1185.                  inside: { 'punctuation': /\./ }
  1186.                },
  1187.                'punctuation': /[:,]/
  1188.              }
  1189.            }
  1190.          });
  1191.          var formatString = /:[^}\r\n]+/.source;
  1192.          var mInterpolationRound = nested(replace(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [regularStringCharacterOrComment]), 2);
  1193.          var mInterpolation = replace(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [
  1194.            mInterpolationRound,
  1195.            formatString
  1196.          ]);
  1197.          var sInterpolationRound = nested(replace(/[^"'/()]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>|\(<<self>>*\)/.source, [regularStringOrCharacter]), 2);
  1198.           var sInterpolation = replace(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [
  1199.             sInterpolationRound,
  1200.             formatString
  1201.           ]);
  1202.           function createInterpolationInside(interpolation, interpolationRound) {
  1203.             return {
  1204.               'interpolation': {
  1205.                 pattern: re(/((?:^|[^{])(?:\{\{)*)<<0>>/.source, [interpolation]),
  1206.                 lookbehind: true,
  1207.                 inside: {
  1208.                   'format-string': {
  1209.                     pattern: re(/(^\{(?:(?![}:])<<0>>)*)<<1>>(?=\}$)/.source, [
  1210.                       interpolationRound,
  1211.                       formatString
  1212.                     ]),
  1213.                     lookbehind: true,
  1214.                     inside: { 'punctuation': /^:/ }
  1215.                   },
  1216.                   'punctuation': /^\{|\}$/,
  1217.                   'expression': {
  1218.                     pattern: /[\s\S]+/,
  1219.                     alias: 'language-csharp',
  1220.                     inside: Prism.languages.csharp
  1221.                   }
  1222.                 }
  1223.               },
  1224.               'string': /[\s\S]+/
  1225.             };
  1226.           }
  1227.           Prism.languages.insertBefore('csharp', 'string', {
  1228.             'interpolation-string': [
  1229.               {
  1230.                 pattern: re(/(^|[^\\])(?:\$@|@\$)"(?:""|\\[\s\S]|\{\{|<<0>>|[^\\{"])*"/.source, [mInterpolation]),
  1231.                 lookbehind: true,
  1232.                 greedy: true,
  1233.                 inside: createInterpolationInside(mInterpolation, mInterpolationRound)
  1234.               },
  1235.               {
  1236.                 pattern: re(/(^|[^@\\])\$"(?:\\.|\{\{|<<0>>|[^\\"{])*"/.source, [sInterpolation]),
  1237.                 lookbehind: true,
  1238.                 greedy: true,
  1239.                 inside: createInterpolationInside(sInterpolation, sInterpolationRound)
  1240.               }
  1241.             ],
  1242.             'char': {
  1243.               pattern: RegExp(character),
  1244.               greedy: true
  1245.             }
  1246.           });
  1247.           Prism.languages.dotnet = Prism.languages.cs = Prism.languages.csharp;
  1248.         }(Prism));
  1249.         (function (Prism) {
  1250.           var string = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
  1251.           Prism.languages.css = {
  1252.             'comment': /\/\*[\s\S]*?\*\//,
  1253.             'atrule': {
  1254.               pattern: RegExp('@[\\w-](?:' + /[^;{\s"']|\s+(?!\s)/.source + '|' + string.source + ')*?' + /(?:;|(?=\s*\{))/.source),
  1255.               inside: {
  1256.                 'rule': /^@[\w-]+/,
  1257.                 'selector-function-argument': {
  1258.                   pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
  1259.                   lookbehind: true,
  1260.                   alias: 'selector'
  1261.                 },
  1262.                 'keyword': {
  1263.                   pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
  1264.                   lookbehind: true
  1265.                 }
  1266.               }
  1267.             },
  1268.             'url': {
  1269.               pattern: RegExp('\\burl\\((?:' + string.source + '|' + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ')\\)', 'i'),
  1270.               greedy: true,
  1271.               inside: {
  1272.                 'function': /^url/i,
  1273.                 'punctuation': /^\(|\)$/,
  1274.                 'string': {
  1275.                   pattern: RegExp('^' + string.source + '$'),
  1276.                   alias: 'url'
  1277.                 }
  1278.               }
  1279.             },
  1280.             'selector': {
  1281.               pattern: RegExp('(^|[{}\\s])[^{}\\s](?:[^{};"\'\\s]|\\s+(?![\\s{])|' + string.source + ')*(?=\\s*\\{)'),
  1282.               lookbehind: true
  1283.             },
  1284.             'string': {
  1285.               pattern: string,
  1286.               greedy: true
  1287.             },
  1288.             'property': {
  1289.               pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
  1290.               lookbehind: true
  1291.             },
  1292.             'important': /!important\b/i,
  1293.             'function': {
  1294.               pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
  1295.               lookbehind: true
  1296.             },
  1297.             'punctuation': /[(){};:,]/
  1298.           };
  1299.           Prism.languages.css['atrule'].inside.rest = Prism.languages.css;
  1300.           var markup = Prism.languages.markup;
  1301.           if (markup) {
  1302.             markup.tag.addInlined('style', 'css');
  1303.             markup.tag.addAttribute('style', 'css');
  1304.           }
  1305.         }(Prism));
  1306.         (function (Prism) {
  1307.           var keywords = /\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record(?!\s*[(){}[\]<>=%~.:,;?+\-*/&|^])|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/;
  1308.           var classNamePrefix = /(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source;
  1309.           var className = {
  1310.             pattern: RegExp(/(^|[^\w.])/.source + classNamePrefix + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source),
  1311.             lookbehind: true,
  1312.             inside: {
  1313.               'namespace': {
  1314.                 pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
  1315.                 inside: { 'punctuation': /\./ }
  1316.               },
  1317.               'punctuation': /\./
  1318.             }
  1319.           };
  1320.           Prism.languages.java = Prism.languages.extend('clike', {
  1321.             'string': {
  1322.               pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/,
  1323.               lookbehind: true,
  1324.               greedy: true
  1325.             },
  1326.             'class-name': [
  1327.               className,
  1328.               {
  1329.                 pattern: RegExp(/(^|[^\w.])/.source + classNamePrefix + /[A-Z]\w*(?=\s+\w+\s*[;,=()]|\s*(?:\[[\s,]*\]\s*)?::\s*new\b)/.source),
  1330.                 lookbehind: true,
  1331.                 inside: className.inside
  1332.               },
  1333.               {
  1334.                 pattern: RegExp(/(\b(?:class|enum|extends|implements|instanceof|interface|new|record|throws)\s+)/.source + classNamePrefix + /[A-Z]\w*\b/.source),
  1335.                 lookbehind: true,
  1336.                 inside: className.inside
  1337.               }
  1338.             ],
  1339.             'keyword': keywords,
  1340.             'function': [
  1341.               Prism.languages.clike.function,
  1342.               {
  1343.                 pattern: /(::\s*)[a-z_]\w*/,
  1344.                 lookbehind: true
  1345.               }
  1346.             ],
  1347.             'number': /\b0b[01][01_]*L?\b|\b0x(?:\.[\da-f_p+-]+|[\da-f_]+(?:\.[\da-f_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i,
  1348.             'operator': {
  1349.               pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,
  1350.               lookbehind: true
  1351.             },
  1352.             'constant': /\b[A-Z][A-Z_\d]+\b/
  1353.           });
  1354.           Prism.languages.insertBefore('java', 'string', {
  1355.             'triple-quoted-string': {
  1356.               pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
  1357.               greedy: true,
  1358.               alias: 'string'
  1359.             },
  1360.             'char': {
  1361.               pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/,
  1362.               greedy: true
  1363.             }
  1364.           });
  1365.           Prism.languages.insertBefore('java', 'class-name', {
  1366.             'annotation': {
  1367.               pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/,
  1368.               lookbehind: true,
  1369.               alias: 'punctuation'
  1370.             },
  1371.             'generics': {
  1372.               pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,
  1373.               inside: {
  1374.                 'class-name': className,
  1375.                 'keyword': keywords,
  1376.                 'punctuation': /[<>(),.:]/,
  1377.                 'operator': /[?&|]/
  1378.               }
  1379.             },
  1380.             'import': [
  1381.               {
  1382.                 pattern: RegExp(/(\bimport\s+)/.source + classNamePrefix + /(?:[A-Z]\w*|\*)(?=\s*;)/.source),
  1383.                 lookbehind: true,
  1384.                 inside: {
  1385.                   'namespace': className.inside.namespace,
  1386.                   'punctuation': /\./,
  1387.                   'operator': /\*/,
  1388.                   'class-name': /\w+/
  1389.                 }
  1390.               },
  1391.               {
  1392.                 pattern: RegExp(/(\bimport\s+static\s+)/.source + classNamePrefix + /(?:\w+|\*)(?=\s*;)/.source),
  1393.                 lookbehind: true,
  1394.                 alias: 'static',
  1395.                 inside: {
  1396.                   'namespace': className.inside.namespace,
  1397.                   'static': /\b\w+$/,
  1398.                   'punctuation': /\./,
  1399.                   'operator': /\*/,
  1400.                   'class-name': /\w+/
  1401.                 }
  1402.               }
  1403.             ],
  1404.             'namespace': {
  1405.               pattern: RegExp(/(\b(?:exports|import(?:\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\s+)(?!<keyword>)[a-z]\w*(?:\.[a-z]\w*)*\.?/.source.replace(/<keyword>/g, function () {
  1406.                 return keywords.source;
  1407.               })),
  1408.               lookbehind: true,
  1409.               inside: { 'punctuation': /\./ }
  1410.             }
  1411.           });
  1412.         }(Prism));
  1413.         Prism.languages.javascript = Prism.languages.extend('clike', {
  1414.           'class-name': [
  1415.             Prism.languages.clike['class-name'],
  1416.             {
  1417.               pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
  1418.               lookbehind: true
  1419.             }
  1420.           ],
  1421.           'keyword': [
  1422.             {
  1423.               pattern: /((?:^|\})\s*)catch\b/,
  1424.               lookbehind: true
  1425.             },
  1426.             {
  1427.               pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
  1428.               lookbehind: true
  1429.             }
  1430.           ],
  1431.           'function': /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
  1432.           'number': {
  1433.             pattern: RegExp(/(^|[^\w$])/.source + '(?:' + (/NaN|Infinity/.source + '|' + /0[bB][01]+(?:_[01]+)*n?/.source + '|' + /0[oO][0-7]+(?:_[0-7]+)*n?/.source + '|' + /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + '|' + /\d+(?:_\d+)*n/.source + '|' + /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source) + ')' + /(?![\w$])/.source),
  1434.             lookbehind: true
  1435.           },
  1436.           'operator': /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
  1437.         });
  1438.         Prism.languages.javascript['class-name'][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/;
  1439.         Prism.languages.insertBefore('javascript', 'keyword', {
  1440.           'regex': {
  1441.             pattern: RegExp(/((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source + /\//.source + '(?:' + /(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/.source + '|' + /(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/.source + ')' + /(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source),
  1442.             lookbehind: true,
  1443.             greedy: true,
  1444.             inside: {
  1445.               'regex-source': {
  1446.                 pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
  1447.                 lookbehind: true,
  1448.                 alias: 'language-regex',
  1449.                 inside: Prism.languages.regex
  1450.               },
  1451.               'regex-delimiter': /^\/|\/$/,
  1452.               'regex-flags': /^[a-z]+$/
  1453.             }
  1454.           },
  1455.           'function-variable': {
  1456.             pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
  1457.             alias: 'function'
  1458.           },
  1459.           'parameter': [
  1460.             {
  1461.               pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
  1462.               lookbehind: true,
  1463.               inside: Prism.languages.javascript
  1464.             },
  1465.             {
  1466.               pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
  1467.               lookbehind: true,
  1468.               inside: Prism.languages.javascript
  1469.             },
  1470.             {
  1471.               pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
  1472.               lookbehind: true,
  1473.               inside: Prism.languages.javascript
  1474.             },
  1475.             {
  1476.               pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,
  1477.               lookbehind: true,
  1478.               inside: Prism.languages.javascript
  1479.             }
  1480.           ],
  1481.           'constant': /\b[A-Z](?:[A-Z_]|\dx?)*\b/
  1482.         });
  1483.         Prism.languages.insertBefore('javascript', 'string', {
  1484.           'hashbang': {
  1485.             pattern: /^#!.*/,
  1486.             greedy: true,
  1487.             alias: 'comment'
  1488.           },
  1489.           'template-string': {
  1490.             pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
  1491.             greedy: true,
  1492.             inside: {
  1493.               'template-punctuation': {
  1494.                 pattern: /^`|`$/,
  1495.                 alias: 'string'
  1496.               },
  1497.               'interpolation': {
  1498.                 pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
  1499.                 lookbehind: true,
  1500.                 inside: {
  1501.                   'interpolation-punctuation': {
  1502.                     pattern: /^\$\{|\}$/,
  1503.                     alias: 'punctuation'
  1504.                   },
  1505.                   rest: Prism.languages.javascript
  1506.                 }
  1507.               },
  1508.               'string': /[\s\S]+/
  1509.             }
  1510.           },
  1511.           'string-property': {
  1512.             pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
  1513.             lookbehind: true,
  1514.             greedy: true,
  1515.             alias: 'property'
  1516.           }
  1517.         });
  1518.         Prism.languages.insertBefore('javascript', 'operator', {
  1519.           'literal-property': {
  1520.             pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
  1521.             lookbehind: true,
  1522.             alias: 'property'
  1523.           }
  1524.         });
  1525.         if (Prism.languages.markup) {
  1526.           Prism.languages.markup.tag.addInlined('script', 'javascript');
  1527.           Prism.languages.markup.tag.addAttribute(/on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source, 'javascript');
  1528.         }
  1529.         Prism.languages.js = Prism.languages.javascript;
  1530.         Prism.languages.markup = {
  1531.           'comment': {
  1532.             pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
  1533.             greedy: true
  1534.           },
  1535.           'prolog': {
  1536.             pattern: /<\?[\s\S]+?\?>/,
  1537.             greedy: true
  1538.           },
  1539.           'doctype': {
  1540.             pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
  1541.             greedy: true,
  1542.             inside: {
  1543.               'internal-subset': {
  1544.                 pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
  1545.                 lookbehind: true,
  1546.                 greedy: true,
  1547.                 inside: null
  1548.               },
  1549.               'string': {
  1550.                 pattern: /"[^"]*"|'[^']*'/,
  1551.                 greedy: true
  1552.               },
  1553.               'punctuation': /^<!|>$|[[\]]/,
  1554.               'doctype-tag': /^DOCTYPE/i,
  1555.               'name': /[^\s<>'"]+/
  1556.             }
  1557.           },
  1558.           'cdata': {
  1559.             pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
  1560.             greedy: true
  1561.           },
  1562.           'tag': {
  1563.             pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
  1564.             greedy: true,
  1565.             inside: {
  1566.               'tag': {
  1567.                 pattern: /^<\/?[^\s>\/]+/,
  1568.                 inside: {
  1569.                   'punctuation': /^<\/?/,
  1570.                   'namespace': /^[^\s>\/:]+:/
  1571.                 }
  1572.               },
  1573.               'special-attr': [],
  1574.               'attr-value': {
  1575.                 pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
  1576.                 inside: {
  1577.                   'punctuation': [
  1578.                     {
  1579.                       pattern: /^=/,
  1580.                       alias: 'attr-equals'
  1581.                     },
  1582.                     {
  1583.                       pattern: /^(\s*)["']|["']$/,
  1584.                       lookbehind: true
  1585.                     }
  1586.                   ]
  1587.                 }
  1588.               },
  1589.               'punctuation': /\/?>/,
  1590.               'attr-name': {
  1591.                 pattern: /[^\s>\/]+/,
  1592.                 inside: { 'namespace': /^[^\s>\/:]+:/ }
  1593.               }
  1594.             }
  1595.           },
  1596.           'entity': [
  1597.             {
  1598.               pattern: /&[\da-z]{1,8};/i,
  1599.               alias: 'named-entity'
  1600.             },
  1601.             /&#x?[\da-f]{1,8};/i
  1602.           ]
  1603.         };
  1604.         Prism.languages.markup['tag'].inside['attr-value'].inside['entity'] = Prism.languages.markup['entity'];
  1605.         Prism.languages.markup['doctype'].inside['internal-subset'].inside = Prism.languages.markup;
  1606.         Prism.hooks.add('wrap', function (env) {
  1607.           if (env.type === 'entity') {
  1608.             env.attributes['title'] = env.content.replace(/&amp;/, '&');
  1609.           }
  1610.         });
  1611.         Object.defineProperty(Prism.languages.markup.tag, 'addInlined', {
  1612.           value: function addInlined(tagName, lang) {
  1613.             var includedCdataInside = {};
  1614.             includedCdataInside['language-' + lang] = {
  1615.               pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
  1616.               lookbehind: true,
  1617.               inside: Prism.languages[lang]
  1618.             };
  1619.             includedCdataInside['cdata'] = /^<!\[CDATA\[|\]\]>$/i;
  1620.             var inside = {
  1621.               'included-cdata': {
  1622.                 pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
  1623.                 inside: includedCdataInside
  1624.               }
  1625.             };
  1626.             inside['language-' + lang] = {
  1627.               pattern: /[\s\S]+/,
  1628.               inside: Prism.languages[lang]
  1629.             };
  1630.             var def = {};
  1631.             def[tagName] = {
  1632.               pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function () {
  1633.                 return tagName;
  1634.               }), 'i'),
  1635.               lookbehind: true,
  1636.               greedy: true,
  1637.               inside: inside
  1638.             };
  1639.             Prism.languages.insertBefore('markup', 'cdata', def);
  1640.           }
  1641.         });
  1642.         Object.defineProperty(Prism.languages.markup.tag, 'addAttribute', {
  1643.           value: function (attrName, lang) {
  1644.             Prism.languages.markup.tag.inside['special-attr'].push({
  1645.               pattern: RegExp(/(^|["'\s])/.source + '(?:' + attrName + ')' + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source, 'i'),
  1646.               lookbehind: true,
  1647.               inside: {
  1648.                 'attr-name': /^[^\s=]+/,
  1649.                 'attr-value': {
  1650.                   pattern: /=[\s\S]+/,
  1651.                   inside: {
  1652.                     'value': {
  1653.                       pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
  1654.                       lookbehind: true,
  1655.                       alias: [
  1656.                         lang,
  1657.                         'language-' + lang
  1658.                       ],
  1659.                       inside: Prism.languages[lang]
  1660.                     },
  1661.                     'punctuation': [
  1662.                       {
  1663.                         pattern: /^=/,
  1664.                         alias: 'attr-equals'
  1665.                       },
  1666.                       /"|'/
  1667.                     ]
  1668.                   }
  1669.                 }
  1670.               }
  1671.             });
  1672.           }
  1673.         });
  1674.         Prism.languages.html = Prism.languages.markup;
  1675.         Prism.languages.mathml = Prism.languages.markup;
  1676.         Prism.languages.svg = Prism.languages.markup;
  1677.         Prism.languages.xml = Prism.languages.extend('markup', {});
  1678.         Prism.languages.ssml = Prism.languages.xml;
  1679.         Prism.languages.atom = Prism.languages.xml;
  1680.         Prism.languages.rss = Prism.languages.xml;
  1681.         (function (Prism) {
  1682.           var comment = /\/\*[\s\S]*?\*\/|\/\/.*|#(?!\[).*/;
  1683.           var constant = [
  1684.             {
  1685.               pattern: /\b(?:false|true)\b/i,
  1686.               alias: 'boolean'
  1687.             },
  1688.             {
  1689.               pattern: /(::\s*)\b[a-z_]\w*\b(?!\s*\()/i,
  1690.               greedy: true,
  1691.               lookbehind: true
  1692.             },
  1693.             {
  1694.               pattern: /(\b(?:case|const)\s+)\b[a-z_]\w*(?=\s*[;=])/i,
  1695.               greedy: true,
  1696.               lookbehind: true
  1697.             },
  1698.             /\b(?:null)\b/i,
  1699.             /\b[A-Z_][A-Z0-9_]*\b(?!\s*\()/
  1700.           ];
  1701.           var number = /\b0b[01]+(?:_[01]+)*\b|\b0o[0-7]+(?:_[0-7]+)*\b|\b0x[\da-f]+(?:_[\da-f]+)*\b|(?:\b\d+(?:_\d+)*\.?(?:\d+(?:_\d+)*)?|\B\.\d+)(?:e[+-]?\d+)?/i;
  1702.           var operator = /<?=>|\?\?=?|\.{3}|\??->|[!=]=?=?|::|\*\*=?|--|\+\+|&&|\|\||<<|>>|[?~]|[/^|%*&<>.+-]=?/;
  1703.           var punctuation = /[{}\[\](),:;]/;
  1704.           Prism.languages.php = {
  1705.             'delimiter': {
  1706.               pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i,
  1707.               alias: 'important'
  1708.             },
  1709.             'comment': comment,
  1710.             'variable': /\$+(?:\w+\b|(?=\{))/,
  1711.             'package': {
  1712.               pattern: /(namespace\s+|use\s+(?:function\s+)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
  1713.               lookbehind: true,
  1714.               inside: { 'punctuation': /\\/ }
  1715.             },
  1716.             'class-name-definition': {
  1717.               pattern: /(\b(?:class|enum|interface|trait)\s+)\b[a-z_]\w*(?!\\)\b/i,
  1718.               lookbehind: true,
  1719.               alias: 'class-name'
  1720.             },
  1721.             'function-definition': {
  1722.               pattern: /(\bfunction\s+)[a-z_]\w*(?=\s*\()/i,
  1723.               lookbehind: true,
  1724.               alias: 'function'
  1725.             },
  1726.             'keyword': [
  1727.               {
  1728.                 pattern: /(\(\s*)\b(?:array|bool|boolean|float|int|integer|object|string)\b(?=\s*\))/i,
  1729.                 alias: 'type-casting',
  1730.                 greedy: true,
  1731.                 lookbehind: true
  1732.               },
  1733.               {
  1734.                 pattern: /([(,?]\s*)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string)\b(?=\s*\$)/i,
  1735.                 alias: 'type-hint',
  1736.                 greedy: true,
  1737.                 lookbehind: true
  1738.               },
  1739.               {
  1740.                 pattern: /(\)\s*:\s*(?:\?\s*)?)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|never|object|self|static|string|void)\b/i,
  1741.                 alias: 'return-type',
  1742.                 greedy: true,
  1743.                 lookbehind: true
  1744.               },
  1745.               {
  1746.                 pattern: /\b(?:array(?!\s*\()|bool|float|int|iterable|mixed|object|string|void)\b/i,
  1747.                 alias: 'type-declaration',
  1748.                 greedy: true
  1749.               },
  1750.               {
  1751.                 pattern: /(\|\s*)(?:false|null)\b|\b(?:false|null)(?=\s*\|)/i,
  1752.                 alias: 'type-declaration',
  1753.                 greedy: true,
  1754.                 lookbehind: true
  1755.               },
  1756.               {
  1757.                 pattern: /\b(?:parent|self|static)(?=\s*::)/i,
  1758.                 alias: 'static-context',
  1759.                 greedy: true
  1760.               },
  1761.               {
  1762.                 pattern: /(\byield\s+)from\b/i,
  1763.                 lookbehind: true
  1764.               },
  1765.               /\bclass\b/i,
  1766.               {
  1767.                 pattern: /((?:^|[^\s>:]|(?:^|[^-])>|(?:^|[^:]):)\s*)\b(?:abstract|and|array|as|break|callable|case|catch|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|enum|eval|exit|extends|final|finally|fn|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|match|namespace|never|new|or|parent|print|private|protected|public|readonly|require|require_once|return|self|static|switch|throw|trait|try|unset|use|var|while|xor|yield|__halt_compiler)\b/i,
  1768.                 lookbehind: true
  1769.               }
  1770.             ],
  1771.             'argument-name': {
  1772.               pattern: /([(,]\s*)\b[a-z_]\w*(?=\s*:(?!:))/i,
  1773.               lookbehind: true
  1774.             },
  1775.             'class-name': [
  1776.               {
  1777.                 pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self|\s+static))\s+|\bcatch\s*\()\b[a-z_]\w*(?!\\)\b/i,
  1778.                 greedy: true,
  1779.                 lookbehind: true
  1780.               },
  1781.               {
  1782.                 pattern: /(\|\s*)\b[a-z_]\w*(?!\\)\b/i,
  1783.                 greedy: true,
  1784.                 lookbehind: true
  1785.               },
  1786.               {
  1787.                 pattern: /\b[a-z_]\w*(?!\\)\b(?=\s*\|)/i,
  1788.                 greedy: true
  1789.               },
  1790.               {
  1791.                 pattern: /(\|\s*)(?:\\?\b[a-z_]\w*)+\b/i,
  1792.                 alias: 'class-name-fully-qualified',
  1793.                 greedy: true,
  1794.                 lookbehind: true,
  1795.                 inside: { 'punctuation': /\\/ }
  1796.               },
  1797.               {
  1798.                 pattern: /(?:\\?\b[a-z_]\w*)+\b(?=\s*\|)/i,
  1799.                 alias: 'class-name-fully-qualified',
  1800.                 greedy: true,
  1801.                 inside: { 'punctuation': /\\/ }
  1802.               },
  1803.               {
  1804.                 pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self\b|\s+static\b))\s+|\bcatch\s*\()(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
  1805.                 alias: 'class-name-fully-qualified',
  1806.                 greedy: true,
  1807.                 lookbehind: true,
  1808.                 inside: { 'punctuation': /\\/ }
  1809.               },
  1810.               {
  1811.                 pattern: /\b[a-z_]\w*(?=\s*\$)/i,
  1812.                 alias: 'type-declaration',
  1813.                 greedy: true
  1814.               },
  1815.               {
  1816.                 pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
  1817.                 alias: [
  1818.                   'class-name-fully-qualified',
  1819.                   'type-declaration'
  1820.                 ],
  1821.                 greedy: true,
  1822.                 inside: { 'punctuation': /\\/ }
  1823.               },
  1824.               {
  1825.                 pattern: /\b[a-z_]\w*(?=\s*::)/i,
  1826.                 alias: 'static-context',
  1827.                 greedy: true
  1828.               },
  1829.               {
  1830.                 pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*::)/i,
  1831.                 alias: [
  1832.                   'class-name-fully-qualified',
  1833.                   'static-context'
  1834.                 ],
  1835.                 greedy: true,
  1836.                 inside: { 'punctuation': /\\/ }
  1837.               },
  1838.               {
  1839.                 pattern: /([(,?]\s*)[a-z_]\w*(?=\s*\$)/i,
  1840.                 alias: 'type-hint',
  1841.                 greedy: true,
  1842.                 lookbehind: true
  1843.               },
  1844.               {
  1845.                 pattern: /([(,?]\s*)(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
  1846.                 alias: [
  1847.                   'class-name-fully-qualified',
  1848.                   'type-hint'
  1849.                 ],
  1850.                 greedy: true,
  1851.                 lookbehind: true,
  1852.                 inside: { 'punctuation': /\\/ }
  1853.               },
  1854.               {
  1855.                 pattern: /(\)\s*:\s*(?:\?\s*)?)\b[a-z_]\w*(?!\\)\b/i,
  1856.                 alias: 'return-type',
  1857.                 greedy: true,
  1858.                 lookbehind: true
  1859.               },
  1860.               {
  1861.                 pattern: /(\)\s*:\s*(?:\?\s*)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
  1862.                 alias: [
  1863.                   'class-name-fully-qualified',
  1864.                   'return-type'
  1865.                 ],
  1866.                 greedy: true,
  1867.                 lookbehind: true,
  1868.                 inside: { 'punctuation': /\\/ }
  1869.               }
  1870.             ],
  1871.             'constant': constant,
  1872.             'function': {
  1873.               pattern: /(^|[^\\\w])\\?[a-z_](?:[\w\\]*\w)?(?=\s*\()/i,
  1874.               lookbehind: true,
  1875.               inside: { 'punctuation': /\\/ }
  1876.             },
  1877.             'property': {
  1878.               pattern: /(->\s*)\w+/,
  1879.               lookbehind: true
  1880.             },
  1881.             'number': number,
  1882.             'operator': operator,
  1883.             'punctuation': punctuation
  1884.           };
  1885.           var string_interpolation = {
  1886.             pattern: /\{\$(?:\{(?:\{[^{}]+\}|[^{}]+)\}|[^{}])+\}|(^|[^\\{])\$+(?:\w+(?:\[[^\r\n\[\]]+\]|->\w+)?)/,
  1887.             lookbehind: true,
  1888.             inside: Prism.languages.php
  1889.           };
  1890.           var string = [
  1891.             {
  1892.               pattern: /<<<'([^']+)'[\r\n](?:.*[\r\n])*?\1;/,
  1893.               alias: 'nowdoc-string',
  1894.               greedy: true,
  1895.               inside: {
  1896.                 'delimiter': {
  1897.                   pattern: /^<<<'[^']+'|[a-z_]\w*;$/i,
  1898.                   alias: 'symbol',
  1899.                   inside: { 'punctuation': /^<<<'?|[';]$/ }
  1900.                 }
  1901.               }
  1902.             },
  1903.             {
  1904.               pattern: /<<<(?:"([^"]+)"[\r\n](?:.*[\r\n])*?\1;|([a-z_]\w*)[\r\n](?:.*[\r\n])*?\2;)/i,
  1905.               alias: 'heredoc-string',
  1906.               greedy: true,
  1907.               inside: {
  1908.                 'delimiter': {
  1909.                   pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
  1910.                   alias: 'symbol',
  1911.                   inside: { 'punctuation': /^<<<"?|[";]$/ }
  1912.                 },
  1913.                 'interpolation': string_interpolation
  1914.               }
  1915.             },
  1916.             {
  1917.               pattern: /`(?:\\[\s\S]|[^\\`])*`/,
  1918.               alias: 'backtick-quoted-string',
  1919.               greedy: true
  1920.             },
  1921.             {
  1922.               pattern: /'(?:\\[\s\S]|[^\\'])*'/,
  1923.               alias: 'single-quoted-string',
  1924.               greedy: true
  1925.             },
  1926.             {
  1927.               pattern: /"(?:\\[\s\S]|[^\\"])*"/,
  1928.               alias: 'double-quoted-string',
  1929.               greedy: true,
  1930.               inside: { 'interpolation': string_interpolation }
  1931.             }
  1932.           ];
  1933.           Prism.languages.insertBefore('php', 'variable', {
  1934.             'string': string,
  1935.             'attribute': {
  1936.               pattern: /#\[(?:[^"'\/#]|\/(?![*/])|\/\/.*$|#(?!\[).*$|\/\*(?:[^*]|\*(?!\/))*\*\/|"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*')+\](?=\s*[a-z$#])/im,
  1937.              greedy: true,
  1938.              inside: {
  1939.                'attribute-content': {
  1940.                  pattern: /^(#\[)[\s\S]+(?=\]$)/,
  1941.                  lookbehind: true,
  1942.                  inside: {
  1943.                    'comment': comment,
  1944.                    'string': string,
  1945.                    'attribute-class-name': [
  1946.                      {
  1947.                        pattern: /([^:]|^)\b[a-z_]\w*(?!\\)\b/i,
  1948.                        alias: 'class-name',
  1949.                        greedy: true,
  1950.                        lookbehind: true
  1951.                      },
  1952.                      {
  1953.                        pattern: /([^:]|^)(?:\\?\b[a-z_]\w*)+/i,
  1954.                        alias: [
  1955.                          'class-name',
  1956.                          'class-name-fully-qualified'
  1957.                        ],
  1958.                        greedy: true,
  1959.                        lookbehind: true,
  1960.                        inside: { 'punctuation': /\\/ }
  1961.                      }
  1962.                    ],
  1963.                    'constant': constant,
  1964.                    'number': number,
  1965.                    'operator': operator,
  1966.                    'punctuation': punctuation
  1967.                  }
  1968.                },
  1969.                'delimiter': {
  1970.                  pattern: /^#\[|\]$/,
  1971.                  alias: 'punctuation'
  1972.                }
  1973.              }
  1974.            }
  1975.          });
  1976.          Prism.hooks.add('before-tokenize', function (env) {
  1977.            if (!/<\?/.test(env.code)) {
  1978.              return;
  1979.            }
  1980.            var phpPattern = /<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/g;
  1981.            Prism.languages['markup-templating'].buildPlaceholders(env, 'php', phpPattern);
  1982.          });
  1983.          Prism.hooks.add('after-tokenize', function (env) {
  1984.            Prism.languages['markup-templating'].tokenizePlaceholders(env, 'php');
  1985.          });
  1986.        }(Prism));
  1987.        Prism.languages.python = {
  1988.          'comment': {
  1989.            pattern: /(^|[^\\])#.*/,
  1990.            lookbehind: true,
  1991.            greedy: true
  1992.          },
  1993.          'string-interpolation': {
  1994.            pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
  1995.             greedy: true,
  1996.             inside: {
  1997.               'interpolation': {
  1998.                 pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
  1999.                 lookbehind: true,
  2000.                 inside: {
  2001.                   'format-spec': {
  2002.                     pattern: /(:)[^:(){}]+(?=\}$)/,
  2003.                     lookbehind: true
  2004.                   },
  2005.                   'conversion-option': {
  2006.                     pattern: /![sra](?=[:}]$)/,
  2007.                     alias: 'punctuation'
  2008.                   },
  2009.                   rest: null
  2010.                 }
  2011.               },
  2012.               'string': /[\s\S]+/
  2013.             }
  2014.           },
  2015.           'triple-quoted-string': {
  2016.             pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
  2017.             greedy: true,
  2018.             alias: 'string'
  2019.           },
  2020.           'string': {
  2021.             pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
  2022.             greedy: true
  2023.           },
  2024.           'function': {
  2025.             pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
  2026.             lookbehind: true
  2027.           },
  2028.           'class-name': {
  2029.             pattern: /(\bclass\s+)\w+/i,
  2030.             lookbehind: true
  2031.           },
  2032.           'decorator': {
  2033.             pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
  2034.             lookbehind: true,
  2035.             alias: [
  2036.               'annotation',
  2037.               'punctuation'
  2038.             ],
  2039.             inside: { 'punctuation': /\./ }
  2040.           },
  2041.           'keyword': /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
  2042.           'builtin': /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
  2043.           'boolean': /\b(?:False|None|True)\b/,
  2044.           'number': /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
  2045.           'operator': /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
  2046.           'punctuation': /[{}[\];(),.:]/
  2047.         };
  2048.         Prism.languages.python['string-interpolation'].inside['interpolation'].inside.rest = Prism.languages.python;
  2049.         Prism.languages.py = Prism.languages.python;
  2050.         (function (Prism) {
  2051.           Prism.languages.ruby = Prism.languages.extend('clike', {
  2052.             'comment': {
  2053.               pattern: /#.*|^=begin\s[\s\S]*?^=end/m,
  2054.               greedy: true
  2055.             },
  2056.             'class-name': {
  2057.               pattern: /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/,
  2058.               lookbehind: true,
  2059.               inside: { 'punctuation': /[.\\]/ }
  2060.             },
  2061.             'keyword': /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/,
  2062.             'operator': /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/,
  2063.             'punctuation': /[(){}[\].,;]/
  2064.           });
  2065.           Prism.languages.insertBefore('ruby', 'operator', {
  2066.             'double-colon': {
  2067.               pattern: /::/,
  2068.               alias: 'punctuation'
  2069.             }
  2070.           });
  2071.           var interpolation = {
  2072.             pattern: /((?:^|[^\\])(?:\\{2})*)#\{(?:[^{}]|\{[^{}]*\})*\}/,
  2073.             lookbehind: true,
  2074.             inside: {
  2075.               'content': {
  2076.                 pattern: /^(#\{)[\s\S]+(?=\}$)/,
  2077.                 lookbehind: true,
  2078.                 inside: Prism.languages.ruby
  2079.               },
  2080.               'delimiter': {
  2081.                 pattern: /^#\{|\}$/,
  2082.                 alias: 'punctuation'
  2083.               }
  2084.             }
  2085.           };
  2086.           delete Prism.languages.ruby.function;
  2087.           var percentExpression = '(?:' + [
  2088.             /([^a-zA-Z0-9\s{(\[<=])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
  2089.             /\((?:[^()\\]|\\[\s\S]|\((?:[^()\\]|\\[\s\S])*\))*\)/.source,
  2090.             /\{(?:[^{}\\]|\\[\s\S]|\{(?:[^{}\\]|\\[\s\S])*\})*\}/.source,
  2091.             /\[(?:[^\[\]\\]|\\[\s\S]|\[(?:[^\[\]\\]|\\[\s\S])*\])*\]/.source,
  2092.             /<(?:[^<>\\]|\\[\s\S]|<(?:[^<>\\]|\\[\s\S])*>)*>/.source
  2093.           ].join('|') + ')';
  2094.           var symbolName = /(?:"(?:\\.|[^"\\\r\n])*"|(?:\b[a-zA-Z_]\w*|[^\s\0-\x7F]+)[?!]?|\$.)/.source;
  2095.           Prism.languages.insertBefore('ruby', 'keyword', {
  2096.             'regex-literal': [
  2097.               {
  2098.                 pattern: RegExp(/%r/.source + percentExpression + /[egimnosux]{0,6}/.source),
  2099.                 greedy: true,
  2100.                 inside: {
  2101.                   'interpolation': interpolation,
  2102.                   'regex': /[\s\S]+/
  2103.                 }
  2104.               },
  2105.               {
  2106.                 pattern: /(^|[^/])\/(?!\/)(?:\[[^\r\n\]]+\]|\\.|[^[/\\\r\n])+\/[egimnosux]{0,6}(?=\s*(?:$|[\r\n,.;})#]))/,
  2107.                 lookbehind: true,
  2108.                 greedy: true,
  2109.                 inside: {
  2110.                   'interpolation': interpolation,
  2111.                   'regex': /[\s\S]+/
  2112.                 }
  2113.               }
  2114.             ],
  2115.             'variable': /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/,
  2116.             'symbol': [
  2117.               {
  2118.                 pattern: RegExp(/(^|[^:]):/.source + symbolName),
  2119.                 lookbehind: true,
  2120.                 greedy: true
  2121.               },
  2122.               {
  2123.                 pattern: RegExp(/([\r\n{(,][ \t]*)/.source + symbolName + /(?=:(?!:))/.source),
  2124.                 lookbehind: true,
  2125.                 greedy: true
  2126.               }
  2127.             ],
  2128.             'method-definition': {
  2129.               pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/,
  2130.               lookbehind: true,
  2131.               inside: {
  2132.                 'function': /\b\w+$/,
  2133.                 'keyword': /^self\b/,
  2134.                 'class-name': /^\w+/,
  2135.                 'punctuation': /\./
  2136.               }
  2137.             }
  2138.           });
  2139.           Prism.languages.insertBefore('ruby', 'string', {
  2140.             'string-literal': [
  2141.               {
  2142.                 pattern: RegExp(/%[qQiIwWs]?/.source + percentExpression),
  2143.                 greedy: true,
  2144.                 inside: {
  2145.                   'interpolation': interpolation,
  2146.                   'string': /[\s\S]+/
  2147.                 }
  2148.               },
  2149.               {
  2150.                 pattern: /("|')(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|(?!\1)[^\\#\r\n])*\1/,
  2151.                 greedy: true,
  2152.                 inside: {
  2153.                   'interpolation': interpolation,
  2154.                   'string': /[\s\S]+/
  2155.                 }
  2156.               },
  2157.               {
  2158.                 pattern: /<<[-~]?([a-z_]\w*)[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
  2159.                 alias: 'heredoc-string',
  2160.                 greedy: true,
  2161.                 inside: {
  2162.                   'delimiter': {
  2163.                     pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i,
  2164.                     inside: {
  2165.                       'symbol': /\b\w+/,
  2166.                       'punctuation': /^<<[-~]?/
  2167.                     }
  2168.                   },
  2169.                   'interpolation': interpolation,
  2170.                   'string': /[\s\S]+/
  2171.                 }
  2172.               },
  2173.               {
  2174.                 pattern: /<<[-~]?'([a-z_]\w*)'[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
  2175.                 alias: 'heredoc-string',
  2176.                 greedy: true,
  2177.                 inside: {
  2178.                   'delimiter': {
  2179.                     pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i,
  2180.                     inside: {
  2181.                       'symbol': /\b\w+/,
  2182.                       'punctuation': /^<<[-~]?'|'$/
  2183.                     }
  2184.                   },
  2185.                   'string': /[\s\S]+/
  2186.                 }
  2187.               }
  2188.             ],
  2189.             'command-literal': [
  2190.               {
  2191.                 pattern: RegExp(/%x/.source + percentExpression),
  2192.                 greedy: true,
  2193.                 inside: {
  2194.                   'interpolation': interpolation,
  2195.                   'command': {
  2196.                     pattern: /[\s\S]+/,
  2197.                     alias: 'string'
  2198.                   }
  2199.                 }
  2200.               },
  2201.               {
  2202.                 pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|[^\\`#\r\n])*`/,
  2203.                 greedy: true,
  2204.                 inside: {
  2205.                   'interpolation': interpolation,
  2206.                   'command': {
  2207.                     pattern: /[\s\S]+/,
  2208.                     alias: 'string'
  2209.                   }
  2210.                 }
  2211.               }
  2212.             ]
  2213.           });
  2214.           delete Prism.languages.ruby.string;
  2215.           Prism.languages.insertBefore('ruby', 'number', {
  2216.             'builtin': /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/,
  2217.             'constant': /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/
  2218.           });
  2219.           Prism.languages.rb = Prism.languages.ruby;
  2220.         }(Prism));
  2221.         var Prism$1 = prismCore.exports;
  2222.         var prismjs = { boltExport: Prism$1 };
  2223.         return prismjs;
  2224.       }));
  2225.       var prism = window.Prism;
  2226.       window.Prism = oldprism;
  2227.       return prism;
  2228.     }(undefined, exports$1, module));
  2229.     var Prism$1 = module.exports.boltExport;
  2230.  
  2231.     var getLanguages$1 = function (editor) {
  2232.       return editor.getParam('codesample_languages');
  2233.     };
  2234.     var useGlobalPrismJS = function (editor) {
  2235.       return editor.getParam('codesample_global_prismjs', false, 'boolean');
  2236.     };
  2237.  
  2238.     var get = function (editor) {
  2239.       return Global.Prism && useGlobalPrismJS(editor) ? Global.Prism : Prism$1;
  2240.     };
  2241.  
  2242.     var getSelectedCodeSample = function (editor) {
  2243.       var node = editor.selection ? editor.selection.getNode() : null;
  2244.       return someIf(isCodeSample(node), node);
  2245.     };
  2246.     var insertCodeSample = function (editor, language, code) {
  2247.       editor.undoManager.transact(function () {
  2248.         var node = getSelectedCodeSample(editor);
  2249.         code = global$1.DOM.encode(code);
  2250.         return node.fold(function () {
  2251.           editor.insertContent('<pre id="__new" class="language-' + language + '">' + code + '</pre>');
  2252.           editor.selection.select(editor.$('#__new').removeAttr('id')[0]);
  2253.         }, function (n) {
  2254.           editor.dom.setAttrib(n, 'class', 'language-' + language);
  2255.           n.innerHTML = code;
  2256.           get(editor).highlightElement(n);
  2257.           editor.selection.select(n);
  2258.         });
  2259.       });
  2260.     };
  2261.     var getCurrentCode = function (editor) {
  2262.       var node = getSelectedCodeSample(editor);
  2263.       return node.fold(constant(''), function (n) {
  2264.         return n.textContent;
  2265.       });
  2266.     };
  2267.  
  2268.     var getLanguages = function (editor) {
  2269.       var defaultLanguages = [
  2270.         {
  2271.           text: 'HTML/XML',
  2272.           value: 'markup'
  2273.         },
  2274.         {
  2275.           text: 'JavaScript',
  2276.           value: 'javascript'
  2277.         },
  2278.         {
  2279.           text: 'CSS',
  2280.           value: 'css'
  2281.         },
  2282.         {
  2283.           text: 'PHP',
  2284.           value: 'php'
  2285.         },
  2286.         {
  2287.           text: 'Ruby',
  2288.           value: 'ruby'
  2289.         },
  2290.         {
  2291.           text: 'Python',
  2292.           value: 'python'
  2293.         },
  2294.         {
  2295.           text: 'Java',
  2296.           value: 'java'
  2297.         },
  2298.         {
  2299.           text: 'C',
  2300.           value: 'c'
  2301.         },
  2302.         {
  2303.           text: 'C#',
  2304.           value: 'csharp'
  2305.         },
  2306.         {
  2307.           text: 'C++',
  2308.           value: 'cpp'
  2309.         }
  2310.       ];
  2311.       var customLanguages = getLanguages$1(editor);
  2312.       return customLanguages ? customLanguages : defaultLanguages;
  2313.     };
  2314.     var getCurrentLanguage = function (editor, fallback) {
  2315.       var node = getSelectedCodeSample(editor);
  2316.       return node.fold(function () {
  2317.         return fallback;
  2318.       }, function (n) {
  2319.         var matches = n.className.match(/language-(\w+)/);
  2320.         return matches ? matches[1] : fallback;
  2321.       });
  2322.     };
  2323.  
  2324.     var open = function (editor) {
  2325.       var languages = getLanguages(editor);
  2326.       var defaultLanguage = head(languages).fold(constant(''), function (l) {
  2327.         return l.value;
  2328.       });
  2329.       var currentLanguage = getCurrentLanguage(editor, defaultLanguage);
  2330.       var currentCode = getCurrentCode(editor);
  2331.       editor.windowManager.open({
  2332.         title: 'Insert/Edit Code Sample',
  2333.         size: 'large',
  2334.         body: {
  2335.           type: 'panel',
  2336.           items: [
  2337.             {
  2338.               type: 'selectbox',
  2339.               name: 'language',
  2340.               label: 'Language',
  2341.               items: languages
  2342.             },
  2343.             {
  2344.               type: 'textarea',
  2345.               name: 'code',
  2346.               label: 'Code view'
  2347.             }
  2348.           ]
  2349.         },
  2350.         buttons: [
  2351.           {
  2352.             type: 'cancel',
  2353.             name: 'cancel',
  2354.             text: 'Cancel'
  2355.           },
  2356.           {
  2357.             type: 'submit',
  2358.             name: 'save',
  2359.             text: 'Save',
  2360.             primary: true
  2361.           }
  2362.         ],
  2363.         initialData: {
  2364.           language: currentLanguage,
  2365.           code: currentCode
  2366.         },
  2367.         onSubmit: function (api) {
  2368.           var data = api.getData();
  2369.           insertCodeSample(editor, data.language, data.code);
  2370.           api.close();
  2371.         }
  2372.       });
  2373.     };
  2374.  
  2375.     var register$1 = function (editor) {
  2376.       editor.addCommand('codesample', function () {
  2377.         var node = editor.selection.getNode();
  2378.         if (editor.selection.isCollapsed() || isCodeSample(node)) {
  2379.           open(editor);
  2380.         } else {
  2381.           editor.formatter.toggle('code');
  2382.         }
  2383.       });
  2384.     };
  2385.  
  2386.     var setup = function (editor) {
  2387.       var $ = editor.$;
  2388.       editor.on('PreProcess', function (e) {
  2389.         $('pre[contenteditable=false]', e.node).filter(trimArg(isCodeSample)).each(function (idx, elm) {
  2390.           var $elm = $(elm), code = elm.textContent;
  2391.           $elm.attr('class', $.trim($elm.attr('class')));
  2392.           $elm.removeAttr('contentEditable');
  2393.           $elm.empty().append($('<code></code>').each(function () {
  2394.             this.textContent = code;
  2395.           }));
  2396.         });
  2397.       });
  2398.       editor.on('SetContent', function () {
  2399.         var unprocessedCodeSamples = $('pre').filter(trimArg(isCodeSample)).filter(function (idx, elm) {
  2400.           return elm.contentEditable !== 'false';
  2401.         });
  2402.         if (unprocessedCodeSamples.length) {
  2403.           editor.undoManager.transact(function () {
  2404.             unprocessedCodeSamples.each(function (idx, elm) {
  2405.               $(elm).find('br').each(function (idx, elm) {
  2406.                 elm.parentNode.replaceChild(editor.getDoc().createTextNode('\n'), elm);
  2407.               });
  2408.               elm.contentEditable = 'false';
  2409.               elm.innerHTML = editor.dom.encode(elm.textContent);
  2410.               get(editor).highlightElement(elm);
  2411.               elm.className = $.trim(elm.className);
  2412.             });
  2413.           });
  2414.         }
  2415.       });
  2416.     };
  2417.  
  2418.     var isCodeSampleSelection = function (editor) {
  2419.       var node = editor.selection.getStart();
  2420.       return editor.dom.is(node, 'pre[class*="language-"]');
  2421.     };
  2422.     var register = function (editor) {
  2423.       var onAction = function () {
  2424.         return editor.execCommand('codesample');
  2425.       };
  2426.       editor.ui.registry.addToggleButton('codesample', {
  2427.         icon: 'code-sample',
  2428.         tooltip: 'Insert/edit code sample',
  2429.         onAction: onAction,
  2430.         onSetup: function (api) {
  2431.           var nodeChangeHandler = function () {
  2432.             api.setActive(isCodeSampleSelection(editor));
  2433.           };
  2434.           editor.on('NodeChange', nodeChangeHandler);
  2435.           return function () {
  2436.             return editor.off('NodeChange', nodeChangeHandler);
  2437.           };
  2438.         }
  2439.       });
  2440.       editor.ui.registry.addMenuItem('codesample', {
  2441.         text: 'Code sample...',
  2442.         icon: 'code-sample',
  2443.         onAction: onAction
  2444.       });
  2445.     };
  2446.  
  2447.     function Plugin () {
  2448.       global$2.add('codesample', function (editor) {
  2449.         setup(editor);
  2450.         register(editor);
  2451.         register$1(editor);
  2452.         editor.on('dblclick', function (ev) {
  2453.           if (isCodeSample(ev.target)) {
  2454.             open(editor);
  2455.           }
  2456.         });
  2457.       });
  2458.     }
  2459.  
  2460.     Plugin();
  2461.  
  2462. }());
  2463.