no message

public/.htaccess

@@ -1,21 +0,0 @@
-<IfModule mod_rewrite.c>
-    <IfModule mod_negotiation.c>
-        Options -MultiViews -Indexes
-    </IfModule>
-
-    RewriteEngine On
-
-    # Handle Authorization Header
-    RewriteCond %{HTTP:Authorization} .
-    RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
-
-    # Redirect Trailing Slashes If Not A Folder...
-    RewriteCond %{REQUEST_FILENAME} !-d
-    RewriteCond %{REQUEST_URI} (.+)/$
-    RewriteRule ^ %1 [L,R=301]
-
-    # Send Requests To Front Controller...
-    RewriteCond %{REQUEST_FILENAME} !-d
-    RewriteCond %{REQUEST_FILENAME} !-f
-    RewriteRule ^ index.php [L]
-</IfModule>

public/README.md

@@ -1 +0,0 @@
-## 此目录所有资源将拷贝到public下

public/css/app.css

@@ -1,163 +0,0 @@
-/* latin-ext */
-
-@font-face {
-  font-family: 'Raleway';
-  font-style: normal;
-  font-weight: 300;
-  src: local("Raleway Light"), local("Raleway-Light"), url(/fonts/ZKwULyCG95tk6mOqHQfRBAsYbbCjybiHxArTLjt7FRU.woff2?d41d8cd98f00b204e9800998ecf8427e) format("woff2");
-  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
-}
-
-/* latin */
-
-@font-face {
-  font-family: 'Raleway';
-  font-style: normal;
-  font-weight: 300;
-  src: local("Raleway Light"), local("Raleway-Light"), url(/fonts/-_Ctzj9b56b8RgXW8FAriQzyDMXhdD8sAj6OAJTFsBI.woff2?d41d8cd98f00b204e9800998ecf8427e) format("woff2");
-  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
-}
-
-/* latin-ext */
-
-@font-face {
-  font-family: 'Raleway';
-  font-style: normal;
-  font-weight: 400;
-  src: local("Raleway"), local("Raleway-Regular"), url(/fonts/YZaO6llzOP57DpTBv2GnyFKPGs1ZzpMvnHX-7fPOuAc.woff2?d41d8cd98f00b204e9800998ecf8427e) format("woff2");
-  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
-}
-
-/* latin */
-
-@font-face {
-  font-family: 'Raleway';
-  font-style: normal;
-  font-weight: 400;
-  src: local("Raleway"), local("Raleway-Regular"), url(/fonts/QAUlVt1jXOgQavlW5wEfxQLUuEpTyoUstqEm5AMlJo4.woff2?d41d8cd98f00b204e9800998ecf8427e) format("woff2");
-  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
-}
-
-/* latin-ext */
-
-@font-face {
-  font-family: 'Raleway';
-  font-style: normal;
-  font-weight: 600;
-  src: local("Raleway SemiBold"), local("Raleway-SemiBold"), url(/fonts/STBOO2waD2LpX45SXYjQBQsYbbCjybiHxArTLjt7FRU.woff2?d41d8cd98f00b204e9800998ecf8427e) format("woff2");
-  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
-}
-
-/* latin */
-
-@font-face {
-  font-family: 'Raleway';
-  font-style: normal;
-  font-weight: 600;
-  src: local("Raleway SemiBold"), local("Raleway-SemiBold"), url(/fonts/xkvoNo9fC8O2RDydKj12bwzyDMXhdD8sAj6OAJTFsBI.woff2?d41d8cd98f00b204e9800998ecf8427e) format("woff2");
-  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
-}
-
-.app-view-loading {
-  position: fixed;
-  top: 0;
-  left: 0;
-  right: 0;
-  bottom: 0;
-  z-index: 99999;
-  background-color: rgba(255, 255, 255, 0.7);
-  display: flex;
-  align-items: center;
-  justify-content: center;
-}
-
-.app-view-loading > div {
-  text-align: center;
-}
-
-.app-view-loading > div > div {
-  color: #ccc;
-  margin: 0;
-  font: 11px verdana;
-  line-height: 16px;
-  text-transform: uppercase;
-  letter-spacing: 1px;
-}
-
-.app-view-loading > div > span {
-  display: inline-block;
-  vertical-align: middle;
-  width: 8px;
-  height: 8px;
-  margin: 2px;
-  background: #007DB6;
-  border-radius: 8px;
-  -webkit-animation: app-view-loadanim 1s infinite alternate;
-          animation: app-view-loadanim 1s infinite alternate;
-}
-
-.app-view-loading > div > span:nth-of-type(2) {
-  background: #008FB2;
-  -webkit-animation-delay: 0.2s;
-          animation-delay: 0.2s;
-}
-
-.app-view-loading > div > span:nth-of-type(3) {
-  background: #009B9E;
-  -webkit-animation-delay: 0.4s;
-          animation-delay: 0.4s;
-}
-
-.app-view-loading > div > span:nth-of-type(4) {
-  background: #00A77D;
-  -webkit-animation-delay: 0.6s;
-          animation-delay: 0.6s;
-}
-
-.app-view-loading > div > span:nth-of-type(5) {
-  background: #00B247;
-  -webkit-animation-delay: 0.8s;
-          animation-delay: 0.8s;
-}
-
-.app-view-loading > div > span:nth-of-type(6) {
-  background: #5AB027;
-  -webkit-animation-delay: 1.0s;
-          animation-delay: 1.0s;
-}
-
-.app-view-loading > div > span:nth-of-type(7) {
-  background: #A0B61E;
-  -webkit-animation-delay: 1.2s;
-          animation-delay: 1.2s;
-}
-
-@-webkit-keyframes app-view-loadanim {
-  0% {
-    opacity: 0;
-  }
-
-  100% {
-    opacity: 1;
-  }
-}
-
-@keyframes app-view-loadanim {
-  0% {
-    opacity: 0;
-  }
-
-  100% {
-    opacity: 1;
-  }
-}
-
-.navbar-laravel {
-  background-color: #fff;
-  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.04);
-}
-
-body {
-  font-family: -apple-system, SF UI Text, Arial, PingFang SC, Hiragino Sans GB, Microsoft YaHei, WenQuanYi Micro Hei, sans-serif;
-}
-

public/index.php

@@ -1,60 +0,0 @@
-<?php
-
-/**
- * Laravel - A PHP Framework For Web Artisans
- *
- * @package  Laravel
- * @author   Taylor Otwell <taylor@laravel.com>
- */
-
-define('LARAVEL_START', microtime(true));
-
-/*
-|--------------------------------------------------------------------------
-| Register The Auto Loader
-|--------------------------------------------------------------------------
-|
-| Composer provides a convenient, automatically generated class loader for
-| our application. We just need to utilize it! We'll simply require it
-| into the script here so that we don't have to worry about manual
-| loading any of our classes later on. It feels great to relax.
-|
-*/
-
-require __DIR__.'/../vendor/autoload.php';
-
-/*
-|--------------------------------------------------------------------------
-| Turn On The Lights
-|--------------------------------------------------------------------------
-|
-| We need to illuminate PHP development, so let us turn on the lights.
-| This bootstraps the framework and gets it ready for use, then it
-| will load up this application so that we can run it and send
-| the responses back to the browser and delight our users.
-|
-*/
-
-$app = require_once __DIR__.'/../bootstrap/app.php';
-
-/*
-|--------------------------------------------------------------------------
-| Run The Application
-|--------------------------------------------------------------------------
-|
-| Once we have the application, we can handle the incoming request
-| through the kernel, and send the associated response back to
-| the client's browser allowing them to enjoy the creative
-| and wonderful application we have prepared for them.
-|
-*/
-
-$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);
-
-$response = $kernel->handle(
-    $request = Illuminate\Http\Request::capture()
-);
-
-$response->send();
-
-$kernel->terminate($request, $response);

public/js/build/langs/zh_CN.js

