]*>/gi, '[quote]');
+ rep(/<\/blockquote>/gi, '[/quote]');
+ rep(/
/gi, '\n');
+ rep(//gi, '\n');
+ rep(/
/gi, '\n');
+ rep(//gi, '');
+ rep(/<\/p>/gi, '\n');
+ rep(/ |\u00a0/gi, ' ');
+ rep(/"/gi, '"');
+ rep(/</gi, '<');
+ rep(/>/gi, '>');
+ rep(/&/gi, '&');
+ return s;
+ };
+ var bbcode2html = function (s) {
+ s = global$1.trim(s);
+ var rep = function (re, str) {
+ s = s.replace(re, str);
+ };
+ rep(/\n/gi, '
');
+ rep(/\[b\]/gi, '');
+ rep(/\[\/b\]/gi, '');
+ rep(/\[i\]/gi, '');
+ rep(/\[\/i\]/gi, '');
+ rep(/\[u\]/gi, '');
+ rep(/\[\/u\]/gi, '');
+ rep(/\[url=([^\]]+)\](.*?)\[\/url\]/gi, '$2');
+ rep(/\[url\](.*?)\[\/url\]/gi, '$1');
+ rep(/\[img\](.*?)\[\/img\]/gi, '
');
+ rep(/\[color=(.*?)\](.*?)\[\/color\]/gi, '$2');
+ rep(/\[code\](.*?)\[\/code\]/gi, '$1 ');
+ rep(/\[quote.*?\](.*?)\[\/quote\]/gi, '$1 ');
+ return s;
+ };
+
+ function Plugin () {
+ global.add('bbcode', function (editor) {
+ editor.on('BeforeSetContent', function (e) {
+ e.content = bbcode2html(e.content);
+ });
+ editor.on('PostProcess', function (e) {
+ if (e.set) {
+ e.content = bbcode2html(e.content);
+ }
+ if (e.get) {
+ e.content = html2bbcode(e.content);
+ }
+ });
+ });
+ }
+
+ Plugin();
+
+}());
diff --git a/resources/public/js/build/plugins/bbcode/plugin.min.js b/resources/public/js/build/plugins/bbcode/plugin.min.js
new file mode 100644
index 00000000..a4d4f9ac
--- /dev/null
+++ b/resources/public/js/build/plugins/bbcode/plugin.min.js
@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Tiny Technologies, Inc. All rights reserved.
+ * Licensed under the LGPL or a commercial license.
+ * For LGPL see License.txt in the project root for license information.
+ * For commercial licenses see https://www.tiny.cloud/
+ *
+ * Version: 5.3.0 (2020-05-21)
+ */
+!function(){"use strict";var o=tinymce.util.Tools.resolve("tinymce.PluginManager"),e=tinymce.util.Tools.resolve("tinymce.util.Tools"),t=function(t){t=e.trim(t);var o=function(o,e){t=t.replace(o,e)};return o(/\n/gi,"
"),o(/\[b\]/gi,""),o(/\[\/b\]/gi,""),o(/\[i\]/gi,""),o(/\[\/i\]/gi,""),o(/\[u\]/gi,""),o(/\[\/u\]/gi,""),o(/\[url=([^\]]+)\](.*?)\[\/url\]/gi,'$2'),o(/\[url\](.*?)\[\/url\]/gi,'$1'),o(/\[img\](.*?)\[\/img\]/gi,''),o(/\[color=(.*?)\](.*?)\[\/color\]/gi,'$2'),o(/\[code\](.*?)\[\/code\]/gi,'$1 '),o(/\[quote.*?\](.*?)\[\/quote\]/gi,'$1 '),t};!function i(){o.add("bbcode",function(o){o.on("BeforeSetContent",function(o){o.content=t(o.content)}),o.on("PostProcess",function(o){o.set&&(o.content=t(o.content)),o.get&&(o.content=function(t){t=e.trim(t);var o=function(o,e){t=t.replace(o,e)};return o(/(.*?)<\/a>/gi,"[url=$1]$2[/url]"),o(/(.*?)<\/font>/gi,"[code][color=$1]$2[/color][/code]"),o(/(.*?)<\/font>/gi,"[quote][color=$1]$2[/color][/quote]"),o(/(.*?)<\/font>/gi,"[code][color=$1]$2[/color][/code]"),o(/(.*?)<\/font>/gi,"[quote][color=$1]$2[/color][/quote]"),o(/(.*?)<\/span>/gi,"[color=$1]$2[/color]"),o(/(.*?)<\/font>/gi,"[color=$1]$2[/color]"),o(/(.*?)<\/span>/gi,"[size=$1]$2[/size]"),o(/(.*?)<\/font>/gi,"$1"),o(//gi,"[img]$1[/img]"),o(/(.*?)<\/span>/gi,"[code]$1[/code]"),o(/(.*?)<\/span>/gi,"[quote]$1[/quote]"),o(/(.*?)<\/strong>/gi,"[code][b]$1[/b][/code]"),o(/(.*?)<\/strong>/gi,"[quote][b]$1[/b][/quote]"),o(/(.*?)<\/em>/gi,"[code][i]$1[/i][/code]"),o(/(.*?)<\/em>/gi,"[quote][i]$1[/i][/quote]"),o(/(.*?)<\/u>/gi,"[code][u]$1[/u][/code]"),o(/(.*?)<\/u>/gi,"[quote][u]$1[/u][/quote]"),o(/<\/(strong|b)>/gi,"[/b]"),o(/<(strong|b)>/gi,"[b]"),o(/<\/(em|i)>/gi,"[/i]"),o(/<(em|i)>/gi,"[i]"),o(/<\/u>/gi,"[/u]"),o(/(.*?)<\/span>/gi,"[u]$1[/u]"),o(//gi,"[u]"),o(/]*>/gi,"[quote]"),o(/<\/blockquote>/gi,"[/quote]"),o(/
/gi,"\n"),o(//gi,"\n"),o(/
/gi,"\n"),o(//gi,""),o(/<\/p>/gi,"\n"),o(/ |\u00a0/gi," "),o(/"/gi,'"'),o(/</gi,"<"),o(/>/gi,">"),o(/&/gi,"&"),t}(o.content))})})}()}();
\ No newline at end of file
diff --git a/resources/public/js/build/plugins/charmap/index.js b/resources/public/js/build/plugins/charmap/index.js
new file mode 100644
index 00000000..13a16738
--- /dev/null
+++ b/resources/public/js/build/plugins/charmap/index.js
@@ -0,0 +1,7 @@
+// Exports the "charmap" plugin for usage with module loaders
+// Usage:
+// CommonJS:
+// require('tinymce/plugins/charmap')
+// ES2015:
+// import 'tinymce/plugins/charmap'
+require('./plugin.js');
\ No newline at end of file
diff --git a/resources/public/js/build/plugins/charmap/plugin.js b/resources/public/js/build/plugins/charmap/plugin.js
new file mode 100644
index 00000000..943b0e44
--- /dev/null
+++ b/resources/public/js/build/plugins/charmap/plugin.js
@@ -0,0 +1,1706 @@
+/**
+ * Copyright (c) Tiny Technologies, Inc. All rights reserved.
+ * Licensed under the LGPL or a commercial license.
+ * For LGPL see License.txt in the project root for license information.
+ * For commercial licenses see https://www.tiny.cloud/
+ *
+ * Version: 5.3.0 (2020-05-21)
+ */
+(function (domGlobals) {
+ 'use strict';
+
+ var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
+
+ var fireInsertCustomChar = function (editor, chr) {
+ return editor.fire('insertCustomChar', { chr: chr });
+ };
+
+ var insertChar = function (editor, chr) {
+ var evtChr = fireInsertCustomChar(editor, chr).chr;
+ editor.execCommand('mceInsertContent', false, evtChr);
+ };
+
+ var global$1 = tinymce.util.Tools.resolve('tinymce.util.Tools');
+
+ var getCharMap = function (editor) {
+ return editor.settings.charmap;
+ };
+ var getCharMapAppend = function (editor) {
+ return editor.settings.charmap_append;
+ };
+
+ var noop = function () {
+ };
+ var constant = function (value) {
+ return function () {
+ return value;
+ };
+ };
+ var never = constant(false);
+ var always = constant(true);
+
+ var none = function () {
+ return NONE;
+ };
+ var NONE = function () {
+ var eq = function (o) {
+ return o.isNone();
+ };
+ var call = function (thunk) {
+ return thunk();
+ };
+ var id = function (n) {
+ return n;
+ };
+ var me = {
+ fold: function (n, _s) {
+ return n();
+ },
+ is: never,
+ isSome: never,
+ isNone: always,
+ getOr: id,
+ getOrThunk: call,
+ getOrDie: function (msg) {
+ throw new Error(msg || 'error: getOrDie called on none.');
+ },
+ getOrNull: constant(null),
+ getOrUndefined: constant(undefined),
+ or: id,
+ orThunk: call,
+ map: none,
+ each: noop,
+ bind: none,
+ exists: never,
+ forall: always,
+ filter: none,
+ equals: eq,
+ equals_: eq,
+ toArray: function () {
+ return [];
+ },
+ toString: constant('none()')
+ };
+ return me;
+ }();
+ var some = function (a) {
+ var constant_a = constant(a);
+ var self = function () {
+ return me;
+ };
+ var bind = function (f) {
+ return f(a);
+ };
+ var me = {
+ fold: function (n, s) {
+ return s(a);
+ },
+ is: function (v) {
+ return a === v;
+ },
+ isSome: always,
+ isNone: never,
+ getOr: constant_a,
+ getOrThunk: constant_a,
+ getOrDie: constant_a,
+ getOrNull: constant_a,
+ getOrUndefined: constant_a,
+ or: self,
+ orThunk: self,
+ map: function (f) {
+ return some(f(a));
+ },
+ each: function (f) {
+ f(a);
+ },
+ bind: bind,
+ exists: bind,
+ forall: bind,
+ filter: function (f) {
+ return f(a) ? me : NONE;
+ },
+ toArray: function () {
+ return [a];
+ },
+ toString: function () {
+ return 'some(' + a + ')';
+ },
+ equals: function (o) {
+ return o.is(a);
+ },
+ equals_: function (o, elementEq) {
+ return o.fold(never, function (b) {
+ return elementEq(a, b);
+ });
+ }
+ };
+ return me;
+ };
+ var from = function (value) {
+ return value === null || value === undefined ? NONE : some(value);
+ };
+ var Option = {
+ some: some,
+ none: none,
+ from: from
+ };
+
+ var typeOf = function (x) {
+ var t = typeof x;
+ if (x === null) {
+ return 'null';
+ } else if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) {
+ return 'array';
+ } else if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) {
+ return 'string';
+ } else {
+ return t;
+ }
+ };
+ var isType = function (type) {
+ return function (value) {
+ return typeOf(value) === type;
+ };
+ };
+ var isArray = isType('array');
+
+ var nativePush = Array.prototype.push;
+ var map = function (xs, f) {
+ var len = xs.length;
+ var r = new Array(len);
+ for (var i = 0; i < len; i++) {
+ var x = xs[i];
+ r[i] = f(x, i);
+ }
+ return r;
+ };
+ var each = function (xs, f) {
+ for (var i = 0, len = xs.length; i < len; i++) {
+ var x = xs[i];
+ f(x, i);
+ }
+ };
+ var findUntil = function (xs, pred, until) {
+ for (var i = 0, len = xs.length; i < len; i++) {
+ var x = xs[i];
+ if (pred(x, i)) {
+ return Option.some(x);
+ } else if (until(x, i)) {
+ break;
+ }
+ }
+ return Option.none();
+ };
+ var find = function (xs, pred) {
+ return findUntil(xs, pred, never);
+ };
+ var flatten = function (xs) {
+ var r = [];
+ for (var i = 0, len = xs.length; i < len; ++i) {
+ if (!isArray(xs[i])) {
+ throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs);
+ }
+ nativePush.apply(r, xs[i]);
+ }
+ return r;
+ };
+ var bind = function (xs, f) {
+ return flatten(map(xs, f));
+ };
+
+ var isArray$1 = global$1.isArray;
+ var UserDefined = 'User Defined';
+ var getDefaultCharMap = function () {
+ return [
+ {
+ name: 'Currency',
+ characters: [
+ [
+ 36,
+ 'dollar sign'
+ ],
+ [
+ 162,
+ 'cent sign'
+ ],
+ [
+ 8364,
+ 'euro sign'
+ ],
+ [
+ 163,
+ 'pound sign'
+ ],
+ [
+ 165,
+ 'yen sign'
+ ],
+ [
+ 164,
+ 'currency sign'
+ ],
+ [
+ 8352,
+ 'euro-currency sign'
+ ],
+ [
+ 8353,
+ 'colon sign'
+ ],
+ [
+ 8354,
+ 'cruzeiro sign'
+ ],
+ [
+ 8355,
+ 'french franc sign'
+ ],
+ [
+ 8356,
+ 'lira sign'
+ ],
+ [
+ 8357,
+ 'mill sign'
+ ],
+ [
+ 8358,
+ 'naira sign'
+ ],
+ [
+ 8359,
+ 'peseta sign'
+ ],
+ [
+ 8360,
+ 'rupee sign'
+ ],
+ [
+ 8361,
+ 'won sign'
+ ],
+ [
+ 8362,
+ 'new sheqel sign'
+ ],
+ [
+ 8363,
+ 'dong sign'
+ ],
+ [
+ 8365,
+ 'kip sign'
+ ],
+ [
+ 8366,
+ 'tugrik sign'
+ ],
+ [
+ 8367,
+ 'drachma sign'
+ ],
+ [
+ 8368,
+ 'german penny symbol'
+ ],
+ [
+ 8369,
+ 'peso sign'
+ ],
+ [
+ 8370,
+ 'guarani sign'
+ ],
+ [
+ 8371,
+ 'austral sign'
+ ],
+ [
+ 8372,
+ 'hryvnia sign'
+ ],
+ [
+ 8373,
+ 'cedi sign'
+ ],
+ [
+ 8374,
+ 'livre tournois sign'
+ ],
+ [
+ 8375,
+ 'spesmilo sign'
+ ],
+ [
+ 8376,
+ 'tenge sign'
+ ],
+ [
+ 8377,
+ 'indian rupee sign'
+ ],
+ [
+ 8378,
+ 'turkish lira sign'
+ ],
+ [
+ 8379,
+ 'nordic mark sign'
+ ],
+ [
+ 8380,
+ 'manat sign'
+ ],
+ [
+ 8381,
+ 'ruble sign'
+ ],
+ [
+ 20870,
+ 'yen character'
+ ],
+ [
+ 20803,
+ 'yuan character'
+ ],
+ [
+ 22291,
+ 'yuan character, in hong kong and taiwan'
+ ],
+ [
+ 22278,
+ 'yen/yuan character variant one'
+ ]
+ ]
+ },
+ {
+ name: 'Text',
+ characters: [
+ [
+ 169,
+ 'copyright sign'
+ ],
+ [
+ 174,
+ 'registered sign'
+ ],
+ [
+ 8482,
+ 'trade mark sign'
+ ],
+ [
+ 8240,
+ 'per mille sign'
+ ],
+ [
+ 181,
+ 'micro sign'
+ ],
+ [
+ 183,
+ 'middle dot'
+ ],
+ [
+ 8226,
+ 'bullet'
+ ],
+ [
+ 8230,
+ 'three dot leader'
+ ],
+ [
+ 8242,
+ 'minutes / feet'
+ ],
+ [
+ 8243,
+ 'seconds / inches'
+ ],
+ [
+ 167,
+ 'section sign'
+ ],
+ [
+ 182,
+ 'paragraph sign'
+ ],
+ [
+ 223,
+ 'sharp s / ess-zed'
+ ]
+ ]
+ },
+ {
+ name: 'Quotations',
+ characters: [
+ [
+ 8249,
+ 'single left-pointing angle quotation mark'
+ ],
+ [
+ 8250,
+ 'single right-pointing angle quotation mark'
+ ],
+ [
+ 171,
+ 'left pointing guillemet'
+ ],
+ [
+ 187,
+ 'right pointing guillemet'
+ ],
+ [
+ 8216,
+ 'left single quotation mark'
+ ],
+ [
+ 8217,
+ 'right single quotation mark'
+ ],
+ [
+ 8220,
+ 'left double quotation mark'
+ ],
+ [
+ 8221,
+ 'right double quotation mark'
+ ],
+ [
+ 8218,
+ 'single low-9 quotation mark'
+ ],
+ [
+ 8222,
+ 'double low-9 quotation mark'
+ ],
+ [
+ 60,
+ 'less-than sign'
+ ],
+ [
+ 62,
+ 'greater-than sign'
+ ],
+ [
+ 8804,
+ 'less-than or equal to'
+ ],
+ [
+ 8805,
+ 'greater-than or equal to'
+ ],
+ [
+ 8211,
+ 'en dash'
+ ],
+ [
+ 8212,
+ 'em dash'
+ ],
+ [
+ 175,
+ 'macron'
+ ],
+ [
+ 8254,
+ 'overline'
+ ],
+ [
+ 164,
+ 'currency sign'
+ ],
+ [
+ 166,
+ 'broken bar'
+ ],
+ [
+ 168,
+ 'diaeresis'
+ ],
+ [
+ 161,
+ 'inverted exclamation mark'
+ ],
+ [
+ 191,
+ 'turned question mark'
+ ],
+ [
+ 710,
+ 'circumflex accent'
+ ],
+ [
+ 732,
+ 'small tilde'
+ ],
+ [
+ 176,
+ 'degree sign'
+ ],
+ [
+ 8722,
+ 'minus sign'
+ ],
+ [
+ 177,
+ 'plus-minus sign'
+ ],
+ [
+ 247,
+ 'division sign'
+ ],
+ [
+ 8260,
+ 'fraction slash'
+ ],
+ [
+ 215,
+ 'multiplication sign'
+ ],
+ [
+ 185,
+ 'superscript one'
+ ],
+ [
+ 178,
+ 'superscript two'
+ ],
+ [
+ 179,
+ 'superscript three'
+ ],
+ [
+ 188,
+ 'fraction one quarter'
+ ],
+ [
+ 189,
+ 'fraction one half'
+ ],
+ [
+ 190,
+ 'fraction three quarters'
+ ]
+ ]
+ },
+ {
+ name: 'Mathematical',
+ characters: [
+ [
+ 402,
+ 'function / florin'
+ ],
+ [
+ 8747,
+ 'integral'
+ ],
+ [
+ 8721,
+ 'n-ary sumation'
+ ],
+ [
+ 8734,
+ 'infinity'
+ ],
+ [
+ 8730,
+ 'square root'
+ ],
+ [
+ 8764,
+ 'similar to'
+ ],
+ [
+ 8773,
+ 'approximately equal to'
+ ],
+ [
+ 8776,
+ 'almost equal to'
+ ],
+ [
+ 8800,
+ 'not equal to'
+ ],
+ [
+ 8801,
+ 'identical to'
+ ],
+ [
+ 8712,
+ 'element of'
+ ],
+ [
+ 8713,
+ 'not an element of'
+ ],
+ [
+ 8715,
+ 'contains as member'
+ ],
+ [
+ 8719,
+ 'n-ary product'
+ ],
+ [
+ 8743,
+ 'logical and'
+ ],
+ [
+ 8744,
+ 'logical or'
+ ],
+ [
+ 172,
+ 'not sign'
+ ],
+ [
+ 8745,
+ 'intersection'
+ ],
+ [
+ 8746,
+ 'union'
+ ],
+ [
+ 8706,
+ 'partial differential'
+ ],
+ [
+ 8704,
+ 'for all'
+ ],
+ [
+ 8707,
+ 'there exists'
+ ],
+ [
+ 8709,
+ 'diameter'
+ ],
+ [
+ 8711,
+ 'backward difference'
+ ],
+ [
+ 8727,
+ 'asterisk operator'
+ ],
+ [
+ 8733,
+ 'proportional to'
+ ],
+ [
+ 8736,
+ 'angle'
+ ]
+ ]
+ },
+ {
+ name: 'Extended Latin',
+ characters: [
+ [
+ 192,
+ 'A - grave'
+ ],
+ [
+ 193,
+ 'A - acute'
+ ],
+ [
+ 194,
+ 'A - circumflex'
+ ],
+ [
+ 195,
+ 'A - tilde'
+ ],
+ [
+ 196,
+ 'A - diaeresis'
+ ],
+ [
+ 197,
+ 'A - ring above'
+ ],
+ [
+ 256,
+ 'A - macron'
+ ],
+ [
+ 198,
+ 'ligature AE'
+ ],
+ [
+ 199,
+ 'C - cedilla'
+ ],
+ [
+ 200,
+ 'E - grave'
+ ],
+ [
+ 201,
+ 'E - acute'
+ ],
+ [
+ 202,
+ 'E - circumflex'
+ ],
+ [
+ 203,
+ 'E - diaeresis'
+ ],
+ [
+ 274,
+ 'E - macron'
+ ],
+ [
+ 204,
+ 'I - grave'
+ ],
+ [
+ 205,
+ 'I - acute'
+ ],
+ [
+ 206,
+ 'I - circumflex'
+ ],
+ [
+ 207,
+ 'I - diaeresis'
+ ],
+ [
+ 298,
+ 'I - macron'
+ ],
+ [
+ 208,
+ 'ETH'
+ ],
+ [
+ 209,
+ 'N - tilde'
+ ],
+ [
+ 210,
+ 'O - grave'
+ ],
+ [
+ 211,
+ 'O - acute'
+ ],
+ [
+ 212,
+ 'O - circumflex'
+ ],
+ [
+ 213,
+ 'O - tilde'
+ ],
+ [
+ 214,
+ 'O - diaeresis'
+ ],
+ [
+ 216,
+ 'O - slash'
+ ],
+ [
+ 332,
+ 'O - macron'
+ ],
+ [
+ 338,
+ 'ligature OE'
+ ],
+ [
+ 352,
+ 'S - caron'
+ ],
+ [
+ 217,
+ 'U - grave'
+ ],
+ [
+ 218,
+ 'U - acute'
+ ],
+ [
+ 219,
+ 'U - circumflex'
+ ],
+ [
+ 220,
+ 'U - diaeresis'
+ ],
+ [
+ 362,
+ 'U - macron'
+ ],
+ [
+ 221,
+ 'Y - acute'
+ ],
+ [
+ 376,
+ 'Y - diaeresis'
+ ],
+ [
+ 562,
+ 'Y - macron'
+ ],
+ [
+ 222,
+ 'THORN'
+ ],
+ [
+ 224,
+ 'a - grave'
+ ],
+ [
+ 225,
+ 'a - acute'
+ ],
+ [
+ 226,
+ 'a - circumflex'
+ ],
+ [
+ 227,
+ 'a - tilde'
+ ],
+ [
+ 228,
+ 'a - diaeresis'
+ ],
+ [
+ 229,
+ 'a - ring above'
+ ],
+ [
+ 257,
+ 'a - macron'
+ ],
+ [
+ 230,
+ 'ligature ae'
+ ],
+ [
+ 231,
+ 'c - cedilla'
+ ],
+ [
+ 232,
+ 'e - grave'
+ ],
+ [
+ 233,
+ 'e - acute'
+ ],
+ [
+ 234,
+ 'e - circumflex'
+ ],
+ [
+ 235,
+ 'e - diaeresis'
+ ],
+ [
+ 275,
+ 'e - macron'
+ ],
+ [
+ 236,
+ 'i - grave'
+ ],
+ [
+ 237,
+ 'i - acute'
+ ],
+ [
+ 238,
+ 'i - circumflex'
+ ],
+ [
+ 239,
+ 'i - diaeresis'
+ ],
+ [
+ 299,
+ 'i - macron'
+ ],
+ [
+ 240,
+ 'eth'
+ ],
+ [
+ 241,
+ 'n - tilde'
+ ],
+ [
+ 242,
+ 'o - grave'
+ ],
+ [
+ 243,
+ 'o - acute'
+ ],
+ [
+ 244,
+ 'o - circumflex'
+ ],
+ [
+ 245,
+ 'o - tilde'
+ ],
+ [
+ 246,
+ 'o - diaeresis'
+ ],
+ [
+ 248,
+ 'o slash'
+ ],
+ [
+ 333,
+ 'o macron'
+ ],
+ [
+ 339,
+ 'ligature oe'
+ ],
+ [
+ 353,
+ 's - caron'
+ ],
+ [
+ 249,
+ 'u - grave'
+ ],
+ [
+ 250,
+ 'u - acute'
+ ],
+ [
+ 251,
+ 'u - circumflex'
+ ],
+ [
+ 252,
+ 'u - diaeresis'
+ ],
+ [
+ 363,
+ 'u - macron'
+ ],
+ [
+ 253,
+ 'y - acute'
+ ],
+ [
+ 254,
+ 'thorn'
+ ],
+ [
+ 255,
+ 'y - diaeresis'
+ ],
+ [
+ 563,
+ 'y - macron'
+ ],
+ [
+ 913,
+ 'Alpha'
+ ],
+ [
+ 914,
+ 'Beta'
+ ],
+ [
+ 915,
+ 'Gamma'
+ ],
+ [
+ 916,
+ 'Delta'
+ ],
+ [
+ 917,
+ 'Epsilon'
+ ],
+ [
+ 918,
+ 'Zeta'
+ ],
+ [
+ 919,
+ 'Eta'
+ ],
+ [
+ 920,
+ 'Theta'
+ ],
+ [
+ 921,
+ 'Iota'
+ ],
+ [
+ 922,
+ 'Kappa'
+ ],
+ [
+ 923,
+ 'Lambda'
+ ],
+ [
+ 924,
+ 'Mu'
+ ],
+ [
+ 925,
+ 'Nu'
+ ],
+ [
+ 926,
+ 'Xi'
+ ],
+ [
+ 927,
+ 'Omicron'
+ ],
+ [
+ 928,
+ 'Pi'
+ ],
+ [
+ 929,
+ 'Rho'
+ ],
+ [
+ 931,
+ 'Sigma'
+ ],
+ [
+ 932,
+ 'Tau'
+ ],
+ [
+ 933,
+ 'Upsilon'
+ ],
+ [
+ 934,
+ 'Phi'
+ ],
+ [
+ 935,
+ 'Chi'
+ ],
+ [
+ 936,
+ 'Psi'
+ ],
+ [
+ 937,
+ 'Omega'
+ ],
+ [
+ 945,
+ 'alpha'
+ ],
+ [
+ 946,
+ 'beta'
+ ],
+ [
+ 947,
+ 'gamma'
+ ],
+ [
+ 948,
+ 'delta'
+ ],
+ [
+ 949,
+ 'epsilon'
+ ],
+ [
+ 950,
+ 'zeta'
+ ],
+ [
+ 951,
+ 'eta'
+ ],
+ [
+ 952,
+ 'theta'
+ ],
+ [
+ 953,
+ 'iota'
+ ],
+ [
+ 954,
+ 'kappa'
+ ],
+ [
+ 955,
+ 'lambda'
+ ],
+ [
+ 956,
+ 'mu'
+ ],
+ [
+ 957,
+ 'nu'
+ ],
+ [
+ 958,
+ 'xi'
+ ],
+ [
+ 959,
+ 'omicron'
+ ],
+ [
+ 960,
+ 'pi'
+ ],
+ [
+ 961,
+ 'rho'
+ ],
+ [
+ 962,
+ 'final sigma'
+ ],
+ [
+ 963,
+ 'sigma'
+ ],
+ [
+ 964,
+ 'tau'
+ ],
+ [
+ 965,
+ 'upsilon'
+ ],
+ [
+ 966,
+ 'phi'
+ ],
+ [
+ 967,
+ 'chi'
+ ],
+ [
+ 968,
+ 'psi'
+ ],
+ [
+ 969,
+ 'omega'
+ ]
+ ]
+ },
+ {
+ name: 'Symbols',
+ characters: [
+ [
+ 8501,
+ 'alef symbol'
+ ],
+ [
+ 982,
+ 'pi symbol'
+ ],
+ [
+ 8476,
+ 'real part symbol'
+ ],
+ [
+ 978,
+ 'upsilon - hook symbol'
+ ],
+ [
+ 8472,
+ 'Weierstrass p'
+ ],
+ [
+ 8465,
+ 'imaginary part'
+ ]
+ ]
+ },
+ {
+ name: 'Arrows',
+ characters: [
+ [
+ 8592,
+ 'leftwards arrow'
+ ],
+ [
+ 8593,
+ 'upwards arrow'
+ ],
+ [
+ 8594,
+ 'rightwards arrow'
+ ],
+ [
+ 8595,
+ 'downwards arrow'
+ ],
+ [
+ 8596,
+ 'left right arrow'
+ ],
+ [
+ 8629,
+ 'carriage return'
+ ],
+ [
+ 8656,
+ 'leftwards double arrow'
+ ],
+ [
+ 8657,
+ 'upwards double arrow'
+ ],
+ [
+ 8658,
+ 'rightwards double arrow'
+ ],
+ [
+ 8659,
+ 'downwards double arrow'
+ ],
+ [
+ 8660,
+ 'left right double arrow'
+ ],
+ [
+ 8756,
+ 'therefore'
+ ],
+ [
+ 8834,
+ 'subset of'
+ ],
+ [
+ 8835,
+ 'superset of'
+ ],
+ [
+ 8836,
+ 'not a subset of'
+ ],
+ [
+ 8838,
+ 'subset of or equal to'
+ ],
+ [
+ 8839,
+ 'superset of or equal to'
+ ],
+ [
+ 8853,
+ 'circled plus'
+ ],
+ [
+ 8855,
+ 'circled times'
+ ],
+ [
+ 8869,
+ 'perpendicular'
+ ],
+ [
+ 8901,
+ 'dot operator'
+ ],
+ [
+ 8968,
+ 'left ceiling'
+ ],
+ [
+ 8969,
+ 'right ceiling'
+ ],
+ [
+ 8970,
+ 'left floor'
+ ],
+ [
+ 8971,
+ 'right floor'
+ ],
+ [
+ 9001,
+ 'left-pointing angle bracket'
+ ],
+ [
+ 9002,
+ 'right-pointing angle bracket'
+ ],
+ [
+ 9674,
+ 'lozenge'
+ ],
+ [
+ 9824,
+ 'black spade suit'
+ ],
+ [
+ 9827,
+ 'black club suit'
+ ],
+ [
+ 9829,
+ 'black heart suit'
+ ],
+ [
+ 9830,
+ 'black diamond suit'
+ ],
+ [
+ 8194,
+ 'en space'
+ ],
+ [
+ 8195,
+ 'em space'
+ ],
+ [
+ 8201,
+ 'thin space'
+ ],
+ [
+ 8204,
+ 'zero width non-joiner'
+ ],
+ [
+ 8205,
+ 'zero width joiner'
+ ],
+ [
+ 8206,
+ 'left-to-right mark'
+ ],
+ [
+ 8207,
+ 'right-to-left mark'
+ ]
+ ]
+ }
+ ];
+ };
+ var charmapFilter = function (charmap) {
+ return global$1.grep(charmap, function (item) {
+ return isArray$1(item) && item.length === 2;
+ });
+ };
+ var getCharsFromSetting = function (settingValue) {
+ if (isArray$1(settingValue)) {
+ return [].concat(charmapFilter(settingValue));
+ }
+ if (typeof settingValue === 'function') {
+ return settingValue();
+ }
+ return [];
+ };
+ var extendCharMap = function (editor, charmap) {
+ var userCharMap = getCharMap(editor);
+ if (userCharMap) {
+ charmap = [{
+ name: UserDefined,
+ characters: getCharsFromSetting(userCharMap)
+ }];
+ }
+ var userCharMapAppend = getCharMapAppend(editor);
+ if (userCharMapAppend) {
+ var userDefinedGroup = global$1.grep(charmap, function (cg) {
+ return cg.name === UserDefined;
+ });
+ if (userDefinedGroup.length) {
+ userDefinedGroup[0].characters = [].concat(userDefinedGroup[0].characters).concat(getCharsFromSetting(userCharMapAppend));
+ return charmap;
+ }
+ return [].concat(charmap).concat({
+ name: UserDefined,
+ characters: getCharsFromSetting(userCharMapAppend)
+ });
+ }
+ return charmap;
+ };
+ var getCharMap$1 = function (editor) {
+ var groups = extendCharMap(editor, getDefaultCharMap());
+ return groups.length > 1 ? [{
+ name: 'All',
+ characters: bind(groups, function (g) {
+ return g.characters;
+ })
+ }].concat(groups) : groups;
+ };
+
+ var get = function (editor) {
+ var getCharMap = function () {
+ return getCharMap$1(editor);
+ };
+ var insertChar$1 = function (chr) {
+ insertChar(editor, chr);
+ };
+ return {
+ getCharMap: getCharMap,
+ insertChar: insertChar$1
+ };
+ };
+
+ var Cell = function (initial) {
+ var value = initial;
+ var get = function () {
+ return value;
+ };
+ var set = function (v) {
+ value = v;
+ };
+ return {
+ get: get,
+ set: set
+ };
+ };
+
+ var last = function (fn, rate) {
+ var timer = null;
+ var cancel = function () {
+ if (timer !== null) {
+ domGlobals.clearTimeout(timer);
+ timer = null;
+ }
+ };
+ var throttle = function () {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ if (timer !== null) {
+ domGlobals.clearTimeout(timer);
+ }
+ timer = domGlobals.setTimeout(function () {
+ fn.apply(null, args);
+ timer = null;
+ }, rate);
+ };
+ return {
+ cancel: cancel,
+ throttle: throttle
+ };
+ };
+
+ var nativeFromCodePoint = String.fromCodePoint;
+ var contains = function (str, substr) {
+ return str.indexOf(substr) !== -1;
+ };
+ var fromCodePoint = function () {
+ var codePoints = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ codePoints[_i] = arguments[_i];
+ }
+ if (nativeFromCodePoint) {
+ return nativeFromCodePoint.apply(void 0, codePoints);
+ } else {
+ var codeUnits = [];
+ var codeLen = 0;
+ var result = '';
+ for (var index = 0, len = codePoints.length; index !== len; ++index) {
+ var codePoint = +codePoints[index];
+ if (!(codePoint < 1114111 && codePoint >>> 0 === codePoint)) {
+ throw RangeError('Invalid code point: ' + codePoint);
+ }
+ if (codePoint <= 65535) {
+ codeLen = codeUnits.push(codePoint);
+ } else {
+ codePoint -= 65536;
+ codeLen = codeUnits.push((codePoint >> 10) + 55296, codePoint % 1024 + 56320);
+ }
+ if (codeLen >= 16383) {
+ result += String.fromCharCode.apply(null, codeUnits);
+ codeUnits.length = 0;
+ }
+ }
+ return result + String.fromCharCode.apply(null, codeUnits);
+ }
+ };
+
+ var charMatches = function (charCode, name, lowerCasePattern) {
+ if (contains(fromCodePoint(charCode).toLowerCase(), lowerCasePattern)) {
+ return true;
+ } else {
+ return contains(name.toLowerCase(), lowerCasePattern) || contains(name.toLowerCase().replace(/\s+/g, ''), lowerCasePattern);
+ }
+ };
+ var scan = function (group, pattern) {
+ var matches = [];
+ var lowerCasePattern = pattern.toLowerCase();
+ each(group.characters, function (g) {
+ if (charMatches(g[0], g[1], lowerCasePattern)) {
+ matches.push(g);
+ }
+ });
+ return map(matches, function (m) {
+ return {
+ text: m[1],
+ value: fromCodePoint(m[0]),
+ icon: fromCodePoint(m[0])
+ };
+ });
+ };
+
+ var patternName = 'pattern';
+ var open = function (editor, charMap) {
+ var makeGroupItems = function () {
+ return [
+ {
+ label: 'Search',
+ type: 'input',
+ name: patternName
+ },
+ {
+ type: 'collection',
+ name: 'results'
+ }
+ ];
+ };
+ var makeTabs = function () {
+ return map(charMap, function (charGroup) {
+ return {
+ title: charGroup.name,
+ name: charGroup.name,
+ items: makeGroupItems()
+ };
+ });
+ };
+ var makePanel = function () {
+ return {
+ type: 'panel',
+ items: makeGroupItems()
+ };
+ };
+ var makeTabPanel = function () {
+ return {
+ type: 'tabpanel',
+ tabs: makeTabs()
+ };
+ };
+ var currentTab = charMap.length === 1 ? Cell(UserDefined) : Cell('All');
+ var scanAndSet = function (dialogApi, pattern) {
+ find(charMap, function (group) {
+ return group.name === currentTab.get();
+ }).each(function (f) {
+ var items = scan(f, pattern);
+ dialogApi.setData({ results: items });
+ });
+ };
+ var SEARCH_DELAY = 40;
+ var updateFilter = last(function (dialogApi) {
+ var pattern = dialogApi.getData().pattern;
+ scanAndSet(dialogApi, pattern);
+ }, SEARCH_DELAY);
+ var body = charMap.length === 1 ? makePanel() : makeTabPanel();
+ var initialData = {
+ pattern: '',
+ results: scan(charMap[0], '')
+ };
+ var bridgeSpec = {
+ title: 'Special Character',
+ size: 'normal',
+ body: body,
+ buttons: [{
+ type: 'cancel',
+ name: 'close',
+ text: 'Close',
+ primary: true
+ }],
+ initialData: initialData,
+ onAction: function (api, details) {
+ if (details.name === 'results') {
+ insertChar(editor, details.value);
+ api.close();
+ }
+ },
+ onTabChange: function (dialogApi, details) {
+ currentTab.set(details.newTabName);
+ updateFilter.throttle(dialogApi);
+ },
+ onChange: function (dialogApi, changeData) {
+ if (changeData.name === patternName) {
+ updateFilter.throttle(dialogApi);
+ }
+ }
+ };
+ var dialogApi = editor.windowManager.open(bridgeSpec);
+ dialogApi.focus(patternName);
+ };
+
+ var register = function (editor, charMap) {
+ editor.addCommand('mceShowCharmap', function () {
+ open(editor, charMap);
+ });
+ };
+
+ var global$2 = tinymce.util.Tools.resolve('tinymce.util.Promise');
+
+ var init = function (editor, all) {
+ editor.ui.registry.addAutocompleter('charmap', {
+ ch: ':',
+ columns: 'auto',
+ minChars: 2,
+ fetch: function (pattern, _maxResults) {
+ return new global$2(function (resolve, _reject) {
+ resolve(scan(all, pattern));
+ });
+ },
+ onAction: function (autocompleteApi, rng, value) {
+ editor.selection.setRng(rng);
+ editor.insertContent(value);
+ autocompleteApi.hide();
+ }
+ });
+ };
+
+ var register$1 = function (editor) {
+ editor.ui.registry.addButton('charmap', {
+ icon: 'insert-character',
+ tooltip: 'Special character',
+ onAction: function () {
+ return editor.execCommand('mceShowCharmap');
+ }
+ });
+ editor.ui.registry.addMenuItem('charmap', {
+ icon: 'insert-character',
+ text: 'Special character...',
+ onAction: function () {
+ return editor.execCommand('mceShowCharmap');
+ }
+ });
+ };
+
+ function Plugin () {
+ global.add('charmap', function (editor) {
+ var charMap = getCharMap$1(editor);
+ register(editor, charMap);
+ register$1(editor);
+ init(editor, charMap[0]);
+ return get(editor);
+ });
+ }
+
+ Plugin();
+
+}(window));
diff --git a/resources/public/js/build/plugins/charmap/plugin.min.js b/resources/public/js/build/plugins/charmap/plugin.min.js
new file mode 100644
index 00000000..7881fcba
--- /dev/null
+++ b/resources/public/js/build/plugins/charmap/plugin.min.js
@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Tiny Technologies, Inc. All rights reserved.
+ * Licensed under the LGPL or a commercial license.
+ * For LGPL see License.txt in the project root for license information.
+ * For commercial licenses see https://www.tiny.cloud/
+ *
+ * Version: 5.3.0 (2020-05-21)
+ */
+!function(s){"use strict";var e,n,r,t,a=tinymce.util.Tools.resolve("tinymce.PluginManager"),l=function(e,n){var r,t=(r=n,e.fire("insertCustomChar",{chr:r}).chr);e.execCommand("mceInsertContent",!1,t)},i=tinymce.util.Tools.resolve("tinymce.util.Tools"),o=function(e){return function(){return e}},c=o(!1),u=o(!0),g=function(){return m},m=(e=function(e){return e.isNone()},{fold:function(e,n){return e()},is:c,isSome:c,isNone:u,getOr:r=function(e){return e},getOrThunk:n=function(e){return e()},getOrDie:function(e){throw new Error(e||"error: getOrDie called on none.")},getOrNull:o(null),getOrUndefined:o(undefined),or:r,orThunk:n,map:g,each:function(){},bind:g,exists:c,forall:u,filter:g,equals:e,equals_:e,toArray:function(){return[]},toString:o("none()")}),f=function(r){var e=o(r),n=function(){return a},t=function(e){return e(r)},a={fold:function(e,n){return n(r)},is:function(e){return r===e},isSome:u,isNone:c,getOr:e,getOrThunk:e,getOrDie:e,getOrNull:e,getOrUndefined:e,or:n,orThunk:n,map:function(e){return f(e(r))},each:function(e){e(r)},bind:t,exists:t,forall:t,filter:function(e){return e(r)?a:m},toArray:function(){return[r]},toString:function(){return"some("+r+")"},equals:function(e){return e.is(r)},equals_:function(e,n){return e.fold(c,function(e){return n(r,e)})}};return a},h={some:f,none:g,from:function(e){return null===e||e===undefined?m:f(e)}},d=(t="array",function(e){return r=typeof(n=e),(null===n?"null":"object"==r&&(Array.prototype.isPrototypeOf(n)||n.constructor&&"Array"===n.constructor.name)?"array":"object"==r&&(String.prototype.isPrototypeOf(n)||n.constructor&&"String"===n.constructor.name)?"string":r)===t;var n,r}),p=Array.prototype.push,y=function(e,n){for(var r=e.length,t=new Array(r),a=0;a>>0===o))throw RangeError("Invalid code point: "+o);16383<=(o<=65535?r.push(o):(o-=65536,r.push(55296+(o>>10),o%1024+56320)))&&(t+=String.fromCharCode.apply(null,r),r.length=0)}return t+String.fromCharCode.apply(null,r)},T=function(e,n){var a=[],i=n.toLowerCase();return function(e,n){for(var r=0,t=e.length;r>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/,
+ 'number': /(?:\b0x(?:[\da-f]+\.?[\da-f]*|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?)[ful]*/i
+ });
+ Prism.languages.insertBefore('c', 'string', {
+ 'macro': {
+ pattern: /(^\s*)#\s*[a-z]+(?:[^\r\n\\]|\\(?:\r\n|[\s\S]))*/im,
+ lookbehind: true,
+ alias: 'property',
+ inside: {
+ 'string': {
+ pattern: /(#\s*include\s*)(?:<.+?>|("|')(?:\\?.)+?\2)/,
+ lookbehind: true
+ },
+ 'directive': {
+ pattern: /(#\s*)\b(?:define|defined|elif|else|endif|error|ifdef|ifndef|if|import|include|line|pragma|undef|using)\b/,
+ lookbehind: true,
+ alias: 'keyword'
+ }
+ }
+ },
+ 'constant': /\b(?:__FILE__|__LINE__|__DATE__|__TIME__|__TIMESTAMP__|__func__|EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|stdin|stdout|stderr)\b/
+ });
+ delete Prism.languages.c['boolean'];
+ },
+ {}
+ ],
+ 2: [
+ function (require, module, exports) {
+ Prism.languages.clike = {
+ 'comment': [
+ {
+ pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+ lookbehind: true
+ },
+ {
+ pattern: /(^|[^\\:])\/\/.*/,
+ lookbehind: true,
+ greedy: true
+ }
+ ],
+ 'string': {
+ pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+ greedy: true
+ },
+ 'class-name': {
+ pattern: /(\b(?:class|interface|extends|implements|trait|instanceof|new)\s+|\bcatch\s+\()[\w.\\]+/i,
+ lookbehind: true,
+ inside: { 'punctuation': /[.\\]/ }
+ },
+ 'keyword': /\b(?:if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\b/,
+ 'boolean': /\b(?:true|false)\b/,
+ 'function': /\w+(?=\()/,
+ 'number': /\b0x[\da-f]+\b|(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?/i,
+ 'operator': /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
+ 'punctuation': /[{}[\];(),.:]/
+ };
+ },
+ {}
+ ],
+ 3: [
+ function (require, module, exports) {
+ (function (global) {
+ var _self = typeof window !== 'undefined' ? window : typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope ? self : {};
+ var Prism = function (_self) {
+ var lang = /\blang(?:uage)?-([\w-]+)\b/i;
+ var uniqueId = 0;
+ var _ = {
+ manual: _self.Prism && _self.Prism.manual,
+ disableWorkerMessageHandler: _self.Prism && _self.Prism.disableWorkerMessageHandler,
+ util: {
+ encode: function (tokens) {
+ if (tokens instanceof Token) {
+ return new Token(tokens.type, _.util.encode(tokens.content), tokens.alias);
+ } else if (Array.isArray(tokens)) {
+ return tokens.map(_.util.encode);
+ } else {
+ return tokens.replace(/&/g, '&').replace(/ text.length) {
+ return;
+ }
+ if (str instanceof Token) {
+ continue;
+ }
+ if (greedy && i != strarr.length - 1) {
+ pattern.lastIndex = pos;
+ var match = pattern.exec(text);
+ if (!match) {
+ break;
+ }
+ var from = match.index + (lookbehind && match[1] ? match[1].length : 0), to = match.index + match[0].length, k = i, p = pos;
+ for (var len = strarr.length; k < len && (p < to || !strarr[k].type && !strarr[k - 1].greedy); ++k) {
+ p += strarr[k].length;
+ if (from >= p) {
+ ++i;
+ pos = p;
+ }
+ }
+ if (strarr[i] instanceof Token) {
+ continue;
+ }
+ delNum = k - i;
+ str = text.slice(pos, p);
+ match.index -= pos;
+ } else {
+ pattern.lastIndex = 0;
+ var match = pattern.exec(str), delNum = 1;
+ }
+ if (!match) {
+ if (oneshot) {
+ break;
+ }
+ continue;
+ }
+ if (lookbehind) {
+ lookbehindLength = match[1] ? match[1].length : 0;
+ }
+ var from = match.index + lookbehindLength, match = match[0].slice(lookbehindLength), to = from + match.length, before = str.slice(0, from), after = str.slice(to);
+ var args = [
+ i,
+ delNum
+ ];
+ if (before) {
+ ++i;
+ pos += before.length;
+ args.push(before);
+ }
+ var wrapped = new Token(token, inside ? _.tokenize(match, inside) : match, alias, match, greedy);
+ args.push(wrapped);
+ if (after) {
+ args.push(after);
+ }
+ Array.prototype.splice.apply(strarr, args);
+ if (delNum != 1)
+ _.matchGrammar(text, strarr, grammar, i, pos, true, token + ',' + j);
+ if (oneshot)
+ break;
+ }
+ }
+ }
+ },
+ tokenize: function (text, grammar) {
+ var strarr = [text];
+ var rest = grammar.rest;
+ if (rest) {
+ for (var token in rest) {
+ grammar[token] = rest[token];
+ }
+ delete grammar.rest;
+ }
+ _.matchGrammar(text, strarr, grammar, 0, 0, false);
+ return strarr;
+ },
+ hooks: {
+ all: {},
+ add: function (name, callback) {
+ var hooks = _.hooks.all;
+ hooks[name] = hooks[name] || [];
+ hooks[name].push(callback);
+ },
+ run: function (name, env) {
+ var callbacks = _.hooks.all[name];
+ if (!callbacks || !callbacks.length) {
+ return;
+ }
+ for (var i = 0, callback; callback = callbacks[i++];) {
+ callback(env);
+ }
+ }
+ },
+ Token: Token
+ };
+ _self.Prism = _;
+ function Token(type, content, alias, matchedStr, greedy) {
+ this.type = type;
+ this.content = content;
+ this.alias = alias;
+ this.length = (matchedStr || '').length | 0;
+ this.greedy = !!greedy;
+ }
+ Token.stringify = function (o, language) {
+ if (typeof o == 'string') {
+ return o;
+ }
+ if (Array.isArray(o)) {
+ return o.map(function (element) {
+ return Token.stringify(element, language);
+ }).join('');
+ }
+ var env = {
+ type: o.type,
+ content: Token.stringify(o.content, language),
+ tag: 'span',
+ classes: [
+ 'token',
+ o.type
+ ],
+ attributes: {},
+ language: language
+ };
+ if (o.alias) {
+ var aliases = Array.isArray(o.alias) ? o.alias : [o.alias];
+ Array.prototype.push.apply(env.classes, aliases);
+ }
+ _.hooks.run('wrap', env);
+ var attributes = Object.keys(env.attributes).map(function (name) {
+ return name + '="' + (env.attributes[name] || '').replace(/"/g, '"') + '"';
+ }).join(' ');
+ return '<' + env.tag + ' class="' + env.classes.join(' ') + '"' + (attributes ? ' ' + attributes : '') + '>' + env.content + '';
+ };
+ if (!_self.document) {
+ if (!_self.addEventListener) {
+ return _;
+ }
+ if (!_.disableWorkerMessageHandler) {
+ _self.addEventListener('message', function (evt) {
+ var message = JSON.parse(evt.data), lang = message.language, code = message.code, immediateClose = message.immediateClose;
+ _self.postMessage(_.highlight(code, _.languages[lang], lang));
+ if (immediateClose) {
+ _self.close();
+ }
+ }, false);
+ }
+ return _;
+ }
+ var script = _.util.currentScript();
+ if (script) {
+ _.filename = script.src;
+ if (script.hasAttribute('data-manual')) {
+ _.manual = true;
+ }
+ }
+ if (!_.manual) {
+ var highlightAutomaticallyCallback = function () {
+ if (!_.manual) {
+ _.highlightAll();
+ }
+ };
+ var readyState = document.readyState;
+ if (readyState === 'loading' || readyState === 'interactive' && script && script.defer) {
+ document.addEventListener('DOMContentLoaded', highlightAutomaticallyCallback);
+ } else {
+ if (window.requestAnimationFrame) {
+ window.requestAnimationFrame(highlightAutomaticallyCallback);
+ } else {
+ window.setTimeout(highlightAutomaticallyCallback, 16);
+ }
+ }
+ }
+ return _;
+ }(_self);
+ if (typeof module !== 'undefined' && module.exports) {
+ module.exports = Prism;
+ }
+ if (typeof global !== 'undefined') {
+ global.Prism = Prism;
+ }
+ }.call(this, typeof global$2 !== 'undefined' ? global$2 : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : {}));
+ },
+ {}
+ ],
+ 4: [
+ function (require, module, exports) {
+ Prism.languages.cpp = Prism.languages.extend('c', {
+ 'class-name': {
+ pattern: /(\b(?:class|enum|struct)\s+)\w+/,
+ lookbehind: true
+ },
+ 'keyword': /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|class|compl|const|constexpr|const_cast|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|float|for|friend|goto|if|inline|int|int8_t|int16_t|int32_t|int64_t|uint8_t|uint16_t|uint32_t|uint64_t|long|mutable|namespace|new|noexcept|nullptr|operator|private|protected|public|register|reinterpret_cast|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/,
+ 'number': {
+ pattern: /(?:\b0b[01']+|\b0x(?:[\da-f']+\.?[\da-f']*|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+\.?[\d']*|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]*/i,
+ greedy: true
+ },
+ 'operator': />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/,
+ 'boolean': /\b(?:true|false)\b/
+ });
+ Prism.languages.insertBefore('cpp', 'string', {
+ 'raw-string': {
+ pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
+ alias: 'string',
+ greedy: true
+ }
+ });
+ },
+ {}
+ ],
+ 5: [
+ function (require, module, exports) {
+ Prism.languages.csharp = Prism.languages.extend('clike', {
+ 'keyword': /\b(?:abstract|add|alias|as|ascending|async|await|base|bool|break|byte|case|catch|char|checked|class|const|continue|decimal|default|delegate|descending|do|double|dynamic|else|enum|event|explicit|extern|false|finally|fixed|float|for|foreach|from|get|global|goto|group|if|implicit|in|int|interface|internal|into|is|join|let|lock|long|namespace|new|null|object|operator|orderby|out|override|params|partial|private|protected|public|readonly|ref|remove|return|sbyte|sealed|select|set|short|sizeof|stackalloc|static|string|struct|switch|this|throw|true|try|typeof|uint|ulong|unchecked|unsafe|ushort|using|value|var|virtual|void|volatile|where|while|yield)\b/,
+ 'string': [
+ {
+ pattern: /@("|')(?:\1\1|\\[\s\S]|(?!\1)[^\\])*\1/,
+ greedy: true
+ },
+ {
+ pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*?\1/,
+ greedy: true
+ }
+ ],
+ 'class-name': [
+ {
+ pattern: /\b[A-Z]\w*(?:\.\w+)*\b(?=\s+\w+)/,
+ inside: { punctuation: /\./ }
+ },
+ {
+ pattern: /(\[)[A-Z]\w*(?:\.\w+)*\b/,
+ lookbehind: true,
+ inside: { punctuation: /\./ }
+ },
+ {
+ pattern: /(\b(?:class|interface)\s+[A-Z]\w*(?:\.\w+)*\s*:\s*)[A-Z]\w*(?:\.\w+)*\b/,
+ lookbehind: true,
+ inside: { punctuation: /\./ }
+ },
+ {
+ pattern: /((?:\b(?:class|interface|new)\s+)|(?:catch\s+\())[A-Z]\w*(?:\.\w+)*\b/,
+ lookbehind: true,
+ inside: { punctuation: /\./ }
+ }
+ ],
+ 'number': /\b0x[\da-f]+\b|(?:\b\d+\.?\d*|\B\.\d+)f?/i,
+ 'operator': />>=?|<<=?|[-=]>|([-+&|?])\1|~|[-+*/%&|^!=<>]=?/,
+ 'punctuation': /\?\.?|::|[{}[\];(),.:]/
+ });
+ Prism.languages.insertBefore('csharp', 'class-name', {
+ 'generic-method': {
+ pattern: /\w+\s*<[^>\r\n]+?>\s*(?=\()/,
+ inside: {
+ function: /^\w+/,
+ 'class-name': {
+ pattern: /\b[A-Z]\w*(?:\.\w+)*\b/,
+ inside: { punctuation: /\./ }
+ },
+ keyword: Prism.languages.csharp.keyword,
+ punctuation: /[<>(),.:]/
+ }
+ },
+ 'preprocessor': {
+ pattern: /(^\s*)#.*/m,
+ lookbehind: true,
+ alias: 'property',
+ inside: {
+ 'directive': {
+ pattern: /(\s*#)\b(?:define|elif|else|endif|endregion|error|if|line|pragma|region|undef|warning)\b/,
+ lookbehind: true,
+ alias: 'keyword'
+ }
+ }
+ }
+ });
+ Prism.languages.dotnet = Prism.languages.cs = Prism.languages.csharp;
+ },
+ {}
+ ],
+ 6: [
+ function (require, module, exports) {
+ (function (Prism) {
+ var string = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
+ Prism.languages.css = {
+ 'comment': /\/\*[\s\S]*?\*\//,
+ 'atrule': {
+ pattern: /@[\w-]+[\s\S]*?(?:;|(?=\s*\{))/,
+ inside: { 'rule': /@[\w-]+/ }
+ },
+ 'url': {
+ pattern: RegExp('url\\((?:' + string.source + '|[^\n\r()]*)\\)', 'i'),
+ inside: {
+ 'function': /^url/i,
+ 'punctuation': /^\(|\)$/
+ }
+ },
+ 'selector': RegExp('[^{}\\s](?:[^{};"\']|' + string.source + ')*?(?=\\s*\\{)'),
+ 'string': {
+ pattern: string,
+ greedy: true
+ },
+ 'property': /[-_a-z\xA0-\uFFFF][-\w\xA0-\uFFFF]*(?=\s*:)/i,
+ 'important': /!important\b/i,
+ 'function': /[-a-z0-9]+(?=\()/i,
+ 'punctuation': /[(){};:,]/
+ };
+ Prism.languages.css['atrule'].inside.rest = Prism.languages.css;
+ var markup = Prism.languages.markup;
+ if (markup) {
+ markup.tag.addInlined('style', 'css');
+ Prism.languages.insertBefore('inside', 'attr-value', {
+ 'style-attr': {
+ pattern: /\s*style=("|')(?:\\[\s\S]|(?!\1)[^\\])*\1/i,
+ inside: {
+ 'attr-name': {
+ pattern: /^\s*style/i,
+ inside: markup.tag.inside
+ },
+ 'punctuation': /^\s*=\s*['"]|['"]\s*$/,
+ 'attr-value': {
+ pattern: /.+/i,
+ inside: Prism.languages.css
+ }
+ },
+ alias: 'language-css'
+ }
+ }, markup.tag);
+ }
+ }(Prism));
+ },
+ {}
+ ],
+ 7: [
+ function (require, module, exports) {
+ (function (Prism) {
+ 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|null|open|opens|package|private|protected|provides|public|requires|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/;
+ var className = /\b[A-Z](?:\w*[a-z]\w*)?\b/;
+ Prism.languages.java = Prism.languages.extend('clike', {
+ 'class-name': [
+ className,
+ /\b[A-Z]\w*(?=\s+\w+\s*[;,=())])/
+ ],
+ 'keyword': keywords,
+ 'function': [
+ Prism.languages.clike.function,
+ {
+ pattern: /(\:\:)[a-z_]\w*/,
+ lookbehind: true
+ }
+ ],
+ 'number': /\b0b[01][01_]*L?\b|\b0x[\da-f_]*\.?[\da-f_p+-]+\b|(?:\b\d[\d_]*\.?[\d_]*|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i,
+ 'operator': {
+ pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,
+ lookbehind: true
+ }
+ });
+ Prism.languages.insertBefore('java', 'string', {
+ 'triple-quoted-string': {
+ pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
+ greedy: true,
+ alias: 'string'
+ }
+ });
+ Prism.languages.insertBefore('java', 'class-name', {
+ 'annotation': {
+ alias: 'punctuation',
+ pattern: /(^|[^.])@\w+/,
+ lookbehind: true
+ },
+ 'namespace': {
+ pattern: /(\b(?:exports|import(?:\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\s+)[a-z]\w*(?:\.[a-z]\w*)+/,
+ lookbehind: true,
+ inside: { 'punctuation': /\./ }
+ },
+ 'generics': {
+ pattern: /<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<[\w\s,.&?]*>)*>)*>)*>/,
+ inside: {
+ 'class-name': className,
+ 'keyword': keywords,
+ 'punctuation': /[<>(),.:]/,
+ 'operator': /[?&|]/
+ }
+ }
+ });
+ }(Prism));
+ },
+ {}
+ ],
+ 8: [
+ function (require, module, exports) {
+ Prism.languages.javascript = Prism.languages.extend('clike', {
+ 'class-name': [
+ Prism.languages.clike['class-name'],
+ {
+ pattern: /(^|[^$\w\xA0-\uFFFF])[_$A-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\.(?:prototype|constructor))/,
+ lookbehind: true
+ }
+ ],
+ 'keyword': [
+ {
+ pattern: /((?:^|})\s*)(?:catch|finally)\b/,
+ lookbehind: true
+ },
+ {
+ pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|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)\b/,
+ lookbehind: true
+ }
+ ],
+ 'number': /\b(?:(?:0[xX](?:[\dA-Fa-f](?:_[\dA-Fa-f])?)+|0[bB](?:[01](?:_[01])?)+|0[oO](?:[0-7](?:_[0-7])?)+)n?|(?:\d(?:_\d)?)+n|NaN|Infinity)\b|(?:\b(?:\d(?:_\d)?)+\.?(?:\d(?:_\d)?)*|\B\.(?:\d(?:_\d)?)+)(?:[Ee][+-]?(?:\d(?:_\d)?)+)?/,
+ 'function': /#?[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
+ 'operator': /--|\+\+|\*\*=?|=>|&&|\|\||[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?[.?]?|[~:]/
+ });
+ Prism.languages.javascript['class-name'][0].pattern = /(\b(?:class|interface|extends|implements|instanceof|new)\s+)[\w.\\]+/;
+ Prism.languages.insertBefore('javascript', 'keyword', {
+ 'regex': {
+ pattern: /((?:^|[^$\w\xA0-\uFFFF."'\])\s])\s*)\/(?:\[(?:[^\]\\\r\n]|\\.)*]|\\.|[^/\\\[\r\n])+\/[gimyus]{0,6}(?=(?:\s|\/\*[\s\S]*?\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/,
+ lookbehind: true,
+ greedy: true
+ },
+ 'function-variable': {
+ pattern: /#?[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*)\s*=>))/,
+ alias: 'function'
+ },
+ 'parameter': [
+ {
+ pattern: /(function(?:\s+[_$A-Za-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*)?\s*\(\s*)(?!\s)(?:[^()]|\([^()]*\))+?(?=\s*\))/,
+ lookbehind: true,
+ inside: Prism.languages.javascript
+ },
+ {
+ pattern: /[_$a-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*=>)/i,
+ inside: Prism.languages.javascript
+ },
+ {
+ pattern: /(\(\s*)(?!\s)(?:[^()]|\([^()]*\))+?(?=\s*\)\s*=>)/,
+ lookbehind: true,
+ inside: Prism.languages.javascript
+ },
+ {
+ 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]))(?:[_$A-Za-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*\s*)\(\s*)(?!\s)(?:[^()]|\([^()]*\))+?(?=\s*\)\s*\{)/,
+ lookbehind: true,
+ inside: Prism.languages.javascript
+ }
+ ],
+ 'constant': /\b[A-Z](?:[A-Z_]|\dx?)*\b/
+ });
+ Prism.languages.insertBefore('javascript', 'string', {
+ 'template-string': {
+ pattern: /`(?:\\[\s\S]|\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})+}|(?!\${)[^\\`])*`/,
+ greedy: true,
+ inside: {
+ 'template-punctuation': {
+ pattern: /^`|`$/,
+ alias: 'string'
+ },
+ 'interpolation': {
+ pattern: /((?:^|[^\\])(?:\\{2})*)\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})+}/,
+ lookbehind: true,
+ inside: {
+ 'interpolation-punctuation': {
+ pattern: /^\${|}$/,
+ alias: 'punctuation'
+ },
+ rest: Prism.languages.javascript
+ }
+ },
+ 'string': /[\s\S]+/
+ }
+ }
+ });
+ if (Prism.languages.markup) {
+ Prism.languages.markup.tag.addInlined('script', 'javascript');
+ }
+ Prism.languages.js = Prism.languages.javascript;
+ },
+ {}
+ ],
+ 9: [
+ function (require, module, exports) {
+ (function (Prism) {
+ function getPlaceholder(language, index) {
+ return '___' + language.toUpperCase() + index + '___';
+ }
+ Object.defineProperties(Prism.languages['markup-templating'] = {}, {
+ buildPlaceholders: {
+ value: function (env, language, placeholderPattern, replaceFilter) {
+ if (env.language !== language) {
+ return;
+ }
+ var tokenStack = env.tokenStack = [];
+ env.code = env.code.replace(placeholderPattern, function (match) {
+ if (typeof replaceFilter === 'function' && !replaceFilter(match)) {
+ return match;
+ }
+ var i = tokenStack.length;
+ var placeholder;
+ while (env.code.indexOf(placeholder = getPlaceholder(language, i)) !== -1)
+ ++i;
+ tokenStack[i] = match;
+ return placeholder;
+ });
+ env.grammar = Prism.languages.markup;
+ }
+ },
+ tokenizePlaceholders: {
+ value: function (env, language) {
+ if (env.language !== language || !env.tokenStack) {
+ return;
+ }
+ env.grammar = Prism.languages[language];
+ var j = 0;
+ var keys = Object.keys(env.tokenStack);
+ function walkTokens(tokens) {
+ for (var i = 0; i < tokens.length; i++) {
+ if (j >= keys.length) {
+ break;
+ }
+ var token = tokens[i];
+ if (typeof token === 'string' || token.content && typeof token.content === 'string') {
+ var k = keys[j];
+ var t = env.tokenStack[k];
+ var s = typeof token === 'string' ? token : token.content;
+ var placeholder = getPlaceholder(language, k);
+ var index = s.indexOf(placeholder);
+ if (index > -1) {
+ ++j;
+ var before = s.substring(0, index);
+ var middle = new Prism.Token(language, Prism.tokenize(t, env.grammar), 'language-' + language, t);
+ var after = s.substring(index + placeholder.length);
+ var replacement = [];
+ if (before) {
+ replacement.push.apply(replacement, walkTokens([before]));
+ }
+ replacement.push(middle);
+ if (after) {
+ replacement.push.apply(replacement, walkTokens([after]));
+ }
+ if (typeof token === 'string') {
+ tokens.splice.apply(tokens, [
+ i,
+ 1
+ ].concat(replacement));
+ } else {
+ token.content = replacement;
+ }
+ }
+ } else if (token.content) {
+ walkTokens(token.content);
+ }
+ }
+ return tokens;
+ }
+ walkTokens(env.tokens);
+ }
+ }
+ });
+ }(Prism));
+ },
+ {}
+ ],
+ 10: [
+ function (require, module, exports) {
+ Prism.languages.markup = {
+ 'comment': //,
+ 'prolog': /<\?[\s\S]+?\?>/,
+ 'doctype': {
+ pattern: /"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:(?!)*\]\s*)?>/i,
+ greedy: true
+ },
+ 'cdata': //i,
+ 'tag': {
+ pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/i,
+ greedy: true,
+ inside: {
+ 'tag': {
+ pattern: /^<\/?[^\s>\/]+/i,
+ inside: {
+ 'punctuation': /^<\/?/,
+ 'namespace': /^[^\s>\/:]+:/
+ }
+ },
+ 'attr-value': {
+ pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/i,
+ inside: {
+ 'punctuation': [
+ /^=/,
+ {
+ pattern: /^(\s*)["']|["']$/,
+ lookbehind: true
+ }
+ ]
+ }
+ },
+ 'punctuation': /\/?>/,
+ 'attr-name': {
+ pattern: /[^\s>\/]+/,
+ inside: { 'namespace': /^[^\s>\/:]+:/ }
+ }
+ }
+ },
+ 'entity': /&#?[\da-z]{1,8};/i
+ };
+ Prism.languages.markup['tag'].inside['attr-value'].inside['entity'] = Prism.languages.markup['entity'];
+ Prism.hooks.add('wrap', function (env) {
+ if (env.type === 'entity') {
+ env.attributes['title'] = env.content.replace(/&/, '&');
+ }
+ });
+ Object.defineProperty(Prism.languages.markup.tag, 'addInlined', {
+ value: function addInlined(tagName, lang) {
+ var includedCdataInside = {};
+ includedCdataInside['language-' + lang] = {
+ pattern: /(^$)/i,
+ lookbehind: true,
+ inside: Prism.languages[lang]
+ };
+ includedCdataInside['cdata'] = /^$/i;
+ var inside = {
+ 'included-cdata': {
+ pattern: //i,
+ inside: includedCdataInside
+ }
+ };
+ inside['language-' + lang] = {
+ pattern: /[\s\S]+/,
+ inside: Prism.languages[lang]
+ };
+ var def = {};
+ def[tagName] = {
+ pattern: RegExp(/(<__[\s\S]*?>)(?:\s*|[\s\S])*?(?=<\/__>)/.source.replace(/__/g, tagName), 'i'),
+ lookbehind: true,
+ greedy: true,
+ inside: inside
+ };
+ Prism.languages.insertBefore('markup', 'cdata', def);
+ }
+ });
+ Prism.languages.xml = Prism.languages.extend('markup', {});
+ Prism.languages.html = Prism.languages.markup;
+ Prism.languages.mathml = Prism.languages.markup;
+ Prism.languages.svg = Prism.languages.markup;
+ },
+ {}
+ ],
+ 11: [
+ function (require, module, exports) {
+ (function (Prism) {
+ Prism.languages.php = Prism.languages.extend('clike', {
+ 'keyword': /\b(?:__halt_compiler|abstract|and|array|as|break|callable|case|catch|class|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|eval|exit|extends|final|finally|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|namespace|new|or|parent|print|private|protected|public|require|require_once|return|static|switch|throw|trait|try|unset|use|var|while|xor|yield)\b/i,
+ 'boolean': {
+ pattern: /\b(?:false|true)\b/i,
+ alias: 'constant'
+ },
+ 'constant': [
+ /\b[A-Z_][A-Z0-9_]*\b/,
+ /\b(?:null)\b/i
+ ],
+ 'comment': {
+ pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
+ lookbehind: true
+ }
+ });
+ Prism.languages.insertBefore('php', 'string', {
+ 'shell-comment': {
+ pattern: /(^|[^\\])#.*/,
+ lookbehind: true,
+ alias: 'comment'
+ }
+ });
+ Prism.languages.insertBefore('php', 'comment', {
+ 'delimiter': {
+ pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i,
+ alias: 'important'
+ }
+ });
+ Prism.languages.insertBefore('php', 'keyword', {
+ 'variable': /\$+(?:\w+\b|(?={))/i,
+ 'package': {
+ pattern: /(\\|namespace\s+|use\s+)[\w\\]+/,
+ lookbehind: true,
+ inside: { punctuation: /\\/ }
+ }
+ });
+ Prism.languages.insertBefore('php', 'operator', {
+ 'property': {
+ pattern: /(->)[\w]+/,
+ lookbehind: true
+ }
+ });
+ var string_interpolation = {
+ pattern: /{\$(?:{(?:{[^{}]+}|[^{}]+)}|[^{}])+}|(^|[^\\{])\$+(?:\w+(?:\[.+?]|->\w+)*)/,
+ lookbehind: true,
+ inside: Prism.languages.php
+ };
+ Prism.languages.insertBefore('php', 'string', {
+ 'nowdoc-string': {
+ pattern: /<<<'([^']+)'(?:\r\n?|\n)(?:.*(?:\r\n?|\n))*?\1;/,
+ greedy: true,
+ alias: 'string',
+ inside: {
+ 'delimiter': {
+ pattern: /^<<<'[^']+'|[a-z_]\w*;$/i,
+ alias: 'symbol',
+ inside: { 'punctuation': /^<<<'?|[';]$/ }
+ }
+ }
+ },
+ 'heredoc-string': {
+ pattern: /<<<(?:"([^"]+)"(?:\r\n?|\n)(?:.*(?:\r\n?|\n))*?\1;|([a-z_]\w*)(?:\r\n?|\n)(?:.*(?:\r\n?|\n))*?\2;)/i,
+ greedy: true,
+ alias: 'string',
+ inside: {
+ 'delimiter': {
+ pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
+ alias: 'symbol',
+ inside: { 'punctuation': /^<<<"?|[";]$/ }
+ },
+ 'interpolation': string_interpolation
+ }
+ },
+ 'single-quoted-string': {
+ pattern: /'(?:\\[\s\S]|[^\\'])*'/,
+ greedy: true,
+ alias: 'string'
+ },
+ 'double-quoted-string': {
+ pattern: /"(?:\\[\s\S]|[^\\"])*"/,
+ greedy: true,
+ alias: 'string',
+ inside: { 'interpolation': string_interpolation }
+ }
+ });
+ delete Prism.languages.php['string'];
+ Prism.hooks.add('before-tokenize', function (env) {
+ if (!/<\?/.test(env.code)) {
+ return;
+ }
+ var phpPattern = /<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#)(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|\/\*[\s\S]*?(?:\*\/|$))*?(?:\?>|$)/ig;
+ Prism.languages['markup-templating'].buildPlaceholders(env, 'php', phpPattern);
+ });
+ Prism.hooks.add('after-tokenize', function (env) {
+ Prism.languages['markup-templating'].tokenizePlaceholders(env, 'php');
+ });
+ }(Prism));
+ },
+ {}
+ ],
+ 12: [
+ function (require, module, exports) {
+ Prism.languages.python = {
+ 'comment': {
+ pattern: /(^|[^\\])#.*/,
+ lookbehind: true
+ },
+ 'string-interpolation': {
+ pattern: /(?:f|rf|fr)(?:("""|''')[\s\S]+?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
+ greedy: true,
+ inside: {
+ 'interpolation': {
+ pattern: /((?:^|[^{])(?:{{)*){(?!{)(?:[^{}]|{(?!{)(?:[^{}]|{(?!{)(?:[^{}])+})+})+}/,
+ lookbehind: true,
+ inside: {
+ 'format-spec': {
+ pattern: /(:)[^:(){}]+(?=}$)/,
+ lookbehind: true
+ },
+ 'conversion-option': {
+ pattern: //,
+ alias: 'punctuation'
+ },
+ rest: null
+ }
+ },
+ 'string': /[\s\S]+/
+ }
+ },
+ 'triple-quoted-string': {
+ pattern: /(?:[rub]|rb|br)?("""|''')[\s\S]+?\1/i,
+ greedy: true,
+ alias: 'string'
+ },
+ 'string': {
+ pattern: /(?:[rub]|rb|br)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
+ greedy: true
+ },
+ 'function': {
+ pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
+ lookbehind: true
+ },
+ 'class-name': {
+ pattern: /(\bclass\s+)\w+/i,
+ lookbehind: true
+ },
+ 'decorator': {
+ pattern: /(^\s*)@\w+(?:\.\w+)*/im,
+ lookbehind: true,
+ alias: [
+ 'annotation',
+ 'punctuation'
+ ],
+ inside: { 'punctuation': /\./ }
+ },
+ 'keyword': /\b(?:and|as|assert|async|await|break|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
+ '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/,
+ 'boolean': /\b(?:True|False|None)\b/,
+ 'number': /(?:\b(?=\d)|\B(?=\.))(?:0[bo])?(?:(?:\d|0x[\da-f])[\da-f]*\.?\d*|\.\d+)(?:e[+-]?\d+)?j?\b/i,
+ 'operator': /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+ 'punctuation': /[{}[\];(),.:]/
+ };
+ Prism.languages.python['string-interpolation'].inside['interpolation'].inside.rest = Prism.languages.python;
+ Prism.languages.py = Prism.languages.python;
+ },
+ {}
+ ],
+ 13: [
+ function (require, module, exports) {
+ (function (Prism) {
+ Prism.languages.ruby = Prism.languages.extend('clike', {
+ 'comment': [
+ /#.*/,
+ {
+ pattern: /^=begin\s[\s\S]*?^=end/m,
+ greedy: true
+ }
+ ],
+ 'class-name': {
+ pattern: /(\b(?:class)\s+|\bcatch\s+\()[\w.\\]+/i,
+ lookbehind: true,
+ inside: { 'punctuation': /[.\\]/ }
+ },
+ 'keyword': /\b(?:alias|and|BEGIN|begin|break|case|class|def|define_method|defined|do|each|else|elsif|END|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|protected|private|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/
+ });
+ var interpolation = {
+ pattern: /#\{[^}]+\}/,
+ inside: {
+ 'delimiter': {
+ pattern: /^#\{|\}$/,
+ alias: 'tag'
+ },
+ rest: Prism.languages.ruby
+ }
+ };
+ delete Prism.languages.ruby.function;
+ Prism.languages.insertBefore('ruby', 'keyword', {
+ 'regex': [
+ {
+ pattern: /%r([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1[gim]{0,3}/,
+ greedy: true,
+ inside: { 'interpolation': interpolation }
+ },
+ {
+ pattern: /%r\((?:[^()\\]|\\[\s\S])*\)[gim]{0,3}/,
+ greedy: true,
+ inside: { 'interpolation': interpolation }
+ },
+ {
+ pattern: /%r\{(?:[^#{}\\]|#(?:\{[^}]+\})?|\\[\s\S])*\}[gim]{0,3}/,
+ greedy: true,
+ inside: { 'interpolation': interpolation }
+ },
+ {
+ pattern: /%r\[(?:[^\[\]\\]|\\[\s\S])*\][gim]{0,3}/,
+ greedy: true,
+ inside: { 'interpolation': interpolation }
+ },
+ {
+ pattern: /%r<(?:[^<>\\]|\\[\s\S])*>[gim]{0,3}/,
+ greedy: true,
+ inside: { 'interpolation': interpolation }
+ },
+ {
+ pattern: /(^|[^/])\/(?!\/)(?:\[.+?]|\\.|[^/\\\r\n])+\/[gim]{0,3}(?=\s*(?:$|[\r\n,.;})]))/,
+ lookbehind: true,
+ greedy: true
+ }
+ ],
+ 'variable': /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/,
+ 'symbol': {
+ pattern: /(^|[^:]):[a-zA-Z_]\w*(?:[?!]|\b)/,
+ lookbehind: true
+ },
+ 'method-definition': {
+ pattern: /(\bdef\s+)[\w.]+/,
+ lookbehind: true,
+ inside: {
+ 'function': /\w+$/,
+ rest: Prism.languages.ruby
+ }
+ }
+ });
+ Prism.languages.insertBefore('ruby', 'number', {
+ 'builtin': /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Stat|Fixnum|Float|Hash|Integer|IO|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|String|Struct|TMS|Symbol|ThreadGroup|Thread|Time|TrueClass)\b/,
+ 'constant': /\b[A-Z]\w*(?:[?!]|\b)/
+ });
+ Prism.languages.ruby.string = [
+ {
+ pattern: /%[qQiIwWxs]?([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1/,
+ greedy: true,
+ inside: { 'interpolation': interpolation }
+ },
+ {
+ pattern: /%[qQiIwWxs]?\((?:[^()\\]|\\[\s\S])*\)/,
+ greedy: true,
+ inside: { 'interpolation': interpolation }
+ },
+ {
+ pattern: /%[qQiIwWxs]?\{(?:[^#{}\\]|#(?:\{[^}]+\})?|\\[\s\S])*\}/,
+ greedy: true,
+ inside: { 'interpolation': interpolation }
+ },
+ {
+ pattern: /%[qQiIwWxs]?\[(?:[^\[\]\\]|\\[\s\S])*\]/,
+ greedy: true,
+ inside: { 'interpolation': interpolation }
+ },
+ {
+ pattern: /%[qQiIwWxs]?<(?:[^<>\\]|\\[\s\S])*>/,
+ greedy: true,
+ inside: { 'interpolation': interpolation }
+ },
+ {
+ pattern: /("|')(?:#\{[^}]+\}|\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+ greedy: true,
+ inside: { 'interpolation': interpolation }
+ }
+ ];
+ Prism.languages.rb = Prism.languages.ruby;
+ }(Prism));
+ },
+ {}
+ ],
+ 14: [
+ function (require, module, exports) {
+ var Prism = require('prismjs/components/prism-core');
+ require('prismjs/components/prism-clike');
+ require('prismjs/components/prism-markup-templating');
+ require('prismjs/components/prism-c');
+ require('prismjs/components/prism-cpp');
+ require('prismjs/components/prism-csharp');
+ require('prismjs/components/prism-css');
+ require('prismjs/components/prism-java');
+ require('prismjs/components/prism-javascript');
+ require('prismjs/components/prism-markup');
+ require('prismjs/components/prism-php');
+ require('prismjs/components/prism-python');
+ require('prismjs/components/prism-ruby');
+ module.exports = { boltExport: Prism };
+ },
+ {
+ 'prismjs/components/prism-c': 1,
+ 'prismjs/components/prism-clike': 2,
+ 'prismjs/components/prism-core': 3,
+ 'prismjs/components/prism-cpp': 4,
+ 'prismjs/components/prism-csharp': 5,
+ 'prismjs/components/prism-css': 6,
+ 'prismjs/components/prism-java': 7,
+ 'prismjs/components/prism-javascript': 8,
+ 'prismjs/components/prism-markup': 10,
+ 'prismjs/components/prism-markup-templating': 9,
+ 'prismjs/components/prism-php': 11,
+ 'prismjs/components/prism-python': 12,
+ 'prismjs/components/prism-ruby': 13
+ }
+ ]
+ }, {}, [14])(14);
+ }));
+ var prism = window.Prism;
+ window.Prism = oldprism;
+ return prism;
+ }(undefined, exports$1, module, undefined));
+ var Prism$1 = module.exports.boltExport;
+
+ var getLanguages = function (editor) {
+ return editor.getParam('codesample_languages');
+ };
+ var useGlobalPrismJS = function (editor) {
+ return editor.getParam('codesample_global_prismjs', false, 'boolean');
+ };
+
+ var get = function (editor) {
+ return Global.Prism && useGlobalPrismJS(editor) ? Global.Prism : Prism$1;
+ };
+
+ var getSelectedCodeSample = function (editor) {
+ var node = editor.selection ? editor.selection.getNode() : null;
+ if (isCodeSample(node)) {
+ return Option.some(node);
+ }
+ return Option.none();
+ };
+ var insertCodeSample = function (editor, language, code) {
+ editor.undoManager.transact(function () {
+ var node = getSelectedCodeSample(editor);
+ code = global$1.DOM.encode(code);
+ return node.fold(function () {
+ editor.insertContent('' + code + '
');
+ editor.selection.select(editor.$('#__new').removeAttr('id')[0]);
+ }, function (n) {
+ editor.dom.setAttrib(n, 'class', 'language-' + language);
+ n.innerHTML = code;
+ get(editor).highlightElement(n);
+ editor.selection.select(n);
+ });
+ });
+ };
+ var getCurrentCode = function (editor) {
+ var node = getSelectedCodeSample(editor);
+ return node.fold(function () {
+ return '';
+ }, function (n) {
+ return n.textContent;
+ });
+ };
+
+ var getLanguages$1 = function (editor) {
+ var defaultLanguages = [
+ {
+ text: 'HTML/XML',
+ value: 'markup'
+ },
+ {
+ text: 'JavaScript',
+ value: 'javascript'
+ },
+ {
+ text: 'CSS',
+ value: 'css'
+ },
+ {
+ text: 'PHP',
+ value: 'php'
+ },
+ {
+ text: 'Ruby',
+ value: 'ruby'
+ },
+ {
+ text: 'Python',
+ value: 'python'
+ },
+ {
+ text: 'Java',
+ value: 'java'
+ },
+ {
+ text: 'C',
+ value: 'c'
+ },
+ {
+ text: 'C#',
+ value: 'csharp'
+ },
+ {
+ text: 'C++',
+ value: 'cpp'
+ }
+ ];
+ var customLanguages = getLanguages(editor);
+ return customLanguages ? customLanguages : defaultLanguages;
+ };
+ var getCurrentLanguage = function (editor, fallback) {
+ var node = getSelectedCodeSample(editor);
+ return node.fold(function () {
+ return fallback;
+ }, function (n) {
+ var matches = n.className.match(/language-(\w+)/);
+ return matches ? matches[1] : fallback;
+ });
+ };
+
+ var head = function (xs) {
+ return xs.length === 0 ? Option.none() : Option.some(xs[0]);
+ };
+
+ var open = function (editor) {
+ var languages = getLanguages$1(editor);
+ var defaultLanguage = head(languages).fold(function () {
+ return '';
+ }, function (l) {
+ return l.value;
+ });
+ var currentLanguage = getCurrentLanguage(editor, defaultLanguage);
+ var currentCode = getCurrentCode(editor);
+ editor.windowManager.open({
+ title: 'Insert/Edit Code Sample',
+ size: 'large',
+ body: {
+ type: 'panel',
+ items: [
+ {
+ type: 'selectbox',
+ name: 'language',
+ label: 'Language',
+ items: languages
+ },
+ {
+ type: 'textarea',
+ name: 'code',
+ label: 'Code view'
+ }
+ ]
+ },
+ buttons: [
+ {
+ type: 'cancel',
+ name: 'cancel',
+ text: 'Cancel'
+ },
+ {
+ type: 'submit',
+ name: 'save',
+ text: 'Save',
+ primary: true
+ }
+ ],
+ initialData: {
+ language: currentLanguage,
+ code: currentCode
+ },
+ onSubmit: function (api) {
+ var data = api.getData();
+ insertCodeSample(editor, data.language, data.code);
+ api.close();
+ }
+ });
+ };
+
+ var register = function (editor) {
+ editor.addCommand('codesample', function () {
+ var node = editor.selection.getNode();
+ if (editor.selection.isCollapsed() || isCodeSample(node)) {
+ open(editor);
+ } else {
+ editor.formatter.toggle('code');
+ }
+ });
+ };
+
+ var setup = function (editor) {
+ var $ = editor.$;
+ editor.on('PreProcess', function (e) {
+ $('pre[contenteditable=false]', e.node).filter(trimArg(isCodeSample)).each(function (idx, elm) {
+ var $elm = $(elm), code = elm.textContent;
+ $elm.attr('class', $.trim($elm.attr('class')));
+ $elm.removeAttr('contentEditable');
+ $elm.empty().append($(''+a+"
"),n.selection.select(n.$("#__new").removeAttr("id")[0])},function(e){n.dom.setAttrib(e,"class","language-"+t),e.innerHTML=a,v(n).highlightElement(e),n.selection.select(e)})}),e.close()}})},_=function(a){a.ui.registry.addToggleButton("codesample",{icon:"code-sample",tooltip:"Insert/edit code sample",onAction:function(){return x(a)},onSetup:function(t){var e=function(){var e,n;t.setActive((n=(e=a).selection.getStart(),e.dom.is(n,'pre[class*="language-"]')))};return a.on("NodeChange",e),function(){return a.off("NodeChange",e)}}}),a.ui.registry.addMenuItem("codesample",{text:"Code sample...",icon:"code-sample",onAction:function(){return x(a)}})};!function F(){r.add("codesample",function(n){var t,r,a;r=(t=n).$,t.on("PreProcess",function(e){r("pre[contenteditable=false]",e.node).filter(m(g)).each(function(e,n){var t=r(n),a=n.textContent;t.attr("class",r.trim(t.attr("class"))),t.removeAttr("contentEditable"),t.empty().append(r("Could not load emoticons
'
+ }]
+ },
+ buttons: [{
+ type: 'cancel',
+ text: 'Close',
+ primary: true
+ }],
+ initialData: {
+ pattern: '',
+ results: []
+ }
+ });
+ dialogApi.focus(patternName);
+ dialogApi.unblock();
+ });
+ }
+ };
+
+ var register = function (editor, database) {
+ var onAction = function () {
+ return open(editor, database);
+ };
+ editor.ui.registry.addButton('emoticons', {
+ tooltip: 'Emoticons',
+ icon: 'emoji',
+ onAction: onAction
+ });
+ editor.ui.registry.addMenuItem('emoticons', {
+ text: 'Emoticons...',
+ icon: 'emoji',
+ onAction: onAction
+ });
+ };
+
+ function Plugin () {
+ global.add('emoticons', function (editor, pluginUrl) {
+ var databaseUrl = getEmoticonDatabaseUrl(editor, pluginUrl);
+ var databaseId = getEmoticonDatabaseId(editor);
+ var database = initDatabase(editor, databaseUrl, databaseId);
+ register(editor, database);
+ init(editor, database);
+ });
+ }
+
+ Plugin();
+
+}(window));
diff --git a/resources/public/js/build/plugins/emoticons/plugin.min.js b/resources/public/js/build/plugins/emoticons/plugin.min.js
new file mode 100644
index 00000000..0f3995b0
--- /dev/null
+++ b/resources/public/js/build/plugins/emoticons/plugin.min.js
@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Tiny Technologies, Inc. All rights reserved.
+ * Licensed under the LGPL or a commercial license.
+ * For LGPL see License.txt in the project root for license information.
+ * For commercial licenses see https://www.tiny.cloud/
+ *
+ * Version: 5.3.0 (2020-05-21)
+ */
+!function(m){"use strict";var n,t,e,u,o=tinymce.util.Tools.resolve("tinymce.PluginManager"),i=function(n){return function(){return n}},a=i(!1),c=i(!0),r=function(){return l},l=(n=function(n){return n.isNone()},{fold:function(n,t){return n()},is:a,isSome:a,isNone:c,getOr:e=function(n){return n},getOrThunk:t=function(n){return n()},getOrDie:function(n){throw new Error(n||"error: getOrDie called on none.")},getOrNull:i(null),getOrUndefined:i(undefined),or:e,orThunk:t,map:r,each:function(){},bind:r,exists:a,forall:c,filter:r,equals:n,equals_:n,toArray:function(){return[]},toString:i("none()")}),s=function(e){var n=i(e),t=function(){return r},o=function(n){return n(e)},r={fold:function(n,t){return t(e)},is:function(n){return e===n},isSome:c,isNone:a,getOr:n,getOrThunk:n,getOrDie:n,getOrNull:n,getOrUndefined:n,or:t,orThunk:t,map:function(n){return s(n(e))},each:function(n){n(e)},bind:o,exists:o,forall:o,filter:function(n){return n(e)?r:l},toArray:function(){return[e]},toString:function(){return"some("+e+")"},equals:function(n){return n.is(e)},equals_:function(n,t){return n.fold(a,function(n){return t(e,n)})}};return r},g={some:s,none:r,from:function(n){return null===n||n===undefined?l:s(n)}},f=function(n,t){return-1!==n.indexOf(t)},d=function(n,t){return f(n.title.toLowerCase(),t)||function(n,t){for(var e=0,o=n.length;eCould not load emoticons
"}]},buttons:[{type:"cancel",text:"Close",primary:!0}],initialData:{pattern:"",results:[]}}),f.focus(S),f.unblock()}))};!function E(){o.add("emoticons",function(n,t){var e,o,r,i,u,a,c,l=(o=t,(e=n).getParam("emoticons_database_url",o+"/js/emojis"+e.suffix+".js")),s=n.getParam("emoticons_database_id","tinymce.plugins.emoticons","string"),f=L(n,l,s);i=f,u=function(){return N(r,i)},(r=n).ui.registry.addButton("emoticons",{tooltip:"Emoticons",icon:"emoji",onAction:u}),r.ui.registry.addMenuItem("emoticons",{text:"Emoticons...",icon:"emoji",onAction:u}),c=f,(a=n).ui.registry.addAutocompleter("emoticons",{ch:":",columns:"auto",minChars:2,fetch:function(t,e){return c.waitForLoad().then(function(){var n=c.listAll();return y(n,t,g.some(e))})},onAction:function(n,t,e){a.selection.setRng(t),a.insertContent(e),n.hide()}})})}()}(window);
\ No newline at end of file
diff --git a/resources/public/js/build/plugins/fullpage/index.js b/resources/public/js/build/plugins/fullpage/index.js
new file mode 100644
index 00000000..c327d6a0
--- /dev/null
+++ b/resources/public/js/build/plugins/fullpage/index.js
@@ -0,0 +1,7 @@
+// Exports the "fullpage" plugin for usage with module loaders
+// Usage:
+// CommonJS:
+// require('tinymce/plugins/fullpage')
+// ES2015:
+// import 'tinymce/plugins/fullpage'
+require('./plugin.js');
\ No newline at end of file
diff --git a/resources/public/js/build/plugins/fullpage/plugin.js b/resources/public/js/build/plugins/fullpage/plugin.js
new file mode 100644
index 00000000..84c02b9f
--- /dev/null
+++ b/resources/public/js/build/plugins/fullpage/plugin.js
@@ -0,0 +1,541 @@
+/**
+ * Copyright (c) Tiny Technologies, Inc. All rights reserved.
+ * Licensed under the LGPL or a commercial license.
+ * For LGPL see License.txt in the project root for license information.
+ * For commercial licenses see https://www.tiny.cloud/
+ *
+ * Version: 5.3.0 (2020-05-21)
+ */
+(function (domGlobals) {
+ 'use strict';
+
+ var Cell = function (initial) {
+ var value = initial;
+ var get = function () {
+ return value;
+ };
+ var set = function (v) {
+ value = v;
+ };
+ return {
+ get: get,
+ set: set
+ };
+ };
+
+ var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
+
+ var __assign = function () {
+ __assign = Object.assign || function __assign(t) {
+ for (var s, i = 1, n = arguments.length; i < n; i++) {
+ s = arguments[i];
+ for (var p in s)
+ if (Object.prototype.hasOwnProperty.call(s, p))
+ t[p] = s[p];
+ }
+ return t;
+ };
+ return __assign.apply(this, arguments);
+ };
+
+ var global$1 = tinymce.util.Tools.resolve('tinymce.util.Tools');
+
+ var global$2 = tinymce.util.Tools.resolve('tinymce.html.DomParser');
+
+ var global$3 = tinymce.util.Tools.resolve('tinymce.html.Node');
+
+ var global$4 = tinymce.util.Tools.resolve('tinymce.html.Serializer');
+
+ var shouldHideInSourceView = function (editor) {
+ return editor.getParam('fullpage_hide_in_source_view');
+ };
+ var getDefaultXmlPi = function (editor) {
+ return editor.getParam('fullpage_default_xml_pi');
+ };
+ var getDefaultEncoding = function (editor) {
+ return editor.getParam('fullpage_default_encoding');
+ };
+ var getDefaultFontFamily = function (editor) {
+ return editor.getParam('fullpage_default_font_family');
+ };
+ var getDefaultFontSize = function (editor) {
+ return editor.getParam('fullpage_default_font_size');
+ };
+ var getDefaultTextColor = function (editor) {
+ return editor.getParam('fullpage_default_text_color');
+ };
+ var getDefaultTitle = function (editor) {
+ return editor.getParam('fullpage_default_title');
+ };
+ var getDefaultDocType = function (editor) {
+ return editor.getParam('fullpage_default_doctype', '');
+ };
+
+ var parseHeader = function (head) {
+ return global$2({
+ validate: false,
+ root_name: '#document'
+ }).parse(head, { format: 'xhtml' });
+ };
+ var htmlToData = function (editor, head) {
+ var headerFragment = parseHeader(head);
+ var data = {};
+ var elm, matches;
+ function getAttr(elm, name) {
+ var value = elm.attr(name);
+ return value || '';
+ }
+ data.fontface = getDefaultFontFamily(editor);
+ data.fontsize = getDefaultFontSize(editor);
+ elm = headerFragment.firstChild;
+ if (elm.type === 7) {
+ data.xml_pi = true;
+ matches = /encoding="([^"]+)"/.exec(elm.value);
+ if (matches) {
+ data.docencoding = matches[1];
+ }
+ }
+ elm = headerFragment.getAll('#doctype')[0];
+ if (elm) {
+ data.doctype = '';
+ }
+ elm = headerFragment.getAll('title')[0];
+ if (elm && elm.firstChild) {
+ data.title = elm.firstChild.value;
+ }
+ global$1.each(headerFragment.getAll('meta'), function (meta) {
+ var name = meta.attr('name');
+ var httpEquiv = meta.attr('http-equiv');
+ var matches;
+ if (name) {
+ data[name.toLowerCase()] = meta.attr('content');
+ } else if (httpEquiv === 'Content-Type') {
+ matches = /charset\s*=\s*(.*)\s*/gi.exec(meta.attr('content'));
+ if (matches) {
+ data.docencoding = matches[1];
+ }
+ }
+ });
+ elm = headerFragment.getAll('html')[0];
+ if (elm) {
+ data.langcode = getAttr(elm, 'lang') || getAttr(elm, 'xml:lang');
+ }
+ data.stylesheets = [];
+ global$1.each(headerFragment.getAll('link'), function (link) {
+ if (link.attr('rel') === 'stylesheet') {
+ data.stylesheets.push(link.attr('href'));
+ }
+ });
+ elm = headerFragment.getAll('body')[0];
+ if (elm) {
+ data.langdir = getAttr(elm, 'dir');
+ data.style = getAttr(elm, 'style');
+ data.visited_color = getAttr(elm, 'vlink');
+ data.link_color = getAttr(elm, 'link');
+ data.active_color = getAttr(elm, 'alink');
+ }
+ return data;
+ };
+ var dataToHtml = function (editor, data, head) {
+ var headerFragment, headElement, html, elm, value;
+ var dom = editor.dom;
+ function setAttr(elm, name, value) {
+ elm.attr(name, value ? value : undefined);
+ }
+ function addHeadNode(node) {
+ if (headElement.firstChild) {
+ headElement.insert(node, headElement.firstChild);
+ } else {
+ headElement.append(node);
+ }
+ }
+ headerFragment = parseHeader(head);
+ headElement = headerFragment.getAll('head')[0];
+ if (!headElement) {
+ elm = headerFragment.getAll('html')[0];
+ headElement = new global$3('head', 1);
+ if (elm.firstChild) {
+ elm.insert(headElement, elm.firstChild, true);
+ } else {
+ elm.append(headElement);
+ }
+ }
+ elm = headerFragment.firstChild;
+ if (data.xml_pi) {
+ value = 'version="1.0"';
+ if (data.docencoding) {
+ value += ' encoding="' + data.docencoding + '"';
+ }
+ if (elm.type !== 7) {
+ elm = new global$3('xml', 7);
+ headerFragment.insert(elm, headerFragment.firstChild, true);
+ }
+ elm.value = value;
+ } else if (elm && elm.type === 7) {
+ elm.remove();
+ }
+ elm = headerFragment.getAll('#doctype')[0];
+ if (data.doctype) {
+ if (!elm) {
+ elm = new global$3('#doctype', 10);
+ if (data.xml_pi) {
+ headerFragment.insert(elm, headerFragment.firstChild);
+ } else {
+ addHeadNode(elm);
+ }
+ }
+ elm.value = data.doctype.substring(9, data.doctype.length - 1);
+ } else if (elm) {
+ elm.remove();
+ }
+ elm = null;
+ global$1.each(headerFragment.getAll('meta'), function (meta) {
+ if (meta.attr('http-equiv') === 'Content-Type') {
+ elm = meta;
+ }
+ });
+ if (data.docencoding) {
+ if (!elm) {
+ elm = new global$3('meta', 1);
+ elm.attr('http-equiv', 'Content-Type');
+ elm.shortEnded = true;
+ addHeadNode(elm);
+ }
+ elm.attr('content', 'text/html; charset=' + data.docencoding);
+ } else if (elm) {
+ elm.remove();
+ }
+ elm = headerFragment.getAll('title')[0];
+ if (data.title) {
+ if (!elm) {
+ elm = new global$3('title', 1);
+ addHeadNode(elm);
+ } else {
+ elm.empty();
+ }
+ elm.append(new global$3('#text', 3)).value = data.title;
+ } else if (elm) {
+ elm.remove();
+ }
+ global$1.each('keywords,description,author,copyright,robots'.split(','), function (name) {
+ var nodes = headerFragment.getAll('meta');
+ var i, meta;
+ var value = data[name];
+ for (i = 0; i < nodes.length; i++) {
+ meta = nodes[i];
+ if (meta.attr('name') === name) {
+ if (value) {
+ meta.attr('content', value);
+ } else {
+ meta.remove();
+ }
+ return;
+ }
+ }
+ if (value) {
+ elm = new global$3('meta', 1);
+ elm.attr('name', name);
+ elm.attr('content', value);
+ elm.shortEnded = true;
+ addHeadNode(elm);
+ }
+ });
+ var currentStyleSheetsMap = {};
+ global$1.each(headerFragment.getAll('link'), function (stylesheet) {
+ if (stylesheet.attr('rel') === 'stylesheet') {
+ currentStyleSheetsMap[stylesheet.attr('href')] = stylesheet;
+ }
+ });
+ global$1.each(data.stylesheets, function (stylesheet) {
+ if (!currentStyleSheetsMap[stylesheet]) {
+ elm = new global$3('link', 1);
+ elm.attr({
+ rel: 'stylesheet',
+ text: 'text/css',
+ href: stylesheet
+ });
+ elm.shortEnded = true;
+ addHeadNode(elm);
+ }
+ delete currentStyleSheetsMap[stylesheet];
+ });
+ global$1.each(currentStyleSheetsMap, function (stylesheet) {
+ stylesheet.remove();
+ });
+ elm = headerFragment.getAll('body')[0];
+ if (elm) {
+ setAttr(elm, 'dir', data.langdir);
+ setAttr(elm, 'style', data.style);
+ setAttr(elm, 'vlink', data.visited_color);
+ setAttr(elm, 'link', data.link_color);
+ setAttr(elm, 'alink', data.active_color);
+ dom.setAttribs(editor.getBody(), {
+ style: data.style,
+ dir: data.dir,
+ vLink: data.visited_color,
+ link: data.link_color,
+ aLink: data.active_color
+ });
+ }
+ elm = headerFragment.getAll('html')[0];
+ if (elm) {
+ setAttr(elm, 'lang', data.langcode);
+ setAttr(elm, 'xml:lang', data.langcode);
+ }
+ if (!headElement.firstChild) {
+ headElement.remove();
+ }
+ html = global$4({
+ validate: false,
+ indent: true,
+ indent_before: 'head,html,body,meta,title,script,link,style',
+ indent_after: 'head,html,body,meta,title,script,link,style'
+ }).serialize(headerFragment);
+ return html.substring(0, html.indexOf('