lib/editor/tiny/js/tinymce/plugins/codesample/plugin.js

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