@@ -1,389 +0,0 @@
-tinymce.addI18n('zh_CN',{
-"Redo": "\u91cd\u505a",
-"Undo": "\u64a4\u9500",
-"Cut": "\u526a\u5207",
-"Copy": "\u590d\u5236",
-"Paste": "\u7c98\u8d34",
-"Select all": "\u5168\u9009",
-"New document": "\u65b0\u6587\u4ef6",
-"Ok": "\u786e\u5b9a",
-"Cancel": "\u53d6\u6d88",
-"Visual aids": "\u7f51\u683c\u7ebf",
-"Bold": "\u7c97\u4f53",
-"Italic": "\u659c\u4f53",
-"Underline": "\u4e0b\u5212\u7ebf",
-"Strikethrough": "\u5220\u9664\u7ebf",
-"Superscript": "\u4e0a\u6807",
-"Subscript": "\u4e0b\u6807",
-"Clear formatting": "\u6e05\u9664\u683c\u5f0f",
-"Align left": "\u5de6\u8fb9\u5bf9\u9f50",
-"Align center": "\u4e2d\u95f4\u5bf9\u9f50",
-"Align right": "\u53f3\u8fb9\u5bf9\u9f50",
-"Justify": "\u4e24\u7aef\u5bf9\u9f50",
-"Bullet list": "\u9879\u76ee\u7b26\u53f7",
-"Numbered list": "\u7f16\u53f7\u5217\u8868",
-"Decrease indent": "\u51cf\u5c11\u7f29\u8fdb",
-"Increase indent": "\u589e\u52a0\u7f29\u8fdb",
-"Close": "\u5173\u95ed",
-"Formats": "\u683c\u5f0f",
-"Your browser doesn't support direct access to the clipboard. Please use the Ctrl+X\/C\/V keyboard shortcuts instead.": "\u4f60\u7684\u6d4f\u89c8\u5668\u4e0d\u652f\u6301\u6253\u5f00\u526a\u8d34\u677f\uff0c\u8bf7\u4f7f\u7528Ctrl+X\/C\/V\u7b49\u5feb\u6377\u952e\u3002",
-"Headers": "\u6807\u9898",
-"Header 1": "\u6807\u98981",
-"Header 2": "\u6807\u98982",
-"Header 3": "\u6807\u98983",
-"Header 4": "\u6807\u98984",
-"Header 5": "\u6807\u98985",
-"Header 6": "\u6807\u98986",
-"Headings": "\u6807\u9898",
-"Heading 1": "\u6807\u98981",
-"Heading 2": "\u6807\u98982",
-"Heading 3": "\u6807\u98983",
-"Heading 4": "\u6807\u98984",
-"Heading 5": "\u6807\u98985",
-"Heading 6": "\u6807\u98986",
-"Preformatted": "\u9884\u5148\u683c\u5f0f\u5316\u7684",
-"Div": "Div",
-"Pre": "Pre",
-"Code": "\u4ee3\u7801",
-"Paragraph": "\u6bb5\u843d",
-"Blockquote": "\u5f15\u6587\u533a\u5757",
-"Inline": "\u6587\u672c",
-"Blocks": "\u57fa\u5757",
-"Paste is now in plain text mode. Contents will now be pasted as plain text until you toggle this option off.": "\u5f53\u524d\u4e3a\u7eaf\u6587\u672c\u7c98\u8d34\u6a21\u5f0f\uff0c\u518d\u6b21\u70b9\u51fb\u53ef\u4ee5\u56de\u5230\u666e\u901a\u7c98\u8d34\u6a21\u5f0f\u3002",
-"Fonts": "\u5b57\u4f53",
-"Font Sizes": "\u5b57\u53f7",
-"Class": "\u7c7b\u578b",
-"Browse for an image": "\u6d4f\u89c8\u56fe\u50cf",
-"OR": "\u6216",
-"Drop an image here": "\u62d6\u653e\u4e00\u5f20\u56fe\u50cf\u81f3\u6b64",
-"Upload": "\u4e0a\u4f20",
-"Block": "\u5757",
-"Align": "\u5bf9\u9f50",
-"Default": "\u9ed8\u8ba4",
-"Circle": "\u7a7a\u5fc3\u5706",
-"Disc": "\u5b9e\u5fc3\u5706",
-"Square": "\u65b9\u5757",
-"Lower Alpha": "\u5c0f\u5199\u82f1\u6587\u5b57\u6bcd",
-"Lower Greek": "\u5c0f\u5199\u5e0c\u814a\u5b57\u6bcd",
-"Lower Roman": "\u5c0f\u5199\u7f57\u9a6c\u5b57\u6bcd",
-"Upper Alpha": "\u5927\u5199\u82f1\u6587\u5b57\u6bcd",
-"Upper Roman": "\u5927\u5199\u7f57\u9a6c\u5b57\u6bcd",
-"Anchor...": "\u951a\u70b9...",
-"Name": "\u540d\u79f0",
-"Id": "\u6807\u8bc6\u7b26",
-"Id should start with a letter, followed only by letters, numbers, dashes, dots, colons or underscores.": "\u6807\u8bc6\u7b26\u5e94\u8be5\u4ee5\u5b57\u6bcd\u5f00\u5934\uff0c\u540e\u8ddf\u5b57\u6bcd\u3001\u6570\u5b57\u3001\u7834\u6298\u53f7\u3001\u70b9\u3001\u5192\u53f7\u6216\u4e0b\u5212\u7ebf\u3002",
-"You have unsaved changes are you sure you want to navigate away?": "\u4f60\u8fd8\u6709\u6587\u6863\u5c1a\u672a\u4fdd\u5b58\uff0c\u786e\u5b9a\u8981\u79bb\u5f00\uff1f",
-"Restore last draft": "\u6062\u590d\u4e0a\u6b21\u7684\u8349\u7a3f",
-"Special characters...": "\u7279\u6b8a\u5b57\u7b26...",
-"Source code": "\u6e90\u4ee3\u7801",
-"Insert\/Edit code sample": "\u63d2\u5165\/\u7f16\u8f91\u4ee3\u7801\u793a\u4f8b",
-"Language": "\u8bed\u8a00",
-"Code sample...": "\u793a\u4f8b\u4ee3\u7801...",
-"Color Picker": "\u9009\u8272\u5668",
-"R": "R",
-"G": "G",
-"B": "B",
-"Left to right": "\u4ece\u5de6\u5230\u53f3",
-"Right to left": "\u4ece\u53f3\u5230\u5de6",
-"Emoticons...": "\u8868\u60c5\u7b26\u53f7...",
-"Metadata and Document Properties": "\u5143\u6570\u636e\u548c\u6587\u6863\u5c5e\u6027",
-"Title": "\u6807\u9898",
-"Keywords": "\u5173\u952e\u8bcd",
-"Description": "\u63cf\u8ff0",
-"Robots": "\u673a\u5668\u4eba",
-"Author": "\u4f5c\u8005",
-"Encoding": "\u7f16\u7801",
-"Fullscreen": "\u5168\u5c4f",
-"Action": "\u64cd\u4f5c",
-"Shortcut": "\u5feb\u6377\u952e",
-"Help": "\u5e2e\u52a9",
-"Address": "\u5730\u5740",
-"Focus to menubar": "\u79fb\u52a8\u7126\u70b9\u5230\u83dc\u5355\u680f",
-"Focus to toolbar": "\u79fb\u52a8\u7126\u70b9\u5230\u5de5\u5177\u680f",
-"Focus to element path": "\u79fb\u52a8\u7126\u70b9\u5230\u5143\u7d20\u8def\u5f84",
-"Focus to contextual toolbar": "\u79fb\u52a8\u7126\u70b9\u5230\u4e0a\u4e0b\u6587\u83dc\u5355",
-"Insert link (if link plugin activated)": "\u63d2\u5165\u94fe\u63a5 (\u5982\u679c\u94fe\u63a5\u63d2\u4ef6\u5df2\u6fc0\u6d3b)",
-"Save (if save plugin activated)": "\u4fdd\u5b58(\u5982\u679c\u4fdd\u5b58\u63d2\u4ef6\u5df2\u6fc0\u6d3b)",
-"Find (if searchreplace plugin activated)": "\u67e5\u627e(\u5982\u679c\u67e5\u627e\u66ff\u6362\u63d2\u4ef6\u5df2\u6fc0\u6d3b)",
-"Plugins installed ({0}):": "\u5df2\u5b89\u88c5\u63d2\u4ef6 ({0}):",
-"Premium plugins:": "\u4f18\u79c0\u63d2\u4ef6\uff1a",
-"Learn more...": "\u4e86\u89e3\u66f4\u591a...",
-"You are using {0}": "\u4f60\u6b63\u5728\u4f7f\u7528 {0}",
-"Plugins": "\u63d2\u4ef6",
-"Handy Shortcuts": "\u5feb\u6377\u952e",
-"Horizontal line": "\u6c34\u5e73\u5206\u5272\u7ebf",
-"Insert\/edit image": "\u63d2\u5165\/\u7f16\u8f91\u56fe\u7247",
-"Image description": "\u56fe\u7247\u63cf\u8ff0",
-"Source": "\u5730\u5740",
-"Dimensions": "\u5927\u5c0f",
-"Constrain proportions": "\u4fdd\u6301\u7eb5\u6a2a\u6bd4",
-"General": "\u666e\u901a",
-"Advanced": "\u9ad8\u7ea7",
-"Style": "\u6837\u5f0f",
-"Vertical space": "\u5782\u76f4\u8fb9\u8ddd",
-"Horizontal space": "\u6c34\u5e73\u8fb9\u8ddd",
-"Border": "\u8fb9\u6846",
-"Insert image": "\u63d2\u5165\u56fe\u7247",
-"Image...": "\u56fe\u7247...",
-"Image list": "\u56fe\u7247\u5217\u8868",
-"Rotate counterclockwise": "\u9006\u65f6\u9488\u65cb\u8f6c",
-"Rotate clockwise": "\u987a\u65f6\u9488\u65cb\u8f6c",
-"Flip vertically": "\u5782\u76f4\u7ffb\u8f6c",
-"Flip horizontally": "\u6c34\u5e73\u7ffb\u8f6c",
-"Edit image": "\u7f16\u8f91\u56fe\u7247",
-"Image options": "\u56fe\u7247\u9009\u9879",
-"Zoom in": "\u653e\u5927",
-"Zoom out": "\u7f29\u5c0f",
-"Crop": "\u88c1\u526a",
-"Resize": "\u8c03\u6574\u5927\u5c0f",
-"Orientation": "\u65b9\u5411",
-"Brightness": "\u4eae\u5ea6",
-"Sharpen": "\u9510\u5316",
-"Contrast": "\u5bf9\u6bd4\u5ea6",
-"Color levels": "\u989c\u8272\u5c42\u6b21",
-"Gamma": "\u4f3d\u9a6c\u503c",
-"Invert": "\u53cd\u8f6c",
-"Apply": "\u5e94\u7528",
-"Back": "\u540e\u9000",
-"Insert date\/time": "\u63d2\u5165\u65e5\u671f\/\u65f6\u95f4",
-"Date\/time": "\u65e5\u671f\/\u65f6\u95f4",
-"Insert\/Edit Link": "\u63d2\u5165\/\u7f16\u8f91\u94fe\u63a5",
-"Insert\/edit link": "\u63d2\u5165\/\u7f16\u8f91\u94fe\u63a5",
-"Text to display": "\u663e\u793a\u6587\u5b57",
-"Url": "\u5730\u5740",
-"Open link in...": "\u94fe\u63a5\u6253\u5f00\u4f4d\u7f6e...",
-"Current window": "\u5f53\u524d\u7a97\u53e3",
-"None": "\u65e0",
-"New window": "\u5728\u65b0\u7a97\u53e3\u6253\u5f00",
-"Remove link": "\u5220\u9664\u94fe\u63a5",
-"Anchors": "\u951a\u70b9",
-"Link...": "\u94fe\u63a5...",
-"Paste or type a link": "\u7c98\u8d34\u6216\u8f93\u5165\u94fe\u63a5",
-"The URL you entered seems to be an email address. Do you want to add the required mailto: prefix?": "\u4f60\u6240\u586b\u5199\u7684URL\u5730\u5740\u4e3a\u90ae\u4ef6\u5730\u5740\uff0c\u9700\u8981\u52a0\u4e0amailto:\u524d\u7f00\u5417\uff1f",
-"The URL you entered seems to be an external link. Do you want to add the required http:\/\/ prefix?": "\u4f60\u6240\u586b\u5199\u7684URL\u5730\u5740\u5c5e\u4e8e\u5916\u90e8\u94fe\u63a5\uff0c\u9700\u8981\u52a0\u4e0ahttp:\/\/:\u524d\u7f00\u5417\uff1f",
-"Link list": "\u94fe\u63a5\u5217\u8868",
-"Insert video": "\u63d2\u5165\u89c6\u9891",
-"Insert\/edit video": "\u63d2\u5165\/\u7f16\u8f91\u89c6\u9891",
-"Insert\/edit media": "\u63d2\u5165\/\u7f16\u8f91\u5a92\u4f53",
-"Alternative source": "\u955c\u50cf",
-"Alternative source URL": "\u66ff\u4ee3\u6765\u6e90\u7f51\u5740",
-"Media poster (Image URL)": "\u5c01\u9762(\u56fe\u7247\u5730\u5740)",
-"Paste your embed code below:": "\u5c06\u5185\u5d4c\u4ee3\u7801\u7c98\u8d34\u5728\u4e0b\u9762:",
-"Embed": "\u5185\u5d4c",
-"Media...": "\u591a\u5a92\u4f53...",
-"Nonbreaking space": "\u4e0d\u95f4\u65ad\u7a7a\u683c",
-"Page break": "\u5206\u9875\u7b26",
-"Paste as text": "\u7c98\u8d34\u4e3a\u6587\u672c",
-"Preview": "\u9884\u89c8",
-"Print...": "\u6253\u5370...",
-"Save": "\u4fdd\u5b58",
-"Find": "\u67e5\u627e",
-"Replace with": "\u66ff\u6362\u4e3a",
-"Replace": "\u66ff\u6362",
-"Replace all": "\u5168\u90e8\u66ff\u6362",
-"Previous": "\u4e0a\u4e00\u4e2a",
-"Next": "\u4e0b\u4e00\u4e2a",
-"Find and replace...": "\u67e5\u627e\u5e76\u66ff\u6362...",
-"Could not find the specified string.": "\u672a\u627e\u5230\u641c\u7d22\u5185\u5bb9.",
-"Match case": "\u533a\u5206\u5927\u5c0f\u5199",
-"Find whole words only": "\u5168\u5b57\u5339\u914d",
-"Spell check": "\u62fc\u5199\u68c0\u67e5",
-"Ignore": "\u5ffd\u7565",
-"Ignore all": "\u5168\u90e8\u5ffd\u7565",
-"Finish": "\u5b8c\u6210",
-"Add to Dictionary": "\u6dfb\u52a0\u5230\u5b57\u5178",
-"Insert table": "\u63d2\u5165\u8868\u683c",
-"Table properties": "\u8868\u683c\u5c5e\u6027",
-"Delete table": "\u5220\u9664\u8868\u683c",
-"Cell": "\u5355\u5143\u683c",
-"Row": "\u884c",
-"Column": "\u5217",
-"Cell properties": "\u5355\u5143\u683c\u5c5e\u6027",
-"Merge cells": "\u5408\u5e76\u5355\u5143\u683c",
-"Split cell": "\u62c6\u5206\u5355\u5143\u683c",
-"Insert row before": "\u5728\u4e0a\u65b9\u63d2\u5165",
-"Insert row after": "\u5728\u4e0b\u65b9\u63d2\u5165",
-"Delete row": "\u5220\u9664\u884c",
-"Row properties": "\u884c\u5c5e\u6027",
-"Cut row": "\u526a\u5207\u884c",
-"Copy row": "\u590d\u5236\u884c",
-"Paste row before": "\u7c98\u8d34\u5230\u4e0a\u65b9",
-"Paste row after": "\u7c98\u8d34\u5230\u4e0b\u65b9",
-"Insert column before": "\u5728\u5de6\u4fa7\u63d2\u5165",
-"Insert column after": "\u5728\u53f3\u4fa7\u63d2\u5165",
-"Delete column": "\u5220\u9664\u5217",
-"Cols": "\u5217",
-"Rows": "\u884c",
-"Width": "\u5bbd",
-"Height": "\u9ad8",
-"Cell spacing": "\u5355\u5143\u683c\u5916\u95f4\u8ddd",
-"Cell padding": "\u5355\u5143\u683c\u5185\u8fb9\u8ddd",
-"Show caption": "\u663e\u793a\u6807\u9898",
-"Left": "\u5de6\u5bf9\u9f50",
-"Center": "\u5c45\u4e2d",
-"Right": "\u53f3\u5bf9\u9f50",
-"Cell type": "\u5355\u5143\u683c\u7c7b\u578b",
-"Scope": "\u8303\u56f4",
-"Alignment": "\u5bf9\u9f50\u65b9\u5f0f",
-"H Align": "\u6c34\u5e73\u5bf9\u9f50",
-"V Align": "\u5782\u76f4\u5bf9\u9f50",
-"Top": "\u9876\u90e8\u5bf9\u9f50",
-"Middle": "\u5782\u76f4\u5c45\u4e2d",
-"Bottom": "\u5e95\u90e8\u5bf9\u9f50",
-"Header cell": "\u8868\u5934\u5355\u5143\u683c",
-"Row group": "\u884c\u7ec4",
-"Column group": "\u5217\u7ec4",
-"Row type": "\u884c\u7c7b\u578b",
-"Header": "\u8868\u5934",
-"Body": "\u8868\u4f53",
-"Footer": "\u8868\u5c3e",
-"Border color": "\u8fb9\u6846\u989c\u8272",
-"Insert template...": "\u63d2\u5165\u6a21\u677f...",
-"Templates": "\u6a21\u677f",
-"Template": "\u6a21\u677f",
-"Text color": "\u6587\u5b57\u989c\u8272",
-"Background color": "\u80cc\u666f\u8272",
-"Custom...": "\u81ea\u5b9a\u4e49...",
-"Custom color": "\u81ea\u5b9a\u4e49\u989c\u8272",
-"No color": "\u65e0",
-"Remove color": "\u79fb\u9664\u989c\u8272",
-"Table of Contents": "\u5185\u5bb9\u5217\u8868",
-"Show blocks": "\u663e\u793a\u533a\u5757\u8fb9\u6846",
-"Show invisible characters": "\u663e\u793a\u4e0d\u53ef\u89c1\u5b57\u7b26",
-"Word count": "\u5b57\u6570",
-"Words: {0}": "\u5b57\u6570\uff1a{0}",
-"{0} words": "{0} \u5b57",
-"File": "\u6587\u4ef6",
-"Edit": "\u7f16\u8f91",
-"Insert": "\u63d2\u5165",
-"View": "\u89c6\u56fe",
-"Format": "\u683c\u5f0f",
-"Table": "\u8868\u683c",
-"Tools": "\u5de5\u5177",
-"Powered by {0}": "\u7531{0}\u9a71\u52a8",
-"Rich Text Area. Press ALT-F9 for menu. Press ALT-F10 for toolbar. Press ALT-0 for help": "\u5728\u7f16\u8f91\u533a\u6309ALT-F9\u6253\u5f00\u83dc\u5355\uff0c\u6309ALT-F10\u6253\u5f00\u5de5\u5177\u680f\uff0c\u6309ALT-0\u67e5\u770b\u5e2e\u52a9",
-"Image title": "\u56fe\u7247\u6807\u9898",
-"Border width": "\u8fb9\u6846\u5bbd\u5ea6",
-"Border style": "\u8fb9\u6846\u6837\u5f0f",
-"Error": "\u9519\u8bef",
-"Warn": "\u8b66\u544a",
-"Valid": "\u6709\u6548",
-"To open the popup, press Shift+Enter": "\u6309Shitf+Enter\u952e\u6253\u5f00\u5bf9\u8bdd\u6846",
-"Rich Text Area. Press ALT-0 for help.": "\u7f16\u8f91\u533a\u3002\u6309Alt+0\u952e\u6253\u5f00\u5e2e\u52a9\u3002",
-"System Font": "\u7cfb\u7edf\u5b57\u4f53",
-"Failed to upload image: {0}": "\u56fe\u7247\u4e0a\u4f20\u5931\u8d25: {0}",
-"Failed to load plugin: {0} from url {1}": "\u63d2\u4ef6\u52a0\u8f7d\u5931\u8d25: {0} \u6765\u81ea\u94fe\u63a5 {1}",
-"Failed to load plugin url: {0}": "\u63d2\u4ef6\u52a0\u8f7d\u5931\u8d25 \u94fe\u63a5: {0}",
-"Failed to initialize plugin: {0}": "\u63d2\u4ef6\u521d\u59cb\u5316\u5931\u8d25: {0}",
-"example": "\u793a\u4f8b",
-"Search": "\u641c\u7d22",
-"All": "\u5168\u90e8",
-"Currency": "\u8d27\u5e01",
-"Text": "\u6587\u5b57",
-"Quotations": "\u5f15\u7528",
-"Mathematical": "\u6570\u5b66",
-"Extended Latin": "\u62c9\u4e01\u8bed\u6269\u5145",
-"Symbols": "\u7b26\u53f7",
-"Arrows": "\u7bad\u5934",
-"User Defined": "\u81ea\u5b9a\u4e49",
-"dollar sign": "\u7f8e\u5143\u7b26\u53f7",
-"currency sign": "\u8d27\u5e01\u7b26\u53f7",
-"euro-currency sign": "\u6b27\u5143\u7b26\u53f7",
-"colon sign": "\u5192\u53f7",
-"cruzeiro sign": "\u514b\u9c81\u8d5b\u7f57\u5e01\u7b26\u53f7",
-"french franc sign": "\u6cd5\u90ce\u7b26\u53f7",
-"lira sign": "\u91cc\u62c9\u7b26\u53f7",
-"mill sign": "\u5bc6\u5c14\u7b26\u53f7",
-"naira sign": "\u5948\u62c9\u7b26\u53f7",
-"peseta sign": "\u6bd4\u585e\u5854\u7b26\u53f7",
-"rupee sign": "\u5362\u6bd4\u7b26\u53f7",
-"won sign": "\u97e9\u5143\u7b26\u53f7",
-"new sheqel sign": "\u65b0\u8c22\u514b\u5c14\u7b26\u53f7",
-"dong sign": "\u8d8a\u5357\u76fe\u7b26\u53f7",
-"kip sign": "\u8001\u631d\u57fa\u666e\u7b26\u53f7",
-"tugrik sign": "\u56fe\u683c\u91cc\u514b\u7b26\u53f7",
-"drachma sign": "\u5fb7\u62c9\u514b\u9a6c\u7b26\u53f7",
-"german penny symbol": "\u5fb7\u56fd\u4fbf\u58eb\u7b26\u53f7",
-"peso sign": "\u6bd4\u7d22\u7b26\u53f7",
-"guarani sign": "\u74dc\u62c9\u5c3c\u7b26\u53f7",
-"austral sign": "\u6fb3\u5143\u7b26\u53f7",
-"hryvnia sign": "\u683c\u91cc\u592b\u5c3c\u4e9a\u7b26\u53f7",
-"cedi sign": "\u585e\u5730\u7b26\u53f7",
-"livre tournois sign": "\u91cc\u5f17\u5f17\u5c14\u7b26\u53f7",
-"spesmilo sign": "spesmilo\u7b26\u53f7",
-"tenge sign": "\u575a\u6208\u7b26\u53f7",
-"indian rupee sign": "\u5370\u5ea6\u5362\u6bd4",
-"turkish lira sign": "\u571f\u8033\u5176\u91cc\u62c9",
-"nordic mark sign": "\u5317\u6b27\u9a6c\u514b",
-"manat sign": "\u9a6c\u7eb3\u7279\u7b26\u53f7",
-"ruble sign": "\u5362\u5e03\u7b26\u53f7",
-"yen character": "\u65e5\u5143\u5b57\u6837",
-"yuan character": "\u4eba\u6c11\u5e01\u5143\u5b57\u6837",
-"yuan character, in hong kong and taiwan": "\u5143\u5b57\u6837\uff08\u6e2f\u53f0\u5730\u533a\uff09",
-"yen\/yuan character variant one": "\u5143\u5b57\u6837\uff08\u5927\u5199\uff09",
-"Loading emoticons...": "\u52a0\u8f7d\u8868\u60c5\u7b26\u53f7...",
-"Could not load emoticons": "\u4e0d\u80fd\u52a0\u8f7d\u8868\u60c5\u7b26\u53f7",
-"People": "\u4eba\u7c7b",
-"Animals and Nature": "\u52a8\u7269\u548c\u81ea\u7136",
-"Food and Drink": "\u98df\u7269\u548c\u996e\u54c1",
-"Activity": "\u6d3b\u52a8",
-"Travel and Places": "\u65c5\u6e38\u548c\u5730\u70b9",
-"Objects": "\u7269\u4ef6",
-"Flags": "\u65d7\u5e1c",
-"Characters": "\u5b57\u7b26",
-"Characters (no spaces)": "\u5b57\u7b26(\u65e0\u7a7a\u683c)",
-"Error: Form submit field collision.": "\u9519\u8bef: \u8868\u5355\u63d0\u4ea4\u5b57\u6bb5\u51b2\u7a81\u3002",
-"Error: No form element found.": "\u9519\u8bef: \u6ca1\u6709\u8868\u5355\u63a7\u4ef6\u3002",
-"Update": "\u66f4\u65b0",
-"Color swatch": "\u989c\u8272\u6837\u672c",
-"Turquoise": "\u9752\u7eff\u8272",
-"Green": "\u7eff\u8272",
-"Blue": "\u84dd\u8272",
-"Purple": "\u7d2b\u8272",
-"Navy Blue": "\u6d77\u519b\u84dd",
-"Dark Turquoise": "\u6df1\u84dd\u7eff\u8272",
-"Dark Green": "\u6df1\u7eff\u8272",
-"Medium Blue": "\u4e2d\u84dd\u8272",
-"Medium Purple": "\u4e2d\u7d2b\u8272",
-"Midnight Blue": "\u6df1\u84dd\u8272",
-"Yellow": "\u9ec4\u8272",
-"Orange": "\u6a59\u8272",
-"Red": "\u7ea2\u8272",
-"Light Gray": "\u6d45\u7070\u8272",
-"Gray": "\u7070\u8272",
-"Dark Yellow": "\u6697\u9ec4\u8272",
-"Dark Orange": "\u6df1\u6a59\u8272",
-"Dark Red": "\u6df1\u7ea2\u8272",
-"Medium Gray": "\u4e2d\u7070\u8272",
-"Dark Gray": "\u6df1\u7070\u8272",
-"Black": "\u9ed1\u8272",
-"White": "\u767d\u8272",
-"Switch to or from fullscreen mode": "\u5207\u6362\u5168\u5c4f\u6a21\u5f0f",
-"Open help dialog": "\u6253\u5f00\u5e2e\u52a9\u5bf9\u8bdd\u6846",
-"history": "\u5386\u53f2",
-"styles": "\u6837\u5f0f",
-"formatting": "\u683c\u5f0f\u5316",
-"alignment": "\u5bf9\u9f50",
-"indentation": "\u7f29\u8fdb",
-"permanent pen": "\u8bb0\u53f7\u7b14",
-"comments": "\u5907\u6ce8",
-"Anchor": "\u951a\u70b9",
-"Special character": "\u7279\u6b8a\u7b26\u53f7",
-"Code sample": "\u4ee3\u7801\u793a\u4f8b",
-"Color": "\u989c\u8272",
-"Emoticons": "\u8868\u60c5",
-"Document properties": "\u6587\u6863\u5c5e\u6027",
-"Image": "\u56fe\u7247",
-"Insert link": "\u63d2\u5165\u94fe\u63a5",
-"Target": "\u6253\u5f00\u65b9\u5f0f",
-"Link": "\u94fe\u63a5",
-"Poster": "\u5c01\u9762",
-"Media": "\u5a92\u4f53",
-"Print": "\u6253\u5370",
-"Prev": "\u4e0a\u4e00\u4e2a",
-"Find and replace": "\u67e5\u627e\u548c\u66ff\u6362",
-"Whole words": "\u5168\u5b57\u5339\u914d",
-"Spellcheck": "\u62fc\u5199\u68c0\u67e5",
-"Caption": "\u6807\u9898",
-"Insert template": "\u63d2\u5165\u6a21\u677f"
-});

public/js/build/plugins/advlist/index.js

@@ -1,7 +0,0 @@
-// Exports the "advlist" plugin for usage with module loaders
-// Usage:
-//   CommonJS:
-//     require('tinymce/plugins/advlist')
-//   ES2015:
-//     import 'tinymce/plugins/advlist'
-require('./plugin.js');

public/js/build/plugins/advlist/plugin.js

@@ -1,317 +0,0 @@
-/**
- * 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.0.7 (2019-06-05)
- */
-(function () {
-var advlist = (function () {
-    'use strict';
-
-    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.util.Tools');
-
-    var applyListFormat = function (editor, listName, styleValue) {
-      var cmd = listName === 'UL' ? 'InsertUnorderedList' : 'InsertOrderedList';
-      editor.execCommand(cmd, false, styleValue === false ? null : { 'list-style-type': styleValue });
-    };
-    var Actions = { applyListFormat: applyListFormat };
-
-    var register = function (editor) {
-      editor.addCommand('ApplyUnorderedListStyle', function (ui, value) {
-        Actions.applyListFormat(editor, 'UL', value['list-style-type']);
-      });
-      editor.addCommand('ApplyOrderedListStyle', function (ui, value) {
-        Actions.applyListFormat(editor, 'OL', value['list-style-type']);
-      });
-    };
-    var Commands = { register: register };
-
-    var getNumberStyles = function (editor) {
-      var styles = editor.getParam('advlist_number_styles', 'default,lower-alpha,lower-greek,lower-roman,upper-alpha,upper-roman');
-      return styles ? styles.split(/[ ,]/) : [];
-    };
-    var getBulletStyles = function (editor) {
-      var styles = editor.getParam('advlist_bullet_styles', 'default,circle,square');
-      return styles ? styles.split(/[ ,]/) : [];
-    };
-    var Settings = {
-      getNumberStyles: getNumberStyles,
-      getBulletStyles: getBulletStyles
-    };
-
-    var constant = function (value) {
-      return function () {
-        return value;
-      };
-    };
-    var never = constant(false);
-    var always = constant(true);
-
-    var never$1 = never;
-    var always$1 = always;
-    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 noop = function () {
-      };
-      var nul = function () {
-        return null;
-      };
-      var undef = function () {
-        return undefined;
-      };
-      var me = {
-        fold: function (n, s) {
-          return n();
-        },
-        is: never$1,
-        isSome: never$1,
-        isNone: always$1,
-        getOr: id,
-        getOrThunk: call,
-        getOrDie: function (msg) {
-          throw new Error(msg || 'error: getOrDie called on none.');
-        },
-        getOrNull: nul,
-        getOrUndefined: undef,
-        or: id,
-        orThunk: call,
-        map: none,
-        ap: none,
-        each: noop,
-        bind: none,
-        flatten: none,
-        exists: never$1,
-        forall: always$1,
-        filter: none,
-        equals: eq,
-        equals_: eq,
-        toArray: function () {
-          return [];
-        },
-        toString: constant('none()')
-      };
-      if (Object.freeze)
-        Object.freeze(me);
-      return me;
-    }();
-    var some = function (a) {
-      var constant_a = function () {
-        return a;
-      };
-      var self = function () {
-        return me;
-      };
-      var map = function (f) {
-        return some(f(a));
-      };
-      var bind = function (f) {
-        return f(a);
-      };
-      var me = {
-        fold: function (n, s) {
-          return s(a);
-        },
-        is: function (v) {
-          return a === v;
-        },
-        isSome: always$1,
-        isNone: never$1,
-        getOr: constant_a,
-        getOrThunk: constant_a,
-        getOrDie: constant_a,
-        getOrNull: constant_a,
-        getOrUndefined: constant_a,
-        or: self,
-        orThunk: self,
-        map: map,
-        ap: function (optfab) {
-          return optfab.fold(none, function (fab) {
-            return some(fab(a));
-          });
-        },
-        each: function (f) {
-          f(a);
-        },
-        bind: bind,
-        flatten: constant_a,
-        exists: bind,
-        forall: bind,
-        filter: function (f) {
-          return f(a) ? me : NONE;
-        },
-        equals: function (o) {
-          return o.is(a);
-        },
-        equals_: function (o, elementEq) {
-          return o.fold(never$1, function (b) {
-            return elementEq(a, b);
-          });
-        },
-        toArray: function () {
-          return [a];
-        },
-        toString: function () {
-          return 'some(' + a + ')';
-        }
-      };
-      return me;
-    };
-    var from = function (value) {
-      return value === null || value === undefined ? NONE : some(value);
-    };
-    var Option = {
-      some: some,
-      none: none,
-      from: from
-    };
-
-    var isChildOfBody = function (editor, elm) {
-      return editor.$.contains(editor.getBody(), elm);
-    };
-    var isTableCellNode = function (node) {
-      return node && /^(TH|TD)$/.test(node.nodeName);
-    };
-    var isListNode = function (editor) {
-      return function (node) {
-        return node && /^(OL|UL|DL)$/.test(node.nodeName) && isChildOfBody(editor, node);
-      };
-    };
-    var getSelectedStyleType = function (editor) {
-      var listElm = editor.dom.getParent(editor.selection.getNode(), 'ol,ul');
-      var style = editor.dom.getStyle(listElm, 'listStyleType');
-      return Option.from(style);
-    };
-    var ListUtils = {
-      isTableCellNode: isTableCellNode,
-      isListNode: isListNode,
-      getSelectedStyleType: getSelectedStyleType
-    };
-
-    var findIndex = function (list, predicate) {
-      for (var index = 0; index < list.length; index++) {
-        var element = list[index];
-        if (predicate(element)) {
-          return index;
-        }
-      }
-      return -1;
-    };
-    var styleValueToText = function (styleValue) {
-      return styleValue.replace(/\-/g, ' ').replace(/\b\w/g, function (chr) {
-        return chr.toUpperCase();
-      });
-    };
-    var isWithinList = function (editor, e, nodeName) {
-      var tableCellIndex = findIndex(e.parents, ListUtils.isTableCellNode);
-      var parents = tableCellIndex !== -1 ? e.parents.slice(0, tableCellIndex) : e.parents;
-      var lists = global$1.grep(parents, ListUtils.isListNode(editor));
-      return lists.length > 0 && lists[0].nodeName === nodeName;
-    };
-    var addSplitButton = function (editor, id, tooltip, cmd, nodeName, styles) {
-      editor.ui.registry.addSplitButton(id, {
-        tooltip: tooltip,
-        icon: nodeName === 'OL' ? 'ordered-list' : 'unordered-list',
-        presets: 'listpreview',
-        columns: 3,
-        fetch: function (callback) {
-          var items = global$1.map(styles, function (styleValue) {
-            var iconStyle = nodeName === 'OL' ? 'num' : 'bull';
-            var iconName = styleValue === 'disc' || styleValue === 'decimal' ? 'default' : styleValue;
-            var itemValue = styleValue === 'default' ? '' : styleValue;
-            var displayText = styleValueToText(styleValue);
-            return {
-              type: 'choiceitem',
-              value: itemValue,
-              icon: 'list-' + iconStyle + '-' + iconName,
-              text: displayText
-            };
-          });
-          callback(items);
-        },
-        onAction: function () {
-          return editor.execCommand(cmd);
-        },
-        onItemAction: function (splitButtonApi, value) {
-          Actions.applyListFormat(editor, nodeName, value);
-        },
-        select: function (value) {
-          var listStyleType = ListUtils.getSelectedStyleType(editor);
-          return listStyleType.map(function (listStyle) {
-            return value === listStyle;
-          }).getOr(false);
-        },
-        onSetup: function (api) {
-          var nodeChangeHandler = function (e) {
-            api.setActive(isWithinList(editor, e, nodeName));
-          };
-          editor.on('NodeChange', nodeChangeHandler);
-          return function () {
-            return editor.off('NodeChange', nodeChangeHandler);
-          };
-        }
-      });
-    };
-    var addButton = function (editor, id, tooltip, cmd, nodeName, styles) {
-      editor.ui.registry.addToggleButton(id, {
-        active: false,
-        tooltip: tooltip,
-        icon: nodeName === 'OL' ? 'ordered-list' : 'unordered-list',
-        onSetup: function (api) {
-          var nodeChangeHandler = function (e) {
-            api.setActive(isWithinList(editor, e, nodeName));
-          };
-          editor.on('NodeChange', nodeChangeHandler);
-          return function () {
-            return editor.off('NodeChange', nodeChangeHandler);
-          };
-        },
-        onAction: function () {
-          return editor.execCommand(cmd);
-        }
-      });
-    };
-    var addControl = function (editor, id, tooltip, cmd, nodeName, styles) {
-      if (styles.length > 0) {
-        addSplitButton(editor, id, tooltip, cmd, nodeName, styles);
-      } else {
-        addButton(editor, id, tooltip, cmd, nodeName, styles);
-      }
-    };
-    var register$1 = function (editor) {
-      addControl(editor, 'numlist', 'Numbered list', 'InsertOrderedList', 'OL', Settings.getNumberStyles(editor));
-      addControl(editor, 'bullist', 'Bullet list', 'InsertUnorderedList', 'UL', Settings.getBulletStyles(editor));
-    };
-    var Buttons = { register: register$1 };
-
-    global.add('advlist', function (editor) {
-      var hasPlugin = function (editor, plugin) {
-        var plugins = editor.settings.plugins ? editor.settings.plugins : '';
-        return global$1.inArray(plugins.split(/[ ,]/), plugin) !== -1;
-      };
-      if (hasPlugin(editor, 'lists')) {
-        Buttons.register(editor);
-        Commands.register(editor);
-      }
-    });
-    function Plugin () {
-    }
-
-    return Plugin;
-
-}());
-})();

public/js/build/plugins/anchor/index.js

@@ -1,7 +0,0 @@
-// Exports the "anchor" plugin for usage with module loaders
-// Usage:
-//   CommonJS:
-//     require('tinymce/plugins/anchor')
-//   ES2015:
-//     import 'tinymce/plugins/anchor'
-require('./plugin.js');

public/js/build/plugins/anchor/plugin.js

@@ -1,147 +0,0 @@
-/**
- * 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.0.7 (2019-06-05)
- */
-(function () {
-var anchor = (function () {
-    'use strict';
-
-    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    var isValidId = function (id) {
-      return /^[A-Za-z][A-Za-z0-9\-:._]*$/.test(id);
-    };
-    var getId = function (editor) {
-      var selectedNode = editor.selection.getNode();
-      var isAnchor = selectedNode.tagName === 'A' && editor.dom.getAttrib(selectedNode, 'href') === '';
-      return isAnchor ? selectedNode.getAttribute('id') || selectedNode.getAttribute('name') : '';
-    };
-    var insert = function (editor, id) {
-      var selectedNode = editor.selection.getNode();
-      var isAnchor = selectedNode.tagName === 'A' && editor.dom.getAttrib(selectedNode, 'href') === '';
-      if (isAnchor) {
-        selectedNode.removeAttribute('name');
-        selectedNode.id = id;
-        editor.undoManager.add();
-      } else {
-        editor.focus();
-        editor.selection.collapse(true);
-        editor.execCommand('mceInsertContent', false, editor.dom.createHTML('a', { id: id }));
-      }
-    };
-    var Anchor = {
-      isValidId: isValidId,
-      getId: getId,
-      insert: insert
-    };
-
-    var insertAnchor = function (editor, newId) {
-      if (!Anchor.isValidId(newId)) {
-        editor.windowManager.alert('Id should start with a letter, followed only by letters, numbers, dashes, dots, colons or underscores.');
-        return true;
-      } else {
-        Anchor.insert(editor, newId);
-        return false;
-      }
-    };
-    var open = function (editor) {
-      var currentId = Anchor.getId(editor);
-      editor.windowManager.open({
-        title: 'Anchor',
-        size: 'normal',
-        body: {
-          type: 'panel',
-          items: [{
-              name: 'id',
-              type: 'input',
-              label: 'ID',
-              placeholder: 'example'
-            }]
-        },
-        buttons: [
-          {
-            type: 'cancel',
-            name: 'cancel',
-            text: 'Cancel'
-          },
-          {
-            type: 'submit',
-            name: 'save',
-            text: 'Save',
-            primary: true
-          }
-        ],
-        initialData: { id: currentId },
-        onSubmit: function (api) {
-          if (!insertAnchor(editor, api.getData().id)) {
-            api.close();
-          }
-        }
-      });
-    };
-    var Dialog = { open: open };
-
-    var register = function (editor) {
-      editor.addCommand('mceAnchor', function () {
-        Dialog.open(editor);
-      });
-    };
-    var Commands = { register: register };
-
-    var isAnchorNode = function (node) {
-      return !node.attr('href') && (node.attr('id') || node.attr('name')) && !node.firstChild;
-    };
-    var setContentEditable = function (state) {
-      return function (nodes) {
-        for (var i = 0; i < nodes.length; i++) {
-          if (isAnchorNode(nodes[i])) {
-            nodes[i].attr('contenteditable', state);
-          }
-        }
-      };
-    };
-    var setup = function (editor) {
-      editor.on('PreInit', function () {
-        editor.parser.addNodeFilter('a', setContentEditable('false'));
-        editor.serializer.addNodeFilter('a', setContentEditable(null));
-      });
-    };
-    var FilterContent = { setup: setup };
-
-    var register$1 = function (editor) {
-      editor.ui.registry.addToggleButton('anchor', {
-        icon: 'bookmark',
-        tooltip: 'Anchor',
-        onAction: function () {
-          return editor.execCommand('mceAnchor');
-        },
-        onSetup: function (buttonApi) {
-          return editor.selection.selectorChangedWithUnbind('a:not([href])', buttonApi.setActive).unbind;
-        }
-      });
-      editor.ui.registry.addMenuItem('anchor', {
-        icon: 'bookmark',
-        text: 'Anchor...',
-        onAction: function () {
-          return editor.execCommand('mceAnchor');
-        }
-      });
-    };
-    var Buttons = { register: register$1 };
-
-    global.add('anchor', function (editor) {
-      FilterContent.setup(editor);
-      Commands.register(editor);
-      Buttons.register(editor);
-    });
-    function Plugin () {
-    }
-
-    return Plugin;
-
-}());
-})();

public/js/build/plugins/autolink/index.js

@@ -1,7 +0,0 @@
-// Exports the "autolink" plugin for usage with module loaders
-// Usage:
-//   CommonJS:
-//     require('tinymce/plugins/autolink')
-//   ES2015:
-//     import 'tinymce/plugins/autolink'
-require('./plugin.js');

public/js/build/plugins/autolink/plugin.js

@@ -1,188 +0,0 @@
-/**
- * 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.0.7 (2019-06-05)
- */
-(function () {
-var autolink = (function () {
-    'use strict';
-
-    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.Env');
-
-    var getAutoLinkPattern = function (editor) {
-      return editor.getParam('autolink_pattern', /^(https?:\/\/|ssh:\/\/|ftp:\/\/|file:\/|www\.|(?:mailto:)?[A-Z0-9._%+\-]+@)(.+)$/i);
-    };
-    var getDefaultLinkTarget = function (editor) {
-      return editor.getParam('default_link_target', '');
-    };
-    var Settings = {
-      getAutoLinkPattern: getAutoLinkPattern,
-      getDefaultLinkTarget: getDefaultLinkTarget
-    };
-
-    var rangeEqualsDelimiterOrSpace = function (rangeString, delimiter) {
-      return rangeString === delimiter || rangeString === ' ' || rangeString.charCodeAt(0) === 160;
-    };
-    var handleEclipse = function (editor) {
-      parseCurrentLine(editor, -1, '(');
-    };
-    var handleSpacebar = function (editor) {
-      parseCurrentLine(editor, 0, '');
-    };
-    var handleEnter = function (editor) {
-      parseCurrentLine(editor, -1, '');
-    };
-    var scopeIndex = function (container, index) {
-      if (index < 0) {
-        index = 0;
-      }
-      if (container.nodeType === 3) {
-        var len = container.data.length;
-        if (index > len) {
-          index = len;
-        }
-      }
-      return index;
-    };
-    var setStart = function (rng, container, offset) {
-      if (container.nodeType !== 1 || container.hasChildNodes()) {
-        rng.setStart(container, scopeIndex(container, offset));
-      } else {
-        rng.setStartBefore(container);
-      }
-    };
-    var setEnd = function (rng, container, offset) {
-      if (container.nodeType !== 1 || container.hasChildNodes()) {
-        rng.setEnd(container, scopeIndex(container, offset));
-      } else {
-        rng.setEndAfter(container);
-      }
-    };
-    var parseCurrentLine = function (editor, endOffset, delimiter) {
-      var rng, end, start, endContainer, bookmark, text, matches, prev, len, rngText;
-      var autoLinkPattern = Settings.getAutoLinkPattern(editor);
-      var defaultLinkTarget = Settings.getDefaultLinkTarget(editor);
-      if (editor.selection.getNode().tagName === 'A') {
-        return;
-      }
-      rng = editor.selection.getRng(true).cloneRange();
-      if (rng.startOffset < 5) {
-        prev = rng.endContainer.previousSibling;
-        if (!prev) {
-          if (!rng.endContainer.firstChild || !rng.endContainer.firstChild.nextSibling) {
-            return;
-          }
-          prev = rng.endContainer.firstChild.nextSibling;
-        }
-        len = prev.length;
-        setStart(rng, prev, len);
-        setEnd(rng, prev, len);
-        if (rng.endOffset < 5) {
-          return;
-        }
-        end = rng.endOffset;
-        endContainer = prev;
-      } else {
-        endContainer = rng.endContainer;
-        if (endContainer.nodeType !== 3 && endContainer.firstChild) {
-          while (endContainer.nodeType !== 3 && endContainer.firstChild) {
-            endContainer = endContainer.firstChild;
-          }
-          if (endContainer.nodeType === 3) {
-            setStart(rng, endContainer, 0);
-            setEnd(rng, endContainer, endContainer.nodeValue.length);
-          }
-        }
-        if (rng.endOffset === 1) {
-          end = 2;
-        } else {
-          end = rng.endOffset - 1 - endOffset;
-        }
-      }
-      start = end;
-      do {
-        setStart(rng, endContainer, end >= 2 ? end - 2 : 0);
-        setEnd(rng, endContainer, end >= 1 ? end - 1 : 0);
-        end -= 1;
-        rngText = rng.toString();
-      } while (rngText !== ' ' && rngText !== '' && rngText.charCodeAt(0) !== 160 && end - 2 >= 0 && rngText !== delimiter);
-      if (rangeEqualsDelimiterOrSpace(rng.toString(), delimiter)) {
-        setStart(rng, endContainer, end);
-        setEnd(rng, endContainer, start);
-        end += 1;
-      } else if (rng.startOffset === 0) {
-        setStart(rng, endContainer, 0);
-        setEnd(rng, endContainer, start);
-      } else {
-        setStart(rng, endContainer, end);
-        setEnd(rng, endContainer, start);
-      }
-      text = rng.toString();
-      if (text.charAt(text.length - 1) === '.') {
-        setEnd(rng, endContainer, start - 1);
-      }
-      text = rng.toString().trim();
-      matches = text.match(autoLinkPattern);
-      if (matches) {
-        if (matches[1] === 'www.') {
-          matches[1] = 'http://www.';
-        } else if (/@$/.test(matches[1]) && !/^mailto:/.test(matches[1])) {
-          matches[1] = 'mailto:' + matches[1];
-        }
-        bookmark = editor.selection.getBookmark();
-        editor.selection.setRng(rng);
-        editor.execCommand('createlink', false, matches[1] + matches[2]);
-        if (defaultLinkTarget) {
-          editor.dom.setAttrib(editor.selection.getNode(), 'target', defaultLinkTarget);
-        }
-        editor.selection.moveToBookmark(bookmark);
-        editor.nodeChanged();
-      }
-    };
-    var setup = function (editor) {
-      var autoUrlDetectState;
-      editor.on('keydown', function (e) {
-        if (e.keyCode === 13) {
-          return handleEnter(editor);
-        }
-      });
-      if (global$1.ie) {
-        editor.on('focus', function () {
-          if (!autoUrlDetectState) {
-            autoUrlDetectState = true;
-            try {
-              editor.execCommand('AutoUrlDetect', false, true);
-            } catch (ex) {
-            }
-          }
-        });
-        return;
-      }
-      editor.on('keypress', function (e) {
-        if (e.keyCode === 41) {
-          return handleEclipse(editor);
-        }
-      });
-      editor.on('keyup', function (e) {
-        if (e.keyCode === 32) {
-          return handleSpacebar(editor);
-        }
-      });
-    };
-    var Keys = { setup: setup };
-
-    global.add('autolink', function (editor) {
-      Keys.setup(editor);
-    });
-    function Plugin () {
-    }
-
-    return Plugin;
-
-}());
-})();

public/js/build/plugins/autoresize/index.js

@@ -1,7 +0,0 @@
-// Exports the "autoresize" plugin for usage with module loaders
-// Usage:
-//   CommonJS:
-//     require('tinymce/plugins/autoresize')
-//   ES2015:
-//     import 'tinymce/plugins/autoresize'
-require('./plugin.js');

public/js/build/plugins/autoresize/plugin.js

@@ -1,183 +0,0 @@
-/**
- * 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.0.7 (2019-06-05)
- */
-(function () {
-var autoresize = (function () {
-    'use strict';
-
-    var Cell = function (initial) {
-      var value = initial;
-      var get = function () {
-        return value;
-      };
-      var set = function (v) {
-        value = v;
-      };
-      var clone = function () {
-        return Cell(get());
-      };
-      return {
-        get: get,
-        set: set,
-        clone: clone
-      };
-    };
-
-    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.Env');
-
-    var global$2 = tinymce.util.Tools.resolve('tinymce.util.Delay');
-
-    var fireResizeEditor = function (editor) {
-      return editor.fire('ResizeEditor');
-    };
-    var Events = { fireResizeEditor: fireResizeEditor };
-
-    var getAutoResizeMinHeight = function (editor) {
-      return editor.getParam('min_height', editor.getElement().offsetHeight, 'number');
-    };
-    var getAutoResizeMaxHeight = function (editor) {
-      return editor.getParam('max_height', 0, 'number');
-    };
-    var getAutoResizeOverflowPadding = function (editor) {
-      return editor.getParam('autoresize_overflow_padding', 1, 'number');
-    };
-    var getAutoResizeBottomMargin = function (editor) {
-      return editor.getParam('autoresize_bottom_margin', 50, 'number');
-    };
-    var shouldAutoResizeOnInit = function (editor) {
-      return editor.getParam('autoresize_on_init', true, 'boolean');
-    };
-    var Settings = {
-      getAutoResizeMinHeight: getAutoResizeMinHeight,
-      getAutoResizeMaxHeight: getAutoResizeMaxHeight,
-      getAutoResizeOverflowPadding: getAutoResizeOverflowPadding,
-      getAutoResizeBottomMargin: getAutoResizeBottomMargin,
-      shouldAutoResizeOnInit: shouldAutoResizeOnInit
-    };
-
-    var isFullscreen = function (editor) {
-      return editor.plugins.fullscreen && editor.plugins.fullscreen.isFullscreen();
-    };
-    var wait = function (editor, oldSize, times, interval, callback) {
-      global$2.setEditorTimeout(editor, function () {
-        resize(editor, oldSize);
-        if (times--) {
-          wait(editor, oldSize, times, interval, callback);
-        } else if (callback) {
-          callback();
-        }
-      }, interval);
-    };
-    var toggleScrolling = function (editor, state) {
-      var body = editor.getBody();
-      if (body) {
-        body.style.overflowY = state ? '' : 'hidden';
-        if (!state) {
-          body.scrollTop = 0;
-        }
-      }
-    };
-    var parseCssValueToInt = function (dom, elm, name, computed) {
-      var value = parseInt(dom.getStyle(elm, name, computed), 10);
-      return isNaN(value) ? 0 : value;
-    };
-    var resize = function (editor, oldSize) {
-      var deltaSize, resizeHeight, contentHeight;
-      var dom = editor.dom;
-      var doc = editor.getDoc();
-      if (!doc) {
-        return;
-      }
-      if (isFullscreen(editor)) {
-        toggleScrolling(editor, true);
-        return;
-      }
-      var docEle = doc.documentElement;
-      var resizeBottomMargin = Settings.getAutoResizeBottomMargin(editor);
-      resizeHeight = Settings.getAutoResizeMinHeight(editor);
-      var marginTop = parseCssValueToInt(dom, docEle, 'margin-top', true);
-      var marginBottom = parseCssValueToInt(dom, docEle, 'margin-bottom', true);
-      contentHeight = docEle.offsetHeight + marginTop + marginBottom + resizeBottomMargin;
-      if (contentHeight < 0) {
-        contentHeight = 0;
-      }
-      var containerHeight = editor.getContainer().offsetHeight;
-      var contentAreaHeight = editor.getContentAreaContainer().offsetHeight;
-      var chromeHeight = containerHeight - contentAreaHeight;
-      if (contentHeight + chromeHeight > Settings.getAutoResizeMinHeight(editor)) {
-        resizeHeight = contentHeight + chromeHeight;
-      }
-      var maxHeight = Settings.getAutoResizeMaxHeight(editor);
-      if (maxHeight && resizeHeight > maxHeight) {
-        resizeHeight = maxHeight;
-        toggleScrolling(editor, true);
-      } else {
-        toggleScrolling(editor, false);
-      }
-      if (resizeHeight !== oldSize.get()) {
-        deltaSize = resizeHeight - oldSize.get();
-        dom.setStyle(editor.getContainer(), 'height', resizeHeight + 'px');
-        oldSize.set(resizeHeight);
-        Events.fireResizeEditor(editor);
-        if (global$1.webkit && deltaSize < 0) {
-          resize(editor, oldSize);
-        }
-      }
-    };
-    var setup = function (editor, oldSize) {
-      editor.on('init', function () {
-        var overflowPadding = Settings.getAutoResizeOverflowPadding(editor);
-        var dom = editor.dom;
-        dom.setStyles(editor.getBody(), {
-          'paddingLeft': overflowPadding,
-          'paddingRight': overflowPadding,
-          'min-height': 0
-        });
-      });
-      editor.on('NodeChange SetContent keyup FullscreenStateChanged ResizeContent', function (e) {
-        resize(editor, oldSize);
-      });
-      if (Settings.shouldAutoResizeOnInit(editor)) {
-        editor.on('init', function () {
-          wait(editor, oldSize, 20, 100, function () {
-            wait(editor, oldSize, 5, 1000);
-          });
-        });
-      }
-    };
-    var Resize = {
-      setup: setup,
-      resize: resize
-    };
-
-    var register = function (editor, oldSize) {
-      editor.addCommand('mceAutoResize', function () {
-        Resize.resize(editor, oldSize);
-      });
-    };
-    var Commands = { register: register };
-
-    global.add('autoresize', function (editor) {
-      if (!editor.settings.hasOwnProperty('resize')) {
-        editor.settings.resize = false;
-      }
-      if (!editor.inline) {
-        var oldSize = Cell(0);
-        Commands.register(editor, oldSize);
-        Resize.setup(editor, oldSize);
-      }
-    });
-    function Plugin () {
-    }
-
-    return Plugin;
-
-}());
-})();

public/js/build/plugins/autosave/index.js

@@ -1,7 +0,0 @@
-// Exports the "autosave" plugin for usage with module loaders
-// Usage:
-//   CommonJS:
-//     require('tinymce/plugins/autosave')
-//   ES2015:
-//     import 'tinymce/plugins/autosave'
-require('./plugin.js');

public/js/build/plugins/autosave/plugin.js

@@ -1,232 +0,0 @@
-/**
- * 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.0.7 (2019-06-05)
- */
-(function () {
-var autosave = (function (domGlobals) {
-    'use strict';
-
-    var Cell = function (initial) {
-      var value = initial;
-      var get = function () {
-        return value;
-      };
-      var set = function (v) {
-        value = v;
-      };
-      var clone = function () {
-        return Cell(get());
-      };
-      return {
-        get: get,
-        set: set,
-        clone: clone
-      };
-    };
-
-    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.util.Delay');
-
-    var global$2 = tinymce.util.Tools.resolve('tinymce.util.LocalStorage');
-
-    var global$3 = tinymce.util.Tools.resolve('tinymce.util.Tools');
-
-    var fireRestoreDraft = function (editor) {
-      return editor.fire('RestoreDraft');
-    };
-    var fireStoreDraft = function (editor) {
-      return editor.fire('StoreDraft');
-    };
-    var fireRemoveDraft = function (editor) {
-      return editor.fire('RemoveDraft');
-    };
-
-    var parse = function (timeString, defaultTime) {
-      var multiples = {
-        s: 1000,
-        m: 60000
-      };
-      var toParse = timeString || defaultTime;
-      var parsedTime = /^(\d+)([ms]?)$/.exec('' + toParse);
-      return (parsedTime[2] ? multiples[parsedTime[2]] : 1) * parseInt(toParse, 10);
-    };
-
-    var shouldAskBeforeUnload = function (editor) {
-      return editor.getParam('autosave_ask_before_unload', true);
-    };
-    var getAutoSavePrefix = function (editor) {
-      var prefix = editor.getParam('autosave_prefix', 'tinymce-autosave-{path}{query}{hash}-{id}-');
-      prefix = prefix.replace(/\{path\}/g, domGlobals.document.location.pathname);
-      prefix = prefix.replace(/\{query\}/g, domGlobals.document.location.search);
-      prefix = prefix.replace(/\{hash\}/g, domGlobals.document.location.hash);
-      prefix = prefix.replace(/\{id\}/g, editor.id);
-      return prefix;
-    };
-    var shouldRestoreWhenEmpty = function (editor) {
-      return editor.getParam('autosave_restore_when_empty', false);
-    };
-    var getAutoSaveInterval = function (editor) {
-      return parse(editor.settings.autosave_interval, '30s');
-    };
-    var getAutoSaveRetention = function (editor) {
-      return parse(editor.settings.autosave_retention, '20m');
-    };
-
-    var isEmpty = function (editor, html) {
-      var forcedRootBlockName = editor.settings.forced_root_block;
-      html = global$3.trim(typeof html === 'undefined' ? editor.getBody().innerHTML : html);
-      return html === '' || new RegExp('^<' + forcedRootBlockName + '[^>]*>((\xA0|&nbsp;|[ \t]|<br[^>]*>)+?|)</' + forcedRootBlockName + '>|<br>$', 'i').test(html);
-    };
-    var hasDraft = function (editor) {
-      var time = parseInt(global$2.getItem(getAutoSavePrefix(editor) + 'time'), 10) || 0;
-      if (new Date().getTime() - time > getAutoSaveRetention(editor)) {
-        removeDraft(editor, false);
-        return false;
-      }
-      return true;
-    };
-    var removeDraft = function (editor, fire) {
-      var prefix = getAutoSavePrefix(editor);
-      global$2.removeItem(prefix + 'draft');
-      global$2.removeItem(prefix + 'time');
-      if (fire !== false) {
-        fireRemoveDraft(editor);
-      }
-    };
-    var storeDraft = function (editor) {
-      var prefix = getAutoSavePrefix(editor);
-      if (!isEmpty(editor) && editor.isDirty()) {
-        global$2.setItem(prefix + 'draft', editor.getContent({
-          format: 'raw',
-          no_events: true
-        }));
-        global$2.setItem(prefix + 'time', new Date().getTime().toString());
-        fireStoreDraft(editor);
-      }
-    };
-    var restoreDraft = function (editor) {
-      var prefix = getAutoSavePrefix(editor);
-      if (hasDraft(editor)) {
-        editor.setContent(global$2.getItem(prefix + 'draft'), { format: 'raw' });
-        fireRestoreDraft(editor);
-      }
-    };
-    var startStoreDraft = function (editor, started) {
-      var interval = getAutoSaveInterval(editor);
-      if (!started.get()) {
-        global$1.setInterval(function () {
-          if (!editor.removed) {
-            storeDraft(editor);
-          }
-        }, interval);
-        started.set(true);
-      }
-    };
-    var restoreLastDraft = function (editor) {
-      editor.undoManager.transact(function () {
-        restoreDraft(editor);
-        removeDraft(editor);
-      });
-      editor.focus();
-    };
-
-    function curry(fn) {
-      var initialArgs = [];
-      for (var _i = 1; _i < arguments.length; _i++) {
-        initialArgs[_i - 1] = arguments[_i];
-      }
-      return function () {
-        var restArgs = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          restArgs[_i] = arguments[_i];
-        }
-        var all = initialArgs.concat(restArgs);
-        return fn.apply(null, all);
-      };
-    }
-
-    var get = function (editor) {
-      return {
-        hasDraft: curry(hasDraft, editor),
-        storeDraft: curry(storeDraft, editor),
-        restoreDraft: curry(restoreDraft, editor),
-        removeDraft: curry(removeDraft, editor),
-        isEmpty: curry(isEmpty, editor)
-      };
-    };
-
-    var global$4 = tinymce.util.Tools.resolve('tinymce.EditorManager');
-
-    var setup = function (editor) {
-      editor.editorManager.on('BeforeUnload', function (e) {
-        var msg;
-        global$3.each(global$4.get(), function (editor) {
-          if (editor.plugins.autosave) {
-            editor.plugins.autosave.storeDraft();
-          }
-          if (!msg && editor.isDirty() && shouldAskBeforeUnload(editor)) {
-            msg = editor.translate('You have unsaved changes are you sure you want to navigate away?');
-          }
-        });
-        if (msg) {
-          e.preventDefault();
-          e.returnValue = msg;
-        }
-      });
-    };
-
-    var makeSetupHandler = function (editor, started) {
-      return function (api) {
-        api.setDisabled(!hasDraft(editor));
-        var editorEventCallback = function () {
-          return api.setDisabled(!hasDraft(editor));
-        };
-        editor.on('StoreDraft RestoreDraft RemoveDraft', editorEventCallback);
-        return function () {
-          return editor.off('StoreDraft RestoreDraft RemoveDraft', editorEventCallback);
-        };
-      };
-    };
-    var register = function (editor, started) {
-      startStoreDraft(editor, started);
-      editor.ui.registry.addButton('restoredraft', {
-        tooltip: 'Restore last draft',
-        icon: 'restore-draft',
-        onAction: function () {
-          restoreLastDraft(editor);
-        },
-        onSetup: makeSetupHandler(editor, started)
-      });
-      editor.ui.registry.addMenuItem('restoredraft', {
-        text: 'Restore last draft',
-        icon: 'restore-draft',
-        onAction: function () {
-          restoreLastDraft(editor);
-        },
-        onSetup: makeSetupHandler(editor, started)
-      });
-    };
-
-    global.add('autosave', function (editor) {
-      var started = Cell(false);
-      setup(editor);
-      register(editor, started);
-      editor.on('init', function () {
-        if (shouldRestoreWhenEmpty(editor) && editor.dom.isEmpty(editor.getBody())) {
-          restoreDraft(editor);
-        }
-      });
-      return get(editor);
-    });
-    function Plugin () {
-    }
-
-    return Plugin;
-
-}(window));
-})();

public/js/build/plugins/bbcode/index.js

@@ -1,7 +0,0 @@
-// Exports the "bbcode" plugin for usage with module loaders
-// Usage:
-//   CommonJS:
-//     require('tinymce/plugins/bbcode')
-//   ES2015:
-//     import 'tinymce/plugins/bbcode'
-require('./plugin.js');

public/js/build/plugins/bbcode/plugin.js

@@ -1,109 +0,0 @@
-/**
- * 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.0.7 (2019-06-05)
- */
-(function () {
-var bbcode = (function () {
-    'use strict';
-
-    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.util.Tools');
-
-    var html2bbcode = function (s) {
-      s = global$1.trim(s);
-      var rep = function (re, str) {
-        s = s.replace(re, str);
-      };
-      rep(/<a.*?href=\"(.*?)\".*?>(.*?)<\/a>/gi, '[url=$1]$2[/url]');
-      rep(/<font.*?color=\"(.*?)\".*?class=\"codeStyle\".*?>(.*?)<\/font>/gi, '[code][color=$1]$2[/color][/code]');
-      rep(/<font.*?color=\"(.*?)\".*?class=\"quoteStyle\".*?>(.*?)<\/font>/gi, '[quote][color=$1]$2[/color][/quote]');
-      rep(/<font.*?class=\"codeStyle\".*?color=\"(.*?)\".*?>(.*?)<\/font>/gi, '[code][color=$1]$2[/color][/code]');
-      rep(/<font.*?class=\"quoteStyle\".*?color=\"(.*?)\".*?>(.*?)<\/font>/gi, '[quote][color=$1]$2[/color][/quote]');
-      rep(/<span style=\"color: ?(.*?);\">(.*?)<\/span>/gi, '[color=$1]$2[/color]');
-      rep(/<font.*?color=\"(.*?)\".*?>(.*?)<\/font>/gi, '[color=$1]$2[/color]');
-      rep(/<span style=\"font-size:(.*?);\">(.*?)<\/span>/gi, '[size=$1]$2[/size]');
-      rep(/<font>(.*?)<\/font>/gi, '$1');
-      rep(/<img.*?src=\"(.*?)\".*?\/>/gi, '[img]$1[/img]');
-      rep(/<span class=\"codeStyle\">(.*?)<\/span>/gi, '[code]$1[/code]');
-      rep(/<span class=\"quoteStyle\">(.*?)<\/span>/gi, '[quote]$1[/quote]');
-      rep(/<strong class=\"codeStyle\">(.*?)<\/strong>/gi, '[code][b]$1[/b][/code]');
-      rep(/<strong class=\"quoteStyle\">(.*?)<\/strong>/gi, '[quote][b]$1[/b][/quote]');
-      rep(/<em class=\"codeStyle\">(.*?)<\/em>/gi, '[code][i]$1[/i][/code]');
-      rep(/<em class=\"quoteStyle\">(.*?)<\/em>/gi, '[quote][i]$1[/i][/quote]');
-      rep(/<u class=\"codeStyle\">(.*?)<\/u>/gi, '[code][u]$1[/u][/code]');
-      rep(/<u class=\"quoteStyle\">(.*?)<\/u>/gi, '[quote][u]$1[/u][/quote]');
-      rep(/<\/(strong|b)>/gi, '[/b]');
-      rep(/<(strong|b)>/gi, '[b]');
-      rep(/<\/(em|i)>/gi, '[/i]');
-      rep(/<(em|i)>/gi, '[i]');
-      rep(/<\/u>/gi, '[/u]');
-      rep(/<span style=\"text-decoration: ?underline;\">(.*?)<\/span>/gi, '[u]$1[/u]');
-      rep(/<u>/gi, '[u]');
-      rep(/<blockquote[^>]*>/gi, '[quote]');
-      rep(/<\/blockquote>/gi, '[/quote]');
-      rep(/<br \/>/gi, '\n');
-      rep(/<br\/>/gi, '\n');
-      rep(/<br>/gi, '\n');
-      rep(/<p>/gi, '');
-      rep(/<\/p>/gi, '\n');
-      rep(/&nbsp;|\u00a0/gi, ' ');
-      rep(/&quot;/gi, '"');
-      rep(/&lt;/gi, '<');
-      rep(/&gt;/gi, '>');
-      rep(/&amp;/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, '<br />');
-      rep(/\[b\]/gi, '<strong>');
-      rep(/\[\/b\]/gi, '</strong>');
-      rep(/\[i\]/gi, '<em>');
-      rep(/\[\/i\]/gi, '</em>');
-      rep(/\[u\]/gi, '<u>');
-      rep(/\[\/u\]/gi, '</u>');
-      rep(/\[url=([^\]]+)\](.*?)\[\/url\]/gi, '<a href="$1">$2</a>');
-      rep(/\[url\](.*?)\[\/url\]/gi, '<a href="$1">$1</a>');
-      rep(/\[img\](.*?)\[\/img\]/gi, '<img src="$1" />');
-      rep(/\[color=(.*?)\](.*?)\[\/color\]/gi, '<font color="$1">$2</font>');
-      rep(/\[code\](.*?)\[\/code\]/gi, '<span class="codeStyle">$1</span>&nbsp;');
-      rep(/\[quote.*?\](.*?)\[\/quote\]/gi, '<span class="quoteStyle">$1</span>&nbsp;');
-      return s;
-    };
-    var Convert = {
-      html2bbcode: html2bbcode,
-      bbcode2html: bbcode2html
-    };
-
-    global.add('bbcode', function () {
-      return {
-        init: function (editor) {
-          editor.on('BeforeSetContent', function (e) {
-            e.content = Convert.bbcode2html(e.content);
-          });
-          editor.on('PostProcess', function (e) {
-            if (e.set) {
-              e.content = Convert.bbcode2html(e.content);
-            }
-            if (e.get) {
-              e.content = Convert.html2bbcode(e.content);
-            }
-          });
-        }
-      };
-    });
-    function Plugin () {
-    }
-
-    return Plugin;
-
-}());
-})();

public/js/build/plugins/charmap/index.js

@@ -1,7 +0,0 @@
-// Exports the "charmap" plugin for usage with module loaders
-// Usage:
-//   CommonJS:
-//     require('tinymce/plugins/charmap')
-//   ES2015:
-//     import 'tinymce/plugins/charmap'
-require('./plugin.js');

public/js/build/plugins/code/index.js

@@ -1,7 +0,0 @@
-// Exports the "code" plugin for usage with module loaders
-// Usage:
-//   CommonJS:
-//     require('tinymce/plugins/code')
-//   ES2015:
-//     import 'tinymce/plugins/code'
-require('./plugin.js');

public/js/build/plugins/code/plugin.js

@@ -1,101 +0,0 @@
-/**
- * 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.0.7 (2019-06-05)
- */
-(function () {
-var code = (function () {
-    'use strict';
-
-    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    var setContent = function (editor, html) {
-      editor.focus();
-      editor.undoManager.transact(function () {
-        editor.setContent(html);
-      });
-      editor.selection.setCursorLocation();
-      editor.nodeChanged();
-    };
-    var getContent = function (editor) {
-      return editor.getContent({ source_view: true });
-    };
-    var Content = {
-      setContent: setContent,
-      getContent: getContent
-    };
-
-    var open = function (editor) {
-      var editorContent = Content.getContent(editor);
-      editor.windowManager.open({
-        title: 'Source Code',
-        size: 'large',
-        body: {
-          type: 'panel',
-          items: [{
-              type: 'textarea',
-              name: 'code'
-            }]
-        },
-        buttons: [
-          {
-            type: 'cancel',
-            name: 'cancel',
-            text: 'Cancel'
-          },
-          {
-            type: 'submit',
-            name: 'save',
-            text: 'Save',
-            primary: true
-          }
-        ],
-        initialData: { code: editorContent },
-        onSubmit: function (api) {
-          Content.setContent(editor, api.getData().code);
-          api.close();
-        }
-      });
-    };
-    var Dialog = { open: open };
-
-    var register = function (editor) {
-      editor.addCommand('mceCodeEditor', function () {
-        Dialog.open(editor);
-      });
-    };
-    var Commands = { register: register };
-
-    var register$1 = function (editor) {
-      editor.ui.registry.addButton('code', {
-        icon: 'sourcecode',
-        tooltip: 'Source code',
-        onAction: function () {
-          return Dialog.open(editor);
-        }
-      });
-      editor.ui.registry.addMenuItem('code', {
-        icon: 'sourcecode',
-        text: 'Source code',
-        onAction: function () {
-          return Dialog.open(editor);
-        }
-      });
-    };
-    var Buttons = { register: register$1 };
-
-    global.add('code', function (editor) {
-      Commands.register(editor);
-      Buttons.register(editor);
-      return {};
-    });
-    function Plugin () {
-    }
-
-    return Plugin;
-
-}());
-})();

public/js/build/plugins/codesample/css/prism.css

@@ -1,138 +0,0 @@
-/* http://prismjs.com/download.html?themes=prism&languages=markup+css+clike+javascript */
-/**
- * prism.js default theme for JavaScript, CSS and HTML
- * Based on dabblet (http://dabblet.com)
- * @author Lea Verou
- */
-
-code[class*="language-"],
-pre[class*="language-"] {
-  color: black;
-  text-shadow: 0 1px white;
-  font-family: Consolas, Monaco, 'Andale Mono', 'Ubuntu Mono', monospace;
-  direction: ltr;
-  text-align: left;
-  white-space: pre;
-  word-spacing: normal;
-  word-break: normal;
-  word-wrap: normal;
-  line-height: 1.5;
-
-  -moz-tab-size: 4;
-  -o-tab-size: 4;
-  tab-size: 4;
-
-  -webkit-hyphens: none;
-  -moz-hyphens: none;
-  -ms-hyphens: none;
-  hyphens: none;
-}
-
-pre[class*="language-"]::-moz-selection, pre[class*="language-"] ::-moz-selection,
-code[class*="language-"]::-moz-selection, code[class*="language-"] ::-moz-selection {
-  text-shadow: none;
-  background: #b3d4fc;
-}
-
-pre[class*="language-"]::selection, pre[class*="language-"] ::selection,
-code[class*="language-"]::selection, code[class*="language-"] ::selection {
-  text-shadow: none;
-  background: #b3d4fc;
-}
-
-@media print {
-  code[class*="language-"],
-  pre[class*="language-"] {
-    text-shadow: none;
-  }
-}
-
-/* Code blocks */
-pre[class*="language-"] {
-  padding: 1em;
-  margin: .5em 0;
-  overflow: auto;
-}
-
-:not(pre) > code[class*="language-"],
-pre[class*="language-"] {
-  background: #f5f2f0;
-}
-
-/* Inline code */
-:not(pre) > code[class*="language-"] {
-  padding: .1em;
-  border-radius: .3em;
-}
-
-.token.comment,
-.token.prolog,
-.token.doctype,
-.token.cdata {
-  color: slategray;
-}
-
-.token.punctuation {
-  color: #999;
-}
-
-.namespace {
-  opacity: .7;
-}
-
-.token.property,
-.token.tag,
-.token.boolean,
-.token.number,
-.token.constant,
-.token.symbol,
-.token.deleted {
-  color: #905;
-}
-
-.token.selector,
-.token.attr-name,
-.token.string,
-.token.char,
-.token.builtin,
-.token.inserted {
-  color: #690;
-}
-
-.token.operator,
-.token.entity,
-.token.url,
-.language-css .token.string,
-.style .token.string {
-  color: #a67f59;
-  background: hsla(0, 0%, 100%, .5);
-}
-
-.token.atrule,
-.token.attr-value,
-.token.keyword {
-  color: #07a;
-}
-
-.token.function {
-  color: #DD4A68;
-}
-
-.token.regex,
-.token.important,
-.token.variable {
-  color: #e90;
-}
-
-.token.important,
-.token.bold {
-  font-weight: bold;
-}
-.token.italic {
-  font-style: italic;
-}
-
-.token.entity {
-  cursor: help;
-}
-

public/js/build/plugins/codesample/index.js

@@ -1,7 +0,0 @@
-// Exports the "codesample" plugin for usage with module loaders
-// Usage:
-//   CommonJS:
-//     require('tinymce/plugins/codesample')
-//   ES2015:
-//     import 'tinymce/plugins/codesample'
-require('./plugin.js');

public/js/build/plugins/colorpicker/index.js

@@ -1,7 +0,0 @@
-// Exports the "colorpicker" plugin for usage with module loaders
-// Usage:
-//   CommonJS:
-//     require('tinymce/plugins/colorpicker')
-//   ES2015:
-//     import 'tinymce/plugins/colorpicker'
-require('./plugin.js');

public/js/build/plugins/colorpicker/plugin.js

@@ -1,24 +0,0 @@
-/**
- * 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.0.7 (2019-06-05)
- */
-(function () {
-var colorpicker = (function (domGlobals) {
-    'use strict';
-
-    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    global.add('colorpicker', function () {
-      domGlobals.console.warn('Color picker plugin is now built in to the core editor, please remove it from your editor configuration');
-    });
-    function Plugin () {
-    }
-
-    return Plugin;
-
-}(window));
-})();

public/js/build/plugins/colorpicker/plugin.min.js

@@ -1,9 +0,0 @@
-/**
- * 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.0.7 (2019-06-05)
- */
-!function(o){"use strict";tinymce.util.Tools.resolve("tinymce.PluginManager").add("colorpicker",function(){o.console.warn("Color picker plugin is now built in to the core editor, please remove it from your editor configuration")}),function i(){}}(window);

public/js/build/plugins/contextmenu/index.js

@@ -1,7 +0,0 @@
-// Exports the "contextmenu" plugin for usage with module loaders
-// Usage:
-//   CommonJS:
-//     require('tinymce/plugins/contextmenu')
-//   ES2015:
-//     import 'tinymce/plugins/contextmenu'
-require('./plugin.js');

public/js/build/plugins/contextmenu/plugin.js

@@ -1,24 +0,0 @@
-/**
- * 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.0.7 (2019-06-05)
- */
-(function () {
-var contextmenu = (function (domGlobals) {
-    'use strict';
-
-    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    global.add('contextmenu', function () {
-      domGlobals.console.warn('Context menu plugin is now built in to the core editor, please remove it from your editor configuration');
-    });
-    function Plugin () {
-    }
-
-    return Plugin;
-
-}(window));
-})();

public/js/build/plugins/contextmenu/plugin.min.js

@@ -1,9 +0,0 @@
-/**
- * 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.0.7 (2019-06-05)
- */
-!function(n){"use strict";tinymce.util.Tools.resolve("tinymce.PluginManager").add("contextmenu",function(){n.console.warn("Context menu plugin is now built in to the core editor, please remove it from your editor configuration")}),function o(){}}(window);

public/js/build/plugins/directionality/index.js

@@ -1,7 +0,0 @@
-// Exports the "directionality" plugin for usage with module loaders
-// Usage:
-//   CommonJS:
-//     require('tinymce/plugins/directionality')
-//   ES2015:
-//     import 'tinymce/plugins/directionality'
-require('./plugin.js');

public/js/build/plugins/directionality/plugin.js

@@ -1,488 +0,0 @@
-/**
- * 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.0.7 (2019-06-05)
- */
-(function () {
-var directionality = (function (domGlobals) {
-    'use strict';
-
-    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.util.Tools');
-
-    var setDir = function (editor, dir) {
-      var dom = editor.dom;
-      var curDir;
-      var blocks = editor.selection.getSelectedBlocks();
-      if (blocks.length) {
-        curDir = dom.getAttrib(blocks[0], 'dir');
-        global$1.each(blocks, function (block) {
-          if (!dom.getParent(block.parentNode, '*[dir="' + dir + '"]', dom.getRoot())) {
-            dom.setAttrib(block, 'dir', curDir !== dir ? dir : null);
-          }
-        });
-        editor.nodeChanged();
-      }
-    };
-    var Direction = { setDir: setDir };
-
-    var register = function (editor) {
-      editor.addCommand('mceDirectionLTR', function () {
-        Direction.setDir(editor, 'ltr');
-      });
-      editor.addCommand('mceDirectionRTL', function () {
-        Direction.setDir(editor, 'rtl');
-      });
-    };
-    var Commands = { register: register };
-
-    var constant = function (value) {
-      return function () {
-        return value;
-      };
-    };
-    var never = constant(false);
-    var always = constant(true);
-
-    var never$1 = never;
-    var always$1 = always;
-    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 noop = function () {
-      };
-      var nul = function () {
-        return null;
-      };
-      var undef = function () {
-        return undefined;
-      };
-      var me = {
-        fold: function (n, s) {
-          return n();
-        },
-        is: never$1,
-        isSome: never$1,
-        isNone: always$1,
-        getOr: id,
-        getOrThunk: call,
-        getOrDie: function (msg) {
-          throw new Error(msg || 'error: getOrDie called on none.');
-        },
-        getOrNull: nul,
-        getOrUndefined: undef,
-        or: id,
-        orThunk: call,
-        map: none,
-        ap: none,
-        each: noop,
-        bind: none,
-        flatten: none,
-        exists: never$1,
-        forall: always$1,
-        filter: none,
-        equals: eq,
-        equals_: eq,
-        toArray: function () {
-          return [];
-        },
-        toString: constant('none()')
-      };
-      if (Object.freeze)
-        Object.freeze(me);
-      return me;
-    }();
-    var some = function (a) {
-      var constant_a = function () {
-        return a;
-      };
-      var self = function () {
-        return me;
-      };
-      var map = function (f) {
-        return some(f(a));
-      };
-      var bind = function (f) {
-        return f(a);
-      };
-      var me = {
-        fold: function (n, s) {
-          return s(a);
-        },
-        is: function (v) {
-          return a === v;
-        },
-        isSome: always$1,
-        isNone: never$1,
-        getOr: constant_a,
-        getOrThunk: constant_a,
-        getOrDie: constant_a,
-        getOrNull: constant_a,
-        getOrUndefined: constant_a,
-        or: self,
-        orThunk: self,
-        map: map,
-        ap: function (optfab) {
-          return optfab.fold(none, function (fab) {
-            return some(fab(a));
-          });
-        },
-        each: function (f) {
-          f(a);
-        },
-        bind: bind,
-        flatten: constant_a,
-        exists: bind,
-        forall: bind,
-        filter: function (f) {
-          return f(a) ? me : NONE;
-        },
-        equals: function (o) {
-          return o.is(a);
-        },
-        equals_: function (o, elementEq) {
-          return o.fold(never$1, function (b) {
-            return elementEq(a, b);
-          });
-        },
-        toArray: function () {
-          return [a];
-        },
-        toString: function () {
-          return 'some(' + a + ')';
-        }
-      };
-      return me;
-    };
-    var from = function (value) {
-      return value === null || value === undefined ? NONE : some(value);
-    };
-    var Option = {
-      some: some,
-      none: none,
-      from: from
-    };
-
-    var fromHtml = function (html, scope) {
-      var doc = scope || domGlobals.document;
-      var div = doc.createElement('div');
-      div.innerHTML = html;
-      if (!div.hasChildNodes() || div.childNodes.length > 1) {
-        domGlobals.console.error('HTML does not have a single root node', html);
-        throw new Error('HTML must have a single root node');
-      }
-      return fromDom(div.childNodes[0]);
-    };
-    var fromTag = function (tag, scope) {
-      var doc = scope || domGlobals.document;
-      var node = doc.createElement(tag);
-      return fromDom(node);
-    };
-    var fromText = function (text, scope) {
-      var doc = scope || domGlobals.document;
-      var node = doc.createTextNode(text);
-      return fromDom(node);
-    };
-    var fromDom = function (node) {
-      if (node === null || node === undefined) {
-        throw new Error('Node cannot be null or undefined');
-      }
-      return { dom: constant(node) };
-    };
-    var fromPoint = function (docElm, x, y) {
-      var doc = docElm.dom();
-      return Option.from(doc.elementFromPoint(x, y)).map(fromDom);
-    };
-    var Element = {
-      fromHtml: fromHtml,
-      fromTag: fromTag,
-      fromText: fromText,
-      fromDom: fromDom,
-      fromPoint: fromPoint
-    };
-
-    var typeOf = function (x) {
-      if (x === null)
-        return 'null';
-      var t = typeof x;
-      if (t === 'object' && Array.prototype.isPrototypeOf(x))
-        return 'array';
-      if (t === 'object' && String.prototype.isPrototypeOf(x))
-        return 'string';
-      return t;
-    };
-    var isType = function (type) {
-      return function (value) {
-        return typeOf(value) === type;
-      };
-    };
-    var isString = isType('string');
-    var isBoolean = isType('boolean');
-    var isFunction = isType('function');
-    var isNumber = isType('number');
-
-    var slice = Array.prototype.slice;
-    var each = function (xs, f) {
-      for (var i = 0, len = xs.length; i < len; i++) {
-        var x = xs[i];
-        f(x, i, xs);
-      }
-    };
-    var from$1 = isFunction(Array.from) ? Array.from : function (x) {
-      return slice.call(x);
-    };
-
-    var keys = Object.keys;
-    var each$1 = function (obj, f) {
-      var props = keys(obj);
-      for (var k = 0, len = props.length; k < len; k++) {
-        var i = props[k];
-        var x = obj[i];
-        f(x, i, obj);
-      }
-    };
-
-    var trim = function (str) {
-      return str.replace(/^\s+|\s+$/g, '');
-    };
-
-    var isSupported = function (dom) {
-      return dom.style !== undefined;
-    };
-
-    var ATTRIBUTE = domGlobals.Node.ATTRIBUTE_NODE;
-    var CDATA_SECTION = domGlobals.Node.CDATA_SECTION_NODE;
-    var COMMENT = domGlobals.Node.COMMENT_NODE;
-    var DOCUMENT = domGlobals.Node.DOCUMENT_NODE;
-    var DOCUMENT_TYPE = domGlobals.Node.DOCUMENT_TYPE_NODE;
-    var DOCUMENT_FRAGMENT = domGlobals.Node.DOCUMENT_FRAGMENT_NODE;
-    var ELEMENT = domGlobals.Node.ELEMENT_NODE;
-    var TEXT = domGlobals.Node.TEXT_NODE;
-    var PROCESSING_INSTRUCTION = domGlobals.Node.PROCESSING_INSTRUCTION_NODE;
-    var ENTITY_REFERENCE = domGlobals.Node.ENTITY_REFERENCE_NODE;
-    var ENTITY = domGlobals.Node.ENTITY_NODE;
-    var NOTATION = domGlobals.Node.NOTATION_NODE;
-
-    var type = function (element) {
-      return element.dom().nodeType;
-    };
-    var isType$1 = function (t) {
-      return function (element) {
-        return type(element) === t;
-      };
-    };
-    var isElement = isType$1(ELEMENT);
-    var isText = isType$1(TEXT);
-
-    var inBody = function (element) {
-      var dom = isText(element) ? element.dom().parentNode : element.dom();
-      return dom !== undefined && dom !== null && dom.ownerDocument.body.contains(dom);
-    };
-
-    var rawSet = function (dom, key, value) {
-      if (isString(value) || isBoolean(value) || isNumber(value)) {
-        dom.setAttribute(key, value + '');
-      } else {
-        domGlobals.console.error('Invalid call to Attr.set. Key ', key, ':: Value ', value, ':: Element ', dom);
-        throw new Error('Attribute value was not simple');
-      }
-    };
-    var set = function (element, key, value) {
-      rawSet(element.dom(), key, value);
-    };
-    var get = function (element, key) {
-      var v = element.dom().getAttribute(key);
-      return v === null ? undefined : v;
-    };
-    var has = function (element, key) {
-      var dom = element.dom();
-      return dom && dom.hasAttribute ? dom.hasAttribute(key) : false;
-    };
-    var remove = function (element, key) {
-      element.dom().removeAttribute(key);
-    };
-
-    var internalSet = function (dom, property, value) {
-      if (!isString(value)) {
-        domGlobals.console.error('Invalid call to CSS.set. Property ', property, ':: Value ', value, ':: Element ', dom);
-        throw new Error('CSS value must be a string: ' + value);
-      }
-      if (isSupported(dom)) {
-        dom.style.setProperty(property, value);
-      }
-    };
-    var internalRemove = function (dom, property) {
-      if (isSupported(dom)) {
-        dom.style.removeProperty(property);
-      }
-    };
-    var set$1 = function (element, property, value) {
-      var dom = element.dom();
-      internalSet(dom, property, value);
-    };
-    var setAll = function (element, css) {
-      var dom = element.dom();
-      each$1(css, function (v, k) {
-        internalSet(dom, k, v);
-      });
-    };
-    var setOptions = function (element, css) {
-      var dom = element.dom();
-      each$1(css, function (v, k) {
-        v.fold(function () {
-          internalRemove(dom, k);
-        }, function (value) {
-          internalSet(dom, k, value);
-        });
-      });
-    };
-    var get$1 = function (element, property) {
-      var dom = element.dom();
-      var styles = domGlobals.window.getComputedStyle(dom);
-      var r = styles.getPropertyValue(property);
-      var v = r === '' && !inBody(element) ? getUnsafeProperty(dom, property) : r;
-      return v === null ? undefined : v;
-    };
-    var getUnsafeProperty = function (dom, property) {
-      return isSupported(dom) ? dom.style.getPropertyValue(property) : '';
-    };
-    var getRaw = function (element, property) {
-      var dom = element.dom();
-      var raw = getUnsafeProperty(dom, property);
-      return Option.from(raw).filter(function (r) {
-        return r.length > 0;
-      });
-    };
-    var getAllRaw = function (element) {
-      var css = {};
-      var dom = element.dom();
-      if (isSupported(dom)) {
-        for (var i = 0; i < dom.style.length; i++) {
-          var ruleName = dom.style.item(i);
-          css[ruleName] = dom.style[ruleName];
-        }
-      }
-      return css;
-    };
-    var isValidValue = function (tag, property, value) {
-      var element = Element.fromTag(tag);
-      set$1(element, property, value);
-      var style = getRaw(element, property);
-      return style.isSome();
-    };
-    var remove$1 = function (element, property) {
-      var dom = element.dom();
-      internalRemove(dom, property);
-      if (has(element, 'style') && trim(get(element, 'style')) === '') {
-        remove(element, 'style');
-      }
-    };
-    var preserve = function (element, f) {
-      var oldStyles = get(element, 'style');
-      var result = f(element);
-      var restore = oldStyles === undefined ? remove : set;
-      restore(element, 'style', oldStyles);
-      return result;
-    };
-    var copy = function (source, target) {
-      var sourceDom = source.dom();
-      var targetDom = target.dom();
-      if (isSupported(sourceDom) && isSupported(targetDom)) {
-        targetDom.style.cssText = sourceDom.style.cssText;
-      }
-    };
-    var reflow = function (e) {
-      return e.dom().offsetWidth;
-    };
-    var transferOne = function (source, destination, style) {
-      getRaw(source, style).each(function (value) {
-        if (getRaw(destination, style).isNone()) {
-          set$1(destination, style, value);
-        }
-      });
-    };
-    var transfer = function (source, destination, styles) {
-      if (!isElement(source) || !isElement(destination)) {
-        return;
-      }
-      each(styles, function (style) {
-        transferOne(source, destination, style);
-      });
-    };
-
-    var Css = /*#__PURE__*/Object.freeze({
-        copy: copy,
-        set: set$1,
-        preserve: preserve,
-        setAll: setAll,
-        setOptions: setOptions,
-        remove: remove$1,
-        get: get$1,
-        getRaw: getRaw,
-        getAllRaw: getAllRaw,
-        isValidValue: isValidValue,
-        reflow: reflow,
-        transfer: transfer
-    });
-
-    var getDirection = function (element) {
-      return get$1(element, 'direction') === 'rtl' ? 'rtl' : 'ltr';
-    };
-
-    var getNodeChangeHandler = function (editor, dir) {
-      return function (api) {
-        var nodeChangeHandler = function (e) {
-          var element = Element.fromDom(e.element);
-          api.setActive(getDirection(element) === dir);
-        };
-        editor.on('NodeChange', nodeChangeHandler);
-        return function () {
-          return editor.off('NodeChange', nodeChangeHandler);
-        };
-      };
-    };
-    var register$1 = function (editor) {
-      editor.ui.registry.addToggleButton('ltr', {
-        tooltip: 'Left to right',
-        icon: 'ltr',
-        onAction: function () {
-          return editor.execCommand('mceDirectionLTR');
-        },
-        onSetup: getNodeChangeHandler(editor, 'ltr')
-      });
-      editor.ui.registry.addToggleButton('rtl', {
-        tooltip: 'Right to left',
-        icon: 'rtl',
-        onAction: function () {
-          return editor.execCommand('mceDirectionRTL');
-        },
-        onSetup: getNodeChangeHandler(editor, 'rtl')
-      });
-    };
-    var Buttons = { register: register$1 };
-
-    global.add('directionality', function (editor) {
-      Commands.register(editor);
-      Buttons.register(editor);
-    });
-    function Plugin () {
-    }
-
-    return Plugin;
-
-}(window));
-})();

public/js/build/plugins/emoticons/index.js

@@ -1,7 +0,0 @@
-// Exports the "emoticons" plugin for usage with module loaders
-// Usage:
-//   CommonJS:
-//     require('tinymce/plugins/emoticons')
-//   ES2015:
-//     import 'tinymce/plugins/emoticons'
-require('./plugin.js');

public/js/build/plugins/emoticons/plugin.js

@@ -1,732 +0,0 @@
-/**
- * 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.0.7 (2019-06-05)
- */
-(function () {
-var emoticons = (function (domGlobals) {
-    'use strict';
-
-    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    var noop = function () {
-    };
-    var constant = function (value) {
-      return function () {
-        return value;
-      };
-    };
-    var identity = function (x) {
-      return x;
-    };
-    var die = function (msg) {
-      return function () {
-        throw new Error(msg);
-      };
-    };
-    var never = constant(false);
-    var always = constant(true);
-
-    var never$1 = never;
-    var always$1 = always;
-    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 noop = function () {
-      };
-      var nul = function () {
-        return null;
-      };
-      var undef = function () {
-        return undefined;
-      };
-      var me = {
-        fold: function (n, s) {
-          return n();
-        },
-        is: never$1,
-        isSome: never$1,
-        isNone: always$1,
-        getOr: id,
-        getOrThunk: call,
-        getOrDie: function (msg) {
-          throw new Error(msg || 'error: getOrDie called on none.');
-        },
-        getOrNull: nul,
-        getOrUndefined: undef,
-        or: id,
-        orThunk: call,
-        map: none,
-        ap: none,
-        each: noop,
-        bind: none,
-        flatten: none,
-        exists: never$1,
-        forall: always$1,
-        filter: none,
-        equals: eq,
-        equals_: eq,
-        toArray: function () {
-          return [];
-        },
-        toString: constant('none()')
-      };
-      if (Object.freeze)
-        Object.freeze(me);
-      return me;
-    }();
-    var some = function (a) {
-      var constant_a = function () {
-        return a;
-      };
-      var self = function () {
-        return me;
-      };
-      var map = function (f) {
-        return some(f(a));
-      };
-      var bind = function (f) {
-        return f(a);
-      };
-      var me = {
-        fold: function (n, s) {
-          return s(a);
-        },
-        is: function (v) {
-          return a === v;
-        },
-        isSome: always$1,
-        isNone: never$1,
-        getOr: constant_a,
-        getOrThunk: constant_a,
-        getOrDie: constant_a,
-        getOrNull: constant_a,
-        getOrUndefined: constant_a,
-        or: self,
-        orThunk: self,
-        map: map,
-        ap: function (optfab) {
-          return optfab.fold(none, function (fab) {
-            return some(fab(a));
-          });
-        },
-        each: function (f) {
-          f(a);
-        },
-        bind: bind,
-        flatten: constant_a,
-        exists: bind,
-        forall: bind,
-        filter: function (f) {
-          return f(a) ? me : NONE;
-        },
-        equals: function (o) {
-          return o.is(a);
-        },
-        equals_: function (o, elementEq) {
-          return o.fold(never$1, function (b) {
-            return elementEq(a, b);
-          });
-        },
-        toArray: function () {
-          return [a];
-        },
-        toString: function () {
-          return 'some(' + a + ')';
-        }
-      };
-      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) {
-      if (x === null)
-        return 'null';
-      var t = typeof x;
-      if (t === 'object' && Array.prototype.isPrototypeOf(x))
-        return 'array';
-      if (t === 'object' && String.prototype.isPrototypeOf(x))
-        return 'string';
-      return t;
-    };
-    var isType = function (type) {
-      return function (value) {
-        return typeOf(value) === type;
-      };
-    };
-    var isFunction = isType('function');
-
-    var slice = Array.prototype.slice;
-    var exists = function (xs, pred) {
-      return findIndex(xs, pred).isSome();
-    };
-    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, xs);
-      }
-      return r;
-    };
-    var findIndex = function (xs, pred) {
-      for (var i = 0, len = xs.length; i < len; i++) {
-        var x = xs[i];
-        if (pred(x, i, xs)) {
-          return Option.some(i);
-        }
-      }
-      return Option.none();
-    };
-    var from$1 = isFunction(Array.from) ? Array.from : function (x) {
-      return slice.call(x);
-    };
-
-    var contains = function (str, substr) {
-      return str.indexOf(substr) !== -1;
-    };
-
-    var emojiMatches = function (emoji, lowerCasePattern) {
-      return contains(emoji.title.toLowerCase(), lowerCasePattern) || exists(emoji.keywords, function (k) {
-        return contains(k.toLowerCase(), lowerCasePattern);
-      });
-    };
-    var emojisFrom = function (list, pattern, maxResults) {
-      var matches = [];
-      var lowerCasePattern = pattern.toLowerCase();
-      var reachedLimit = maxResults.fold(function () {
-        return never;
-      }, function (max) {
-        return function (size) {
-          return size >= max;
-        };
-      });
-      for (var i = 0; i < list.length; i++) {
-        if (pattern.length === 0 || emojiMatches(list[i], lowerCasePattern)) {
-          matches.push({
-            value: list[i].char,
-            text: list[i].title,
-            icon: list[i].char
-          });
-          if (reachedLimit(matches.length)) {
-            break;
-          }
-        }
-      }
-      return matches;
-    };
-
-    var init = function (editor, database) {
-      editor.ui.registry.addAutocompleter('emoticons', {
-        ch: ':',
-        columns: 'auto',
-        minChars: 2,
-        fetch: function (pattern, maxResults) {
-          return database.waitForLoad().then(function () {
-            var candidates = database.listAll();
-            return emojisFrom(candidates, pattern, Option.some(maxResults));
-          });
-        },
-        onAction: function (autocompleteApi, rng, value) {
-          editor.selection.setRng(rng);
-          editor.insertContent(value);
-          autocompleteApi.hide();
-        }
-      });
-    };
-
-    var Cell = function (initial) {
-      var value = initial;
-      var get = function () {
-        return value;
-      };
-      var set = function (v) {
-        value = v;
-      };
-      var clone = function () {
-        return Cell(get());
-      };
-      return {
-        get: get,
-        set: set,
-        clone: clone
-      };
-    };
-
-    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 insertEmoticon = function (editor, ch) {
-      editor.insertContent(ch);
-    };
-
-    var Global = typeof domGlobals.window !== 'undefined' ? domGlobals.window : Function('return this;')();
-
-    var keys = Object.keys;
-    var hasOwnProperty = Object.hasOwnProperty;
-    var each = function (obj, f) {
-      var props = keys(obj);
-      for (var k = 0, len = props.length; k < len; k++) {
-        var i = props[k];
-        var x = obj[i];
-        f(x, i, obj);
-      }
-    };
-    var map$1 = function (obj, f) {
-      return tupleMap(obj, function (x, i, obj) {
-        return {
-          k: i,
-          v: f(x, i, obj)
-        };
-      });
-    };
-    var tupleMap = function (obj, f) {
-      var r = {};
-      each(obj, function (x, i) {
-        var tuple = f(x, i, obj);
-        r[tuple.k] = tuple.v;
-      });
-      return r;
-    };
-    var has = function (obj, key) {
-      return hasOwnProperty.call(obj, key);
-    };
-
-    var value = function (o) {
-      var is = function (v) {
-        return o === v;
-      };
-      var or = function (opt) {
-        return value(o);
-      };
-      var orThunk = function (f) {
-        return value(o);
-      };
-      var map = function (f) {
-        return value(f(o));
-      };
-      var mapError = function (f) {
-        return value(o);
-      };
-      var each = function (f) {
-        f(o);
-      };
-      var bind = function (f) {
-        return f(o);
-      };
-      var fold = function (_, onValue) {
-        return onValue(o);
-      };
-      var exists = function (f) {
-        return f(o);
-      };
-      var forall = function (f) {
-        return f(o);
-      };
-      var toOption = function () {
-        return Option.some(o);
-      };
-      return {
-        is: is,
-        isValue: always,
-        isError: never,
-        getOr: constant(o),
-        getOrThunk: constant(o),
-        getOrDie: constant(o),
-        or: or,
-        orThunk: orThunk,
-        fold: fold,
-        map: map,
-        mapError: mapError,
-        each: each,
-        bind: bind,
-        exists: exists,
-        forall: forall,
-        toOption: toOption
-      };
-    };
-    var error = function (message) {
-      var getOrThunk = function (f) {
-        return f();
-      };
-      var getOrDie = function () {
-        return die(String(message))();
-      };
-      var or = function (opt) {
-        return opt;
-      };
-      var orThunk = function (f) {
-        return f();
-      };
-      var map = function (f) {
-        return error(message);
-      };
-      var mapError = function (f) {
-        return error(f(message));
-      };
-      var bind = function (f) {
-        return error(message);
-      };
-      var fold = function (onError, _) {
-        return onError(message);
-      };
-      return {
-        is: never,
-        isValue: never,
-        isError: always,
-        getOr: identity,
-        getOrThunk: getOrThunk,
-        getOrDie: getOrDie,
-        or: or,
-        orThunk: orThunk,
-        fold: fold,
-        map: map,
-        mapError: mapError,
-        each: noop,
-        bind: bind,
-        exists: never,
-        forall: always,
-        toOption: Option.none
-      };
-    };
-    var fromOption = function (opt, err) {
-      return opt.fold(function () {
-        return error(err);
-      }, value);
-    };
-    var Result = {
-      value: value,
-      error: error,
-      fromOption: fromOption
-    };
-
-    var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
-    var shallow = function (old, nu) {
-      return nu;
-    };
-    var baseMerge = function (merger) {
-      return function () {
-        var objects = new Array(arguments.length);
-        for (var i = 0; i < objects.length; i++)
-          objects[i] = arguments[i];
-        if (objects.length === 0)
-          throw new Error('Can\'t merge zero objects');
-        var ret = {};
-        for (var j = 0; j < objects.length; j++) {
-          var curObject = objects[j];
-          for (var key in curObject)
-            if (hasOwnProperty$1.call(curObject, key)) {
-              ret[key] = merger(ret[key], curObject[key]);
-            }
-        }
-        return ret;
-      };
-    };
-    var merge = baseMerge(shallow);
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.dom.ScriptLoader');
-
-    var global$2 = tinymce.util.Tools.resolve('tinymce.util.Promise');
-
-    var global$3 = tinymce.util.Tools.resolve('tinymce.util.Delay');
-
-    var getEmoticonDatabaseUrl = function (editor, pluginUrl) {
-      return editor.getParam('emoticons_database_url', pluginUrl + '/js/emojis' + editor.suffix + '.js');
-    };
-    var getAppendedEmoticons = function (editor) {
-      return editor.getParam('emoticons_append', {}, 'object');
-    };
-    var Settings = {
-      getEmoticonDatabaseUrl: getEmoticonDatabaseUrl,
-      getAppendedEmoticons: getAppendedEmoticons
-    };
-
-    var ALL_CATEGORY = 'All';
-    var categoryNameMap = {
-      symbols: 'Symbols',
-      people: 'People',
-      animals_and_nature: 'Animals and Nature',
-      food_and_drink: 'Food and Drink',
-      activity: 'Activity',
-      travel_and_places: 'Travel and Places',
-      objects: 'Objects',
-      flags: 'Flags',
-      user: 'User Defined'
-    };
-    var GLOBAL_NAME = 'emoticons_plugin_database';
-    var extractGlobal = function (url) {
-      if (Global.tinymce[GLOBAL_NAME]) {
-        var result = Result.value(Global.tinymce[GLOBAL_NAME]);
-        delete Global.tinymce[GLOBAL_NAME];
-        return result;
-      } else {
-        return Result.error('URL ' + url + ' did not contain the expected format for emoticons');
-      }
-    };
-    var translateCategory = function (categories, name) {
-      return has(categories, name) ? categories[name] : name;
-    };
-    var getUserDefinedEmoticons = function (editor) {
-      var userDefinedEmoticons = Settings.getAppendedEmoticons(editor);
-      return map$1(userDefinedEmoticons, function (value) {
-        return merge({
-          keywords: [],
-          category: 'user'
-        }, value);
-      });
-    };
-    var initDatabase = function (editor, databaseUrl) {
-      var categories = Cell(Option.none());
-      var all = Cell(Option.none());
-      var processEmojis = function (emojis) {
-        var cats = {};
-        var everything = [];
-        each(emojis, function (lib, title) {
-          var entry = {
-            title: title,
-            keywords: lib.keywords,
-            char: lib.char,
-            category: translateCategory(categoryNameMap, lib.category)
-          };
-          var current = cats[entry.category] !== undefined ? cats[entry.category] : [];
-          cats[entry.category] = current.concat([entry]);
-          everything.push(entry);
-        });
-        categories.set(Option.some(cats));
-        all.set(Option.some(everything));
-      };
-      editor.on('init', function () {
-        global$1.ScriptLoader.loadScript(databaseUrl, function () {
-          extractGlobal(databaseUrl).fold(function (err) {
-            domGlobals.console.log(err);
-            categories.set(Option.some({}));
-            all.set(Option.some([]));
-          }, function (emojis) {
-            var userEmojis = getUserDefinedEmoticons(editor);
-            processEmojis(merge(emojis, userEmojis));
-          });
-        }, function () {
-        });
-      });
-      var listCategory = function (category) {
-        if (category === ALL_CATEGORY) {
-          return listAll();
-        }
-        return categories.get().bind(function (cats) {
-          return Option.from(cats[category]);
-        }).getOr([]);
-      };
-      var listAll = function () {
-        return all.get().getOr([]);
-      };
-      var listCategories = function () {
-        return [ALL_CATEGORY].concat(keys(categories.get().getOr({})));
-      };
-      var waitForLoad = function () {
-        if (hasLoaded()) {
-          return global$2.resolve(true);
-        } else {
-          return new global$2(function (resolve, reject) {
-            var numRetries = 3;
-            var interval = global$3.setInterval(function () {
-              if (hasLoaded()) {
-                global$3.clearInterval(interval);
-                resolve(true);
-              } else {
-                numRetries--;
-                if (numRetries < 0) {
-                  domGlobals.console.log('Could not load emojis from url: ' + databaseUrl);
-                  global$3.clearInterval(interval);
-                  reject(false);
-                }
-              }
-            }, 500);
-          });
-        }
-      };
-      var hasLoaded = function () {
-        return categories.get().isSome() && all.get().isSome();
-      };
-      return {
-        listCategories: listCategories,
-        hasLoaded: hasLoaded,
-        waitForLoad: waitForLoad,
-        listAll: listAll,
-        listCategory: listCategory
-      };
-    };
-
-    var patternName = 'pattern';
-    var open = function (editor, database) {
-      var initialState = {
-        pattern: '',
-        results: emojisFrom(database.listAll(), '', Option.some(300))
-      };
-      var currentTab = Cell(ALL_CATEGORY);
-      var scan = function (dialogApi) {
-        var dialogData = dialogApi.getData();
-        var category = currentTab.get();
-        var candidates = database.listCategory(category);
-        var results = emojisFrom(candidates, dialogData[patternName], category === ALL_CATEGORY ? Option.some(300) : Option.none());
-        dialogApi.setData({ results: results });
-      };
-      var updateFilter = last(function (dialogApi) {
-        scan(dialogApi);
-      }, 200);
-      var searchField = {
-        label: 'Search',
-        type: 'input',
-        name: patternName
-      };
-      var resultsField = {
-        type: 'collection',
-        name: 'results'
-      };
-      var getInitialState = function () {
-        var body = {
-          type: 'tabpanel',
-          tabs: map(database.listCategories(), function (cat) {
-            return {
-              title: cat,
-              name: cat,
-              items: [
-                searchField,
-                resultsField
-              ]
-            };
-          })
-        };
-        return {
-          title: 'Emoticons',
-          size: 'normal',
-          body: body,
-          initialData: initialState,
-          onTabChange: function (dialogApi, details) {
-            currentTab.set(details.newTabName);
-            updateFilter.throttle(dialogApi);
-          },
-          onChange: updateFilter.throttle,
-          onAction: function (dialogApi, actionData) {
-            if (actionData.name === 'results') {
-              insertEmoticon(editor, actionData.value);
-              dialogApi.close();
-            }
-          },
-          buttons: [{
-              type: 'cancel',
-              text: 'Close',
-              primary: true
-            }]
-        };
-      };
-      var dialogApi = editor.windowManager.open(getInitialState());
-      dialogApi.focus(patternName);
-      if (!database.hasLoaded()) {
-        dialogApi.block('Loading emoticons...');
-        database.waitForLoad().then(function () {
-          dialogApi.redial(getInitialState());
-          updateFilter.throttle(dialogApi);
-          dialogApi.focus(patternName);
-          dialogApi.unblock();
-        }).catch(function (err) {
-          dialogApi.redial({
-            title: 'Emoticons',
-            body: {
-              type: 'panel',
-              items: [{
-                  type: 'alertbanner',
-                  level: 'error',
-                  icon: 'warning',
-                  text: '<p>Could not load emoticons</p>'
-                }]
-            },
-            buttons: [{
-                type: 'cancel',
-                text: 'Close',
-                primary: true
-              }],
-            initialData: {
-              pattern: '',
-              results: []
-            }
-          });
-          dialogApi.focus(patternName);
-          dialogApi.unblock();
-        });
-      }
-    };
-    var Dialog = { open: open };
-
-    var register = function (editor, database) {
-      var onAction = function () {
-        return Dialog.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
-      });
-    };
-    var Buttons = { register: register };
-
-    global.add('emoticons', function (editor, pluginUrl) {
-      var databaseUrl = Settings.getEmoticonDatabaseUrl(editor, pluginUrl);
-      var database = initDatabase(editor, databaseUrl);
-      Buttons.register(editor, database);
-      init(editor, database);
-    });
-    function Plugin () {
-    }
-
-    return Plugin;
-
-}(window));
-})();

public/js/build/plugins/fullpage/index.js

@@ -1,7 +0,0 @@
-// Exports the "fullpage" plugin for usage with module loaders
-// Usage:
-//   CommonJS:
-//     require('tinymce/plugins/fullpage')
-//   ES2015:
-//     import 'tinymce/plugins/fullpage'
-require('./plugin.js');

public/js/build/plugins/fullpage/plugin.js

@@ -1,581 +0,0 @@
-/**
- * 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.0.7 (2019-06-05)
- */
-(function () {
-var fullpage = (function (domGlobals) {
-    'use strict';
-
-    var Cell = function (initial) {
-      var value = initial;
-      var get = function () {
-        return value;
-      };
-      var set = function (v) {
-        value = v;
-      };
-      var clone = function () {
-        return Cell(get());
-      };
-      return {
-        get: get,
-        set: set,
-        clone: clone
-      };
-    };
-
-    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    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', '<!DOCTYPE html>');
-    };
-    var Settings = {
-      shouldHideInSourceView: shouldHideInSourceView,
-      getDefaultXmlPi: getDefaultXmlPi,
-      getDefaultEncoding: getDefaultEncoding,
-      getDefaultFontFamily: getDefaultFontFamily,
-      getDefaultFontSize: getDefaultFontSize,
-      getDefaultTextColor: getDefaultTextColor,
-      getDefaultTitle: getDefaultTitle,
-      getDefaultDocType: getDefaultDocType
-    };
-
-    var parseHeader = function (head) {
-      return global$2({
-        validate: false,
-        root_name: '#document'
-      }).parse(head);
-    };
-    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 = Settings.getDefaultFontFamily(editor);
-      data.fontsize = Settings.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 = '<!DOCTYPE' + elm.value + '>';
-      }
-      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('</body>'));
-    };
-    var Parser = {
-      parseHeader: parseHeader,
-      htmlToData: htmlToData,
-      dataToHtml: dataToHtml
-    };
-
-    var hasOwnProperty = Object.prototype.hasOwnProperty;
-    var shallow = function (old, nu) {
-      return nu;
-    };
-    var baseMerge = function (merger) {
-      return function () {
-        var objects = new Array(arguments.length);
-        for (var i = 0; i < objects.length; i++)
-          objects[i] = arguments[i];
-        if (objects.length === 0)
-          throw new Error('Can\'t merge zero objects');
-        var ret = {};
-        for (var j = 0; j < objects.length; j++) {
-          var curObject = objects[j];
-          for (var key in curObject)
-            if (hasOwnProperty.call(curObject, key)) {
-              ret[key] = merger(ret[key], curObject[key]);
-            }
-        }
-        return ret;
-      };
-    };
-    var merge = baseMerge(shallow);
-
-    var open = function (editor, headState) {
-      var data = Parser.htmlToData(editor, headState.get());
-      var defaultData = {
-        title: '',
-        keywords: '',
-        description: '',
-        robots: '',
-        author: '',
-        docencoding: ''
-      };
-      var initialData = merge(defaultData, data);
-      editor.windowManager.open({
-        title: 'Metadata and Document Properties',
-        size: 'normal',
-        body: {
-          type: 'panel',
-          items: [
-            {
-              name: 'title',
-              type: 'input',
-              label: 'Title'
-            },
-            {
-              name: 'keywords',
-              type: 'input',
-              label: 'Keywords'
-            },
-            {
-              name: 'description',
-              type: 'input',
-              label: 'Description'
-            },
-            {
-              name: 'robots',
-              type: 'input',
-              label: 'Robots'
-            },
-            {
-              name: 'author',
-              type: 'input',
-              label: 'Author'
-            },
-            {
-              name: 'docencoding',
-              type: 'input',
-              label: 'Encoding'
-            }
-          ]
-        },
-        buttons: [
-          {
-            type: 'cancel',
-            name: 'cancel',
-            text: 'Cancel'
-          },
-          {
-            type: 'submit',
-            name: 'save',
-            text: 'Save',
-            primary: true
-          }
-        ],
-        initialData: initialData,
-        onSubmit: function (api) {
-          var nuData = api.getData();
-          var headHtml = Parser.dataToHtml(editor, global$1.extend(data, nuData), headState.get());
-          headState.set(headHtml);
-          api.close();
-        }
-      });
-    };
-    var Dialog = { open: open };
-
-    var register = function (editor, headState) {
-      editor.addCommand('mceFullPageProperties', function () {
-        Dialog.open(editor, headState);
-      });
-    };
-    var Commands = { register: register };
-
-    var protectHtml = function (protect, html) {
-      global$1.each(protect, function (pattern) {
-        html = html.replace(pattern, function (str) {
-          return '<!--mce:protected ' + escape(str) + '-->';
-        });
-      });
-      return html;
-    };
-    var unprotectHtml = function (html) {
-      return html.replace(/<!--mce:protected ([\s\S]*?)-->/g, function (a, m) {
-        return unescape(m);
-      });
-    };
-    var Protect = {
-      protectHtml: protectHtml,
-      unprotectHtml: unprotectHtml
-    };
-
-    var each = global$1.each;
-    var low = function (s) {
-      return s.replace(/<\/?[A-Z]+/g, function (a) {
-        return a.toLowerCase();
-      });
-    };
-    var handleSetContent = function (editor, headState, footState, evt) {
-      var startPos, endPos, content, headerFragment, styles = '';
-      var dom = editor.dom;
-      if (evt.selection) {
-        return;
-      }
-      content = Protect.protectHtml(editor.settings.protect, evt.content);
-      if (evt.format === 'raw' && headState.get()) {
-        return;
-      }
-      if (evt.source_view && Settings.shouldHideInSourceView(editor)) {
-        return;
-      }
-      if (content.length === 0 && !evt.source_view) {
-        content = global$1.trim(headState.get()) + '\n' + global$1.trim(content) + '\n' + global$1.trim(footState.get());
-      }
-      content = content.replace(/<(\/?)BODY/gi, '<$1body');
-      startPos = content.indexOf('<body');
-      if (startPos !== -1) {
-        startPos = content.indexOf('>', startPos);
-        headState.set(low(content.substring(0, startPos + 1)));
-        endPos = content.indexOf('</body', startPos);
-        if (endPos === -1) {
-          endPos = content.length;
-        }
-        evt.content = global$1.trim(content.substring(startPos + 1, endPos));
-        footState.set(low(content.substring(endPos)));
-      } else {
-        headState.set(getDefaultHeader(editor));
-        footState.set('\n</body>\n</html>');
-      }
-      headerFragment = Parser.parseHeader(headState.get());
-      each(headerFragment.getAll('style'), function (node) {
-        if (node.firstChild) {
-          styles += node.firstChild.value;
-        }
-      });
-      var bodyElm = headerFragment.getAll('body')[0];
-      if (bodyElm) {
-        dom.setAttribs(editor.getBody(), {
-          style: bodyElm.attr('style') || '',
-          dir: bodyElm.attr('dir') || '',
-          vLink: bodyElm.attr('vlink') || '',
-          link: bodyElm.attr('link') || '',
-          aLink: bodyElm.attr('alink') || ''
-        });
-      }
-      dom.remove('fullpage_styles');
-      var headElm = editor.getDoc().getElementsByTagName('head')[0];
-      if (styles) {
-        var styleElm = dom.add(headElm, 'style', { id: 'fullpage_styles' });
-        styleElm.appendChild(domGlobals.document.createTextNode(styles));
-      }
-      var currentStyleSheetsMap = {};
-      global$1.each(headElm.getElementsByTagName('link'), function (stylesheet) {
-        if (stylesheet.rel === 'stylesheet' && stylesheet.getAttribute('data-mce-fullpage')) {
-          currentStyleSheetsMap[stylesheet.href] = stylesheet;
-        }
-      });
-      global$1.each(headerFragment.getAll('link'), function (stylesheet) {
-        var href = stylesheet.attr('href');
-        if (!href) {
-          return true;
-        }
-        if (!currentStyleSheetsMap[href] && stylesheet.attr('rel') === 'stylesheet') {
-          dom.add(headElm, 'link', {
-            'rel': 'stylesheet',
-            'text': 'text/css',
-            'href': href,
-            'data-mce-fullpage': '1'
-          });
-        }
-        delete currentStyleSheetsMap[href];
-      });
-      global$1.each(currentStyleSheetsMap, function (stylesheet) {
-        stylesheet.parentNode.removeChild(stylesheet);
-      });
-    };
-    var getDefaultHeader = function (editor) {
-      var header = '', value, styles = '';
-      if (Settings.getDefaultXmlPi(editor)) {
-        var piEncoding = Settings.getDefaultEncoding(editor);
-        header += '<?xml version="1.0" encoding="' + (piEncoding ? piEncoding : 'ISO-8859-1') + '" ?>\n';
-      }
-      header += Settings.getDefaultDocType(editor);
-      header += '\n<html>\n<head>\n';
-      if (value = Settings.getDefaultTitle(editor)) {
-        header += '<title>' + value + '</title>\n';
-      }
-      if (value = Settings.getDefaultEncoding(editor)) {
-        header += '<meta http-equiv="Content-Type" content="text/html; charset=' + value + '" />\n';
-      }
-      if (value = Settings.getDefaultFontFamily(editor)) {
-        styles += 'font-family: ' + value + ';';
-      }
-      if (value = Settings.getDefaultFontSize(editor)) {
-        styles += 'font-size: ' + value + ';';
-      }
-      if (value = Settings.getDefaultTextColor(editor)) {
-        styles += 'color: ' + value + ';';
-      }
-      header += '</head>\n<body' + (styles ? ' style="' + styles + '"' : '') + '>\n';
-      return header;
-    };
-    var handleGetContent = function (editor, head, foot, evt) {
-      if (!evt.selection && (!evt.source_view || !Settings.shouldHideInSourceView(editor))) {
-        evt.content = Protect.unprotectHtml(global$1.trim(head) + '\n' + global$1.trim(evt.content) + '\n' + global$1.trim(foot));
-      }
-    };
-    var setup = function (editor, headState, footState) {
-      editor.on('BeforeSetContent', function (evt) {
-        handleSetContent(editor, headState, footState, evt);
-      });
-      editor.on('GetContent', function (evt) {
-        handleGetContent(editor, headState.get(), footState.get(), evt);
-      });
-    };
-    var FilterContent = { setup: setup };
-
-    var register$1 = function (editor) {
-      editor.ui.registry.addButton('fullpage', {
-        tooltip: 'Metadata and document properties',
-        icon: 'document-properties',
-        onAction: function () {
-          editor.execCommand('mceFullPageProperties');
-        }
-      });
-      editor.ui.registry.addMenuItem('fullpage', {
-        text: 'Metadata and document properties',
-        icon: 'document-properties',
-        onAction: function () {
-          editor.execCommand('mceFullPageProperties');
-        }
-      });
-    };
-    var Buttons = { register: register$1 };
-
-    global.add('fullpage', function (editor) {
-      var headState = Cell(''), footState = Cell('');
-      Commands.register(editor, headState);
-      Buttons.register(editor);
-      FilterContent.setup(editor, headState, footState);
-    });
-    function Plugin () {
-    }
-
-    return Plugin;
-
-}(window));
-})();

public/js/build/plugins/fullscreen/index.js

@@ -1,7 +0,0 @@
-// Exports the "fullscreen" plugin for usage with module loaders
-// Usage:
-//   CommonJS:
-//     require('tinymce/plugins/fullscreen')
-//   ES2015:
-//     import 'tinymce/plugins/fullscreen'
-require('./plugin.js');

public/js/build/plugins/fullscreen/plugin.js

@@ -1,159 +0,0 @@
-/**
- * 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.0.7 (2019-06-05)
- */
-(function () {
-var fullscreen = (function (domGlobals) {
-    'use strict';
-
-    var Cell = function (initial) {
-      var value = initial;
-      var get = function () {
-        return value;
-      };
-      var set = function (v) {
-        value = v;
-      };
-      var clone = function () {
-        return Cell(get());
-      };
-      return {
-        get: get,
-        set: set,
-        clone: clone
-      };
-    };
-
-    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    var get = function (fullscreenState) {
-      return {
-        isFullscreen: function () {
-          return fullscreenState.get() !== null;
-        }
-      };
-    };
-    var Api = { get: get };
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');
-
-    var fireFullscreenStateChanged = function (editor, state) {
-      editor.fire('FullscreenStateChanged', { state: state });
-    };
-    var Events = { fireFullscreenStateChanged: fireFullscreenStateChanged };
-
-    var DOM = global$1.DOM;
-    var getScrollPos = function () {
-      var vp = DOM.getViewPort();
-      return {
-        x: vp.x,
-        y: vp.y
-      };
-    };
-    var setScrollPos = function (pos) {
-      domGlobals.window.scrollTo(pos.x, pos.y);
-    };
-    var toggleFullscreen = function (editor, fullscreenState) {
-      var body = domGlobals.document.body;
-      var documentElement = domGlobals.document.documentElement;
-      var editorContainerStyle;
-      var editorContainer, iframe, iframeStyle;
-      var fullscreenInfo = fullscreenState.get();
-      editorContainer = editor.getContainer();
-      editorContainerStyle = editorContainer.style;
-      iframe = editor.getContentAreaContainer().firstChild;
-      iframeStyle = iframe.style;
-      if (!fullscreenInfo) {
-        var newFullScreenInfo = {
-          scrollPos: getScrollPos(),
-          containerWidth: editorContainerStyle.width,
-          containerHeight: editorContainerStyle.height,
-          iframeWidth: iframeStyle.width,
-          iframeHeight: iframeStyle.height
-        };
-        iframeStyle.width = iframeStyle.height = '100%';
-        editorContainerStyle.width = editorContainerStyle.height = '';
-        DOM.addClass(body, 'tox-fullscreen');
-        DOM.addClass(documentElement, 'tox-fullscreen');
-        DOM.addClass(editorContainer, 'tox-fullscreen');
-        fullscreenState.set(newFullScreenInfo);
-        Events.fireFullscreenStateChanged(editor, true);
-      } else {
-        iframeStyle.width = fullscreenInfo.iframeWidth;
-        iframeStyle.height = fullscreenInfo.iframeHeight;
-        if (fullscreenInfo.containerWidth) {
-          editorContainerStyle.width = fullscreenInfo.containerWidth;
-        }
-        if (fullscreenInfo.containerHeight) {
-          editorContainerStyle.height = fullscreenInfo.containerHeight;
-        }
-        DOM.removeClass(body, 'tox-fullscreen');
-        DOM.removeClass(documentElement, 'tox-fullscreen');
-        DOM.removeClass(editorContainer, 'tox-fullscreen');
-        setScrollPos(fullscreenInfo.scrollPos);
-        fullscreenState.set(null);
-        Events.fireFullscreenStateChanged(editor, false);
-      }
-    };
-    var Actions = { toggleFullscreen: toggleFullscreen };
-
-    var register = function (editor, fullscreenState) {
-      editor.addCommand('mceFullScreen', function () {
-        Actions.toggleFullscreen(editor, fullscreenState);
-      });
-    };
-    var Commands = { register: register };
-
-    var makeSetupHandler = function (editor, fullscreenState) {
-      return function (api) {
-        api.setActive(fullscreenState.get() !== null);
-        var editorEventCallback = function (e) {
-          return api.setActive(e.state);
-        };
-        editor.on('FullscreenStateChanged', editorEventCallback);
-        return function () {
-          return editor.off('FullscreenStateChanged', editorEventCallback);
-        };
-      };
-    };
-    var register$1 = function (editor, fullscreenState) {
-      editor.ui.registry.addToggleMenuItem('fullscreen', {
-        text: 'Fullscreen',
-        shortcut: 'Meta+Shift+F',
-        onAction: function () {
-          return editor.execCommand('mceFullScreen');
-        },
-        onSetup: makeSetupHandler(editor, fullscreenState)
-      });
-      editor.ui.registry.addToggleButton('fullscreen', {
-        tooltip: 'Fullscreen',
-        icon: 'fullscreen',
-        onAction: function () {
-          return editor.execCommand('mceFullScreen');
-        },
-        onSetup: makeSetupHandler(editor, fullscreenState)
-      });
-    };
-    var Buttons = { register: register$1 };
-
-    global.add('fullscreen', function (editor) {
-      var fullscreenState = Cell(null);
-      if (editor.settings.inline) {
-        return Api.get(fullscreenState);
-      }
-      Commands.register(editor, fullscreenState);
-      Buttons.register(editor, fullscreenState);
-      editor.addShortcut('Meta+Shift+F', '', 'mceFullScreen');
-      return Api.get(fullscreenState);
-    });
-    function Plugin () {
-    }
-
-    return Plugin;
-
-}(window));
-})();

public/js/build/plugins/help/index.js

@@ -1,7 +0,0 @@
-// Exports the "help" plugin for usage with module loaders
-// Usage:
-//   CommonJS:
-//     require('tinymce/plugins/help')
-//   ES2015:
-//     import 'tinymce/plugins/help'
-require('./plugin.js');

public/js/build/plugins/help/plugin.js

@@ -1,914 +0,0 @@
-/**
- * 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.0.7 (2019-06-05)
- */
-(function () {
-var help = (function () {
-    'use strict';
-
-    var Cell = function (initial) {
-      var value = initial;
-      var get = function () {
-        return value;
-      };
-      var set = function (v) {
-        value = v;
-      };
-      var clone = function () {
-        return Cell(get());
-      };
-      return {
-        get: get,
-        set: set,
-        clone: clone
-      };
-    };
-
-    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    var get = function (customTabs) {
-      var addTab = function (spec) {
-        var currentCustomTabs = customTabs.get();
-        currentCustomTabs[spec.name] = spec;
-        customTabs.set(currentCustomTabs);
-      };
-      return { addTab: addTab };
-    };
-
-    var register = function (editor, dialogOpener) {
-      editor.addCommand('mceHelp', dialogOpener);
-    };
-    var Commands = { register: register };
-
-    var register$1 = function (editor, dialogOpener) {
-      editor.ui.registry.addButton('help', {
-        icon: 'help',
-        tooltip: 'Help',
-        onAction: dialogOpener
-      });
-      editor.ui.registry.addMenuItem('help', {
-        text: 'Help',
-        icon: 'help',
-        shortcut: 'Alt+0',
-        onAction: dialogOpener
-      });
-    };
-    var Buttons = { register: register$1 };
-
-    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 constant = function (value) {
-      return function () {
-        return value;
-      };
-    };
-    function curry(fn) {
-      var initialArgs = [];
-      for (var _i = 1; _i < arguments.length; _i++) {
-        initialArgs[_i - 1] = arguments[_i];
-      }
-      return function () {
-        var restArgs = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          restArgs[_i] = arguments[_i];
-        }
-        var all = initialArgs.concat(restArgs);
-        return fn.apply(null, all);
-      };
-    }
-    var not = function (f) {
-      return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          args[_i] = arguments[_i];
-        }
-        return !f.apply(null, args);
-      };
-    };
-    var never = constant(false);
-    var always = constant(true);
-
-    var never$1 = never;
-    var always$1 = always;
-    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 noop = function () {
-      };
-      var nul = function () {
-        return null;
-      };
-      var undef = function () {
-        return undefined;
-      };
-      var me = {
-        fold: function (n, s) {
-          return n();
-        },
-        is: never$1,
-        isSome: never$1,
-        isNone: always$1,
-        getOr: id,
-        getOrThunk: call,
-        getOrDie: function (msg) {
-          throw new Error(msg || 'error: getOrDie called on none.');
-        },
-        getOrNull: nul,
-        getOrUndefined: undef,
-        or: id,
-        orThunk: call,
-        map: none,
-        ap: none,
-        each: noop,
-        bind: none,
-        flatten: none,
-        exists: never$1,
-        forall: always$1,
-        filter: none,
-        equals: eq,
-        equals_: eq,
-        toArray: function () {
-          return [];
-        },
-        toString: constant('none()')
-      };
-      if (Object.freeze)
-        Object.freeze(me);
-      return me;
-    }();
-    var some = function (a) {
-      var constant_a = function () {
-        return a;
-      };
-      var self = function () {
-        return me;
-      };
-      var map = function (f) {
-        return some(f(a));
-      };
-      var bind = function (f) {
-        return f(a);
-      };
-      var me = {
-        fold: function (n, s) {
-          return s(a);
-        },
-        is: function (v) {
-          return a === v;
-        },
-        isSome: always$1,
-        isNone: never$1,
-        getOr: constant_a,
-        getOrThunk: constant_a,
-        getOrDie: constant_a,
-        getOrNull: constant_a,
-        getOrUndefined: constant_a,
-        or: self,
-        orThunk: self,
-        map: map,
-        ap: function (optfab) {
-          return optfab.fold(none, function (fab) {
-            return some(fab(a));
-          });
-        },
-        each: function (f) {
-          f(a);
-        },
-        bind: bind,
-        flatten: constant_a,
-        exists: bind,
-        forall: bind,
-        filter: function (f) {
-          return f(a) ? me : NONE;
-        },
-        equals: function (o) {
-          return o.is(a);
-        },
-        equals_: function (o, elementEq) {
-          return o.fold(never$1, function (b) {
-            return elementEq(a, b);
-          });
-        },
-        toArray: function () {
-          return [a];
-        },
-        toString: function () {
-          return 'some(' + a + ')';
-        }
-      };
-      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) {
-      if (x === null)
-        return 'null';
-      var t = typeof x;
-      if (t === 'object' && Array.prototype.isPrototypeOf(x))
-        return 'array';
-      if (t === 'object' && String.prototype.isPrototypeOf(x))
-        return 'string';
-      return t;
-    };
-    var isType = function (type) {
-      return function (value) {
-        return typeOf(value) === type;
-      };
-    };
-    var isFunction = isType('function');
-
-    var slice = Array.prototype.slice;
-    var rawIndexOf = function () {
-      var pIndexOf = Array.prototype.indexOf;
-      var fastIndex = function (xs, x) {
-        return pIndexOf.call(xs, x);
-      };
-      var slowIndex = function (xs, x) {
-        return slowIndexOf(xs, x);
-      };
-      return pIndexOf === undefined ? slowIndex : fastIndex;
-    }();
-    var indexOf = function (xs, x) {
-      var r = rawIndexOf(xs, x);
-      return r === -1 ? Option.none() : Option.some(r);
-    };
-    var contains = function (xs, x) {
-      return rawIndexOf(xs, x) > -1;
-    };
-    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, xs);
-      }
-      return r;
-    };
-    var filter = function (xs, pred) {
-      var r = [];
-      for (var i = 0, len = xs.length; i < len; i++) {
-        var x = xs[i];
-        if (pred(x, i, xs)) {
-          r.push(x);
-        }
-      }
-      return r;
-    };
-    var find = function (xs, pred) {
-      for (var i = 0, len = xs.length; i < len; i++) {
-        var x = xs[i];
-        if (pred(x, i, xs)) {
-          return Option.some(x);
-        }
-      }
-      return Option.none();
-    };
-    var slowIndexOf = function (xs, x) {
-      for (var i = 0, len = xs.length; i < len; ++i) {
-        if (xs[i] === x) {
-          return i;
-        }
-      }
-      return -1;
-    };
-    var from$1 = isFunction(Array.from) ? Array.from : function (x) {
-      return slice.call(x);
-    };
-
-    var keys = Object.keys;
-    var hasOwnProperty = Object.hasOwnProperty;
-    var get$1 = function (obj, key) {
-      return has(obj, key) ? Option.from(obj[key]) : Option.none();
-    };
-    var has = function (obj, key) {
-      return hasOwnProperty.call(obj, key);
-    };
-
-    var cat = function (arr) {
-      var r = [];
-      var push = function (x) {
-        r.push(x);
-      };
-      for (var i = 0; i < arr.length; i++) {
-        arr[i].each(push);
-      }
-      return r;
-    };
-
-    var getHelpTabs = function (editor) {
-      return Option.from(editor.getParam('help_tabs'));
-    };
-
-    var shortcuts = [
-      {
-        shortcuts: ['Meta + B'],
-        action: 'Bold'
-      },
-      {
-        shortcuts: ['Meta + I'],
-        action: 'Italic'
-      },
-      {
-        shortcuts: ['Meta + U'],
-        action: 'Underline'
-      },
-      {
-        shortcuts: ['Meta + A'],
-        action: 'Select all'
-      },
-      {
-        shortcuts: [
-          'Meta + Y',
-          'Meta + Shift + Z'
-        ],
-        action: 'Redo'
-      },
-      {
-        shortcuts: ['Meta + Z'],
-        action: 'Undo'
-      },
-      {
-        shortcuts: ['Access + 1'],
-        action: 'Header 1'
-      },
-      {
-        shortcuts: ['Access + 2'],
-        action: 'Header 2'
-      },
-      {
-        shortcuts: ['Access + 3'],
-        action: 'Header 3'
-      },
-      {
-        shortcuts: ['Access + 4'],
-        action: 'Header 4'
-      },
-      {
-        shortcuts: ['Access + 5'],
-        action: 'Header 5'
-      },
-      {
-        shortcuts: ['Access + 6'],
-        action: 'Header 6'
-      },
-      {
-        shortcuts: ['Access + 7'],
-        action: 'Paragraph'
-      },
-      {
-        shortcuts: ['Access + 8'],
-        action: 'Div'
-      },
-      {
-        shortcuts: ['Access + 9'],
-        action: 'Address'
-      },
-      {
-        shortcuts: ['Alt + 0'],
-        action: 'Open help dialog'
-      },
-      {
-        shortcuts: ['Alt + F9'],
-        action: 'Focus to menubar'
-      },
-      {
-        shortcuts: ['Alt + F10'],
-        action: 'Focus to toolbar'
-      },
-      {
-        shortcuts: ['Alt + F11'],
-        action: 'Focus to element path'
-      },
-      {
-        shortcuts: ['Ctrl + F9'],
-        action: 'Focus to contextual toolbar'
-      },
-      {
-        shortcuts: ['Shift + Enter'],
-        action: 'Open popup menu for split buttons'
-      },
-      {
-        shortcuts: ['Meta + K'],
-        action: 'Insert link (if link plugin activated)'
-      },
-      {
-        shortcuts: ['Meta + S'],
-        action: 'Save (if save plugin activated)'
-      },
-      {
-        shortcuts: ['Meta + F'],
-        action: 'Find (if searchreplace plugin activated)'
-      },
-      {
-        shortcuts: ['Meta + Shift + F'],
-        action: 'Switch to or from fullscreen mode'
-      }
-    ];
-    var KeyboardShortcuts = { shortcuts: shortcuts };
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.Env');
-
-    var convertText = function (source) {
-      var mac = {
-        alt: '&#x2325;',
-        ctrl: '&#x2303;',
-        shift: '&#x21E7;',
-        meta: '&#x2318;',
-        access: '&#x2303;&#x2325;'
-      };
-      var other = {
-        meta: 'Ctrl ',
-        access: 'Shift + Alt '
-      };
-      var replace = global$1.mac ? mac : other;
-      var shortcut = source.split('+');
-      var updated = map(shortcut, function (segment) {
-        var search = segment.toLowerCase().trim();
-        return has(replace, search) ? replace[search] : segment;
-      });
-      return global$1.mac ? updated.join('').replace(/\s/, '') : updated.join('+');
-    };
-    var ConvertShortcut = { convertText: convertText };
-
-    var tab = function () {
-      var shortcutList = map(KeyboardShortcuts.shortcuts, function (shortcut) {
-        var shortcutText = map(shortcut.shortcuts, ConvertShortcut.convertText).join(' or ');
-        return [
-          shortcut.action,
-          shortcutText
-        ];
-      });
-      var tablePanel = {
-        type: 'table',
-        header: [
-          'Action',
-          'Shortcut'
-        ],
-        cells: shortcutList
-      };
-      return {
-        name: 'shortcuts',
-        title: 'Handy Shortcuts',
-        items: [tablePanel]
-      };
-    };
-    var KeyboardShortcutsTab = { tab: tab };
-
-    var supplant = function (str, obj) {
-      var isStringOrNumber = function (a) {
-        var t = typeof a;
-        return t === 'string' || t === 'number';
-      };
-      return str.replace(/\$\{([^{}]*)\}/g, function (fullMatch, key) {
-        var value = obj[key];
-        return isStringOrNumber(value) ? value.toString() : fullMatch;
-      });
-    };
-
-    var global$2 = tinymce.util.Tools.resolve('tinymce.util.I18n');
-
-    var urls = [
-      {
-        key: 'advlist',
-        name: 'Advanced List'
-      },
-      {
-        key: 'anchor',
-        name: 'Anchor'
-      },
-      {
-        key: 'autolink',
-        name: 'Autolink'
-      },
-      {
-        key: 'autoresize',
-        name: 'Autoresize'
-      },
-      {
-        key: 'autosave',
-        name: 'Autosave'
-      },
-      {
-        key: 'bbcode',
-        name: 'BBCode'
-      },
-      {
-        key: 'charmap',
-        name: 'Character Map'
-      },
-      {
-        key: 'code',
-        name: 'Code'
-      },
-      {
-        key: 'codesample',
-        name: 'Code Sample'
-      },
-      {
-        key: 'colorpicker',
-        name: 'Color Picker'
-      },
-      {
-        key: 'directionality',
-        name: 'Directionality'
-      },
-      {
-        key: 'emoticons',
-        name: 'Emoticons'
-      },
-      {
-        key: 'fullpage',
-        name: 'Full Page'
-      },
-      {
-        key: 'fullscreen',
-        name: 'Full Screen'
-      },
-      {
-        key: 'help',
-        name: 'Help'
-      },
-      {
-        key: 'hr',
-        name: 'Horizontal Rule'
-      },
-      {
-        key: 'image',
-        name: 'Image'
-      },
-      {
-        key: 'imagetools',
-        name: 'Image Tools'
-      },
-      {
-        key: 'importcss',
-        name: 'Import CSS'
-      },
-      {
-        key: 'insertdatetime',
-        name: 'Insert Date/Time'
-      },
-      {
-        key: 'legacyoutput',
-        name: 'Legacy Output'
-      },
-      {
-        key: 'link',
-        name: 'Link'
-      },
-      {
-        key: 'lists',
-        name: 'Lists'
-      },
-      {
-        key: 'media',
-        name: 'Media'
-      },
-      {
-        key: 'nonbreaking',
-        name: 'Nonbreaking'
-      },
-      {
-        key: 'noneditable',
-        name: 'Noneditable'
-      },
-      {
-        key: 'pagebreak',
-        name: 'Page Break'
-      },
-      {
-        key: 'paste',
-        name: 'Paste'
-      },
-      {
-        key: 'preview',
-        name: 'Preview'
-      },
-      {
-        key: 'print',
-        name: 'Print'
-      },
-      {
-        key: 'save',
-        name: 'Save'
-      },
-      {
-        key: 'searchreplace',
-        name: 'Search and Replace'
-      },
-      {
-        key: 'spellchecker',
-        name: 'Spell Checker'
-      },
-      {
-        key: 'tabfocus',
-        name: 'Tab Focus'
-      },
-      {
-        key: 'table',
-        name: 'Table'
-      },
-      {
-        key: 'template',
-        name: 'Template'
-      },
-      {
-        key: 'textcolor',
-        name: 'Text Color'
-      },
-      {
-        key: 'textpattern',
-        name: 'Text Pattern'
-      },
-      {
-        key: 'toc',
-        name: 'Table of Contents'
-      },
-      {
-        key: 'visualblocks',
-        name: 'Visual Blocks'
-      },
-      {
-        key: 'visualchars',
-        name: 'Visual Characters'
-      },
-      {
-        key: 'wordcount',
-        name: 'Word Count'
-      },
-      {
-        key: 'advcode',
-        name: 'Advanced Code Editor*'
-      },
-      {
-        key: 'formatpainter',
-        name: 'Format Painter*'
-      },
-      {
-        key: 'powerpaste',
-        name: 'PowerPaste*'
-      },
-      {
-        key: 'tinydrive',
-        name: 'Tiny Drive*'
-      },
-      {
-        key: 'tinymcespellchecker',
-        name: 'Spell Checker Pro*'
-      },
-      {
-        key: 'a11ychecker',
-        name: 'Accessibility Checker*'
-      },
-      {
-        key: 'linkchecker',
-        name: 'Link Checker*'
-      },
-      {
-        key: 'mentions',
-        name: 'Mentions*'
-      },
-      {
-        key: 'mediaembed',
-        name: 'Enhanced Media Embed*'
-      },
-      {
-        key: 'checklist',
-        name: 'Checklist*'
-      },
-      {
-        key: 'casechange',
-        name: 'Case Change*'
-      },
-      {
-        key: 'permanentpen',
-        name: 'Permanent Pen*'
-      },
-      {
-        key: 'pageembed',
-        name: 'Page Embed*'
-      },
-      {
-        key: 'tinycomments',
-        name: 'Tiny Comments*'
-      }
-    ];
-    var PluginUrls = { urls: urls };
-
-    var tab$1 = function (editor) {
-      var availablePlugins = function () {
-        var premiumPlugins = [
-          'Accessibility Checker',
-          'Advanced Code Editor',
-          'Case Change',
-          'Checklist',
-          'Tiny Comments',
-          'Tiny Drive',
-          'Enhanced Media Embed',
-          'Format Painter',
-          'Link Checker',
-          'Mentions',
-          'MoxieManager',
-          'Page Embed',
-          'Permanent Pen',
-          'PowerPaste',
-          'Spell Checker Pro'
-        ];
-        var premiumPluginList = map(premiumPlugins, function (plugin) {
-          return '<li>' + global$2.translate(plugin) + '</li>';
-        }).join('');
-        return '<div data-mce-tabstop="1" tabindex="-1">' + '<p><b>' + global$2.translate('Premium plugins:') + '</b></p>' + '<ul>' + premiumPluginList + '<li style="list-style: none; margin-top: 1em;"><a href="https://www.tiny.cloud/pricing/?utm_campaign=editor_referral&utm_medium=help_dialog&utm_source=tinymce" target="_blank">' + global$2.translate('Learn more...') + '</a></li>' + '</ul>' + '</div>';
-      };
-      var makeLink = curry(supplant, '<a href="${url}" target="_blank" rel="noopener">${name}</a>');
-      var maybeUrlize = function (editor, key) {
-        return find(PluginUrls.urls, function (x) {
-          return x.key === key;
-        }).fold(function () {
-          var getMetadata = editor.plugins[key].getMetadata;
-          return typeof getMetadata === 'function' ? makeLink(getMetadata()) : key;
-        }, function (x) {
-          return makeLink({
-            name: x.name,
-            url: 'https://www.tiny.cloud/docs/plugins/' + x.key
-          });
-        });
-      };
-      var getPluginKeys = function (editor) {
-        var keys$1 = keys(editor.plugins);
-        return editor.settings.forced_plugins === undefined ? keys$1 : filter(keys$1, not(curry(contains, editor.settings.forced_plugins)));
-      };
-      var pluginLister = function (editor) {
-        var pluginKeys = getPluginKeys(editor);
-        var pluginLis = map(pluginKeys, function (key) {
-          return '<li>' + maybeUrlize(editor, key) + '</li>';
-        });
-        var count = pluginLis.length;
-        var pluginsString = pluginLis.join('');
-        var html = '<p><b>' + global$2.translate([
-          'Plugins installed ({0}):',
-          count
-        ]) + '</b></p>' + '<ul>' + pluginsString + '</ul>';
-        return html;
-      };
-      var installedPlugins = function (editor) {
-        if (editor == null) {
-          return '';
-        }
-        return '<div data-mce-tabstop="1" tabindex="-1">' + pluginLister(editor) + '</div>';
-      };
-      var htmlPanel = {
-        type: 'htmlpanel',
-        presets: 'document',
-        html: [
-          installedPlugins(editor),
-          availablePlugins()
-        ].join('')
-      };
-      return {
-        name: 'plugins',
-        title: 'Plugins',
-        items: [htmlPanel]
-      };
-    };
-    var PluginsTab = { tab: tab$1 };
-
-    var global$3 = tinymce.util.Tools.resolve('tinymce.EditorManager');
-
-    var tab$2 = function () {
-      var getVersion = function (major, minor) {
-        return major.indexOf('@') === 0 ? 'X.X.X' : major + '.' + minor;
-      };
-      var version = getVersion(global$3.majorVersion, global$3.minorVersion);
-      var changeLogLink = '<a href="https://www.tinymce.com/docs/changelog/?utm_campaign=editor_referral&utm_medium=help_dialog&utm_source=tinymce" target="_blank">TinyMCE ' + version + '</a>';
-      var htmlPanel = {
-        type: 'htmlpanel',
-        html: '<p>' + global$2.translate([
-          'You are using {0}',
-          changeLogLink
-        ]) + '</p>',
-        presets: 'document'
-      };
-      return {
-        name: 'versions',
-        title: 'Version',
-        items: [htmlPanel]
-      };
-    };
-    var VersionTab = { tab: tab$2 };
-
-    var parseHelpTabsSetting = function (tabsFromSettings, tabs) {
-      var newTabs = {};
-      var names = map(tabsFromSettings, function (t) {
-        if (typeof t === 'string') {
-          if (has(tabs, t)) {
-            newTabs[t] = tabs[t];
-          }
-          return t;
-        } else {
-          newTabs[t.name] = t;
-          return t.name;
-        }
-      });
-      return {
-        tabs: newTabs,
-        names: names
-      };
-    };
-    var getNamesFromTabs = function (tabs) {
-      var names = keys(tabs);
-      var versionsIdx = indexOf(names, 'versions');
-      versionsIdx.each(function (idx) {
-        names.splice(idx, 1);
-        names.push('versions');
-      });
-      return {
-        tabs: tabs,
-        names: names
-      };
-    };
-    var parseCustomTabs = function (editor, customTabs) {
-      var _a;
-      var shortcuts = KeyboardShortcutsTab.tab();
-      var plugins = PluginsTab.tab(editor);
-      var versions = VersionTab.tab();
-      var tabs = __assign((_a = {}, _a[shortcuts.name] = shortcuts, _a[plugins.name] = plugins, _a[versions.name] = versions, _a), customTabs.get());
-      return getHelpTabs(editor).fold(function () {
-        return getNamesFromTabs(tabs);
-      }, function (tabsFromSettings) {
-        return parseHelpTabsSetting(tabsFromSettings, tabs);
-      });
-    };
-    var init = function (editor, customTabs) {
-      return function () {
-        var _a = parseCustomTabs(editor, customTabs), tabs = _a.tabs, names = _a.names;
-        var foundTabs = map(names, function (name) {
-          return get$1(tabs, name);
-        });
-        var dialogTabs = cat(foundTabs);
-        var body = {
-          type: 'tabpanel',
-          tabs: dialogTabs
-        };
-        editor.windowManager.open({
-          title: 'Help',
-          size: 'medium',
-          body: body,
-          buttons: [{
-              type: 'cancel',
-              name: 'close',
-              text: 'Close',
-              primary: true
-            }],
-          initialData: {}
-        });
-      };
-    };
-
-    global.add('help', function (editor) {
-      var customTabs = Cell({});
-      var api = get(customTabs);
-      var dialogOpener = init(editor, customTabs);
-      Buttons.register(editor, dialogOpener);
-      Commands.register(editor, dialogOpener);
-      editor.shortcuts.add('Alt+0', 'Open help dialog', 'mceHelp');
-      return api;
-    });
-    function Plugin () {
-    }
-
-    return Plugin;
-
-}());
-})();