~

package.json

@@ -20,7 +20,6 @@
     "@element-plus/icons-vue": "^2.1.0",
     "@vueuse/components": "^9.13.0",
     "@vueuse/core": "^9.13.0",
-    "agora-rtc-sdk-ng": "^4.17.2",
     "axios": "^1.3.6",
     "element-plus": "^2.3.4",
     "tinymce": "^6.4.2",

pnpm-lock.yaml

@@ -1,5 +1,9 @@
 lockfileVersion: '6.0'
 
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
 dependencies:
   '@element-plus/icons-vue':
     specifier: ^2.1.0
@@ -10,9 +14,6 @@ dependencies:
   '@vueuse/core':
     specifier: ^9.13.0
     version: 9.13.0(vue@3.2.47)
-  agora-rtc-sdk-ng:
-    specifier: ^4.17.2
-    version: 4.17.2
   axios:
     specifier: ^1.3.6
     version: 1.3.6
@@ -961,16 +962,6 @@ packages:
     hasBin: true
     dev: true
 
-  /agora-rtc-sdk-ng@4.17.2:
-    resolution: {integrity: sha512-ErIHOYgf3R/ya3gVCCBKRw3RMdATmoM/8aUGOob4g0VHBBkVDEf9JT0RW2jQgtwm61jszWof+wo2duQDBgTfpw==}
-    dependencies:
-      agora-rte-extension: 1.2.3
-    dev: false
-
-  /agora-rte-extension@1.2.3:
-    resolution: {integrity: sha512-k3yNrYVyzJRoQJjaJUktKUI1XRtf8J1XsW8OzYKFqGlS8WQRMsES1+Phj2rfuEriiLObfuyuCimG6KHQCt5tiw==}
-    dev: false
-
   /ajv@6.12.6:
     resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==}
     dependencies:

public/tiny/icons/default/index.js

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

public/tiny/langs/zh-Hans.preview.json

@@ -1,406 +0,0 @@
-{
-  "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",
-  "Remove": "\u79fb\u9664",
-  "Align left": "\u5de6\u8fb9\u5bf9\u9f50",
-  "Align center": "\u4e2d\u95f4\u5bf9\u9f50",
-  "Align right": "\u53f3\u8fb9\u5bf9\u9f50",
-  "No alignment": "\u672a\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",
-  "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": "\u5206\u533a",
-  "Pre": "\u524d\u671f",
-  "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\u4f53\u5927\u5c0f",
-  "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",
-  "Uploading image": "\u4e0a\u4f20\u56fe\u7247",
-  "Block": "\u5757",
-  "Align": "\u5bf9\u9f50",
-  "Default": "\u9884\u8bbe",
-  "Circle": "\u7a7a\u5fc3\u5706",
-  "Disc": "\u5b9e\u5fc3\u5706",
-  "Square": "\u5b9e\u5fc3\u65b9\u5757",
-  "Lower Alpha": "\u5c0f\u5199\u82f1\u6587\u5b57\u6bcd",
-  "Lower Greek": "\u5c0f\u5199\u5e0c\u814a\u5b57\u6bcd",
-  "Lower Roman": "\u5c0f\u5199\u7f57\u9a6c\u6570\u5b57",
-  "Upper Alpha": "\u5927\u5199\u82f1\u6587\u5b57\u6bcd",
-  "Upper Roman": "\u5927\u5199\u7f57\u9a6c\u6570\u5b57",
-  "Anchor...": "\u951a\u70b9...",
-  "Anchor": "\u951a\u70b9",
-  "Name": "\u540d\u79f0",
-  "ID": "ID",
-  "ID should start with a letter, followed only by letters, numbers, dashes, dots, colons or underscores.": "ID\u5e94\u8be5\u4ee5\u82f1\u6587\u5b57\u6bcd\u5f00\u5934\uff0c\u540e\u9762\u53ea\u80fd\u6709\u82f1\u6587\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 character...": "\u7279\u6b8a\u5b57\u7b26...",
-  "Special Character": "\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...",
-  "Left to right": "\u7531\u5de6\u5230\u53f3",
-  "Right to left": "\u7531\u53f3\u5230\u5de6",
-  "Title": "\u6807\u9898",
-  "Fullscreen": "\u5168\u5c4f\u5e55",
-  "Action": "\u52a8\u4f5c",
-  "Shortcut": "\u5feb\u6377\u65b9\u5f0f",
-  "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": "\u5168\u90e8\u5916\u6302\u7a0b\u5e8f",
-  "Handy Shortcuts": "\u5feb\u6377\u952e",
-  "Horizontal line": "\u6c34\u5e73\u5206\u5272\u7ebf",
-  "Insert/edit image": "\u63d2\u5165/\u7f16\u8f91\u56fe\u7247",
-  "Alternative description": "\u66ff\u4ee3\u63cf\u8ff0",
-  "Accessibility": "\u8f85\u52a9\u529f\u80fd",
-  "Image is decorative": "\u56fe\u50cf\u662f\u88c5\u9970\u6027\u7684",
-  "Source": "\u539f\u59cb\u7801",
-  "Dimensions": "\u5c3a\u5bf8",
-  "Constrain proportions": "\u4fdd\u6301\u6bd4\u4f8b",
-  "General": "\u4e00\u822c",
-  "Advanced": "\u9ad8\u7ea7",
-  "Style": "\u6837\u5f0f",
-  "Vertical space": "\u5782\u76f4\u95f4\u8ddd",
-  "Horizontal space": "\u6c34\u5e73\u95f4\u8ddd",
-  "Border": "\u6846\u7ebf",
-  "Insert image": "\u63d2\u5165\u56fe\u7247",
-  "Image...": "\u56fe\u7247...",
-  "Image list": "\u56fe\u7247\u6e05\u5355",
-  "Resize": "\u8c03\u6574\u5927\u5c0f",
-  "Insert date/time": "\u63d2\u5165\u65e5\u671f/\u65f6\u95f4",
-  "Date/time": "\u65e5\u671f/\u65f6\u95f4",
-  "Insert/edit link": "\u63d2\u5165/\u7f16\u8f91\u94fe\u63a5",
-  "Text to display": "\u8981\u663e\u793a\u7684\u6587\u672c",
-  "Url": "\u5730\u5740",
-  "Open link in...": "\u94fe\u63a5\u6253\u5f00\u4f4d\u7f6e...",
-  "Current window": "\u5f53\u524d\u7a97\u53e3",
-  "None": "\u65e0",
-  "New window": "\u65b0\u7a97\u53e3",
-  "Open link": "\u6253\u5f00\u94fe\u63a5",
-  "Remove link": "\u79fb\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",
-  "The URL you entered seems to be an external link. Do you want to add the required https:// prefix?": "\u60a8\u8f93\u5165\u7684 URL \u4f3c\u4e4e\u662f\u4e00\u4e2a\u5916\u90e8\u94fe\u63a5\u3002\u60a8\u60f3\u6dfb\u52a0\u6240\u9700\u7684 https:// \u524d\u7f00\u5417\uff1f",
-  "Link list": "\u94fe\u63a5\u6e05\u5355",
-  "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",
-  "Print...": "\u6253\u5370...",
-  "Save": "\u4fdd\u5b58",
-  "Find": "\u5bfb\u627e",
-  "Replace with": "\u66ff\u6362\u4e3a",
-  "Replace": "\u66ff\u6362",
-  "Replace all": "\u66ff\u6362\u5168\u90e8",
-  "Previous": "\u4e0a\u4e00\u4e2a",
-  "Next": "\u4e0b\u4e00\u4e2a",
-  "Find and Replace": "\u67e5\u627e\u548c\u66ff\u6362",
-  "Find and replace...": "\u67e5\u627e\u5e76\u66ff\u6362...",
-  "Could not find the specified string.": "\u672a\u627e\u5230\u641c\u7d22\u5185\u5bb9\u3002",
-  "Match case": "\u5927\u5c0f\u5199\u5339\u914d",
-  "Find whole words only": "\u5168\u5b57\u5339\u914d",
-  "Find in selection": "\u5728\u9009\u533a\u4e2d\u67e5\u627e",
-  "Insert table": "\u63d2\u5165\u8868\u683c",
-  "Table properties": "\u8868\u683c\u5c5e\u6027",
-  "Delete table": "\u5220\u9664\u8868\u683c",
-  "Cell": "\u50a8\u5b58\u683c",
-  "Row": "\u884c",
-  "Column": "\u680f\u76ee",
-  "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\u884c",
-  "Insert row after": "\u5728\u4e0b\u65b9\u63d2\u5165\u884c",
-  "Delete row": "\u5220\u9664\u884c",
-  "Row properties": "\u884c\u5c5e\u6027",
-  "Cut row": "\u526a\u5207\u884c",
-  "Cut column": "\u526a\u5207\u5217",
-  "Copy row": "\u590d\u5236\u884c",
-  "Copy column": "\u590d\u5236\u5217",
-  "Paste row before": "\u7c98\u8d34\u884c\u5230\u4e0a\u65b9",
-  "Paste column before": "\u7c98\u8d34\u6b64\u5217\u524d",
-  "Paste row after": "\u7c98\u8d34\u884c\u5230\u4e0b\u65b9",
-  "Paste column after": "\u7c98\u8d34\u540e\u9762\u7684\u5217",
-  "Insert column before": "\u5728\u5de6\u4fa7\u63d2\u5165\u5217",
-  "Insert column after": "\u5728\u53f3\u4fa7\u63d2\u5165\u5217",
-  "Delete column": "\u5220\u9664\u5217",
-  "Cols": "\u5217",
-  "Rows": "\u884c\u6570",
-  "Width": "\u5bbd\u5ea6",
-  "Height": "\u9ad8\u5ea6",
-  "Cell spacing": "\u5355\u5143\u683c\u5916\u95f4\u8ddd",
-  "Cell padding": "\u5355\u5143\u683c\u5185\u8fb9\u8ddd",
-  "Row clipboard actions": "\u884c\u526a\u8d34\u677f\u64cd\u4f5c",
-  "Column clipboard actions": "\u5217\u526a\u8d34\u677f\u64cd\u4f5c",
-  "Table styles": "\u8868\u683c\u6837\u5f0f",
-  "Cell styles": "\u5355\u5143\u683c\u6837\u5f0f",
-  "Column header": "\u5217\u6807\u9898",
-  "Row header": "\u884c\u5934",
-  "Table caption": "\u8868\u683c\u6807\u9898",
-  "Caption": "\u6807\u9898",
-  "Show caption": "\u663e\u793a\u6807\u9898",
-  "Left": "\u5de6",
-  "Center": "\u5c45\u4e2d",
-  "Right": "\u53f3",
-  "Cell type": "\u50a8\u5b58\u683c\u522b",
-  "Scope": "\u8303\u56f4",
-  "Alignment": "\u5bf9\u9f50",
-  "Horizontal align": "\u6c34\u5e73\u5bf9\u9f50",
-  "Vertical align": "\u5782\u76f4\u5bf9\u9f50",
-  "Top": "\u4e0a\u65b9\u5bf9\u9f50",
-  "Middle": "\u5c45\u4e2d\u5bf9\u9f50",
-  "Bottom": "\u4e0b\u65b9\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": "\u6846\u7ebf\u989c\u8272",
-  "Solid": "\u5b9e\u7ebf",
-  "Dotted": "\u865a\u7ebf",
-  "Dashed": "\u865a\u7ebf",
-  "Double": "\u53cc\u7cbe\u5ea6",
-  "Groove": "\u51f9\u69fd",
-  "Ridge": "\u6d77\u810a\u5ea7",
-  "Inset": "\u5d4c\u5165",
-  "Outset": "\u5916\u7f6e",
-  "Hidden": "\u9690\u85cf",
-  "Insert template...": "\u63d2\u5165\u6a21\u677f...",
-  "Templates": "\u6a21\u677f",
-  "Template": "\u6a21\u677f",
-  "Insert Template": "\u63d2\u5165\u6a21\u677f",
-  "Text color": "\u6587\u672c\u989c\u8272",
-  "Background color": "\u80cc\u666f\u989c\u8272",
-  "Custom...": "\u81ea\u5b9a\u4e49......",
-  "Custom color": "\u81ea\u5b9a\u4e49\u989c\u8272",
-  "No color": "\u65e0",
-  "Remove color": "\u79fb\u9664\u989c\u8272",
-  "Show blocks": "\u663e\u793a\u533a\u5757\u8fb9\u6846",
-  "Show invisible characters": "\u663e\u793a\u4e0d\u53ef\u89c1\u5b57\u7b26",
-  "Word count": "\u5b57\u6570",
-  "Count": "\u8ba1\u6570",
-  "Document": "\u6587\u6863",
-  "Selection": "\u9009\u62e9",
-  "Words": "\u5355\u8bcd",
-  "Words: {0}": "\u5b57\u6570\uff1a{0}",
-  "{0} words": "{0} \u5b57",
-  "File": "\u6587\u4ef6",
-  "Edit": "\u7f16\u8f91",
-  "Insert": "\u63d2\u5165",
-  "View": "\u67e5\u770b",
-  "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": "\u7f16\u8f91\u533a\u3002\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": "\u5bcc\u6587\u672c\u533a\u57df",
-  "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",
-  "Emojis": "Emojis",
-  "Emojis...": "Emojis...",
-  "Loading emojis...": "\u6b63\u5728\u52a0\u8f7dEmojis...",
-  "Could not load emojis": "\u65e0\u6cd5\u52a0\u8f7dEmojis",
-  "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)",
-  "{0} characters": "{0} \u4e2a\u5b57\u7b26",
-  "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",
-  "Color swatch": "\u989c\u8272\u6837\u672c",
-  "Color Picker": "\u9009\u8272\u5668",
-  "Invalid hex color code: {0}": "\u5341\u516d\u8fdb\u5236\u989c\u8272\u4ee3\u7801\u65e0\u6548\uff1a {0}",
-  "Invalid input": "\u65e0\u6548\u8f93\u5165",
-  "R": "R",
-  "Red component": "\u7ea2\u8272\u90e8\u5206",
-  "G": "G",
-  "Green component": "\u7eff\u8272\u90e8\u5206",
-  "B": "B",
-  "Blue component": "\u767d\u8272\u90e8\u5206",
-  "#": "#",
-  "Hex color code": "\u5341\u516d\u8fdb\u5236\u989c\u8272\u4ee3\u7801",
-  "Range 0 to 255": "\u8303\u56f40\u81f3255",
-  "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",
-  "Light Green": "\u6d45\u7eff\u8272",
-  "Light Yellow": "\u6d45\u9ec4\u8272",
-  "Light Red": "\u6d45\u7ea2\u8272",
-  "Light Purple": "\u6d45\u7d2b\u8272",
-  "Light Blue": "\u6d45\u84dd\u8272",
-  "Dark Purple": "\u6df1\u7d2b\u8272",
-  "Dark Blue": "\u6df1\u84dd\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",
-  "Font": "\u5b57\u4f53",
-  "Size": "\u5b57\u53f7",
-  "More...": "\u66f4\u591a...",
-  "Select...": "\u9009\u62e9...",
-  "Preferences": "\u9996\u9009\u9879",
-  "Yes": "\u662f",
-  "No": "\u5426",
-  "Keyboard Navigation": "\u952e\u76d8\u6307\u5f15",
-  "Version": "\u7248\u672c",
-  "Code view": "\u4ee3\u7801\u89c6\u56fe",
-  "Open popup menu for split buttons": "\u6253\u5f00\u5f39\u51fa\u5f0f\u83dc\u5355\uff0c\u7528\u4e8e\u62c6\u5206\u6309\u94ae",
-  "List Properties": "\u5217\u8868\u5c5e\u6027",
-  "List properties...": "\u6807\u9898\u5b57\u4f53\u5c5e\u6027",
-  "Start list at number": "\u4ee5\u6570\u5b57\u5f00\u59cb\u5217\u8868",
-  "Line height": "\u884c\u9ad8",
-  "Dropped file type is not supported": "",
-  "Loading...": "",
-  "ImageProxy HTTP error: Rejected request": "",
-  "ImageProxy HTTP error: Could not find Image Proxy": "",
-  "ImageProxy HTTP error: Incorrect Image Proxy URL": "",
-  "ImageProxy HTTP error: Unknown ImageProxy error": ""
-}

public/tiny/models/dom/index.js

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

public/tiny/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/tiny/plugins/advlist/plugin.js

@@ -1,246 +0,0 @@
-/**
- * TinyMCE version 6.0.3 (2022-05-25)
- */
-
-(function () {
-    'use strict';
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    const applyListFormat = (editor, listName, styleValue) => {
-      const cmd = listName === 'UL' ? 'InsertUnorderedList' : 'InsertOrderedList';
-      editor.execCommand(cmd, false, styleValue === false ? null : { 'list-style-type': styleValue });
-    };
-
-    const register$2 = editor => {
-      editor.addCommand('ApplyUnorderedListStyle', (ui, value) => {
-        applyListFormat(editor, 'UL', value['list-style-type']);
-      });
-      editor.addCommand('ApplyOrderedListStyle', (ui, value) => {
-        applyListFormat(editor, 'OL', value['list-style-type']);
-      });
-    };
-
-    const option = name => editor => editor.options.get(name);
-    const register$1 = editor => {
-      const registerOption = editor.options.register;
-      registerOption('advlist_number_styles', {
-        processor: 'string[]',
-        default: 'default,lower-alpha,lower-greek,lower-roman,upper-alpha,upper-roman'.split(',')
-      });
-      registerOption('advlist_bullet_styles', {
-        processor: 'string[]',
-        default: 'default,circle,square'.split(',')
-      });
-    };
-    const getNumberStyles = option('advlist_number_styles');
-    const getBulletStyles = option('advlist_bullet_styles');
-
-    var global = tinymce.util.Tools.resolve('tinymce.util.Tools');
-
-    const isNullable = a => a === null || a === undefined;
-    const isNonNullable = a => !isNullable(a);
-
-    class Optional {
-      constructor(tag, value) {
-        this.tag = tag;
-        this.value = value;
-      }
-      static some(value) {
-        return new Optional(true, value);
-      }
-      static none() {
-        return Optional.singletonNone;
-      }
-      fold(onNone, onSome) {
-        if (this.tag) {
-          return onSome(this.value);
-        } else {
-          return onNone();
-        }
-      }
-      isSome() {
-        return this.tag;
-      }
-      isNone() {
-        return !this.tag;
-      }
-      map(mapper) {
-        if (this.tag) {
-          return Optional.some(mapper(this.value));
-        } else {
-          return Optional.none();
-        }
-      }
-      bind(binder) {
-        if (this.tag) {
-          return binder(this.value);
-        } else {
-          return Optional.none();
-        }
-      }
-      exists(predicate) {
-        return this.tag && predicate(this.value);
-      }
-      forall(predicate) {
-        return !this.tag || predicate(this.value);
-      }
-      filter(predicate) {
-        if (!this.tag || predicate(this.value)) {
-          return this;
-        } else {
-          return Optional.none();
-        }
-      }
-      getOr(replacement) {
-        return this.tag ? this.value : replacement;
-      }
-      or(replacement) {
-        return this.tag ? this : replacement;
-      }
-      getOrThunk(thunk) {
-        return this.tag ? this.value : thunk();
-      }
-      orThunk(thunk) {
-        return this.tag ? this : thunk();
-      }
-      getOrDie(message) {
-        if (!this.tag) {
-          throw new Error(message !== null && message !== void 0 ? message : 'Called getOrDie on None');
-        } else {
-          return this.value;
-        }
-      }
-      static from(value) {
-        return isNonNullable(value) ? Optional.some(value) : Optional.none();
-      }
-      getOrNull() {
-        return this.tag ? this.value : null;
-      }
-      getOrUndefined() {
-        return this.value;
-      }
-      each(worker) {
-        if (this.tag) {
-          worker(this.value);
-        }
-      }
-      toArray() {
-        return this.tag ? [this.value] : [];
-      }
-      toString() {
-        return this.tag ? `some(${ this.value })` : 'none()';
-      }
-    }
-    Optional.singletonNone = new Optional(false);
-
-    const isChildOfBody = (editor, elm) => {
-      return editor.dom.isChildOf(elm, editor.getBody());
-    };
-    const isTableCellNode = node => {
-      return node && /^(TH|TD)$/.test(node.nodeName);
-    };
-    const isListNode = editor => node => {
-      return node && /^(OL|UL|DL)$/.test(node.nodeName) && isChildOfBody(editor, node);
-    };
-    const getSelectedStyleType = editor => {
-      const listElm = editor.dom.getParent(editor.selection.getNode(), 'ol,ul');
-      const style = editor.dom.getStyle(listElm, 'listStyleType');
-      return Optional.from(style);
-    };
-
-    const findIndex = (list, predicate) => {
-      for (let index = 0; index < list.length; index++) {
-        const element = list[index];
-        if (predicate(element)) {
-          return index;
-        }
-      }
-      return -1;
-    };
-    const styleValueToText = styleValue => {
-      return styleValue.replace(/\-/g, ' ').replace(/\b\w/g, chr => {
-        return chr.toUpperCase();
-      });
-    };
-    const isWithinList = (editor, e, nodeName) => {
-      const tableCellIndex = findIndex(e.parents, isTableCellNode);
-      const parents = tableCellIndex !== -1 ? e.parents.slice(0, tableCellIndex) : e.parents;
-      const lists = global.grep(parents, isListNode(editor));
-      return lists.length > 0 && lists[0].nodeName === nodeName;
-    };
-    const makeSetupHandler = (editor, nodeName) => api => {
-      const nodeChangeHandler = e => {
-        api.setActive(isWithinList(editor, e, nodeName));
-      };
-      editor.on('NodeChange', nodeChangeHandler);
-      return () => editor.off('NodeChange', nodeChangeHandler);
-    };
-    const addSplitButton = (editor, id, tooltip, cmd, nodeName, styles) => {
-      editor.ui.registry.addSplitButton(id, {
-        tooltip,
-        icon: nodeName === 'OL' ? 'ordered-list' : 'unordered-list',
-        presets: 'listpreview',
-        columns: 3,
-        fetch: callback => {
-          const items = global.map(styles, styleValue => {
-            const iconStyle = nodeName === 'OL' ? 'num' : 'bull';
-            const iconName = styleValue === 'disc' || styleValue === 'decimal' ? 'default' : styleValue;
-            const itemValue = styleValue === 'default' ? '' : styleValue;
-            const displayText = styleValueToText(styleValue);
-            return {
-              type: 'choiceitem',
-              value: itemValue,
-              icon: 'list-' + iconStyle + '-' + iconName,
-              text: displayText
-            };
-          });
-          callback(items);
-        },
-        onAction: () => editor.execCommand(cmd),
-        onItemAction: (_splitButtonApi, value) => {
-          applyListFormat(editor, nodeName, value);
-        },
-        select: value => {
-          const listStyleType = getSelectedStyleType(editor);
-          return listStyleType.map(listStyle => value === listStyle).getOr(false);
-        },
-        onSetup: makeSetupHandler(editor, nodeName)
-      });
-    };
-    const addButton = (editor, id, tooltip, cmd, nodeName, _styles) => {
-      editor.ui.registry.addToggleButton(id, {
-        active: false,
-        tooltip,
-        icon: nodeName === 'OL' ? 'ordered-list' : 'unordered-list',
-        onSetup: makeSetupHandler(editor, nodeName),
-        onAction: () => editor.execCommand(cmd)
-      });
-    };
-    const addControl = (editor, id, tooltip, cmd, nodeName, styles) => {
-      if (styles.length > 1) {
-        addSplitButton(editor, id, tooltip, cmd, nodeName, styles);
-      } else {
-        addButton(editor, id, tooltip, cmd, nodeName);
-      }
-    };
-    const register = editor => {
-      addControl(editor, 'numlist', 'Numbered list', 'InsertOrderedList', 'OL', getNumberStyles(editor));
-      addControl(editor, 'bullist', 'Bullet list', 'InsertUnorderedList', 'UL', getBulletStyles(editor));
-    };
-
-    var Plugin = () => {
-      global$1.add('advlist', editor => {
-        if (editor.hasPlugin('lists')) {
-          register$1(editor);
-          register(editor);
-          register$2(editor);
-        } else {
-          console.error('Please use the Lists plugin together with the Advanced List plugin.');
-        }
-      });
-    };
-
-    Plugin();
-
-})();

public/tiny/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/tiny/plugins/anchor/plugin.js

@@ -1,195 +0,0 @@
-/**
- * TinyMCE version 6.0.3 (2022-05-25)
- */
-
-(function () {
-    'use strict';
-
-    var global$2 = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.dom.RangeUtils');
-
-    var global = tinymce.util.Tools.resolve('tinymce.util.Tools');
-
-    const option = name => editor => editor.options.get(name);
-    const register$2 = editor => {
-      const registerOption = editor.options.register;
-      registerOption('allow_html_in_named_anchor', {
-        processor: 'boolean',
-        default: false
-      });
-    };
-    const allowHtmlInNamedAnchor = option('allow_html_in_named_anchor');
-
-    const namedAnchorSelector = 'a:not([href])';
-    const isEmptyString = str => !str;
-    const getIdFromAnchor = elm => {
-      const id = elm.getAttribute('id') || elm.getAttribute('name');
-      return id || '';
-    };
-    const isAnchor = elm => elm && elm.nodeName.toLowerCase() === 'a';
-    const isNamedAnchor = elm => isAnchor(elm) && !elm.getAttribute('href') && getIdFromAnchor(elm) !== '';
-    const isEmptyNamedAnchor = elm => isNamedAnchor(elm) && !elm.firstChild;
-
-    const removeEmptyNamedAnchorsInSelection = editor => {
-      const dom = editor.dom;
-      global$1(dom).walk(editor.selection.getRng(), nodes => {
-        global.each(nodes, node => {
-          if (isEmptyNamedAnchor(node)) {
-            dom.remove(node, false);
-          }
-        });
-      });
-    };
-    const isValidId = id => /^[A-Za-z][A-Za-z0-9\-:._]*$/.test(id);
-    const getNamedAnchor = editor => editor.dom.getParent(editor.selection.getStart(), namedAnchorSelector);
-    const getId = editor => {
-      const anchor = getNamedAnchor(editor);
-      if (anchor) {
-        return getIdFromAnchor(anchor);
-      } else {
-        return '';
-      }
-    };
-    const createAnchor = (editor, id) => {
-      editor.undoManager.transact(() => {
-        if (!allowHtmlInNamedAnchor(editor)) {
-          editor.selection.collapse(true);
-        }
-        if (editor.selection.isCollapsed()) {
-          editor.insertContent(editor.dom.createHTML('a', { id }));
-        } else {
-          removeEmptyNamedAnchorsInSelection(editor);
-          editor.formatter.remove('namedAnchor', null, null, true);
-          editor.formatter.apply('namedAnchor', { value: id });
-          editor.addVisual();
-        }
-      });
-    };
-    const updateAnchor = (editor, id, anchorElement) => {
-      anchorElement.removeAttribute('name');
-      anchorElement.id = id;
-      editor.addVisual();
-      editor.undoManager.add();
-    };
-    const insert = (editor, id) => {
-      const anchor = getNamedAnchor(editor);
-      if (anchor) {
-        updateAnchor(editor, id, anchor);
-      } else {
-        createAnchor(editor, id);
-      }
-      editor.focus();
-    };
-
-    const insertAnchor = (editor, newId) => {
-      if (!isValidId(newId)) {
-        editor.windowManager.alert('ID should start with a letter, followed only by letters, numbers, dashes, dots, colons or underscores.');
-        return false;
-      } else {
-        insert(editor, newId);
-        return true;
-      }
-    };
-    const open = editor => {
-      const currentId = 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: api => {
-          if (insertAnchor(editor, api.getData().id)) {
-            api.close();
-          }
-        }
-      });
-    };
-
-    const register$1 = editor => {
-      editor.addCommand('mceAnchor', () => {
-        open(editor);
-      });
-    };
-
-    const isNamedAnchorNode = node => node && isEmptyString(node.attr('href')) && !isEmptyString(node.attr('id') || node.attr('name'));
-    const isEmptyNamedAnchorNode = node => isNamedAnchorNode(node) && !node.firstChild;
-    const setContentEditable = state => nodes => {
-      for (let i = 0; i < nodes.length; i++) {
-        const node = nodes[i];
-        if (isEmptyNamedAnchorNode(node)) {
-          node.attr('contenteditable', state);
-        }
-      }
-    };
-    const setup = editor => {
-      editor.on('PreInit', () => {
-        editor.parser.addNodeFilter('a', setContentEditable('false'));
-        editor.serializer.addNodeFilter('a', setContentEditable(null));
-      });
-    };
-
-    const registerFormats = editor => {
-      editor.formatter.register('namedAnchor', {
-        inline: 'a',
-        selector: namedAnchorSelector,
-        remove: 'all',
-        split: true,
-        deep: true,
-        attributes: { id: '%value' },
-        onmatch: (node, _fmt, _itemName) => {
-          return isNamedAnchor(node);
-        }
-      });
-    };
-
-    const register = editor => {
-      editor.ui.registry.addToggleButton('anchor', {
-        icon: 'bookmark',
-        tooltip: 'Anchor',
-        onAction: () => editor.execCommand('mceAnchor'),
-        onSetup: buttonApi => editor.selection.selectorChangedWithUnbind('a:not([href])', buttonApi.setActive).unbind
-      });
-      editor.ui.registry.addMenuItem('anchor', {
-        icon: 'bookmark',
-        text: 'Anchor...',
-        onAction: () => editor.execCommand('mceAnchor')
-      });
-    };
-
-    var Plugin = () => {
-      global$2.add('anchor', editor => {
-        register$2(editor);
-        setup(editor);
-        register$1(editor);
-        register(editor);
-        editor.on('PreInit', () => {
-          registerFormats(editor);
-        });
-      });
-    };
-
-    Plugin();
-
-})();

public/tiny/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/tiny/plugins/autolink/plugin.js

@@ -1,204 +0,0 @@
-/**
- * TinyMCE version 6.0.3 (2022-05-25)
- */
-
-(function () {
-  'use strict';
-
-  var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-  const link = () => /(?:[A-Za-z][A-Za-z\d.+-]{0,14}:\/\/(?:[-.~*+=!&;:'%@?^${}(),\w]+@)?|www\.|[-;:&=+$,.\w]+@)[A-Za-z\d-]+(?:\.[A-Za-z\d-]+)*(?::\d+)?(?:\/(?:[-+~=.,%()\/\w]*[-+~=%()\/\w])?)?(?:\?(?:[-.~*+=!&;:'%@?^${}(),\/\w]+))?(?:#(?:[-.~*+=!&;:'%@?^${}(),\/\w]+))?/g;
-
-  const option = name => editor => editor.options.get(name);
-  const register = editor => {
-    const registerOption = editor.options.register;
-    registerOption('autolink_pattern', {
-      processor: 'regexp',
-      default: new RegExp('^' + link().source + '$', 'i')
-    });
-    registerOption('link_default_target', { processor: 'string' });
-    registerOption('link_default_protocol', {
-      processor: 'string',
-      default: 'https'
-    });
-  };
-  const getAutoLinkPattern = option('autolink_pattern');
-  const getDefaultLinkTarget = option('link_default_target');
-  const getDefaultLinkProtocol = option('link_default_protocol');
-
-  const hasProto = (v, constructor, predicate) => {
-    var _a;
-    if (predicate(v, constructor.prototype)) {
-      return true;
-    } else {
-      return ((_a = v.constructor) === null || _a === void 0 ? void 0 : _a.name) === constructor.name;
-    }
-  };
-  const typeOf = x => {
-    const t = typeof x;
-    if (x === null) {
-      return 'null';
-    } else if (t === 'object' && Array.isArray(x)) {
-      return 'array';
-    } else if (t === 'object' && hasProto(x, String, (o, proto) => proto.isPrototypeOf(o))) {
-      return 'string';
-    } else {
-      return t;
-    }
-  };
-  const isType = type => value => typeOf(value) === type;
-  const isString = isType('string');
-
-  const checkRange = (str, substr, start) => substr === '' || str.length >= substr.length && str.substr(start, start + substr.length) === substr;
-  const contains = (str, substr) => {
-    return str.indexOf(substr) !== -1;
-  };
-  const startsWith = (str, prefix) => {
-    return checkRange(str, prefix, 0);
-  };
-
-  const rangeEqualsBracketOrSpace = rangeString => /^[(\[{ \u00a0]$/.test(rangeString);
-  const isTextNode = node => node.nodeType === 3;
-  const isElement = node => node.nodeType === 1;
-  const handleBracket = editor => parseCurrentLine(editor, -1);
-  const handleSpacebar = editor => parseCurrentLine(editor, 0);
-  const handleEnter = editor => parseCurrentLine(editor, -1);
-  const scopeIndex = (container, index) => {
-    if (index < 0) {
-      index = 0;
-    }
-    if (isTextNode(container)) {
-      const len = container.data.length;
-      if (index > len) {
-        index = len;
-      }
-    }
-    return index;
-  };
-  const setStart = (rng, container, offset) => {
-    if (!isElement(container) || container.hasChildNodes()) {
-      rng.setStart(container, scopeIndex(container, offset));
-    } else {
-      rng.setStartBefore(container);
-    }
-  };
-  const setEnd = (rng, container, offset) => {
-    if (!isElement(container) || container.hasChildNodes()) {
-      rng.setEnd(container, scopeIndex(container, offset));
-    } else {
-      rng.setEndAfter(container);
-    }
-  };
-  const hasProtocol = url => /^([A-Za-z][A-Za-z\d.+-]*:\/\/)|mailto:/.test(url);
-  const isPunctuation = char => /[?!,.;:]/.test(char);
-  const parseCurrentLine = (editor, endOffset) => {
-    let end, endContainer, bookmark, text, prev, len, rngText;
-    const autoLinkPattern = getAutoLinkPattern(editor);
-    const defaultLinkTarget = getDefaultLinkTarget(editor);
-    if (editor.dom.getParent(editor.selection.getNode(), 'a[href]') !== null) {
-      return;
-    }
-    const rng = editor.selection.getRng().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 (!isTextNode(endContainer) && endContainer.firstChild) {
-        while (!isTextNode(endContainer) && endContainer.firstChild) {
-          endContainer = endContainer.firstChild;
-        }
-        if (isTextNode(endContainer)) {
-          setStart(rng, endContainer, 0);
-          setEnd(rng, endContainer, endContainer.nodeValue.length);
-        }
-      }
-      if (rng.endOffset === 1) {
-        end = 2;
-      } else {
-        end = rng.endOffset - 1 - endOffset;
-      }
-    }
-    const 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 (!rangeEqualsBracketOrSpace(rngText) && end - 2 >= 0);
-    if (rangeEqualsBracketOrSpace(rng.toString())) {
-      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 (isPunctuation(text.charAt(text.length - 1))) {
-      setEnd(rng, endContainer, start - 1);
-    }
-    text = rng.toString().trim();
-    const matches = text.match(autoLinkPattern);
-    const protocol = getDefaultLinkProtocol(editor);
-    if (matches) {
-      let url = matches[0];
-      if (startsWith(url, 'www.')) {
-        url = protocol + '://' + url;
-      } else if (contains(url, '@') && !hasProtocol(url)) {
-        url = 'mailto:' + url;
-      }
-      bookmark = editor.selection.getBookmark();
-      editor.selection.setRng(rng);
-      editor.getDoc().execCommand('createlink', false, url);
-      if (isString(defaultLinkTarget)) {
-        editor.dom.setAttrib(editor.selection.getNode(), 'target', defaultLinkTarget);
-      }
-      editor.selection.moveToBookmark(bookmark);
-      editor.nodeChanged();
-    }
-  };
-  const setup = editor => {
-    editor.on('keydown', e => {
-      if (e.keyCode === 13) {
-        return handleEnter(editor);
-      }
-    });
-    editor.on('keypress', e => {
-      if (e.keyCode === 41 || e.keyCode === 93 || e.keyCode === 125) {
-        return handleBracket(editor);
-      }
-    });
-    editor.on('keyup', e => {
-      if (e.keyCode === 32) {
-        return handleSpacebar(editor);
-      }
-    });
-  };
-
-  var Plugin = () => {
-    global.add('autolink', editor => {
-      register(editor);
-      setup(editor);
-    });
-  };
-
-  Plugin();
-
-})();

public/tiny/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/tiny/plugins/autoresize/plugin.js

@@ -1,156 +0,0 @@
-/**
- * TinyMCE version 6.0.3 (2022-05-25)
- */
-
-(function () {
-    'use strict';
-
-    const Cell = initial => {
-      let value = initial;
-      const get = () => {
-        return value;
-      };
-      const set = v => {
-        value = v;
-      };
-      return {
-        get,
-        set
-      };
-    };
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    var global = tinymce.util.Tools.resolve('tinymce.Env');
-
-    const fireResizeEditor = editor => editor.dispatch('ResizeEditor');
-
-    const option = name => editor => editor.options.get(name);
-    const register$1 = editor => {
-      const registerOption = editor.options.register;
-      registerOption('autoresize_overflow_padding', {
-        processor: 'number',
-        default: 1
-      });
-      registerOption('autoresize_bottom_margin', {
-        processor: 'number',
-        default: 50
-      });
-    };
-    const getMinHeight = option('min_height');
-    const getMaxHeight = option('max_height');
-    const getAutoResizeOverflowPadding = option('autoresize_overflow_padding');
-    const getAutoResizeBottomMargin = option('autoresize_bottom_margin');
-
-    const isFullscreen = editor => editor.plugins.fullscreen && editor.plugins.fullscreen.isFullscreen();
-    const toggleScrolling = (editor, state) => {
-      const body = editor.getBody();
-      if (body) {
-        body.style.overflowY = state ? '' : 'hidden';
-        if (!state) {
-          body.scrollTop = 0;
-        }
-      }
-    };
-    const parseCssValueToInt = (dom, elm, name, computed) => {
-      const value = parseInt(dom.getStyle(elm, name, computed), 10);
-      return isNaN(value) ? 0 : value;
-    };
-    const shouldScrollIntoView = trigger => {
-      if ((trigger === null || trigger === void 0 ? void 0 : trigger.type.toLowerCase()) === 'setcontent') {
-        const setContentEvent = trigger;
-        return setContentEvent.selection === true || setContentEvent.paste === true;
-      } else {
-        return false;
-      }
-    };
-    const resize = (editor, oldSize, trigger) => {
-      var _a;
-      const dom = editor.dom;
-      const doc = editor.getDoc();
-      if (!doc) {
-        return;
-      }
-      if (isFullscreen(editor)) {
-        toggleScrolling(editor, true);
-        return;
-      }
-      const docEle = doc.documentElement;
-      const resizeBottomMargin = getAutoResizeBottomMargin(editor);
-      const minHeight = (_a = getMinHeight(editor)) !== null && _a !== void 0 ? _a : editor.getElement().offsetHeight;
-      let resizeHeight = minHeight;
-      const marginTop = parseCssValueToInt(dom, docEle, 'margin-top', true);
-      const marginBottom = parseCssValueToInt(dom, docEle, 'margin-bottom', true);
-      let contentHeight = docEle.offsetHeight + marginTop + marginBottom + resizeBottomMargin;
-      if (contentHeight < 0) {
-        contentHeight = 0;
-      }
-      const containerHeight = editor.getContainer().offsetHeight;
-      const contentAreaHeight = editor.getContentAreaContainer().offsetHeight;
-      const chromeHeight = containerHeight - contentAreaHeight;
-      if (contentHeight + chromeHeight > minHeight) {
-        resizeHeight = contentHeight + chromeHeight;
-      }
-      const maxHeight = getMaxHeight(editor);
-      if (maxHeight && resizeHeight > maxHeight) {
-        resizeHeight = maxHeight;
-        toggleScrolling(editor, true);
-      } else {
-        toggleScrolling(editor, false);
-      }
-      if (resizeHeight !== oldSize.get()) {
-        const deltaSize = resizeHeight - oldSize.get();
-        dom.setStyle(editor.getContainer(), 'height', resizeHeight + 'px');
-        oldSize.set(resizeHeight);
-        fireResizeEditor(editor);
-        if (global.browser.isSafari() && (global.os.isMacOS() || global.os.isiOS())) {
-          const win = editor.getWin();
-          win.scrollTo(win.pageXOffset, win.pageYOffset);
-        }
-        if (editor.hasFocus() && shouldScrollIntoView(trigger)) {
-          editor.selection.scrollIntoView();
-        }
-        if ((global.browser.isSafari() || global.browser.isChromium()) && deltaSize < 0) {
-          resize(editor, oldSize, trigger);
-        }
-      }
-    };
-    const setup = (editor, oldSize) => {
-      editor.on('init', () => {
-        const overflowPadding = getAutoResizeOverflowPadding(editor);
-        const dom = editor.dom;
-        dom.setStyles(editor.getDoc().documentElement, { height: 'auto' });
-        dom.setStyles(editor.getBody(), {
-          'paddingLeft': overflowPadding,
-          'paddingRight': overflowPadding,
-          'min-height': 0
-        });
-      });
-      editor.on('NodeChange SetContent keyup FullscreenStateChanged ResizeContent', e => {
-        resize(editor, oldSize, e);
-      });
-    };
-
-    const register = (editor, oldSize) => {
-      editor.addCommand('mceAutoResize', () => {
-        resize(editor, oldSize);
-      });
-    };
-
-    var Plugin = () => {
-      global$1.add('autoresize', editor => {
-        register$1(editor);
-        if (!editor.options.isSet('resize')) {
-          editor.options.set('resize', false);
-        }
-        if (!editor.inline) {
-          const oldSize = Cell(0);
-          register(editor, oldSize);
-          setup(editor, oldSize);
-        }
-      });
-    };
-
-    Plugin();
-
-})();

public/tiny/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/tiny/plugins/autosave/plugin.js

@@ -1,232 +0,0 @@
-/**
- * TinyMCE version 6.0.3 (2022-05-25)
- */
-
-(function () {
-    'use strict';
-
-    var global$4 = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    const hasProto = (v, constructor, predicate) => {
-      var _a;
-      if (predicate(v, constructor.prototype)) {
-        return true;
-      } else {
-        return ((_a = v.constructor) === null || _a === void 0 ? void 0 : _a.name) === constructor.name;
-      }
-    };
-    const typeOf = x => {
-      const t = typeof x;
-      if (x === null) {
-        return 'null';
-      } else if (t === 'object' && Array.isArray(x)) {
-        return 'array';
-      } else if (t === 'object' && hasProto(x, String, (o, proto) => proto.isPrototypeOf(o))) {
-        return 'string';
-      } else {
-        return t;
-      }
-    };
-    const isType = type => value => typeOf(value) === type;
-    const eq = t => a => t === a;
-    const isString = isType('string');
-    const isUndefined = eq(undefined);
-
-    var global$3 = tinymce.util.Tools.resolve('tinymce.util.Delay');
-
-    var global$2 = tinymce.util.Tools.resolve('tinymce.util.LocalStorage');
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.util.Tools');
-
-    const fireRestoreDraft = editor => editor.dispatch('RestoreDraft');
-    const fireStoreDraft = editor => editor.dispatch('StoreDraft');
-    const fireRemoveDraft = editor => editor.dispatch('RemoveDraft');
-
-    const parse = timeString => {
-      const multiples = {
-        s: 1000,
-        m: 60000
-      };
-      const parsedTime = /^(\d+)([ms]?)$/.exec(timeString);
-      return (parsedTime[2] ? multiples[parsedTime[2]] : 1) * parseInt(timeString, 10);
-    };
-
-    const option = name => editor => editor.options.get(name);
-    const register$1 = editor => {
-      const registerOption = editor.options.register;
-      const timeProcessor = value => {
-        const valid = isString(value);
-        if (valid) {
-          return {
-            value: parse(value),
-            valid
-          };
-        } else {
-          return {
-            valid: false,
-            message: 'Must be a string.'
-          };
-        }
-      };
-      registerOption('autosave_ask_before_unload', {
-        processor: 'boolean',
-        default: true
-      });
-      registerOption('autosave_prefix', {
-        processor: 'string',
-        default: 'tinymce-autosave-{path}{query}{hash}-{id}-'
-      });
-      registerOption('autosave_restore_when_empty', {
-        processor: 'boolean',
-        default: false
-      });
-      registerOption('autosave_interval', {
-        processor: timeProcessor,
-        default: '30s'
-      });
-      registerOption('autosave_retention', {
-        processor: timeProcessor,
-        default: '20m'
-      });
-    };
-    const shouldAskBeforeUnload = option('autosave_ask_before_unload');
-    const shouldRestoreWhenEmpty = option('autosave_restore_when_empty');
-    const getAutoSaveInterval = option('autosave_interval');
-    const getAutoSaveRetention = option('autosave_retention');
-    const getAutoSavePrefix = editor => {
-      const location = document.location;
-      return editor.options.get('autosave_prefix').replace(/{path}/g, location.pathname).replace(/{query}/g, location.search).replace(/{hash}/g, location.hash).replace(/{id}/g, editor.id);
-    };
-
-    const isEmpty = (editor, html) => {
-      if (isUndefined(html)) {
-        return editor.dom.isEmpty(editor.getBody());
-      } else {
-        const trimmedHtml = global$1.trim(html);
-        if (trimmedHtml === '') {
-          return true;
-        } else {
-          const fragment = new DOMParser().parseFromString(trimmedHtml, 'text/html');
-          return editor.dom.isEmpty(fragment);
-        }
-      }
-    };
-    const hasDraft = editor => {
-      const time = parseInt(global$2.getItem(getAutoSavePrefix(editor) + 'time'), 10) || 0;
-      if (new Date().getTime() - time > getAutoSaveRetention(editor)) {
-        removeDraft(editor, false);
-        return false;
-      }
-      return true;
-    };
-    const removeDraft = (editor, fire) => {
-      const prefix = getAutoSavePrefix(editor);
-      global$2.removeItem(prefix + 'draft');
-      global$2.removeItem(prefix + 'time');
-      if (fire !== false) {
-        fireRemoveDraft(editor);
-      }
-    };
-    const storeDraft = editor => {
-      const 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);
-      }
-    };
-    const restoreDraft = editor => {
-      const prefix = getAutoSavePrefix(editor);
-      if (hasDraft(editor)) {
-        editor.setContent(global$2.getItem(prefix + 'draft'), { format: 'raw' });
-        fireRestoreDraft(editor);
-      }
-    };
-    const startStoreDraft = editor => {
-      const interval = getAutoSaveInterval(editor);
-      global$3.setEditorInterval(editor, () => {
-        storeDraft(editor);
-      }, interval);
-    };
-    const restoreLastDraft = editor => {
-      editor.undoManager.transact(() => {
-        restoreDraft(editor);
-        removeDraft(editor);
-      });
-      editor.focus();
-    };
-
-    const get = editor => ({
-      hasDraft: () => hasDraft(editor),
-      storeDraft: () => storeDraft(editor),
-      restoreDraft: () => restoreDraft(editor),
-      removeDraft: fire => removeDraft(editor, fire),
-      isEmpty: html => isEmpty(editor, html)
-    });
-
-    var global = tinymce.util.Tools.resolve('tinymce.EditorManager');
-
-    const setup = editor => {
-      editor.editorManager.on('BeforeUnload', e => {
-        let msg;
-        global$1.each(global.get(), 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;
-        }
-      });
-    };
-
-    const makeSetupHandler = editor => api => {
-      api.setEnabled(hasDraft(editor));
-      const editorEventCallback = () => api.setEnabled(hasDraft(editor));
-      editor.on('StoreDraft RestoreDraft RemoveDraft', editorEventCallback);
-      return () => editor.off('StoreDraft RestoreDraft RemoveDraft', editorEventCallback);
-    };
-    const register = editor => {
-      startStoreDraft(editor);
-      editor.ui.registry.addButton('restoredraft', {
-        tooltip: 'Restore last draft',
-        icon: 'restore-draft',
-        onAction: () => {
-          restoreLastDraft(editor);
-        },
-        onSetup: makeSetupHandler(editor)
-      });
-      editor.ui.registry.addMenuItem('restoredraft', {
-        text: 'Restore last draft',
-        icon: 'restore-draft',
-        onAction: () => {
-          restoreLastDraft(editor);
-        },
-        onSetup: makeSetupHandler(editor)
-      });
-    };
-
-    var Plugin = () => {
-      global$4.add('autosave', editor => {
-        register$1(editor);
-        setup(editor);
-        register(editor);
-        editor.on('init', () => {
-          if (shouldRestoreWhenEmpty(editor) && editor.dom.isEmpty(editor.getBody())) {
-            restoreDraft(editor);
-          }
-        });
-        return get(editor);
-      });
-    };
-
-    Plugin();
-
-})();

public/tiny/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/tiny/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/tiny/plugins/code/plugin.js

@@ -1,85 +0,0 @@
-/**
- * TinyMCE version 6.0.3 (2022-05-25)
- */
-
-(function () {
-    'use strict';
-
-    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    const setContent = (editor, html) => {
-      editor.focus();
-      editor.undoManager.transact(() => {
-        editor.setContent(html);
-      });
-      editor.selection.setCursorLocation();
-      editor.nodeChanged();
-    };
-    const getContent = editor => {
-      return editor.getContent({ source_view: true });
-    };
-
-    const open = editor => {
-      const editorContent = 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: api => {
-          setContent(editor, api.getData().code);
-          api.close();
-        }
-      });
-    };
-
-    const register$1 = editor => {
-      editor.addCommand('mceCodeEditor', () => {
-        open(editor);
-      });
-    };
-
-    const register = editor => {
-      const onAction = () => editor.execCommand('mceCodeEditor');
-      editor.ui.registry.addButton('code', {
-        icon: 'sourcecode',
-        tooltip: 'Source code',
-        onAction
-      });
-      editor.ui.registry.addMenuItem('code', {
-        icon: 'sourcecode',
-        text: 'Source code',
-        onAction
-      });
-    };
-
-    var Plugin = () => {
-      global.add('code', editor => {
-        register$1(editor);
-        register(editor);
-        return {};
-      });
-    };
-
-    Plugin();
-
-})();

public/tiny/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/tiny/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/tiny/plugins/directionality/plugin.js

@@ -1,384 +0,0 @@
-/**
- * TinyMCE version 6.0.3 (2022-05-25)
- */
-
-(function () {
-    'use strict';
-
-    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    const hasProto = (v, constructor, predicate) => {
-      var _a;
-      if (predicate(v, constructor.prototype)) {
-        return true;
-      } else {
-        return ((_a = v.constructor) === null || _a === void 0 ? void 0 : _a.name) === constructor.name;
-      }
-    };
-    const typeOf = x => {
-      const t = typeof x;
-      if (x === null) {
-        return 'null';
-      } else if (t === 'object' && Array.isArray(x)) {
-        return 'array';
-      } else if (t === 'object' && hasProto(x, String, (o, proto) => proto.isPrototypeOf(o))) {
-        return 'string';
-      } else {
-        return t;
-      }
-    };
-    const isType$1 = type => value => typeOf(value) === type;
-    const isSimpleType = type => value => typeof value === type;
-    const isString = isType$1('string');
-    const isBoolean = isSimpleType('boolean');
-    const isNullable = a => a === null || a === undefined;
-    const isNonNullable = a => !isNullable(a);
-    const isFunction = isSimpleType('function');
-    const isNumber = isSimpleType('number');
-
-    const compose1 = (fbc, fab) => a => fbc(fab(a));
-    const constant = value => {
-      return () => {
-        return value;
-      };
-    };
-    const never = constant(false);
-
-    class Optional {
-      constructor(tag, value) {
-        this.tag = tag;
-        this.value = value;
-      }
-      static some(value) {
-        return new Optional(true, value);
-      }
-      static none() {
-        return Optional.singletonNone;
-      }
-      fold(onNone, onSome) {
-        if (this.tag) {
-          return onSome(this.value);
-        } else {
-          return onNone();
-        }
-      }
-      isSome() {
-        return this.tag;
-      }
-      isNone() {
-        return !this.tag;
-      }
-      map(mapper) {
-        if (this.tag) {
-          return Optional.some(mapper(this.value));
-        } else {
-          return Optional.none();
-        }
-      }
-      bind(binder) {
-        if (this.tag) {
-          return binder(this.value);
-        } else {
-          return Optional.none();
-        }
-      }
-      exists(predicate) {
-        return this.tag && predicate(this.value);
-      }
-      forall(predicate) {
-        return !this.tag || predicate(this.value);
-      }
-      filter(predicate) {
-        if (!this.tag || predicate(this.value)) {
-          return this;
-        } else {
-          return Optional.none();
-        }
-      }
-      getOr(replacement) {
-        return this.tag ? this.value : replacement;
-      }
-      or(replacement) {
-        return this.tag ? this : replacement;
-      }
-      getOrThunk(thunk) {
-        return this.tag ? this.value : thunk();
-      }
-      orThunk(thunk) {
-        return this.tag ? this : thunk();
-      }
-      getOrDie(message) {
-        if (!this.tag) {
-          throw new Error(message !== null && message !== void 0 ? message : 'Called getOrDie on None');
-        } else {
-          return this.value;
-        }
-      }
-      static from(value) {
-        return isNonNullable(value) ? Optional.some(value) : Optional.none();
-      }
-      getOrNull() {
-        return this.tag ? this.value : null;
-      }
-      getOrUndefined() {
-        return this.value;
-      }
-      each(worker) {
-        if (this.tag) {
-          worker(this.value);
-        }
-      }
-      toArray() {
-        return this.tag ? [this.value] : [];
-      }
-      toString() {
-        return this.tag ? `some(${ this.value })` : 'none()';
-      }
-    }
-    Optional.singletonNone = new Optional(false);
-
-    const map = (xs, f) => {
-      const len = xs.length;
-      const r = new Array(len);
-      for (let i = 0; i < len; i++) {
-        const x = xs[i];
-        r[i] = f(x, i);
-      }
-      return r;
-    };
-    const each = (xs, f) => {
-      for (let i = 0, len = xs.length; i < len; i++) {
-        const x = xs[i];
-        f(x, i);
-      }
-    };
-    const filter = (xs, pred) => {
-      const r = [];
-      for (let i = 0, len = xs.length; i < len; i++) {
-        const x = xs[i];
-        if (pred(x, i)) {
-          r.push(x);
-        }
-      }
-      return r;
-    };
-
-    const DOCUMENT = 9;
-    const DOCUMENT_FRAGMENT = 11;
-    const ELEMENT = 1;
-    const TEXT = 3;
-
-    const fromHtml = (html, scope) => {
-      const doc = scope || document;
-      const div = doc.createElement('div');
-      div.innerHTML = html;
-      if (!div.hasChildNodes() || div.childNodes.length > 1) {
-        const message = 'HTML does not have a single root node';
-        console.error(message, html);
-        throw new Error(message);
-      }
-      return fromDom(div.childNodes[0]);
-    };
-    const fromTag = (tag, scope) => {
-      const doc = scope || document;
-      const node = doc.createElement(tag);
-      return fromDom(node);
-    };
-    const fromText = (text, scope) => {
-      const doc = scope || document;
-      const node = doc.createTextNode(text);
-      return fromDom(node);
-    };
-    const fromDom = node => {
-      if (node === null || node === undefined) {
-        throw new Error('Node cannot be null or undefined');
-      }
-      return { dom: node };
-    };
-    const fromPoint = (docElm, x, y) => Optional.from(docElm.dom.elementFromPoint(x, y)).map(fromDom);
-    const SugarElement = {
-      fromHtml,
-      fromTag,
-      fromText,
-      fromDom,
-      fromPoint
-    };
-
-    const is = (element, selector) => {
-      const dom = element.dom;
-      if (dom.nodeType !== ELEMENT) {
-        return false;
-      } else {
-        const elem = dom;
-        if (elem.matches !== undefined) {
-          return elem.matches(selector);
-        } else if (elem.msMatchesSelector !== undefined) {
-          return elem.msMatchesSelector(selector);
-        } else if (elem.webkitMatchesSelector !== undefined) {
-          return elem.webkitMatchesSelector(selector);
-        } else if (elem.mozMatchesSelector !== undefined) {
-          return elem.mozMatchesSelector(selector);
-        } else {
-          throw new Error('Browser lacks native selectors');
-        }
-      }
-    };
-
-    typeof window !== 'undefined' ? window : Function('return this;')();
-
-    const name = element => {
-      const r = element.dom.nodeName;
-      return r.toLowerCase();
-    };
-    const type = element => element.dom.nodeType;
-    const isType = t => element => type(element) === t;
-    const isElement = isType(ELEMENT);
-    const isText = isType(TEXT);
-    const isDocument = isType(DOCUMENT);
-    const isDocumentFragment = isType(DOCUMENT_FRAGMENT);
-    const isTag = tag => e => isElement(e) && name(e) === tag;
-
-    const owner = element => SugarElement.fromDom(element.dom.ownerDocument);
-    const documentOrOwner = dos => isDocument(dos) ? dos : owner(dos);
-    const parent = element => Optional.from(element.dom.parentNode).map(SugarElement.fromDom);
-    const children$2 = element => map(element.dom.childNodes, SugarElement.fromDom);
-
-    const rawSet = (dom, key, value) => {
-      if (isString(value) || isBoolean(value) || isNumber(value)) {
-        dom.setAttribute(key, value + '');
-      } else {
-        console.error('Invalid call to Attribute.set. Key ', key, ':: Value ', value, ':: Element ', dom);
-        throw new Error('Attribute value was not simple');
-      }
-    };
-    const set = (element, key, value) => {
-      rawSet(element.dom, key, value);
-    };
-    const remove = (element, key) => {
-      element.dom.removeAttribute(key);
-    };
-
-    const isShadowRoot = dos => isDocumentFragment(dos) && isNonNullable(dos.dom.host);
-    const supported = isFunction(Element.prototype.attachShadow) && isFunction(Node.prototype.getRootNode);
-    const getRootNode = supported ? e => SugarElement.fromDom(e.dom.getRootNode()) : documentOrOwner;
-    const getShadowRoot = e => {
-      const r = getRootNode(e);
-      return isShadowRoot(r) ? Optional.some(r) : Optional.none();
-    };
-    const getShadowHost = e => SugarElement.fromDom(e.dom.host);
-
-    const inBody = element => {
-      const dom = isText(element) ? element.dom.parentNode : element.dom;
-      if (dom === undefined || dom === null || dom.ownerDocument === null) {
-        return false;
-      }
-      const doc = dom.ownerDocument;
-      return getShadowRoot(SugarElement.fromDom(dom)).fold(() => doc.body.contains(dom), compose1(inBody, getShadowHost));
-    };
-
-    const ancestor$1 = (scope, predicate, isRoot) => {
-      let element = scope.dom;
-      const stop = isFunction(isRoot) ? isRoot : never;
-      while (element.parentNode) {
-        element = element.parentNode;
-        const el = SugarElement.fromDom(element);
-        if (predicate(el)) {
-          return Optional.some(el);
-        } else if (stop(el)) {
-          break;
-        }
-      }
-      return Optional.none();
-    };
-
-    const ancestor = (scope, selector, isRoot) => ancestor$1(scope, e => is(e, selector), isRoot);
-
-    const isSupported = dom => dom.style !== undefined && isFunction(dom.style.getPropertyValue);
-
-    const get = (element, property) => {
-      const dom = element.dom;
-      const styles = window.getComputedStyle(dom);
-      const r = styles.getPropertyValue(property);
-      return r === '' && !inBody(element) ? getUnsafeProperty(dom, property) : r;
-    };
-    const getUnsafeProperty = (dom, property) => isSupported(dom) ? dom.style.getPropertyValue(property) : '';
-
-    const getDirection = element => get(element, 'direction') === 'rtl' ? 'rtl' : 'ltr';
-
-    const children$1 = (scope, predicate) => filter(children$2(scope), predicate);
-
-    const children = (scope, selector) => children$1(scope, e => is(e, selector));
-
-    const getParentElement = element => parent(element).filter(isElement);
-    const getNormalizedBlock = (element, isListItem) => {
-      const normalizedElement = isListItem ? ancestor(element, 'ol,ul') : Optional.some(element);
-      return normalizedElement.getOr(element);
-    };
-    const isListItem = isTag('li');
-    const setDir = (editor, dir) => {
-      const selectedBlocks = editor.selection.getSelectedBlocks();
-      if (selectedBlocks.length > 0) {
-        each(selectedBlocks, block => {
-          const blockElement = SugarElement.fromDom(block);
-          const isBlockElementListItem = isListItem(blockElement);
-          const normalizedBlock = getNormalizedBlock(blockElement, isBlockElementListItem);
-          const normalizedBlockParent = getParentElement(normalizedBlock);
-          normalizedBlockParent.each(parent => {
-            const parentDirection = getDirection(parent);
-            if (parentDirection !== dir) {
-              set(normalizedBlock, 'dir', dir);
-            } else if (getDirection(normalizedBlock) !== dir) {
-              remove(normalizedBlock, 'dir');
-            }
-            if (isBlockElementListItem) {
-              const listItems = children(normalizedBlock, 'li[dir]');
-              each(listItems, listItem => remove(listItem, 'dir'));
-            }
-          });
-        });
-        editor.nodeChanged();
-      }
-    };
-
-    const register$1 = editor => {
-      editor.addCommand('mceDirectionLTR', () => {
-        setDir(editor, 'ltr');
-      });
-      editor.addCommand('mceDirectionRTL', () => {
-        setDir(editor, 'rtl');
-      });
-    };
-
-    const getNodeChangeHandler = (editor, dir) => api => {
-      const nodeChangeHandler = e => {
-        const element = SugarElement.fromDom(e.element);
-        api.setActive(getDirection(element) === dir);
-      };
-      editor.on('NodeChange', nodeChangeHandler);
-      return () => editor.off('NodeChange', nodeChangeHandler);
-    };
-    const register = editor => {
-      editor.ui.registry.addToggleButton('ltr', {
-        tooltip: 'Left to right',
-        icon: 'ltr',
-        onAction: () => editor.execCommand('mceDirectionLTR'),
-        onSetup: getNodeChangeHandler(editor, 'ltr')
-      });
-      editor.ui.registry.addToggleButton('rtl', {
-        tooltip: 'Right to left',
-        icon: 'rtl',
-        onAction: () => editor.execCommand('mceDirectionRTL'),
-        onSetup: getNodeChangeHandler(editor, 'rtl')
-      });
-    };
-
-    var Plugin = () => {
-      global.add('directionality', editor => {
-        register$1(editor);
-        register(editor);
-      });
-    };
-
-    Plugin();
-
-})();

public/tiny/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/tiny/plugins/emoticons/plugin.js

@@ -1,577 +0,0 @@
-/**
- * TinyMCE version 6.0.3 (2022-05-25)
- */
-
-(function () {
-    'use strict';
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    const eq = t => a => t === a;
-    const isNull = eq(null);
-    const isNullable = a => a === null || a === undefined;
-    const isNonNullable = a => !isNullable(a);
-
-    const noop = () => {
-    };
-    const constant = value => {
-      return () => {
-        return value;
-      };
-    };
-    const never = constant(false);
-
-    class Optional {
-      constructor(tag, value) {
-        this.tag = tag;
-        this.value = value;
-      }
-      static some(value) {
-        return new Optional(true, value);
-      }
-      static none() {
-        return Optional.singletonNone;
-      }
-      fold(onNone, onSome) {
-        if (this.tag) {
-          return onSome(this.value);
-        } else {
-          return onNone();
-        }
-      }
-      isSome() {
-        return this.tag;
-      }
-      isNone() {
-        return !this.tag;
-      }
-      map(mapper) {
-        if (this.tag) {
-          return Optional.some(mapper(this.value));
-        } else {
-          return Optional.none();
-        }
-      }
-      bind(binder) {
-        if (this.tag) {
-          return binder(this.value);
-        } else {
-          return Optional.none();
-        }
-      }
-      exists(predicate) {
-        return this.tag && predicate(this.value);
-      }
-      forall(predicate) {
-        return !this.tag || predicate(this.value);
-      }
-      filter(predicate) {
-        if (!this.tag || predicate(this.value)) {
-          return this;
-        } else {
-          return Optional.none();
-        }
-      }
-      getOr(replacement) {
-        return this.tag ? this.value : replacement;
-      }
-      or(replacement) {
-        return this.tag ? this : replacement;
-      }
-      getOrThunk(thunk) {
-        return this.tag ? this.value : thunk();
-      }
-      orThunk(thunk) {
-        return this.tag ? this : thunk();
-      }
-      getOrDie(message) {
-        if (!this.tag) {
-          throw new Error(message !== null && message !== void 0 ? message : 'Called getOrDie on None');
-        } else {
-          return this.value;
-        }
-      }
-      static from(value) {
-        return isNonNullable(value) ? Optional.some(value) : Optional.none();
-      }
-      getOrNull() {
-        return this.tag ? this.value : null;
-      }
-      getOrUndefined() {
-        return this.value;
-      }
-      each(worker) {
-        if (this.tag) {
-          worker(this.value);
-        }
-      }
-      toArray() {
-        return this.tag ? [this.value] : [];
-      }
-      toString() {
-        return this.tag ? `some(${ this.value })` : 'none()';
-      }
-    }
-    Optional.singletonNone = new Optional(false);
-
-    const exists = (xs, pred) => {
-      for (let i = 0, len = xs.length; i < len; i++) {
-        const x = xs[i];
-        if (pred(x, i)) {
-          return true;
-        }
-      }
-      return false;
-    };
-    const map$1 = (xs, f) => {
-      const len = xs.length;
-      const r = new Array(len);
-      for (let i = 0; i < len; i++) {
-        const x = xs[i];
-        r[i] = f(x, i);
-      }
-      return r;
-    };
-    const each$1 = (xs, f) => {
-      for (let i = 0, len = xs.length; i < len; i++) {
-        const x = xs[i];
-        f(x, i);
-      }
-    };
-
-    const Cell = initial => {
-      let value = initial;
-      const get = () => {
-        return value;
-      };
-      const set = v => {
-        value = v;
-      };
-      return {
-        get,
-        set
-      };
-    };
-
-    const last = (fn, rate) => {
-      let timer = null;
-      const cancel = () => {
-        if (!isNull(timer)) {
-          clearTimeout(timer);
-          timer = null;
-        }
-      };
-      const throttle = (...args) => {
-        cancel();
-        timer = setTimeout(() => {
-          timer = null;
-          fn.apply(null, args);
-        }, rate);
-      };
-      return {
-        cancel,
-        throttle
-      };
-    };
-
-    const insertEmoticon = (editor, ch) => {
-      editor.insertContent(ch);
-    };
-
-    const keys = Object.keys;
-    const hasOwnProperty = Object.hasOwnProperty;
-    const each = (obj, f) => {
-      const props = keys(obj);
-      for (let k = 0, len = props.length; k < len; k++) {
-        const i = props[k];
-        const x = obj[i];
-        f(x, i);
-      }
-    };
-    const map = (obj, f) => {
-      return tupleMap(obj, (x, i) => ({
-        k: i,
-        v: f(x, i)
-      }));
-    };
-    const tupleMap = (obj, f) => {
-      const r = {};
-      each(obj, (x, i) => {
-        const tuple = f(x, i);
-        r[tuple.k] = tuple.v;
-      });
-      return r;
-    };
-    const has = (obj, key) => hasOwnProperty.call(obj, key);
-
-    const shallow = (old, nu) => {
-      return nu;
-    };
-    const baseMerge = merger => {
-      return (...objects) => {
-        if (objects.length === 0) {
-          throw new Error(`Can't merge zero objects`);
-        }
-        const ret = {};
-        for (let j = 0; j < objects.length; j++) {
-          const curObject = objects[j];
-          for (const key in curObject) {
-            if (has(curObject, key)) {
-              ret[key] = merger(ret[key], curObject[key]);
-            }
-          }
-        }
-        return ret;
-      };
-    };
-    const merge = baseMerge(shallow);
-
-    const singleton = doRevoke => {
-      const subject = Cell(Optional.none());
-      const revoke = () => subject.get().each(doRevoke);
-      const clear = () => {
-        revoke();
-        subject.set(Optional.none());
-      };
-      const isSet = () => subject.get().isSome();
-      const get = () => subject.get();
-      const set = s => {
-        revoke();
-        subject.set(Optional.some(s));
-      };
-      return {
-        clear,
-        isSet,
-        get,
-        set
-      };
-    };
-    const value = () => {
-      const subject = singleton(noop);
-      const on = f => subject.get().each(f);
-      return {
-        ...subject,
-        on
-      };
-    };
-
-    const checkRange = (str, substr, start) => substr === '' || str.length >= substr.length && str.substr(start, start + substr.length) === substr;
-    const contains = (str, substr) => {
-      return str.indexOf(substr) !== -1;
-    };
-    const startsWith = (str, prefix) => {
-      return checkRange(str, prefix, 0);
-    };
-
-    var global = tinymce.util.Tools.resolve('tinymce.Resource');
-
-    const DEFAULT_ID = 'tinymce.plugins.emoticons';
-    const option = name => editor => editor.options.get(name);
-    const register$2 = (editor, pluginUrl) => {
-      const registerOption = editor.options.register;
-      registerOption('emoticons_database', {
-        processor: 'string',
-        default: 'emojis'
-      });
-      registerOption('emoticons_database_url', {
-        processor: 'string',
-        default: `${ pluginUrl }/js/${ getEmojiDatabase(editor) }${ editor.suffix }.js`
-      });
-      registerOption('emoticons_database_id', {
-        processor: 'string',
-        default: DEFAULT_ID
-      });
-      registerOption('emoticons_append', {
-        processor: 'object',
-        default: {}
-      });
-      registerOption('emoticons_images_url', {
-        processor: 'string',
-        default: 'https://twemoji.maxcdn.com/v/13.0.1/72x72/'
-      });
-    };
-    const getEmojiDatabase = option('emoticons_database');
-    const getEmojiDatabaseUrl = option('emoticons_database_url');
-    const getEmojiDatabaseId = option('emoticons_database_id');
-    const getAppendedEmoji = option('emoticons_append');
-    const getEmojiImageUrl = option('emoticons_images_url');
-
-    const ALL_CATEGORY = 'All';
-    const 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'
-    };
-    const translateCategory = (categories, name) => has(categories, name) ? categories[name] : name;
-    const getUserDefinedEmoji = editor => {
-      const userDefinedEmoticons = getAppendedEmoji(editor);
-      return map(userDefinedEmoticons, value => ({
-        keywords: [],
-        category: 'user',
-        ...value
-      }));
-    };
-    const initDatabase = (editor, databaseUrl, databaseId) => {
-      const categories = value();
-      const all = value();
-      const emojiImagesUrl = getEmojiImageUrl(editor);
-      const getEmoji = lib => {
-        if (startsWith(lib.char, '<img')) {
-          return lib.char.replace(/src="([^"]+)"/, (match, url) => `src="${ emojiImagesUrl }${ url }"`);
-        } else {
-          return lib.char;
-        }
-      };
-      const processEmojis = emojis => {
-        const cats = {};
-        const everything = [];
-        each(emojis, (lib, title) => {
-          const entry = {
-            title,
-            keywords: lib.keywords,
-            char: getEmoji(lib),
-            category: translateCategory(categoryNameMap, lib.category)
-          };
-          const current = cats[entry.category] !== undefined ? cats[entry.category] : [];
-          cats[entry.category] = current.concat([entry]);
-          everything.push(entry);
-        });
-        categories.set(cats);
-        all.set(everything);
-      };
-      editor.on('init', () => {
-        global.load(databaseId, databaseUrl).then(emojis => {
-          const userEmojis = getUserDefinedEmoji(editor);
-          processEmojis(merge(emojis, userEmojis));
-        }, err => {
-          console.log(`Failed to load emojis: ${ err }`);
-          categories.set({});
-          all.set([]);
-        });
-      });
-      const listCategory = category => {
-        if (category === ALL_CATEGORY) {
-          return listAll();
-        }
-        return categories.get().bind(cats => Optional.from(cats[category])).getOr([]);
-      };
-      const listAll = () => all.get().getOr([]);
-      const listCategories = () => [ALL_CATEGORY].concat(keys(categories.get().getOr({})));
-      const waitForLoad = () => {
-        if (hasLoaded()) {
-          return Promise.resolve(true);
-        } else {
-          return new Promise((resolve, reject) => {
-            let numRetries = 15;
-            const interval = setInterval(() => {
-              if (hasLoaded()) {
-                clearInterval(interval);
-                resolve(true);
-              } else {
-                numRetries--;
-                if (numRetries < 0) {
-                  console.log('Could not load emojis from url: ' + databaseUrl);
-                  clearInterval(interval);
-                  reject(false);
-                }
-              }
-            }, 100);
-          });
-        }
-      };
-      const hasLoaded = () => categories.isSet() && all.isSet();
-      return {
-        listCategories,
-        hasLoaded,
-        waitForLoad,
-        listAll,
-        listCategory
-      };
-    };
-
-    const emojiMatches = (emoji, lowerCasePattern) => contains(emoji.title.toLowerCase(), lowerCasePattern) || exists(emoji.keywords, k => contains(k.toLowerCase(), lowerCasePattern));
-    const emojisFrom = (list, pattern, maxResults) => {
-      const matches = [];
-      const lowerCasePattern = pattern.toLowerCase();
-      const reachedLimit = maxResults.fold(() => never, max => size => size >= max);
-      for (let 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;
-    };
-
-    const patternName = 'pattern';
-    const open = (editor, database) => {
-      const initialState = {
-        pattern: '',
-        results: emojisFrom(database.listAll(), '', Optional.some(300))
-      };
-      const currentTab = Cell(ALL_CATEGORY);
-      const scan = dialogApi => {
-        const dialogData = dialogApi.getData();
-        const category = currentTab.get();
-        const candidates = database.listCategory(category);
-        const results = emojisFrom(candidates, dialogData[patternName], category === ALL_CATEGORY ? Optional.some(300) : Optional.none());
-        dialogApi.setData({ results });
-      };
-      const updateFilter = last(dialogApi => {
-        scan(dialogApi);
-      }, 200);
-      const searchField = {
-        label: 'Search',
-        type: 'input',
-        name: patternName
-      };
-      const resultsField = {
-        type: 'collection',
-        name: 'results'
-      };
-      const getInitialState = () => {
-        const body = {
-          type: 'tabpanel',
-          tabs: map$1(database.listCategories(), cat => ({
-            title: cat,
-            name: cat,
-            items: [
-              searchField,
-              resultsField
-            ]
-          }))
-        };
-        return {
-          title: 'Emojis',
-          size: 'normal',
-          body,
-          initialData: initialState,
-          onTabChange: (dialogApi, details) => {
-            currentTab.set(details.newTabName);
-            updateFilter.throttle(dialogApi);
-          },
-          onChange: updateFilter.throttle,
-          onAction: (dialogApi, actionData) => {
-            if (actionData.name === 'results') {
-              insertEmoticon(editor, actionData.value);
-              dialogApi.close();
-            }
-          },
-          buttons: [{
-              type: 'cancel',
-              text: 'Close',
-              primary: true
-            }]
-        };
-      };
-      const dialogApi = editor.windowManager.open(getInitialState());
-      dialogApi.focus(patternName);
-      if (!database.hasLoaded()) {
-        dialogApi.block('Loading emojis...');
-        database.waitForLoad().then(() => {
-          dialogApi.redial(getInitialState());
-          updateFilter.throttle(dialogApi);
-          dialogApi.focus(patternName);
-          dialogApi.unblock();
-        }).catch(_err => {
-          dialogApi.redial({
-            title: 'Emojis',
-            body: {
-              type: 'panel',
-              items: [{
-                  type: 'alertbanner',
-                  level: 'error',
-                  icon: 'warning',
-                  text: 'Could not load emojis'
-                }]
-            },
-            buttons: [{
-                type: 'cancel',
-                text: 'Close',
-                primary: true
-              }],
-            initialData: {
-              pattern: '',
-              results: []
-            }
-          });
-          dialogApi.focus(patternName);
-          dialogApi.unblock();
-        });
-      }
-    };
-
-    const register$1 = (editor, database) => {
-      editor.addCommand('mceEmoticons', () => open(editor, database));
-    };
-
-    const setup = editor => {
-      editor.on('PreInit', () => {
-        editor.parser.addAttributeFilter('data-emoticon', nodes => {
-          each$1(nodes, node => {
-            node.attr('data-mce-resize', 'false');
-            node.attr('data-mce-placeholder', '1');
-          });
-        });
-      });
-    };
-
-    const init = (editor, database) => {
-      editor.ui.registry.addAutocompleter('emoticons', {
-        ch: ':',
-        columns: 'auto',
-        minChars: 2,
-        fetch: (pattern, maxResults) => database.waitForLoad().then(() => {
-          const candidates = database.listAll();
-          return emojisFrom(candidates, pattern, Optional.some(maxResults));
-        }),
-        onAction: (autocompleteApi, rng, value) => {
-          editor.selection.setRng(rng);
-          editor.insertContent(value);
-          autocompleteApi.hide();
-        }
-      });
-    };
-
-    const register = editor => {
-      const onAction = () => editor.execCommand('mceEmoticons');
-      editor.ui.registry.addButton('emoticons', {
-        tooltip: 'Emojis',
-        icon: 'emoji',
-        onAction
-      });
-      editor.ui.registry.addMenuItem('emoticons', {
-        text: 'Emojis...',
-        icon: 'emoji',
-        onAction
-      });
-    };
-
-    var Plugin = () => {
-      global$1.add('emoticons', (editor, pluginUrl) => {
-        register$2(editor, pluginUrl);
-        const databaseUrl = getEmojiDatabaseUrl(editor);
-        const databaseId = getEmojiDatabaseId(editor);
-        const database = initDatabase(editor, databaseUrl, databaseId);
-        register$1(editor, database);
-        register(editor);
-        init(editor, database);
-        setup(editor);
-      });
-    };
-
-    Plugin();
-
-})();

public/tiny/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/tiny/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/tiny/plugins/help/plugin.js

@@ -1,848 +0,0 @@
-/**
- * TinyMCE version 6.0.3 (2022-05-25)
- */
-
-(function () {
-    'use strict';
-
-    const Cell = initial => {
-      let value = initial;
-      const get = () => {
-        return value;
-      };
-      const set = v => {
-        value = v;
-      };
-      return {
-        get,
-        set
-      };
-    };
-
-    var global$3 = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    const get$1 = customTabs => {
-      const addTab = spec => {
-        const currentCustomTabs = customTabs.get();
-        currentCustomTabs[spec.name] = spec;
-        customTabs.set(currentCustomTabs);
-      };
-      return { addTab };
-    };
-
-    const register$2 = (editor, dialogOpener) => {
-      editor.addCommand('mceHelp', dialogOpener);
-    };
-
-    const option = name => editor => editor.options.get(name);
-    const register$1 = editor => {
-      const registerOption = editor.options.register;
-      registerOption('help_tabs', { processor: 'array' });
-    };
-    const getHelpTabs = option('help_tabs');
-    const getForcedPlugins = option('forced_plugins');
-
-    const register = (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
-      });
-    };
-
-    const eq = t => a => t === a;
-    const isUndefined = eq(undefined);
-    const isNullable = a => a === null || a === undefined;
-    const isNonNullable = a => !isNullable(a);
-
-    const constant = value => {
-      return () => {
-        return value;
-      };
-    };
-    const never = constant(false);
-
-    class Optional {
-      constructor(tag, value) {
-        this.tag = tag;
-        this.value = value;
-      }
-      static some(value) {
-        return new Optional(true, value);
-      }
-      static none() {
-        return Optional.singletonNone;
-      }
-      fold(onNone, onSome) {
-        if (this.tag) {
-          return onSome(this.value);
-        } else {
-          return onNone();
-        }
-      }
-      isSome() {
-        return this.tag;
-      }
-      isNone() {
-        return !this.tag;
-      }
-      map(mapper) {
-        if (this.tag) {
-          return Optional.some(mapper(this.value));
-        } else {
-          return Optional.none();
-        }
-      }
-      bind(binder) {
-        if (this.tag) {
-          return binder(this.value);
-        } else {
-          return Optional.none();
-        }
-      }
-      exists(predicate) {
-        return this.tag && predicate(this.value);
-      }
-      forall(predicate) {
-        return !this.tag || predicate(this.value);
-      }
-      filter(predicate) {
-        if (!this.tag || predicate(this.value)) {
-          return this;
-        } else {
-          return Optional.none();
-        }
-      }
-      getOr(replacement) {
-        return this.tag ? this.value : replacement;
-      }
-      or(replacement) {
-        return this.tag ? this : replacement;
-      }
-      getOrThunk(thunk) {
-        return this.tag ? this.value : thunk();
-      }
-      orThunk(thunk) {
-        return this.tag ? this : thunk();
-      }
-      getOrDie(message) {
-        if (!this.tag) {
-          throw new Error(message !== null && message !== void 0 ? message : 'Called getOrDie on None');
-        } else {
-          return this.value;
-        }
-      }
-      static from(value) {
-        return isNonNullable(value) ? Optional.some(value) : Optional.none();
-      }
-      getOrNull() {
-        return this.tag ? this.value : null;
-      }
-      getOrUndefined() {
-        return this.value;
-      }
-      each(worker) {
-        if (this.tag) {
-          worker(this.value);
-        }
-      }
-      toArray() {
-        return this.tag ? [this.value] : [];
-      }
-      toString() {
-        return this.tag ? `some(${ this.value })` : 'none()';
-      }
-    }
-    Optional.singletonNone = new Optional(false);
-
-    const nativeIndexOf = Array.prototype.indexOf;
-    const rawIndexOf = (ts, t) => nativeIndexOf.call(ts, t);
-    const contains = (xs, x) => rawIndexOf(xs, x) > -1;
-    const map = (xs, f) => {
-      const len = xs.length;
-      const r = new Array(len);
-      for (let i = 0; i < len; i++) {
-        const x = xs[i];
-        r[i] = f(x, i);
-      }
-      return r;
-    };
-    const filter = (xs, pred) => {
-      const r = [];
-      for (let i = 0, len = xs.length; i < len; i++) {
-        const x = xs[i];
-        if (pred(x, i)) {
-          r.push(x);
-        }
-      }
-      return r;
-    };
-    const findUntil = (xs, pred, until) => {
-      for (let i = 0, len = xs.length; i < len; i++) {
-        const x = xs[i];
-        if (pred(x, i)) {
-          return Optional.some(x);
-        } else if (until(x, i)) {
-          break;
-        }
-      }
-      return Optional.none();
-    };
-    const find = (xs, pred) => {
-      return findUntil(xs, pred, never);
-    };
-
-    const keys = Object.keys;
-    const hasOwnProperty = Object.hasOwnProperty;
-    const get = (obj, key) => {
-      return has(obj, key) ? Optional.from(obj[key]) : Optional.none();
-    };
-    const has = (obj, key) => hasOwnProperty.call(obj, key);
-
-    const cat = arr => {
-      const r = [];
-      const push = x => {
-        r.push(x);
-      };
-      for (let i = 0; i < arr.length; i++) {
-        arr[i].each(push);
-      }
-      return r;
-    };
-
-    const description = `<h1>Editor UI keyboard navigation</h1>
-
-<h2>Activating keyboard navigation</h2>
-
-<p>The sections of the outer UI of the editor - the menubar, toolbar, sidebar and footer - are all keyboard navigable. As such, there are multiple ways to activate keyboard navigation:</p>
-<ul>
-  <li>Focus the menubar: Alt + F9 (Windows) or &#x2325;F9 (MacOS)</li>
-  <li>Focus the toolbar: Alt + F10 (Windows) or &#x2325;F10 (MacOS)</li>
-  <li>Focus the footer: Alt + F11 (Windows) or &#x2325;F11 (MacOS)</li>
-</ul>
-
-<p>Focusing the menubar or toolbar will start keyboard navigation at the first item in the menubar or toolbar, which will be highlighted with a gray background. Focusing the footer will start keyboard navigation at the first item in the element path, which will be highlighted with an underline. </p>
-
-<h2>Moving between UI sections</h2>
-
-<p>When keyboard navigation is active, pressing tab will move the focus to the next major section of the UI, where applicable. These sections are:</p>
-<ul>
-  <li>the menubar</li>
-  <li>each group of the toolbar </li>
-  <li>the sidebar</li>
-  <li>the element path in the footer </li>
-  <li>the wordcount toggle button in the footer </li>
-  <li>the branding link in the footer </li>
-  <li>the editor resize handle in the footer</li>
-</ul>
-
-<p>Pressing shift + tab will move backwards through the same sections, except when moving from the footer to the toolbar. Focusing the element path then pressing shift + tab will move focus to the first toolbar group, not the last.</p>
-
-<h2>Moving within UI sections</h2>
-
-<p>Keyboard navigation within UI sections can usually be achieved using the left and right arrow keys. This includes:</p>
-<ul>
-  <li>moving between menus in the menubar</li>
-  <li>moving between buttons in a toolbar group</li>
-  <li>moving between items in the element path</li>
-</ul>
-
-<p>In all these UI sections, keyboard navigation will cycle within the section. For example, focusing the last button in a toolbar group then pressing right arrow will move focus to the first item in the same toolbar group. </p>
-
-<h1>Executing buttons</h1>
-
-<p>To execute a button, navigate the selection to the desired button and hit space or enter.</p>
-
-<h1>Opening, navigating and closing menus</h1>
-
-<p>When focusing a menubar button or a toolbar button with a menu, pressing space, enter or down arrow will open the menu. When the menu opens the first item will be selected. To move up or down the menu, press the up or down arrow key respectively. This is the same for submenus, which can also be opened and closed using the left and right arrow keys.</p>
-
-<p>To close any active menu, hit the escape key. When a menu is closed the selection will be restored to its previous selection. This also works for closing submenus.</p>
-
-<h1>Context toolbars and menus</h1>
-
-<p>To focus an open context toolbar such as the table context toolbar, press Ctrl + F9 (Windows) or &#x2303;F9 (MacOS).</p>
-
-<p>Context toolbar navigation is the same as toolbar navigation, and context menu navigation is the same as standard menu navigation.</p>
-
-<h1>Dialog navigation</h1>
-
-<p>There are two types of dialog UIs in TinyMCE: tabbed dialogs and non-tabbed dialogs.</p>
-
-<p>When a non-tabbed dialog is opened, the first interactive component in the dialog will be focused. Users can navigate between interactive components by pressing tab. This includes any footer buttons. Navigation will cycle back to the first dialog component if tab is pressed while focusing the last component in the dialog. Pressing shift + tab will navigate backwards.</p>
-
-<p>When a tabbed dialog is opened, the first button in the tab menu is focused. Pressing tab will navigate to the first interactive component in that tab, and will cycle through the tab\u2019s components, the footer buttons, then back to the tab button. To switch to another tab, focus the tab button for the current tab, then use the arrow keys to cycle through the tab buttons.</p>`;
-    const tab$3 = () => {
-      const body = {
-        type: 'htmlpanel',
-        presets: 'document',
-        html: description
-      };
-      return {
-        name: 'keyboardnav',
-        title: 'Keyboard Navigation',
-        items: [body]
-      };
-    };
-
-    var global$2 = tinymce.util.Tools.resolve('tinymce.Env');
-
-    const convertText = source => {
-      const isMac = global$2.os.isMacOS() || global$2.os.isiOS();
-      const mac = {
-        alt: '&#x2325;',
-        ctrl: '&#x2303;',
-        shift: '&#x21E7;',
-        meta: '&#x2318;',
-        access: '&#x2303;&#x2325;'
-      };
-      const other = {
-        meta: 'Ctrl ',
-        access: 'Shift + Alt '
-      };
-      const replace = isMac ? mac : other;
-      const shortcut = source.split('+');
-      const updated = map(shortcut, segment => {
-        const search = segment.toLowerCase().trim();
-        return has(replace, search) ? replace[search] : segment;
-      });
-      return isMac ? updated.join('').replace(/\s/, '') : updated.join('+');
-    };
-
-    const 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: 'Heading 1'
-      },
-      {
-        shortcuts: ['Access + 2'],
-        action: 'Heading 2'
-      },
-      {
-        shortcuts: ['Access + 3'],
-        action: 'Heading 3'
-      },
-      {
-        shortcuts: ['Access + 4'],
-        action: 'Heading 4'
-      },
-      {
-        shortcuts: ['Access + 5'],
-        action: 'Heading 5'
-      },
-      {
-        shortcuts: ['Access + 6'],
-        action: 'Heading 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'
-      }
-    ];
-
-    const tab$2 = () => {
-      const shortcutList = map(shortcuts, shortcut => {
-        const shortcutText = map(shortcut.shortcuts, convertText).join(' or ');
-        return [
-          shortcut.action,
-          shortcutText
-        ];
-      });
-      const tablePanel = {
-        type: 'table',
-        header: [
-          'Action',
-          'Shortcut'
-        ],
-        cells: shortcutList
-      };
-      return {
-        name: 'shortcuts',
-        title: 'Handy Shortcuts',
-        items: [tablePanel]
-      };
-    };
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.util.I18n');
-
-    const urls = map([
-      {
-        key: 'advlist',
-        name: 'Advanced List'
-      },
-      {
-        key: 'anchor',
-        name: 'Anchor'
-      },
-      {
-        key: 'autolink',
-        name: 'Autolink'
-      },
-      {
-        key: 'autoresize',
-        name: 'Autoresize'
-      },
-      {
-        key: 'autosave',
-        name: 'Autosave'
-      },
-      {
-        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: 'fullscreen',
-        name: 'Full Screen'
-      },
-      {
-        key: 'help',
-        name: 'Help'
-      },
-      {
-        key: 'image',
-        name: 'Image'
-      },
-      {
-        key: 'importcss',
-        name: 'Import CSS'
-      },
-      {
-        key: 'insertdatetime',
-        name: 'Insert Date/Time'
-      },
-      {
-        key: 'link',
-        name: 'Link'
-      },
-      {
-        key: 'lists',
-        name: 'Lists'
-      },
-      {
-        key: 'media',
-        name: 'Media'
-      },
-      {
-        key: 'nonbreaking',
-        name: 'Nonbreaking'
-      },
-      {
-        key: 'pagebreak',
-        name: 'Page Break'
-      },
-      {
-        key: 'preview',
-        name: 'Preview'
-      },
-      {
-        key: 'quickbars',
-        name: 'Quick Toolbars'
-      },
-      {
-        key: 'save',
-        name: 'Save'
-      },
-      {
-        key: 'searchreplace',
-        name: 'Search and Replace'
-      },
-      {
-        key: 'table',
-        name: 'Table'
-      },
-      {
-        key: 'template',
-        name: 'Template'
-      },
-      {
-        key: 'textcolor',
-        name: 'Text Color'
-      },
-      {
-        key: 'visualblocks',
-        name: 'Visual Blocks'
-      },
-      {
-        key: 'visualchars',
-        name: 'Visual Characters'
-      },
-      {
-        key: 'wordcount',
-        name: 'Word Count'
-      },
-      {
-        key: 'a11ychecker',
-        name: 'Accessibility Checker',
-        type: 'premium'
-      },
-      {
-        key: 'advcode',
-        name: 'Advanced Code Editor',
-        type: 'premium'
-      },
-      {
-        key: 'advtable',
-        name: 'Advanced Tables',
-        type: 'premium'
-      },
-      {
-        key: 'autocorrect',
-        name: 'Autocorrect',
-        type: 'premium'
-      },
-      {
-        key: 'casechange',
-        name: 'Case Change',
-        type: 'premium'
-      },
-      {
-        key: 'checklist',
-        name: 'Checklist',
-        type: 'premium'
-      },
-      {
-        key: 'editimage',
-        name: 'Enhanced Image Editing',
-        type: 'premium'
-      },
-      {
-        key: 'mediaembed',
-        name: 'Enhanced Media Embed',
-        type: 'premium',
-        slug: 'introduction-to-mediaembed'
-      },
-      {
-        key: 'export',
-        name: 'Export',
-        type: 'premium'
-      },
-      {
-        key: 'formatpainter',
-        name: 'Format Painter',
-        type: 'premium'
-      },
-      {
-        key: 'linkchecker',
-        name: 'Link Checker',
-        type: 'premium'
-      },
-      {
-        key: 'mentions',
-        name: 'Mentions',
-        type: 'premium'
-      },
-      {
-        key: 'pageembed',
-        name: 'Page Embed',
-        type: 'premium'
-      },
-      {
-        key: 'permanentpen',
-        name: 'Permanent Pen',
-        type: 'premium'
-      },
-      {
-        key: 'powerpaste',
-        name: 'PowerPaste',
-        type: 'premium',
-        slug: 'introduction-to-powerpaste'
-      },
-      {
-        key: 'rtc',
-        name: 'Real-Time Collaboration',
-        type: 'premium',
-        slug: 'rtc-introduction'
-      },
-      {
-        key: 'tinymcespellchecker',
-        name: 'Spell Checker Pro',
-        type: 'premium',
-        slug: 'introduction-to-tiny-spellchecker'
-      },
-      {
-        key: 'tinycomments',
-        name: 'Tiny Comments',
-        type: 'premium',
-        slug: 'introduction-to-tiny-comments'
-      },
-      {
-        key: 'tinydrive',
-        name: 'Tiny Drive',
-        type: 'premium',
-        slug: 'tinydrive-introduction'
-      },
-      {
-        key: 'tableofcontents',
-        name: 'Table of Contents',
-        type: 'premium'
-      }
-    ], item => ({
-      ...item,
-      type: item.type || 'opensource',
-      slug: item.slug || item.key
-    }));
-
-    const tab$1 = editor => {
-      const availablePlugins = () => {
-        const premiumPlugins = filter(urls, ({key, type}) => {
-          return key !== 'autocorrect' && type === 'premium';
-        });
-        const premiumPluginList = map(premiumPlugins, plugin => '<li>' + global$1.translate(plugin.name) + '</li>').join('');
-        return '<div data-mce-tabstop="1" tabindex="-1">' + '<p><b>' + global$1.translate('Premium plugins:') + '</b></p>' + '<ul>' + premiumPluginList + '<li class="tox-help__more-link" "><a href="https://www.tiny.cloud/pricing/?utm_campaign=editor_referral&utm_medium=help_dialog&utm_source=tinymce" target="_blank">' + global$1.translate('Learn more...') + '</a></li>' + '</ul>' + '</div>';
-      };
-      const makeLink = p => `<a href="${ p.url }" target="_blank" rel="noopener">${ p.name }</a>`;
-      const maybeUrlize = (editor, key) => find(urls, x => {
-        return x.key === key;
-      }).fold(() => {
-        const getMetadata = editor.plugins[key].getMetadata;
-        return typeof getMetadata === 'function' ? makeLink(getMetadata()) : key;
-      }, x => {
-        const name = x.type === 'premium' ? `${ x.name }*` : x.name;
-        return makeLink({
-          name,
-          url: `https://www.tiny.cloud/docs/tinymce/6/${ x.slug }/`
-        });
-      });
-      const getPluginKeys = editor => {
-        const keys$1 = keys(editor.plugins);
-        const forcedPlugins = getForcedPlugins(editor);
-        return isUndefined(forcedPlugins) ? keys$1 : filter(keys$1, k => !contains(forcedPlugins, k));
-      };
-      const pluginLister = editor => {
-        const pluginKeys = getPluginKeys(editor);
-        const pluginLis = map(pluginKeys, key => {
-          return '<li>' + maybeUrlize(editor, key) + '</li>';
-        });
-        const count = pluginLis.length;
-        const pluginsString = pluginLis.join('');
-        const html = '<p><b>' + global$1.translate([
-          'Plugins installed ({0}):',
-          count
-        ]) + '</b></p>' + '<ul>' + pluginsString + '</ul>';
-        return html;
-      };
-      const installedPlugins = editor => {
-        if (editor == null) {
-          return '';
-        }
-        return '<div data-mce-tabstop="1" tabindex="-1">' + pluginLister(editor) + '</div>';
-      };
-      const htmlPanel = {
-        type: 'htmlpanel',
-        presets: 'document',
-        html: [
-          installedPlugins(editor),
-          availablePlugins()
-        ].join('')
-      };
-      return {
-        name: 'plugins',
-        title: 'Plugins',
-        items: [htmlPanel]
-      };
-    };
-
-    var global = tinymce.util.Tools.resolve('tinymce.EditorManager');
-
-    const tab = () => {
-      const getVersion = (major, minor) => major.indexOf('@') === 0 ? 'X.X.X' : major + '.' + minor;
-      const version = getVersion(global.majorVersion, global.minorVersion);
-      const changeLogLink = '<a href="https://www.tiny.cloud/docs/tinymce/6/changelog/?utm_campaign=editor_referral&utm_medium=help_dialog&utm_source=tinymce" target="_blank">TinyMCE ' + version + '</a>';
-      const htmlPanel = {
-        type: 'htmlpanel',
-        html: '<p>' + global$1.translate([
-          'You are using {0}',
-          changeLogLink
-        ]) + '</p>',
-        presets: 'document'
-      };
-      return {
-        name: 'versions',
-        title: 'Version',
-        items: [htmlPanel]
-      };
-    };
-
-    const parseHelpTabsSetting = (tabsFromSettings, tabs) => {
-      const newTabs = {};
-      const names = map(tabsFromSettings, 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
-      };
-    };
-    const getNamesFromTabs = tabs => {
-      const names = keys(tabs);
-      const idx = names.indexOf('versions');
-      if (idx !== -1) {
-        names.splice(idx, 1);
-        names.push('versions');
-      }
-      return {
-        tabs,
-        names
-      };
-    };
-    const parseCustomTabs = (editor, customTabs) => {
-      const shortcuts = tab$2();
-      const nav = tab$3();
-      const plugins = tab$1(editor);
-      const versions = tab();
-      const tabs = {
-        [shortcuts.name]: shortcuts,
-        [nav.name]: nav,
-        [plugins.name]: plugins,
-        [versions.name]: versions,
-        ...customTabs.get()
-      };
-      return Optional.from(getHelpTabs(editor)).fold(() => getNamesFromTabs(tabs), tabsFromSettings => parseHelpTabsSetting(tabsFromSettings, tabs));
-    };
-    const init = (editor, customTabs) => () => {
-      const {tabs, names} = parseCustomTabs(editor, customTabs);
-      const foundTabs = map(names, name => get(tabs, name));
-      const dialogTabs = cat(foundTabs);
-      const body = {
-        type: 'tabpanel',
-        tabs: dialogTabs
-      };
-      editor.windowManager.open({
-        title: 'Help',
-        size: 'medium',
-        body,
-        buttons: [{
-            type: 'cancel',
-            name: 'close',
-            text: 'Close',
-            primary: true
-          }],
-        initialData: {}
-      });
-    };
-
-    var Plugin = () => {
-      global$3.add('help', editor => {
-        const customTabs = Cell({});
-        const api = get$1(customTabs);
-        register$1(editor);
-        const dialogOpener = init(editor, customTabs);
-        register(editor, dialogOpener);
-        register$2(editor, dialogOpener);
-        editor.shortcuts.add('Alt+0', 'Open help dialog', 'mceHelp');
-        return api;
-      });
-    };
-
-    Plugin();
-
-})();

public/tiny/plugins/image/index.js

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

public/tiny/plugins/importcss/index.js

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

public/tiny/plugins/importcss/plugin.js

@@ -1,342 +0,0 @@
-/**
- * TinyMCE version 6.0.3 (2022-05-25)
- */
-
-(function () {
-    'use strict';
-
-    var global$4 = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    const hasProto = (v, constructor, predicate) => {
-      var _a;
-      if (predicate(v, constructor.prototype)) {
-        return true;
-      } else {
-        return ((_a = v.constructor) === null || _a === void 0 ? void 0 : _a.name) === constructor.name;
-      }
-    };
-    const typeOf = x => {
-      const t = typeof x;
-      if (x === null) {
-        return 'null';
-      } else if (t === 'object' && Array.isArray(x)) {
-        return 'array';
-      } else if (t === 'object' && hasProto(x, String, (o, proto) => proto.isPrototypeOf(o))) {
-        return 'string';
-      } else {
-        return t;
-      }
-    };
-    const isType = type => value => typeOf(value) === type;
-    const isSimpleType = type => value => typeof value === type;
-    const isString = isType('string');
-    const isObject = isType('object');
-    const isArray = isType('array');
-    const isFunction = isSimpleType('function');
-
-    var global$3 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');
-
-    var global$2 = tinymce.util.Tools.resolve('tinymce.EditorManager');
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.Env');
-
-    var global = tinymce.util.Tools.resolve('tinymce.util.Tools');
-
-    const option = name => editor => editor.options.get(name);
-    const register = editor => {
-      const registerOption = editor.options.register;
-      const filterProcessor = value => isString(value) || isFunction(value) || isObject(value);
-      registerOption('importcss_merge_classes', {
-        processor: 'boolean',
-        default: true
-      });
-      registerOption('importcss_exclusive', {
-        processor: 'boolean',
-        default: true
-      });
-      registerOption('importcss_selector_converter', { processor: 'function' });
-      registerOption('importcss_selector_filter', { processor: filterProcessor });
-      registerOption('importcss_file_filter', { processor: filterProcessor });
-      registerOption('importcss_groups', { processor: 'object[]' });
-      registerOption('importcss_append', {
-        processor: 'boolean',
-        default: false
-      });
-    };
-    const shouldMergeClasses = option('importcss_merge_classes');
-    const shouldImportExclusive = option('importcss_exclusive');
-    const getSelectorConverter = option('importcss_selector_converter');
-    const getSelectorFilter = option('importcss_selector_filter');
-    const getCssGroups = option('importcss_groups');
-    const shouldAppend = option('importcss_append');
-    const getFileFilter = option('importcss_file_filter');
-    const getSkin = option('skin');
-    const getSkinUrl = option('skin_url');
-
-    const nativePush = Array.prototype.push;
-    const map = (xs, f) => {
-      const len = xs.length;
-      const r = new Array(len);
-      for (let i = 0; i < len; i++) {
-        const x = xs[i];
-        r[i] = f(x, i);
-      }
-      return r;
-    };
-    const flatten = xs => {
-      const r = [];
-      for (let i = 0, len = xs.length; i < len; ++i) {
-        if (!isArray(xs[i])) {
-          throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs);
-        }
-        nativePush.apply(r, xs[i]);
-      }
-      return r;
-    };
-    const bind = (xs, f) => flatten(map(xs, f));
-
-    const generate = () => {
-      const ungroupedOrder = [];
-      const groupOrder = [];
-      const groups = {};
-      const addItemToGroup = (groupTitle, itemInfo) => {
-        if (groups[groupTitle]) {
-          groups[groupTitle].push(itemInfo);
-        } else {
-          groupOrder.push(groupTitle);
-          groups[groupTitle] = [itemInfo];
-        }
-      };
-      const addItem = itemInfo => {
-        ungroupedOrder.push(itemInfo);
-      };
-      const toFormats = () => {
-        const groupItems = bind(groupOrder, g => {
-          const items = groups[g];
-          return items.length === 0 ? [] : [{
-              title: g,
-              items
-            }];
-        });
-        return groupItems.concat(ungroupedOrder);
-      };
-      return {
-        addItemToGroup,
-        addItem,
-        toFormats
-      };
-    };
-
-    const internalEditorStyle = /^\.(?:ephox|tiny-pageembed|mce)(?:[.-]+\w+)+$/;
-    const removeCacheSuffix = url => {
-      const cacheSuffix = global$1.cacheSuffix;
-      if (isString(url)) {
-        url = url.replace('?' + cacheSuffix, '').replace('&' + cacheSuffix, '');
-      }
-      return url;
-    };
-    const isSkinContentCss = (editor, href) => {
-      const skin = getSkin(editor);
-      if (skin) {
-        const skinUrlBase = getSkinUrl(editor);
-        const skinUrl = skinUrlBase ? editor.documentBaseURI.toAbsolute(skinUrlBase) : global$2.baseURL + '/skins/ui/' + skin;
-        const contentSkinUrlPart = global$2.baseURL + '/skins/content/';
-        return href === skinUrl + '/content' + (editor.inline ? '.inline' : '') + '.min.css' || href.indexOf(contentSkinUrlPart) !== -1;
-      }
-      return false;
-    };
-    const compileFilter = filter => {
-      if (isString(filter)) {
-        return value => {
-          return value.indexOf(filter) !== -1;
-        };
-      } else if (filter instanceof RegExp) {
-        return value => {
-          return filter.test(value);
-        };
-      }
-      return filter;
-    };
-    const isCssImportRule = rule => rule.styleSheet;
-    const isCssPageRule = rule => rule.selectorText;
-    const getSelectors = (editor, doc, fileFilter) => {
-      const selectors = [];
-      const contentCSSUrls = {};
-      const append = (styleSheet, imported) => {
-        let href = styleSheet.href, rules;
-        href = removeCacheSuffix(href);
-        if (!href || !fileFilter(href, imported) || isSkinContentCss(editor, href)) {
-          return;
-        }
-        global.each(styleSheet.imports, styleSheet => {
-          append(styleSheet, true);
-        });
-        try {
-          rules = styleSheet.cssRules || styleSheet.rules;
-        } catch (e) {
-        }
-        global.each(rules, cssRule => {
-          if (isCssImportRule(cssRule)) {
-            append(cssRule.styleSheet, true);
-          } else if (isCssPageRule(cssRule)) {
-            global.each(cssRule.selectorText.split(','), selector => {
-              selectors.push(global.trim(selector));
-            });
-          }
-        });
-      };
-      global.each(editor.contentCSS, url => {
-        contentCSSUrls[url] = true;
-      });
-      if (!fileFilter) {
-        fileFilter = (href, imported) => {
-          return imported || contentCSSUrls[href];
-        };
-      }
-      try {
-        global.each(doc.styleSheets, styleSheet => {
-          append(styleSheet);
-        });
-      } catch (e) {
-      }
-      return selectors;
-    };
-    const defaultConvertSelectorToFormat = (editor, selectorText) => {
-      let format;
-      const selector = /^(?:([a-z0-9\-_]+))?(\.[a-z0-9_\-\.]+)$/i.exec(selectorText);
-      if (!selector) {
-        return;
-      }
-      const elementName = selector[1];
-      const classes = selector[2].substr(1).split('.').join(' ');
-      const inlineSelectorElements = global.makeMap('a,img');
-      if (selector[1]) {
-        format = { title: selectorText };
-        if (editor.schema.getTextBlockElements()[elementName]) {
-          format.block = elementName;
-        } else if (editor.schema.getBlockElements()[elementName] || inlineSelectorElements[elementName.toLowerCase()]) {
-          format.selector = elementName;
-        } else {
-          format.inline = elementName;
-        }
-      } else if (selector[2]) {
-        format = {
-          inline: 'span',
-          title: selectorText.substr(1),
-          classes
-        };
-      }
-      if (shouldMergeClasses(editor)) {
-        format.classes = classes;
-      } else {
-        format.attributes = { class: classes };
-      }
-      return format;
-    };
-    const getGroupsBySelector = (groups, selector) => {
-      return global.grep(groups, group => {
-        return !group.filter || group.filter(selector);
-      });
-    };
-    const compileUserDefinedGroups = groups => {
-      return global.map(groups, group => {
-        return global.extend({}, group, {
-          original: group,
-          selectors: {},
-          filter: compileFilter(group.filter)
-        });
-      });
-    };
-    const isExclusiveMode = (editor, group) => {
-      return group === null || shouldImportExclusive(editor);
-    };
-    const isUniqueSelector = (editor, selector, group, globallyUniqueSelectors) => {
-      return !(isExclusiveMode(editor, group) ? selector in globallyUniqueSelectors : selector in group.selectors);
-    };
-    const markUniqueSelector = (editor, selector, group, globallyUniqueSelectors) => {
-      if (isExclusiveMode(editor, group)) {
-        globallyUniqueSelectors[selector] = true;
-      } else {
-        group.selectors[selector] = true;
-      }
-    };
-    const convertSelectorToFormat = (editor, plugin, selector, group) => {
-      let selectorConverter;
-      if (group && group.selector_converter) {
-        selectorConverter = group.selector_converter;
-      } else if (getSelectorConverter(editor)) {
-        selectorConverter = getSelectorConverter(editor);
-      } else {
-        selectorConverter = () => {
-          return defaultConvertSelectorToFormat(editor, selector);
-        };
-      }
-      return selectorConverter.call(plugin, selector, group);
-    };
-    const setup = editor => {
-      editor.on('init', () => {
-        const model = generate();
-        const globallyUniqueSelectors = {};
-        const selectorFilter = compileFilter(getSelectorFilter(editor));
-        const groups = compileUserDefinedGroups(getCssGroups(editor));
-        const processSelector = (selector, group) => {
-          if (isUniqueSelector(editor, selector, group, globallyUniqueSelectors)) {
-            markUniqueSelector(editor, selector, group, globallyUniqueSelectors);
-            const format = convertSelectorToFormat(editor, editor.plugins.importcss, selector, group);
-            if (format) {
-              const formatName = format.name || global$3.DOM.uniqueId();
-              editor.formatter.register(formatName, format);
-              return {
-                title: format.title,
-                format: formatName
-              };
-            }
-          }
-          return null;
-        };
-        global.each(getSelectors(editor, editor.getDoc(), compileFilter(getFileFilter(editor))), selector => {
-          if (!internalEditorStyle.test(selector)) {
-            if (!selectorFilter || selectorFilter(selector)) {
-              const selectorGroups = getGroupsBySelector(groups, selector);
-              if (selectorGroups.length > 0) {
-                global.each(selectorGroups, group => {
-                  const menuItem = processSelector(selector, group);
-                  if (menuItem) {
-                    model.addItemToGroup(group.title, menuItem);
-                  }
-                });
-              } else {
-                const menuItem = processSelector(selector, null);
-                if (menuItem) {
-                  model.addItem(menuItem);
-                }
-              }
-            }
-          }
-        });
-        const items = model.toFormats();
-        editor.dispatch('addStyleModifications', {
-          items,
-          replace: !shouldAppend(editor)
-        });
-      });
-    };
-
-    const get = editor => {
-      const convertSelectorToFormat = selectorText => {
-        return defaultConvertSelectorToFormat(editor, selectorText);
-      };
-      return { convertSelectorToFormat };
-    };
-
-    var Plugin = () => {
-      global$4.add('importcss', editor => {
-        register(editor);
-        setup(editor);
-        return get(editor);
-      });
-    };
-
-    Plugin();
-
-})();

public/tiny/plugins/insertdatetime/index.js

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

public/tiny/plugins/insertdatetime/plugin.js

@@ -1,176 +0,0 @@
-/**
- * TinyMCE version 6.0.3 (2022-05-25)
- */
-
-(function () {
-    'use strict';
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    const option = name => editor => editor.options.get(name);
-    const register$2 = editor => {
-      const registerOption = editor.options.register;
-      registerOption('insertdatetime_dateformat', {
-        processor: 'string',
-        default: editor.translate('%Y-%m-%d')
-      });
-      registerOption('insertdatetime_timeformat', {
-        processor: 'string',
-        default: editor.translate('%H:%M:%S')
-      });
-      registerOption('insertdatetime_formats', {
-        processor: 'string[]',
-        default: [
-          '%H:%M:%S',
-          '%Y-%m-%d',
-          '%I:%M:%S %p',
-          '%D'
-        ]
-      });
-      registerOption('insertdatetime_element', {
-        processor: 'boolean',
-        default: false
-      });
-    };
-    const getDateFormat = option('insertdatetime_dateformat');
-    const getTimeFormat = option('insertdatetime_timeformat');
-    const getFormats = option('insertdatetime_formats');
-    const shouldInsertTimeElement = option('insertdatetime_element');
-    const getDefaultDateTime = editor => {
-      const formats = getFormats(editor);
-      return formats.length > 0 ? formats[0] : getTimeFormat(editor);
-    };
-
-    const daysShort = 'Sun Mon Tue Wed Thu Fri Sat Sun'.split(' ');
-    const daysLong = 'Sunday Monday Tuesday Wednesday Thursday Friday Saturday Sunday'.split(' ');
-    const monthsShort = 'Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec'.split(' ');
-    const monthsLong = 'January February March April May June July August September October November December'.split(' ');
-    const addZeros = (value, len) => {
-      value = '' + value;
-      if (value.length < len) {
-        for (let i = 0; i < len - value.length; i++) {
-          value = '0' + value;
-        }
-      }
-      return value;
-    };
-    const getDateTime = (editor, fmt, date = new Date()) => {
-      fmt = fmt.replace('%D', '%m/%d/%Y');
-      fmt = fmt.replace('%r', '%I:%M:%S %p');
-      fmt = fmt.replace('%Y', '' + date.getFullYear());
-      fmt = fmt.replace('%y', '' + date.getYear());
-      fmt = fmt.replace('%m', addZeros(date.getMonth() + 1, 2));
-      fmt = fmt.replace('%d', addZeros(date.getDate(), 2));
-      fmt = fmt.replace('%H', '' + addZeros(date.getHours(), 2));
-      fmt = fmt.replace('%M', '' + addZeros(date.getMinutes(), 2));
-      fmt = fmt.replace('%S', '' + addZeros(date.getSeconds(), 2));
-      fmt = fmt.replace('%I', '' + ((date.getHours() + 11) % 12 + 1));
-      fmt = fmt.replace('%p', '' + (date.getHours() < 12 ? 'AM' : 'PM'));
-      fmt = fmt.replace('%B', '' + editor.translate(monthsLong[date.getMonth()]));
-      fmt = fmt.replace('%b', '' + editor.translate(monthsShort[date.getMonth()]));
-      fmt = fmt.replace('%A', '' + editor.translate(daysLong[date.getDay()]));
-      fmt = fmt.replace('%a', '' + editor.translate(daysShort[date.getDay()]));
-      fmt = fmt.replace('%%', '%');
-      return fmt;
-    };
-    const updateElement = (editor, timeElm, computerTime, userTime) => {
-      const newTimeElm = editor.dom.create('time', { datetime: computerTime }, userTime);
-      timeElm.parentNode.insertBefore(newTimeElm, timeElm);
-      editor.dom.remove(timeElm);
-      editor.selection.select(newTimeElm, true);
-      editor.selection.collapse(false);
-    };
-    const insertDateTime = (editor, format) => {
-      if (shouldInsertTimeElement(editor)) {
-        const userTime = getDateTime(editor, format);
-        let computerTime;
-        if (/%[HMSIp]/.test(format)) {
-          computerTime = getDateTime(editor, '%Y-%m-%dT%H:%M');
-        } else {
-          computerTime = getDateTime(editor, '%Y-%m-%d');
-        }
-        const timeElm = editor.dom.getParent(editor.selection.getStart(), 'time');
-        if (timeElm) {
-          updateElement(editor, timeElm, computerTime, userTime);
-        } else {
-          editor.insertContent('<time datetime="' + computerTime + '">' + userTime + '</time>');
-        }
-      } else {
-        editor.insertContent(getDateTime(editor, format));
-      }
-    };
-
-    const register$1 = editor => {
-      editor.addCommand('mceInsertDate', (_ui, value) => {
-        insertDateTime(editor, value !== null && value !== void 0 ? value : getDateFormat(editor));
-      });
-      editor.addCommand('mceInsertTime', (_ui, value) => {
-        insertDateTime(editor, value !== null && value !== void 0 ? value : getTimeFormat(editor));
-      });
-    };
-
-    const Cell = initial => {
-      let value = initial;
-      const get = () => {
-        return value;
-      };
-      const set = v => {
-        value = v;
-      };
-      return {
-        get,
-        set
-      };
-    };
-
-    var global = tinymce.util.Tools.resolve('tinymce.util.Tools');
-
-    const register = editor => {
-      const formats = getFormats(editor);
-      const defaultFormat = Cell(getDefaultDateTime(editor));
-      const insertDateTime = format => editor.execCommand('mceInsertDate', false, format);
-      editor.ui.registry.addSplitButton('insertdatetime', {
-        icon: 'insert-time',
-        tooltip: 'Insert date/time',
-        select: value => value === defaultFormat.get(),
-        fetch: done => {
-          done(global.map(formats, format => ({
-            type: 'choiceitem',
-            text: getDateTime(editor, format),
-            value: format
-          })));
-        },
-        onAction: _api => {
-          insertDateTime(defaultFormat.get());
-        },
-        onItemAction: (_api, value) => {
-          defaultFormat.set(value);
-          insertDateTime(value);
-        }
-      });
-      const makeMenuItemHandler = format => () => {
-        defaultFormat.set(format);
-        insertDateTime(format);
-      };
-      editor.ui.registry.addNestedMenuItem('insertdatetime', {
-        icon: 'insert-time',
-        text: 'Date/time',
-        getSubmenuItems: () => global.map(formats, format => ({
-          type: 'menuitem',
-          text: getDateTime(editor, format),
-          onAction: makeMenuItemHandler(format)
-        }))
-      });
-    };
-
-    var Plugin = () => {
-      global$1.add('insertdatetime', editor => {
-        register$2(editor);
-        register$1(editor);
-        register(editor);
-      });
-    };
-
-    Plugin();
-
-})();

public/tiny/plugins/link/index.js

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

public/tiny/plugins/lists/index.js

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

public/tiny/plugins/media/index.js

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

public/tiny/plugins/nonbreaking/index.js

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

public/tiny/plugins/nonbreaking/plugin.js

@@ -1,111 +0,0 @@
-/**
- * TinyMCE version 6.0.3 (2022-05-25)
- */
-
-(function () {
-    'use strict';
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    const isSimpleType = type => value => typeof value === type;
-    const isBoolean = isSimpleType('boolean');
-    const isNumber = isSimpleType('number');
-
-    const option = name => editor => editor.options.get(name);
-    const register$2 = editor => {
-      const registerOption = editor.options.register;
-      registerOption('nonbreaking_force_tab', {
-        processor: value => {
-          if (isBoolean(value)) {
-            return {
-              value: value ? 3 : 0,
-              valid: true
-            };
-          } else if (isNumber(value)) {
-            return {
-              value,
-              valid: true
-            };
-          } else {
-            return {
-              valid: false,
-              message: 'Must be a boolean or number.'
-            };
-          }
-        },
-        default: false
-      });
-      registerOption('nonbreaking_wrap', {
-        processor: 'boolean',
-        default: true
-      });
-    };
-    const getKeyboardSpaces = option('nonbreaking_force_tab');
-    const wrapNbsps = option('nonbreaking_wrap');
-
-    const stringRepeat = (string, repeats) => {
-      let str = '';
-      for (let index = 0; index < repeats; index++) {
-        str += string;
-      }
-      return str;
-    };
-    const isVisualCharsEnabled = editor => editor.plugins.visualchars ? editor.plugins.visualchars.isEnabled() : false;
-    const insertNbsp = (editor, times) => {
-      const classes = () => isVisualCharsEnabled(editor) ? 'mce-nbsp-wrap mce-nbsp' : 'mce-nbsp-wrap';
-      const nbspSpan = () => `<span class="${ classes() }" contenteditable="false">${ stringRepeat('&nbsp;', times) }</span>`;
-      const shouldWrap = wrapNbsps(editor);
-      const html = shouldWrap || editor.plugins.visualchars ? nbspSpan() : stringRepeat('&nbsp;', times);
-      editor.undoManager.transact(() => editor.insertContent(html));
-    };
-
-    const register$1 = editor => {
-      editor.addCommand('mceNonBreaking', () => {
-        insertNbsp(editor, 1);
-      });
-    };
-
-    var global = tinymce.util.Tools.resolve('tinymce.util.VK');
-
-    const setup = editor => {
-      const spaces = getKeyboardSpaces(editor);
-      if (spaces > 0) {
-        editor.on('keydown', e => {
-          if (e.keyCode === global.TAB && !e.isDefaultPrevented()) {
-            if (e.shiftKey) {
-              return;
-            }
-            e.preventDefault();
-            e.stopImmediatePropagation();
-            insertNbsp(editor, spaces);
-          }
-        });
-      }
-    };
-
-    const register = editor => {
-      const onAction = () => editor.execCommand('mceNonBreaking');
-      editor.ui.registry.addButton('nonbreaking', {
-        icon: 'non-breaking',
-        tooltip: 'Nonbreaking space',
-        onAction
-      });
-      editor.ui.registry.addMenuItem('nonbreaking', {
-        icon: 'non-breaking',
-        text: 'Nonbreaking space',
-        onAction
-      });
-    };
-
-    var Plugin = () => {
-      global$1.add('nonbreaking', editor => {
-        register$2(editor);
-        register$1(editor);
-        register(editor);
-        setup(editor);
-      });
-    };
-
-    Plugin();
-
-})();

public/tiny/plugins/pagebreak/index.js

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

public/tiny/plugins/pagebreak/plugin.js

@@ -1,105 +0,0 @@
-/**
- * TinyMCE version 6.0.3 (2022-05-25)
- */
-
-(function () {
-    'use strict';
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    var global = tinymce.util.Tools.resolve('tinymce.Env');
-
-    const option = name => editor => editor.options.get(name);
-    const register$2 = editor => {
-      const registerOption = editor.options.register;
-      registerOption('pagebreak_separator', {
-        processor: 'string',
-        default: '<!-- pagebreak -->'
-      });
-      registerOption('pagebreak_split_block', {
-        processor: 'boolean',
-        default: false
-      });
-    };
-    const getSeparatorHtml = option('pagebreak_separator');
-    const shouldSplitBlock = option('pagebreak_split_block');
-
-    const pageBreakClass = 'mce-pagebreak';
-    const getPlaceholderHtml = shouldSplitBlock => {
-      const html = `<img src="${ global.transparentSrc }" class="${ pageBreakClass }" data-mce-resize="false" data-mce-placeholder />`;
-      return shouldSplitBlock ? `<p>${ html }</p>` : html;
-    };
-    const setup$1 = editor => {
-      const separatorHtml = getSeparatorHtml(editor);
-      const shouldSplitBlock$1 = () => shouldSplitBlock(editor);
-      const pageBreakSeparatorRegExp = new RegExp(separatorHtml.replace(/[\?\.\*\[\]\(\)\{\}\+\^\$\:]/g, a => {
-        return '\\' + a;
-      }), 'gi');
-      editor.on('BeforeSetContent', e => {
-        e.content = e.content.replace(pageBreakSeparatorRegExp, getPlaceholderHtml(shouldSplitBlock$1()));
-      });
-      editor.on('PreInit', () => {
-        editor.serializer.addNodeFilter('img', nodes => {
-          let i = nodes.length, node, className;
-          while (i--) {
-            node = nodes[i];
-            className = node.attr('class');
-            if (className && className.indexOf(pageBreakClass) !== -1) {
-              const parentNode = node.parent;
-              if (editor.schema.getBlockElements()[parentNode.name] && shouldSplitBlock$1()) {
-                parentNode.type = 3;
-                parentNode.value = separatorHtml;
-                parentNode.raw = true;
-                node.remove();
-                continue;
-              }
-              node.type = 3;
-              node.value = separatorHtml;
-              node.raw = true;
-            }
-          }
-        });
-      });
-    };
-
-    const register$1 = editor => {
-      editor.addCommand('mcePageBreak', () => {
-        editor.insertContent(getPlaceholderHtml(shouldSplitBlock(editor)));
-      });
-    };
-
-    const setup = editor => {
-      editor.on('ResolveName', e => {
-        if (e.target.nodeName === 'IMG' && editor.dom.hasClass(e.target, pageBreakClass)) {
-          e.name = 'pagebreak';
-        }
-      });
-    };
-
-    const register = editor => {
-      const onAction = () => editor.execCommand('mcePageBreak');
-      editor.ui.registry.addButton('pagebreak', {
-        icon: 'page-break',
-        tooltip: 'Page break',
-        onAction
-      });
-      editor.ui.registry.addMenuItem('pagebreak', {
-        text: 'Page break',
-        icon: 'page-break',
-        onAction
-      });
-    };
-
-    var Plugin = () => {
-      global$1.add('pagebreak', editor => {
-        register$2(editor);
-        register$1(editor);
-        register(editor);
-        setup$1(editor);
-        setup(editor);
-      });
-    };
-
-    Plugin();
-
-})();

public/tiny/plugins/preview/index.js

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

public/tiny/plugins/preview/plugin.js

@@ -1,96 +0,0 @@
-/**
- * TinyMCE version 6.0.3 (2022-05-25)
- */
-
-(function () {
-    'use strict';
-
-    var global$2 = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.Env');
-
-    var global = tinymce.util.Tools.resolve('tinymce.util.Tools');
-
-    const option = name => editor => editor.options.get(name);
-    const getContentStyle = option('content_style');
-    const shouldUseContentCssCors = option('content_css_cors');
-    const getBodyClass = option('body_class');
-    const getBodyId = option('body_id');
-
-    const getPreviewHtml = editor => {
-      var _a;
-      let headHtml = '';
-      const encode = editor.dom.encode;
-      const contentStyle = (_a = getContentStyle(editor)) !== null && _a !== void 0 ? _a : '';
-      headHtml += '<base href="' + encode(editor.documentBaseURI.getURI()) + '">';
-      const cors = shouldUseContentCssCors(editor) ? ' crossorigin="anonymous"' : '';
-      global.each(editor.contentCSS, url => {
-        headHtml += '<link type="text/css" rel="stylesheet" href="' + encode(editor.documentBaseURI.toAbsolute(url)) + '"' + cors + '>';
-      });
-      if (contentStyle) {
-        headHtml += '<style type="text/css">' + contentStyle + '</style>';
-      }
-      const bodyId = getBodyId(editor);
-      const bodyClass = getBodyClass(editor);
-      const isMetaKeyPressed = global$1.os.isMacOS() || global$1.os.isiOS() ? 'e.metaKey' : 'e.ctrlKey && !e.altKey';
-      const preventClicksOnLinksScript = '<script>' + 'document.addEventListener && document.addEventListener("click", function(e) {' + 'for (var elm = e.target; elm; elm = elm.parentNode) {' + 'if (elm.nodeName === "A" && !(' + isMetaKeyPressed + ')) {' + 'e.preventDefault();' + '}' + '}' + '}, false);' + '</script> ';
-      const directionality = editor.getBody().dir;
-      const dirAttr = directionality ? ' dir="' + encode(directionality) + '"' : '';
-      const previewHtml = '<!DOCTYPE html>' + '<html>' + '<head>' + headHtml + '</head>' + '<body id="' + encode(bodyId) + '" class="mce-content-body ' + encode(bodyClass) + '"' + dirAttr + '>' + editor.getContent() + preventClicksOnLinksScript + '</body>' + '</html>';
-      return previewHtml;
-    };
-
-    const open = editor => {
-      const content = getPreviewHtml(editor);
-      const dataApi = editor.windowManager.open({
-        title: 'Preview',
-        size: 'large',
-        body: {
-          type: 'panel',
-          items: [{
-              name: 'preview',
-              type: 'iframe',
-              sandboxed: true
-            }]
-        },
-        buttons: [{
-            type: 'cancel',
-            name: 'close',
-            text: 'Close',
-            primary: true
-          }],
-        initialData: { preview: content }
-      });
-      dataApi.focus('close');
-    };
-
-    const register$1 = editor => {
-      editor.addCommand('mcePreview', () => {
-        open(editor);
-      });
-    };
-
-    const register = editor => {
-      const onAction = () => editor.execCommand('mcePreview');
-      editor.ui.registry.addButton('preview', {
-        icon: 'preview',
-        tooltip: 'Preview',
-        onAction
-      });
-      editor.ui.registry.addMenuItem('preview', {
-        icon: 'preview',
-        text: 'Preview',
-        onAction
-      });
-    };
-
-    var Plugin = () => {
-      global$2.add('preview', editor => {
-        register$1(editor);
-        register(editor);
-      });
-    };
-
-    Plugin();
-
-})();

public/tiny/plugins/quickbars/index.js

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

public/tiny/plugins/quickbars/plugin.js

@@ -1,421 +0,0 @@
-/**
- * TinyMCE version 6.0.3 (2022-05-25)
- */
-
-(function () {
-    'use strict';
-
-    var global$2 = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    const hasProto = (v, constructor, predicate) => {
-      var _a;
-      if (predicate(v, constructor.prototype)) {
-        return true;
-      } else {
-        return ((_a = v.constructor) === null || _a === void 0 ? void 0 : _a.name) === constructor.name;
-      }
-    };
-    const typeOf = x => {
-      const t = typeof x;
-      if (x === null) {
-        return 'null';
-      } else if (t === 'object' && Array.isArray(x)) {
-        return 'array';
-      } else if (t === 'object' && hasProto(x, String, (o, proto) => proto.isPrototypeOf(o))) {
-        return 'string';
-      } else {
-        return t;
-      }
-    };
-    const isType = type => value => typeOf(value) === type;
-    const isSimpleType = type => value => typeof value === type;
-    const isString = isType('string');
-    const isBoolean = isSimpleType('boolean');
-    const isNullable = a => a === null || a === undefined;
-    const isNonNullable = a => !isNullable(a);
-    const isFunction = isSimpleType('function');
-
-    const option = name => editor => editor.options.get(name);
-    const register = editor => {
-      const registerOption = editor.options.register;
-      const toolbarProcessor = defaultValue => value => {
-        const valid = isBoolean(value) || isString(value);
-        if (valid) {
-          if (isBoolean(value)) {
-            return {
-              value: value ? defaultValue : '',
-              valid
-            };
-          } else {
-            return {
-              value: value.trim(),
-              valid
-            };
-          }
-        } else {
-          return {
-            valid: false,
-            message: 'Must be a boolean or string.'
-          };
-        }
-      };
-      const defaultSelectionToolbar = 'bold italic | quicklink h2 h3 blockquote';
-      registerOption('quickbars_selection_toolbar', {
-        processor: toolbarProcessor(defaultSelectionToolbar),
-        default: defaultSelectionToolbar
-      });
-      const defaultInsertToolbar = 'quickimage quicktable';
-      registerOption('quickbars_insert_toolbar', {
-        processor: toolbarProcessor(defaultInsertToolbar),
-        default: defaultInsertToolbar
-      });
-      const defaultImageToolbar = 'alignleft aligncenter alignright';
-      registerOption('quickbars_image_toolbar', {
-        processor: toolbarProcessor(defaultImageToolbar),
-        default: defaultImageToolbar
-      });
-    };
-    const getTextSelectionToolbarItems = option('quickbars_selection_toolbar');
-    const getInsertToolbarItems = option('quickbars_insert_toolbar');
-    const getImageToolbarItems = option('quickbars_image_toolbar');
-
-    let unique = 0;
-    const generate = prefix => {
-      const date = new Date();
-      const time = date.getTime();
-      const random = Math.floor(Math.random() * 1000000000);
-      unique++;
-      return prefix + '_' + random + unique + String(time);
-    };
-
-    const insertTable = (editor, columns, rows) => {
-      editor.execCommand('mceInsertTable', false, {
-        rows,
-        columns
-      });
-    };
-    const insertBlob = (editor, base64, blob) => {
-      const blobCache = editor.editorUpload.blobCache;
-      const blobInfo = blobCache.create(generate('mceu'), blob, base64);
-      blobCache.add(blobInfo);
-      editor.insertContent(editor.dom.createHTML('img', { src: blobInfo.blobUri() }));
-    };
-
-    const blobToBase64 = blob => {
-      return new Promise(resolve => {
-        const reader = new FileReader();
-        reader.onloadend = () => {
-          resolve(reader.result.split(',')[1]);
-        };
-        reader.readAsDataURL(blob);
-      });
-    };
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.Env');
-
-    var global = tinymce.util.Tools.resolve('tinymce.util.Delay');
-
-    const pickFile = editor => new Promise(resolve => {
-      const fileInput = document.createElement('input');
-      fileInput.type = 'file';
-      fileInput.accept = 'image/*';
-      fileInput.style.position = 'fixed';
-      fileInput.style.left = '0';
-      fileInput.style.top = '0';
-      fileInput.style.opacity = '0.001';
-      document.body.appendChild(fileInput);
-      const changeHandler = e => {
-        resolve(Array.prototype.slice.call(e.target.files));
-      };
-      fileInput.addEventListener('change', changeHandler);
-      const cancelHandler = e => {
-        const cleanup = () => {
-          resolve([]);
-          fileInput.parentNode.removeChild(fileInput);
-        };
-        if (global$1.os.isAndroid() && e.type !== 'remove') {
-          global.setEditorTimeout(editor, cleanup, 0);
-        } else {
-          cleanup();
-        }
-        editor.off('focusin remove', cancelHandler);
-      };
-      editor.on('focusin remove', cancelHandler);
-      fileInput.click();
-    });
-
-    const setupButtons = editor => {
-      editor.ui.registry.addButton('quickimage', {
-        icon: 'image',
-        tooltip: 'Insert image',
-        onAction: () => {
-          pickFile(editor).then(files => {
-            if (files.length > 0) {
-              const blob = files[0];
-              blobToBase64(blob).then(base64 => {
-                insertBlob(editor, base64, blob);
-              });
-            }
-          });
-        }
-      });
-      editor.ui.registry.addButton('quicktable', {
-        icon: 'table',
-        tooltip: 'Insert table',
-        onAction: () => {
-          insertTable(editor, 2, 2);
-        }
-      });
-    };
-
-    const constant = value => {
-      return () => {
-        return value;
-      };
-    };
-    const never = constant(false);
-
-    class Optional {
-      constructor(tag, value) {
-        this.tag = tag;
-        this.value = value;
-      }
-      static some(value) {
-        return new Optional(true, value);
-      }
-      static none() {
-        return Optional.singletonNone;
-      }
-      fold(onNone, onSome) {
-        if (this.tag) {
-          return onSome(this.value);
-        } else {
-          return onNone();
-        }
-      }
-      isSome() {
-        return this.tag;
-      }
-      isNone() {
-        return !this.tag;
-      }
-      map(mapper) {
-        if (this.tag) {
-          return Optional.some(mapper(this.value));
-        } else {
-          return Optional.none();
-        }
-      }
-      bind(binder) {
-        if (this.tag) {
-          return binder(this.value);
-        } else {
-          return Optional.none();
-        }
-      }
-      exists(predicate) {
-        return this.tag && predicate(this.value);
-      }
-      forall(predicate) {
-        return !this.tag || predicate(this.value);
-      }
-      filter(predicate) {
-        if (!this.tag || predicate(this.value)) {
-          return this;
-        } else {
-          return Optional.none();
-        }
-      }
-      getOr(replacement) {
-        return this.tag ? this.value : replacement;
-      }
-      or(replacement) {
-        return this.tag ? this : replacement;
-      }
-      getOrThunk(thunk) {
-        return this.tag ? this.value : thunk();
-      }
-      orThunk(thunk) {
-        return this.tag ? this : thunk();
-      }
-      getOrDie(message) {
-        if (!this.tag) {
-          throw new Error(message !== null && message !== void 0 ? message : 'Called getOrDie on None');
-        } else {
-          return this.value;
-        }
-      }
-      static from(value) {
-        return isNonNullable(value) ? Optional.some(value) : Optional.none();
-      }
-      getOrNull() {
-        return this.tag ? this.value : null;
-      }
-      getOrUndefined() {
-        return this.value;
-      }
-      each(worker) {
-        if (this.tag) {
-          worker(this.value);
-        }
-      }
-      toArray() {
-        return this.tag ? [this.value] : [];
-      }
-      toString() {
-        return this.tag ? `some(${ this.value })` : 'none()';
-      }
-    }
-    Optional.singletonNone = new Optional(false);
-
-    var ClosestOrAncestor = (is, ancestor, scope, a, isRoot) => {
-      if (is(scope, a)) {
-        return Optional.some(scope);
-      } else if (isFunction(isRoot) && isRoot(scope)) {
-        return Optional.none();
-      } else {
-        return ancestor(scope, a, isRoot);
-      }
-    };
-
-    const ELEMENT = 1;
-
-    const fromHtml = (html, scope) => {
-      const doc = scope || document;
-      const div = doc.createElement('div');
-      div.innerHTML = html;
-      if (!div.hasChildNodes() || div.childNodes.length > 1) {
-        const message = 'HTML does not have a single root node';
-        console.error(message, html);
-        throw new Error(message);
-      }
-      return fromDom(div.childNodes[0]);
-    };
-    const fromTag = (tag, scope) => {
-      const doc = scope || document;
-      const node = doc.createElement(tag);
-      return fromDom(node);
-    };
-    const fromText = (text, scope) => {
-      const doc = scope || document;
-      const node = doc.createTextNode(text);
-      return fromDom(node);
-    };
-    const fromDom = node => {
-      if (node === null || node === undefined) {
-        throw new Error('Node cannot be null or undefined');
-      }
-      return { dom: node };
-    };
-    const fromPoint = (docElm, x, y) => Optional.from(docElm.dom.elementFromPoint(x, y)).map(fromDom);
-    const SugarElement = {
-      fromHtml,
-      fromTag,
-      fromText,
-      fromDom,
-      fromPoint
-    };
-
-    const is = (element, selector) => {
-      const dom = element.dom;
-      if (dom.nodeType !== ELEMENT) {
-        return false;
-      } else {
-        const elem = dom;
-        if (elem.matches !== undefined) {
-          return elem.matches(selector);
-        } else if (elem.msMatchesSelector !== undefined) {
-          return elem.msMatchesSelector(selector);
-        } else if (elem.webkitMatchesSelector !== undefined) {
-          return elem.webkitMatchesSelector(selector);
-        } else if (elem.mozMatchesSelector !== undefined) {
-          return elem.mozMatchesSelector(selector);
-        } else {
-          throw new Error('Browser lacks native selectors');
-        }
-      }
-    };
-
-    typeof window !== 'undefined' ? window : Function('return this;')();
-
-    const name = element => {
-      const r = element.dom.nodeName;
-      return r.toLowerCase();
-    };
-
-    const ancestor$1 = (scope, predicate, isRoot) => {
-      let element = scope.dom;
-      const stop = isFunction(isRoot) ? isRoot : never;
-      while (element.parentNode) {
-        element = element.parentNode;
-        const el = SugarElement.fromDom(element);
-        if (predicate(el)) {
-          return Optional.some(el);
-        } else if (stop(el)) {
-          break;
-        }
-      }
-      return Optional.none();
-    };
-    const closest$1 = (scope, predicate, isRoot) => {
-      const is = (s, test) => test(s);
-      return ClosestOrAncestor(is, ancestor$1, scope, predicate, isRoot);
-    };
-
-    const ancestor = (scope, selector, isRoot) => ancestor$1(scope, e => is(e, selector), isRoot);
-    const closest = (scope, selector, isRoot) => {
-      const is$1 = (element, selector) => is(element, selector);
-      return ClosestOrAncestor(is$1, ancestor, scope, selector, isRoot);
-    };
-
-    const addToEditor$1 = editor => {
-      const insertToolbarItems = getInsertToolbarItems(editor);
-      if (insertToolbarItems.length > 0) {
-        editor.ui.registry.addContextToolbar('quickblock', {
-          predicate: node => {
-            const sugarNode = SugarElement.fromDom(node);
-            const textBlockElementsMap = editor.schema.getTextBlockElements();
-            const isRoot = elem => elem.dom === editor.getBody();
-            return closest(sugarNode, 'table', isRoot).fold(() => closest$1(sugarNode, elem => name(elem) in textBlockElementsMap && editor.dom.isEmpty(elem.dom), isRoot).isSome(), never);
-          },
-          items: insertToolbarItems,
-          position: 'line',
-          scope: 'editor'
-        });
-      }
-    };
-
-    const addToEditor = editor => {
-      const isEditable = node => editor.dom.getContentEditableParent(node) !== 'false';
-      const isImage = node => node.nodeName === 'IMG' || node.nodeName === 'FIGURE' && /image/i.test(node.className);
-      const imageToolbarItems = getImageToolbarItems(editor);
-      if (imageToolbarItems.length > 0) {
-        editor.ui.registry.addContextToolbar('imageselection', {
-          predicate: isImage,
-          items: imageToolbarItems,
-          position: 'node'
-        });
-      }
-      const textToolbarItems = getTextSelectionToolbarItems(editor);
-      if (textToolbarItems.length > 0) {
-        editor.ui.registry.addContextToolbar('textselection', {
-          predicate: node => !isImage(node) && !editor.selection.isCollapsed() && isEditable(node),
-          items: textToolbarItems,
-          position: 'selection',
-          scope: 'editor'
-        });
-      }
-    };
-
-    var Plugin = () => {
-      global$2.add('quickbars', editor => {
-        register(editor);
-        setupButtons(editor);
-        addToEditor$1(editor);
-        addToEditor(editor);
-      });
-    };
-
-    Plugin();
-
-})();

public/tiny/plugins/save/index.js

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

public/tiny/plugins/save/plugin.js

@@ -1,118 +0,0 @@
-/**
- * TinyMCE version 6.0.3 (2022-05-25)
- */
-
-(function () {
-    'use strict';
-
-    var global$2 = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    const isSimpleType = type => value => typeof value === type;
-    const isFunction = isSimpleType('function');
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');
-
-    var global = tinymce.util.Tools.resolve('tinymce.util.Tools');
-
-    const option = name => editor => editor.options.get(name);
-    const register$2 = editor => {
-      const registerOption = editor.options.register;
-      registerOption('save_enablewhendirty', {
-        processor: 'boolean',
-        default: true
-      });
-      registerOption('save_onsavecallback', { processor: 'function' });
-      registerOption('save_oncancelcallback', { processor: 'function' });
-    };
-    const enableWhenDirty = option('save_enablewhendirty');
-    const getOnSaveCallback = option('save_onsavecallback');
-    const getOnCancelCallback = option('save_oncancelcallback');
-
-    const displayErrorMessage = (editor, message) => {
-      editor.notificationManager.open({
-        text: message,
-        type: 'error'
-      });
-    };
-    const save = editor => {
-      const formObj = global$1.DOM.getParent(editor.id, 'form');
-      if (enableWhenDirty(editor) && !editor.isDirty()) {
-        return;
-      }
-      editor.save();
-      const onSaveCallback = getOnSaveCallback(editor);
-      if (isFunction(onSaveCallback)) {
-        onSaveCallback.call(editor, editor);
-        editor.nodeChanged();
-        return;
-      }
-      if (formObj) {
-        editor.setDirty(false);
-        if (!formObj.onsubmit || formObj.onsubmit()) {
-          if (typeof formObj.submit === 'function') {
-            formObj.submit();
-          } else {
-            displayErrorMessage(editor, 'Error: Form submit field collision.');
-          }
-        }
-        editor.nodeChanged();
-      } else {
-        displayErrorMessage(editor, 'Error: No form element found.');
-      }
-    };
-    const cancel = editor => {
-      const h = global.trim(editor.startContent);
-      const onCancelCallback = getOnCancelCallback(editor);
-      if (isFunction(onCancelCallback)) {
-        onCancelCallback.call(editor, editor);
-        return;
-      }
-      editor.resetContent(h);
-    };
-
-    const register$1 = editor => {
-      editor.addCommand('mceSave', () => {
-        save(editor);
-      });
-      editor.addCommand('mceCancel', () => {
-        cancel(editor);
-      });
-    };
-
-    const stateToggle = editor => api => {
-      const handler = () => {
-        api.setEnabled(!enableWhenDirty(editor) || editor.isDirty());
-      };
-      handler();
-      editor.on('NodeChange dirty', handler);
-      return () => editor.off('NodeChange dirty', handler);
-    };
-    const register = editor => {
-      editor.ui.registry.addButton('save', {
-        icon: 'save',
-        tooltip: 'Save',
-        enabled: false,
-        onAction: () => editor.execCommand('mceSave'),
-        onSetup: stateToggle(editor)
-      });
-      editor.ui.registry.addButton('cancel', {
-        icon: 'cancel',
-        tooltip: 'Cancel',
-        enabled: false,
-        onAction: () => editor.execCommand('mceCancel'),
-        onSetup: stateToggle(editor)
-      });
-      editor.addShortcut('Meta+S', '', 'mceSave');
-    };
-
-    var Plugin = () => {
-      global$2.add('save', editor => {
-        register$2(editor);
-        register(editor);
-        register$1(editor);
-      });
-    };
-
-    Plugin();
-
-})();

public/tiny/plugins/searchreplace/index.js

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

public/tiny/plugins/table/index.js

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

public/tiny/plugins/template/index.js

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

public/tiny/plugins/template/plugin.js

@@ -1,536 +0,0 @@
-/**
- * TinyMCE version 6.0.3 (2022-05-25)
- */
-
-(function () {
-    'use strict';
-
-    var global$2 = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    const hasProto = (v, constructor, predicate) => {
-      var _a;
-      if (predicate(v, constructor.prototype)) {
-        return true;
-      } else {
-        return ((_a = v.constructor) === null || _a === void 0 ? void 0 : _a.name) === constructor.name;
-      }
-    };
-    const typeOf = x => {
-      const t = typeof x;
-      if (x === null) {
-        return 'null';
-      } else if (t === 'object' && Array.isArray(x)) {
-        return 'array';
-      } else if (t === 'object' && hasProto(x, String, (o, proto) => proto.isPrototypeOf(o))) {
-        return 'string';
-      } else {
-        return t;
-      }
-    };
-    const isType = type => value => typeOf(value) === type;
-    const isSimpleType = type => value => typeof value === type;
-    const isString = isType('string');
-    const isObject = isType('object');
-    const isArray = isType('array');
-    const isNullable = a => a === null || a === undefined;
-    const isNonNullable = a => !isNullable(a);
-    const isFunction = isSimpleType('function');
-    const isArrayOf = (value, pred) => {
-      if (isArray(value)) {
-        for (let i = 0, len = value.length; i < len; ++i) {
-          if (!pred(value[i])) {
-            return false;
-          }
-        }
-        return true;
-      }
-      return false;
-    };
-
-    const constant = value => {
-      return () => {
-        return value;
-      };
-    };
-    function curry(fn, ...initialArgs) {
-      return (...restArgs) => {
-        const all = initialArgs.concat(restArgs);
-        return fn.apply(null, all);
-      };
-    }
-    const never = constant(false);
-
-    var global$1 = tinymce.util.Tools.resolve('tinymce.util.Tools');
-
-    const option = name => editor => editor.options.get(name);
-    const register$2 = editor => {
-      const registerOption = editor.options.register;
-      registerOption('template_cdate_classes', {
-        processor: 'string',
-        default: 'cdate'
-      });
-      registerOption('template_mdate_classes', {
-        processor: 'string',
-        default: 'mdate'
-      });
-      registerOption('template_selected_content_classes', {
-        processor: 'string',
-        default: 'selcontent'
-      });
-      registerOption('template_preview_replace_values', { processor: 'object' });
-      registerOption('template_replace_values', { processor: 'object' });
-      registerOption('templates', { processor: value => isString(value) || isArrayOf(value, isObject) || isFunction(value) });
-      registerOption('template_cdate_format', {
-        processor: 'string',
-        default: editor.translate('%Y-%m-%d')
-      });
-      registerOption('template_mdate_format', {
-        processor: 'string',
-        default: editor.translate('%Y-%m-%d')
-      });
-    };
-    const getCreationDateClasses = option('template_cdate_classes');
-    const getModificationDateClasses = option('template_mdate_classes');
-    const getSelectedContentClasses = option('template_selected_content_classes');
-    const getPreviewReplaceValues = option('template_preview_replace_values');
-    const getTemplateReplaceValues = option('template_replace_values');
-    const getTemplates = option('templates');
-    const getCdateFormat = option('template_cdate_format');
-    const getMdateFormat = option('template_mdate_format');
-    const getContentStyle = option('content_style');
-    const shouldUseContentCssCors = option('content_css_cors');
-    const getBodyClass = option('body_class');
-
-    const addZeros = (value, len) => {
-      value = '' + value;
-      if (value.length < len) {
-        for (let i = 0; i < len - value.length; i++) {
-          value = '0' + value;
-        }
-      }
-      return value;
-    };
-    const getDateTime = (editor, fmt, date = new Date()) => {
-      const daysShort = 'Sun Mon Tue Wed Thu Fri Sat Sun'.split(' ');
-      const daysLong = 'Sunday Monday Tuesday Wednesday Thursday Friday Saturday Sunday'.split(' ');
-      const monthsShort = 'Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec'.split(' ');
-      const monthsLong = 'January February March April May June July August September October November December'.split(' ');
-      fmt = fmt.replace('%D', '%m/%d/%Y');
-      fmt = fmt.replace('%r', '%I:%M:%S %p');
-      fmt = fmt.replace('%Y', '' + date.getFullYear());
-      fmt = fmt.replace('%y', '' + date.getYear());
-      fmt = fmt.replace('%m', addZeros(date.getMonth() + 1, 2));
-      fmt = fmt.replace('%d', addZeros(date.getDate(), 2));
-      fmt = fmt.replace('%H', '' + addZeros(date.getHours(), 2));
-      fmt = fmt.replace('%M', '' + addZeros(date.getMinutes(), 2));
-      fmt = fmt.replace('%S', '' + addZeros(date.getSeconds(), 2));
-      fmt = fmt.replace('%I', '' + ((date.getHours() + 11) % 12 + 1));
-      fmt = fmt.replace('%p', '' + (date.getHours() < 12 ? 'AM' : 'PM'));
-      fmt = fmt.replace('%B', '' + editor.translate(monthsLong[date.getMonth()]));
-      fmt = fmt.replace('%b', '' + editor.translate(monthsShort[date.getMonth()]));
-      fmt = fmt.replace('%A', '' + editor.translate(daysLong[date.getDay()]));
-      fmt = fmt.replace('%a', '' + editor.translate(daysShort[date.getDay()]));
-      fmt = fmt.replace('%%', '%');
-      return fmt;
-    };
-
-    const createTemplateList = (editor, callback) => {
-      return () => {
-        const templateList = getTemplates(editor);
-        if (isFunction(templateList)) {
-          templateList(callback);
-        } else if (isString(templateList)) {
-          fetch(templateList).then(res => {
-            if (res.ok) {
-              res.json().then(callback);
-            }
-          });
-        } else {
-          callback(templateList);
-        }
-      };
-    };
-    const replaceTemplateValues = (html, templateValues) => {
-      global$1.each(templateValues, (v, k) => {
-        if (isFunction(v)) {
-          v = v(k);
-        }
-        html = html.replace(new RegExp('\\{\\$' + k + '\\}', 'g'), v);
-      });
-      return html;
-    };
-    const replaceVals = (editor, scope) => {
-      const dom = editor.dom, vl = getTemplateReplaceValues(editor);
-      global$1.each(dom.select('*', scope), e => {
-        global$1.each(vl, (v, k) => {
-          if (dom.hasClass(e, k)) {
-            if (isFunction(v)) {
-              v(e);
-            }
-          }
-        });
-      });
-    };
-    const hasClass = (n, c) => new RegExp('\\b' + c + '\\b', 'g').test(n.className);
-    const insertTemplate = (editor, _ui, html) => {
-      const dom = editor.dom;
-      const sel = editor.selection.getContent();
-      html = replaceTemplateValues(html, getTemplateReplaceValues(editor));
-      let el = dom.create('div', null, html);
-      const n = dom.select('.mceTmpl', el);
-      if (n && n.length > 0) {
-        el = dom.create('div', null);
-        el.appendChild(n[0].cloneNode(true));
-      }
-      global$1.each(dom.select('*', el), n => {
-        if (hasClass(n, getCreationDateClasses(editor).replace(/\s+/g, '|'))) {
-          n.innerHTML = getDateTime(editor, getCdateFormat(editor));
-        }
-        if (hasClass(n, getModificationDateClasses(editor).replace(/\s+/g, '|'))) {
-          n.innerHTML = getDateTime(editor, getMdateFormat(editor));
-        }
-        if (hasClass(n, getSelectedContentClasses(editor).replace(/\s+/g, '|'))) {
-          n.innerHTML = sel;
-        }
-      });
-      replaceVals(editor, el);
-      editor.execCommand('mceInsertContent', false, el.innerHTML);
-      editor.addVisual();
-    };
-
-    class Optional {
-      constructor(tag, value) {
-        this.tag = tag;
-        this.value = value;
-      }
-      static some(value) {
-        return new Optional(true, value);
-      }
-      static none() {
-        return Optional.singletonNone;
-      }
-      fold(onNone, onSome) {
-        if (this.tag) {
-          return onSome(this.value);
-        } else {
-          return onNone();
-        }
-      }
-      isSome() {
-        return this.tag;
-      }
-      isNone() {
-        return !this.tag;
-      }
-      map(mapper) {
-        if (this.tag) {
-          return Optional.some(mapper(this.value));
-        } else {
-          return Optional.none();
-        }
-      }
-      bind(binder) {
-        if (this.tag) {
-          return binder(this.value);
-        } else {
-          return Optional.none();
-        }
-      }
-      exists(predicate) {
-        return this.tag && predicate(this.value);
-      }
-      forall(predicate) {
-        return !this.tag || predicate(this.value);
-      }
-      filter(predicate) {
-        if (!this.tag || predicate(this.value)) {
-          return this;
-        } else {
-          return Optional.none();
-        }
-      }
-      getOr(replacement) {
-        return this.tag ? this.value : replacement;
-      }
-      or(replacement) {
-        return this.tag ? this : replacement;
-      }
-      getOrThunk(thunk) {
-        return this.tag ? this.value : thunk();
-      }
-      orThunk(thunk) {
-        return this.tag ? this : thunk();
-      }
-      getOrDie(message) {
-        if (!this.tag) {
-          throw new Error(message !== null && message !== void 0 ? message : 'Called getOrDie on None');
-        } else {
-          return this.value;
-        }
-      }
-      static from(value) {
-        return isNonNullable(value) ? Optional.some(value) : Optional.none();
-      }
-      getOrNull() {
-        return this.tag ? this.value : null;
-      }
-      getOrUndefined() {
-        return this.value;
-      }
-      each(worker) {
-        if (this.tag) {
-          worker(this.value);
-        }
-      }
-      toArray() {
-        return this.tag ? [this.value] : [];
-      }
-      toString() {
-        return this.tag ? `some(${ this.value })` : 'none()';
-      }
-    }
-    Optional.singletonNone = new Optional(false);
-
-    const map = (xs, f) => {
-      const len = xs.length;
-      const r = new Array(len);
-      for (let i = 0; i < len; i++) {
-        const x = xs[i];
-        r[i] = f(x, i);
-      }
-      return r;
-    };
-    const findUntil = (xs, pred, until) => {
-      for (let i = 0, len = xs.length; i < len; i++) {
-        const x = xs[i];
-        if (pred(x, i)) {
-          return Optional.some(x);
-        } else if (until(x, i)) {
-          break;
-        }
-      }
-      return Optional.none();
-    };
-    const find = (xs, pred) => {
-      return findUntil(xs, pred, never);
-    };
-
-    var global = tinymce.util.Tools.resolve('tinymce.Env');
-
-    const hasOwnProperty = Object.hasOwnProperty;
-    const get = (obj, key) => {
-      return has(obj, key) ? Optional.from(obj[key]) : Optional.none();
-    };
-    const has = (obj, key) => hasOwnProperty.call(obj, key);
-
-    const entitiesAttr = {
-      '"': '&quot;',
-      '<': '&lt;',
-      '>': '&gt;',
-      '&': '&amp;',
-      '\'': '&#039;'
-    };
-    const htmlEscape = html => html.replace(/["'<>&]/g, match => get(entitiesAttr, match).getOr(match));
-
-    const getPreviewContent = (editor, html) => {
-      var _a;
-      if (html.indexOf('<html>') === -1) {
-        let contentCssEntries = '';
-        const contentStyle = (_a = getContentStyle(editor)) !== null && _a !== void 0 ? _a : '';
-        const cors = shouldUseContentCssCors(editor) ? ' crossorigin="anonymous"' : '';
-        global$1.each(editor.contentCSS, url => {
-          contentCssEntries += '<link type="text/css" rel="stylesheet" href="' + editor.documentBaseURI.toAbsolute(url) + '"' + cors + '>';
-        });
-        if (contentStyle) {
-          contentCssEntries += '<style type="text/css">' + contentStyle + '</style>';
-        }
-        const bodyClass = getBodyClass(editor);
-        const encode = editor.dom.encode;
-        const isMetaKeyPressed = global.os.isMacOS() || global.os.isiOS() ? 'e.metaKey' : 'e.ctrlKey && !e.altKey';
-        const preventClicksOnLinksScript = '<script>' + 'document.addEventListener && document.addEventListener("click", function(e) {' + 'for (var elm = e.target; elm; elm = elm.parentNode) {' + 'if (elm.nodeName === "A" && !(' + isMetaKeyPressed + ')) {' + 'e.preventDefault();' + '}' + '}' + '}, false);' + '</script> ';
-        const directionality = editor.getBody().dir;
-        const dirAttr = directionality ? ' dir="' + encode(directionality) + '"' : '';
-        html = '<!DOCTYPE html>' + '<html>' + '<head>' + '<base href="' + encode(editor.documentBaseURI.getURI()) + '">' + contentCssEntries + preventClicksOnLinksScript + '</head>' + '<body class="' + encode(bodyClass) + '"' + dirAttr + '>' + html + '</body>' + '</html>';
-      }
-      return replaceTemplateValues(html, getPreviewReplaceValues(editor));
-    };
-    const open = (editor, templateList) => {
-      const createTemplates = () => {
-        if (!templateList || templateList.length === 0) {
-          const message = editor.translate('No templates defined.');
-          editor.notificationManager.open({
-            text: message,
-            type: 'info'
-          });
-          return Optional.none();
-        }
-        return Optional.from(global$1.map(templateList, (template, index) => {
-          const isUrlTemplate = t => t.url !== undefined;
-          return {
-            selected: index === 0,
-            text: template.title,
-            value: {
-              url: isUrlTemplate(template) ? Optional.from(template.url) : Optional.none(),
-              content: !isUrlTemplate(template) ? Optional.from(template.content) : Optional.none(),
-              description: template.description
-            }
-          };
-        }));
-      };
-      const createSelectBoxItems = templates => map(templates, t => ({
-        text: t.text,
-        value: t.text
-      }));
-      const findTemplate = (templates, templateTitle) => find(templates, t => t.text === templateTitle);
-      const loadFailedAlert = api => {
-        editor.windowManager.alert('Could not load the specified template.', () => api.focus('template'));
-      };
-      const getTemplateContent = t => t.value.url.fold(() => Promise.resolve(t.value.content.getOr('')), url => fetch(url).then(res => res.ok ? res.text() : Promise.reject()));
-      const onChange = (templates, updateDialog) => (api, change) => {
-        if (change.name === 'template') {
-          const newTemplateTitle = api.getData().template;
-          findTemplate(templates, newTemplateTitle).each(t => {
-            api.block('Loading...');
-            getTemplateContent(t).then(previewHtml => {
-              updateDialog(api, t, previewHtml);
-            }).catch(() => {
-              updateDialog(api, t, '');
-              api.setEnabled('save', false);
-              loadFailedAlert(api);
-            });
-          });
-        }
-      };
-      const onSubmit = templates => api => {
-        const data = api.getData();
-        findTemplate(templates, data.template).each(t => {
-          getTemplateContent(t).then(previewHtml => {
-            editor.execCommand('mceInsertTemplate', false, previewHtml);
-            api.close();
-          }).catch(() => {
-            api.setEnabled('save', false);
-            loadFailedAlert(api);
-          });
-        });
-      };
-      const openDialog = templates => {
-        const selectBoxItems = createSelectBoxItems(templates);
-        const buildDialogSpec = (bodyItems, initialData) => ({
-          title: 'Insert Template',
-          size: 'large',
-          body: {
-            type: 'panel',
-            items: bodyItems
-          },
-          initialData,
-          buttons: [
-            {
-              type: 'cancel',
-              name: 'cancel',
-              text: 'Cancel'
-            },
-            {
-              type: 'submit',
-              name: 'save',
-              text: 'Save',
-              primary: true
-            }
-          ],
-          onSubmit: onSubmit(templates),
-          onChange: onChange(templates, updateDialog)
-        });
-        const updateDialog = (dialogApi, template, previewHtml) => {
-          const content = getPreviewContent(editor, previewHtml);
-          const bodyItems = [
-            {
-              type: 'selectbox',
-              name: 'template',
-              label: 'Templates',
-              items: selectBoxItems
-            },
-            {
-              type: 'htmlpanel',
-              html: `<p aria-live="polite">${ htmlEscape(template.value.description) }</p>`
-            },
-            {
-              label: 'Preview',
-              type: 'iframe',
-              name: 'preview',
-              sandboxed: false
-            }
-          ];
-          const initialData = {
-            template: template.text,
-            preview: content
-          };
-          dialogApi.unblock();
-          dialogApi.redial(buildDialogSpec(bodyItems, initialData));
-          dialogApi.focus('template');
-        };
-        const dialogApi = editor.windowManager.open(buildDialogSpec([], {
-          template: '',
-          preview: ''
-        }));
-        dialogApi.block('Loading...');
-        getTemplateContent(templates[0]).then(previewHtml => {
-          updateDialog(dialogApi, templates[0], previewHtml);
-        }).catch(() => {
-          updateDialog(dialogApi, templates[0], '');
-          dialogApi.setEnabled('save', false);
-          loadFailedAlert(dialogApi);
-        });
-      };
-      const optTemplates = createTemplates();
-      optTemplates.each(openDialog);
-    };
-
-    const showDialog = editor => templates => {
-      open(editor, templates);
-    };
-    const register$1 = editor => {
-      editor.addCommand('mceInsertTemplate', curry(insertTemplate, editor));
-      editor.addCommand('mceTemplate', createTemplateList(editor, showDialog(editor)));
-    };
-
-    const setup = editor => {
-      editor.on('PreProcess', o => {
-        const dom = editor.dom, dateFormat = getMdateFormat(editor);
-        global$1.each(dom.select('div', o.node), e => {
-          if (dom.hasClass(e, 'mceTmpl')) {
-            global$1.each(dom.select('*', e), e => {
-              if (dom.hasClass(e, getModificationDateClasses(editor).replace(/\s+/g, '|'))) {
-                e.innerHTML = getDateTime(editor, dateFormat);
-              }
-            });
-            replaceVals(editor, e);
-          }
-        });
-      });
-    };
-
-    const register = editor => {
-      const onAction = () => editor.execCommand('mceTemplate');
-      editor.ui.registry.addButton('template', {
-        icon: 'template',
-        tooltip: 'Insert template',
-        onAction
-      });
-      editor.ui.registry.addMenuItem('template', {
-        icon: 'template',
-        text: 'Insert template...',
-        onAction
-      });
-    };
-
-    var Plugin = () => {
-      global$2.add('template', editor => {
-        register$2(editor);
-        register(editor);
-        register$1(editor);
-        setup(editor);
-      });
-    };
-
-    Plugin();
-
-})();

public/tiny/plugins/visualblocks/index.js

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

public/tiny/plugins/visualblocks/plugin.js

@@ -1,98 +0,0 @@
-/**
- * TinyMCE version 6.0.3 (2022-05-25)
- */
-
-(function () {
-    'use strict';
-
-    const Cell = initial => {
-      let value = initial;
-      const get = () => {
-        return value;
-      };
-      const set = v => {
-        value = v;
-      };
-      return {
-        get,
-        set
-      };
-    };
-
-    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    const fireVisualBlocks = (editor, state) => {
-      editor.dispatch('VisualBlocks', { state });
-    };
-
-    const toggleVisualBlocks = (editor, pluginUrl, enabledState) => {
-      const dom = editor.dom;
-      dom.toggleClass(editor.getBody(), 'mce-visualblocks');
-      enabledState.set(!enabledState.get());
-      fireVisualBlocks(editor, enabledState.get());
-    };
-
-    const register$2 = (editor, pluginUrl, enabledState) => {
-      editor.addCommand('mceVisualBlocks', () => {
-        toggleVisualBlocks(editor, pluginUrl, enabledState);
-      });
-    };
-
-    const option = name => editor => editor.options.get(name);
-    const register$1 = editor => {
-      const registerOption = editor.options.register;
-      registerOption('visualblocks_default_state', {
-        processor: 'boolean',
-        default: false
-      });
-    };
-    const isEnabledByDefault = option('visualblocks_default_state');
-
-    const setup = (editor, pluginUrl, enabledState) => {
-      editor.on('PreviewFormats AfterPreviewFormats', e => {
-        if (enabledState.get()) {
-          editor.dom.toggleClass(editor.getBody(), 'mce-visualblocks', e.type === 'afterpreviewformats');
-        }
-      });
-      editor.on('init', () => {
-        if (isEnabledByDefault(editor)) {
-          toggleVisualBlocks(editor, pluginUrl, enabledState);
-        }
-      });
-    };
-
-    const toggleActiveState = (editor, enabledState) => api => {
-      api.setActive(enabledState.get());
-      const editorEventCallback = e => api.setActive(e.state);
-      editor.on('VisualBlocks', editorEventCallback);
-      return () => editor.off('VisualBlocks', editorEventCallback);
-    };
-    const register = (editor, enabledState) => {
-      const onAction = () => editor.execCommand('mceVisualBlocks');
-      editor.ui.registry.addToggleButton('visualblocks', {
-        icon: 'visualblocks',
-        tooltip: 'Show blocks',
-        onAction,
-        onSetup: toggleActiveState(editor, enabledState)
-      });
-      editor.ui.registry.addToggleMenuItem('visualblocks', {
-        text: 'Show blocks',
-        icon: 'visualblocks',
-        onAction,
-        onSetup: toggleActiveState(editor, enabledState)
-      });
-    };
-
-    var Plugin = () => {
-      global.add('visualblocks', (editor, pluginUrl) => {
-        register$1(editor);
-        const enabledState = Cell(false);
-        register$2(editor, pluginUrl, enabledState);
-        register(editor, enabledState);
-        setup(editor, pluginUrl, enabledState);
-      });
-    };
-
-    Plugin();
-
-})();

public/tiny/plugins/visualchars/index.js

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

public/tiny/plugins/visualchars/plugin.js

@@ -1,506 +0,0 @@
-/**
- * TinyMCE version 6.0.3 (2022-05-25)
- */
-
-(function () {
-    'use strict';
-
-    const Cell = initial => {
-      let value = initial;
-      const get = () => {
-        return value;
-      };
-      const set = v => {
-        value = v;
-      };
-      return {
-        get,
-        set
-      };
-    };
-
-    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
-
-    const get$2 = toggleState => {
-      const isEnabled = () => {
-        return toggleState.get();
-      };
-      return { isEnabled };
-    };
-
-    const fireVisualChars = (editor, state) => {
-      return editor.dispatch('VisualChars', { state });
-    };
-
-    const hasProto = (v, constructor, predicate) => {
-      var _a;
-      if (predicate(v, constructor.prototype)) {
-        return true;
-      } else {
-        return ((_a = v.constructor) === null || _a === void 0 ? void 0 : _a.name) === constructor.name;
-      }
-    };
-    const typeOf = x => {
-      const t = typeof x;
-      if (x === null) {
-        return 'null';
-      } else if (t === 'object' && Array.isArray(x)) {
-        return 'array';
-      } else if (t === 'object' && hasProto(x, String, (o, proto) => proto.isPrototypeOf(o))) {
-        return 'string';
-      } else {
-        return t;
-      }
-    };
-    const isType$1 = type => value => typeOf(value) === type;
-    const isSimpleType = type => value => typeof value === type;
-    const eq = t => a => t === a;
-    const isString = isType$1('string');
-    const isNull = eq(null);
-    const isBoolean = isSimpleType('boolean');
-    const isNullable = a => a === null || a === undefined;
-    const isNonNullable = a => !isNullable(a);
-    const isNumber = isSimpleType('number');
-
-    class Optional {
-      constructor(tag, value) {
-        this.tag = tag;
-        this.value = value;
-      }
-      static some(value) {
-        return new Optional(true, value);
-      }
-      static none() {
-        return Optional.singletonNone;
-      }
-      fold(onNone, onSome) {
-        if (this.tag) {
-          return onSome(this.value);
-        } else {
-          return onNone();
-        }
-      }
-      isSome() {
-        return this.tag;
-      }
-      isNone() {
-        return !this.tag;
-      }
-      map(mapper) {
-        if (this.tag) {
-          return Optional.some(mapper(this.value));
-        } else {
-          return Optional.none();
-        }
-      }
-      bind(binder) {
-        if (this.tag) {
-          return binder(this.value);
-        } else {
-          return Optional.none();
-        }
-      }
-      exists(predicate) {
-        return this.tag && predicate(this.value);
-      }
-      forall(predicate) {
-        return !this.tag || predicate(this.value);
-      }
-      filter(predicate) {
-        if (!this.tag || predicate(this.value)) {
-          return this;
-        } else {
-          return Optional.none();
-        }
-      }
-      getOr(replacement) {
-        return this.tag ? this.value : replacement;
-      }
-      or(replacement) {
-        return this.tag ? this : replacement;
-      }
-      getOrThunk(thunk) {
-        return this.tag ? this.value : thunk();
-      }
-      orThunk(thunk) {
-        return this.tag ? this : thunk();
-      }
-      getOrDie(message) {
-        if (!this.tag) {
-          throw new Error(message !== null && message !== void 0 ? message : 'Called getOrDie on None');
-        } else {
-          return this.value;
-        }
-      }
-      static from(value) {
-        return isNonNullable(value) ? Optional.some(value) : Optional.none();
-      }
-      getOrNull() {
-        return this.tag ? this.value : null;
-      }
-      getOrUndefined() {
-        return this.value;
-      }
-      each(worker) {
-        if (this.tag) {
-          worker(this.value);
-        }
-      }
-      toArray() {
-        return this.tag ? [this.value] : [];
-      }
-      toString() {
-        return this.tag ? `some(${ this.value })` : 'none()';
-      }
-    }
-    Optional.singletonNone = new Optional(false);
-
-    const map = (xs, f) => {
-      const len = xs.length;
-      const r = new Array(len);
-      for (let i = 0; i < len; i++) {
-        const x = xs[i];
-        r[i] = f(x, i);
-      }
-      return r;
-    };
-    const each$1 = (xs, f) => {
-      for (let i = 0, len = xs.length; i < len; i++) {
-        const x = xs[i];
-        f(x, i);
-      }
-    };
-    const filter = (xs, pred) => {
-      const r = [];
-      for (let i = 0, len = xs.length; i < len; i++) {
-        const x = xs[i];
-        if (pred(x, i)) {
-          r.push(x);
-        }
-      }
-      return r;
-    };
-
-    const keys = Object.keys;
-    const each = (obj, f) => {
-      const props = keys(obj);
-      for (let k = 0, len = props.length; k < len; k++) {
-        const i = props[k];
-        const x = obj[i];
-        f(x, i);
-      }
-    };
-
-    typeof window !== 'undefined' ? window : Function('return this;')();
-
-    const TEXT = 3;
-
-    const type = element => element.dom.nodeType;
-    const value = element => element.dom.nodeValue;
-    const isType = t => element => type(element) === t;
-    const isText = isType(TEXT);
-
-    const rawSet = (dom, key, value) => {
-      if (isString(value) || isBoolean(value) || isNumber(value)) {
-        dom.setAttribute(key, value + '');
-      } else {
-        console.error('Invalid call to Attribute.set. Key ', key, ':: Value ', value, ':: Element ', dom);
-        throw new Error('Attribute value was not simple');
-      }
-    };
-    const set = (element, key, value) => {
-      rawSet(element.dom, key, value);
-    };
-    const get$1 = (element, key) => {
-      const v = element.dom.getAttribute(key);
-      return v === null ? undefined : v;
-    };
-    const remove$3 = (element, key) => {
-      element.dom.removeAttribute(key);
-    };
-
-    const read = (element, attr) => {
-      const value = get$1(element, attr);
-      return value === undefined || value === '' ? [] : value.split(' ');
-    };
-    const add$2 = (element, attr, id) => {
-      const old = read(element, attr);
-      const nu = old.concat([id]);
-      set(element, attr, nu.join(' '));
-      return true;
-    };
-    const remove$2 = (element, attr, id) => {
-      const nu = filter(read(element, attr), v => v !== id);
-      if (nu.length > 0) {
-        set(element, attr, nu.join(' '));
-      } else {
-        remove$3(element, attr);
-      }
-      return false;
-    };
-
-    const supports = element => element.dom.classList !== undefined;
-    const get = element => read(element, 'class');
-    const add$1 = (element, clazz) => add$2(element, 'class', clazz);
-    const remove$1 = (element, clazz) => remove$2(element, 'class', clazz);
-
-    const add = (element, clazz) => {
-      if (supports(element)) {
-        element.dom.classList.add(clazz);
-      } else {
-        add$1(element, clazz);
-      }
-    };
-    const cleanClass = element => {
-      const classList = supports(element) ? element.dom.classList : get(element);
-      if (classList.length === 0) {
-        remove$3(element, 'class');
-      }
-    };
-    const remove = (element, clazz) => {
-      if (supports(element)) {
-        const classList = element.dom.classList;
-        classList.remove(clazz);
-      } else {
-        remove$1(element, clazz);
-      }
-      cleanClass(element);
-    };
-
-    const fromHtml = (html, scope) => {
-      const doc = scope || document;
-      const div = doc.createElement('div');
-      div.innerHTML = html;
-      if (!div.hasChildNodes() || div.childNodes.length > 1) {
-        const message = 'HTML does not have a single root node';
-        console.error(message, html);
-        throw new Error(message);
-      }
-      return fromDom(div.childNodes[0]);
-    };
-    const fromTag = (tag, scope) => {
-      const doc = scope || document;
-      const node = doc.createElement(tag);
-      return fromDom(node);
-    };
-    const fromText = (text, scope) => {
-      const doc = scope || document;
-      const node = doc.createTextNode(text);
-      return fromDom(node);
-    };
-    const fromDom = node => {
-      if (node === null || node === undefined) {
-        throw new Error('Node cannot be null or undefined');
-      }
-      return { dom: node };
-    };
-    const fromPoint = (docElm, x, y) => Optional.from(docElm.dom.elementFromPoint(x, y)).map(fromDom);
-    const SugarElement = {
-      fromHtml,
-      fromTag,
-      fromText,
-      fromDom,
-      fromPoint
-    };
-
-    const charMap = {
-      '\xA0': 'nbsp',
-      '\xAD': 'shy'
-    };
-    const charMapToRegExp = (charMap, global) => {
-      let regExp = '';
-      each(charMap, (_value, key) => {
-        regExp += key;
-      });
-      return new RegExp('[' + regExp + ']', global ? 'g' : '');
-    };
-    const charMapToSelector = charMap => {
-      let selector = '';
-      each(charMap, value => {
-        if (selector) {
-          selector += ',';
-        }
-        selector += 'span.mce-' + value;
-      });
-      return selector;
-    };
-    const regExp = charMapToRegExp(charMap);
-    const regExpGlobal = charMapToRegExp(charMap, true);
-    const selector = charMapToSelector(charMap);
-    const nbspClass = 'mce-nbsp';
-
-    const wrapCharWithSpan = value => '<span data-mce-bogus="1" class="mce-' + charMap[value] + '">' + value + '</span>';
-
-    const isMatch = n => {
-      const value$1 = value(n);
-      return isText(n) && value$1 !== undefined && regExp.test(value$1);
-    };
-    const filterDescendants = (scope, predicate) => {
-      let result = [];
-      const dom = scope.dom;
-      const children = map(dom.childNodes, SugarElement.fromDom);
-      each$1(children, x => {
-        if (predicate(x)) {
-          result = result.concat([x]);
-        }
-        result = result.concat(filterDescendants(x, predicate));
-      });
-      return result;
-    };
-    const findParentElm = (elm, rootElm) => {
-      while (elm.parentNode) {
-        if (elm.parentNode === rootElm) {
-          return elm;
-        }
-        elm = elm.parentNode;
-      }
-    };
-    const replaceWithSpans = text => text.replace(regExpGlobal, wrapCharWithSpan);
-
-    const isWrappedNbsp = node => node.nodeName.toLowerCase() === 'span' && node.classList.contains('mce-nbsp-wrap');
-    const show = (editor, rootElm) => {
-      const nodeList = filterDescendants(SugarElement.fromDom(rootElm), isMatch);
-      each$1(nodeList, n => {
-        const parent = n.dom.parentNode;
-        if (isWrappedNbsp(parent)) {
-          add(SugarElement.fromDom(parent), nbspClass);
-        } else {
-          const withSpans = replaceWithSpans(editor.dom.encode(value(n)));
-          const div = editor.dom.create('div', null, withSpans);
-          let node;
-          while (node = div.lastChild) {
-            editor.dom.insertAfter(node, n.dom);
-          }
-          editor.dom.remove(n.dom);
-        }
-      });
-    };
-    const hide = (editor, rootElm) => {
-      const nodeList = editor.dom.select(selector, rootElm);
-      each$1(nodeList, node => {
-        if (isWrappedNbsp(node)) {
-          remove(SugarElement.fromDom(node), nbspClass);
-        } else {
-          editor.dom.remove(node, true);
-        }
-      });
-    };
-    const toggle = editor => {
-      const body = editor.getBody();
-      const bookmark = editor.selection.getBookmark();
-      let parentNode = findParentElm(editor.selection.getNode(), body);
-      parentNode = parentNode !== undefined ? parentNode : body;
-      hide(editor, parentNode);
-      show(editor, parentNode);
-      editor.selection.moveToBookmark(bookmark);
-    };
-
-    const applyVisualChars = (editor, toggleState) => {
-      fireVisualChars(editor, toggleState.get());
-      const body = editor.getBody();
-      if (toggleState.get() === true) {
-        show(editor, body);
-      } else {
-        hide(editor, body);
-      }
-    };
-    const toggleVisualChars = (editor, toggleState) => {
-      toggleState.set(!toggleState.get());
-      const bookmark = editor.selection.getBookmark();
-      applyVisualChars(editor, toggleState);
-      editor.selection.moveToBookmark(bookmark);
-    };
-
-    const register$2 = (editor, toggleState) => {
-      editor.addCommand('mceVisualChars', () => {
-        toggleVisualChars(editor, toggleState);
-      });
-    };
-
-    const option = name => editor => editor.options.get(name);
-    const register$1 = editor => {
-      const registerOption = editor.options.register;
-      registerOption('visualchars_default_state', {
-        processor: 'boolean',
-        default: false
-      });
-    };
-    const isEnabledByDefault = option('visualchars_default_state');
-
-    const setup$1 = (editor, toggleState) => {
-      editor.on('init', () => {
-        applyVisualChars(editor, toggleState);
-      });
-    };
-
-    const first = (fn, rate) => {
-      let timer = null;
-      const cancel = () => {
-        if (!isNull(timer)) {
-          clearTimeout(timer);
-          timer = null;
-        }
-      };
-      const throttle = (...args) => {
-        if (isNull(timer)) {
-          timer = setTimeout(() => {
-            timer = null;
-            fn.apply(null, args);
-          }, rate);
-        }
-      };
-      return {
-        cancel,
-        throttle
-      };
-    };
-
-    const setup = (editor, toggleState) => {
-      const debouncedToggle = first(() => {
-        toggle(editor);
-      }, 300);
-      editor.on('keydown', e => {
-        if (toggleState.get() === true) {
-          e.keyCode === 13 ? toggle(editor) : debouncedToggle.throttle();
-        }
-      });
-      editor.on('remove', debouncedToggle.cancel);
-    };
-
-    const toggleActiveState = (editor, enabledStated) => api => {
-      api.setActive(enabledStated.get());
-      const editorEventCallback = e => api.setActive(e.state);
-      editor.on('VisualChars', editorEventCallback);
-      return () => editor.off('VisualChars', editorEventCallback);
-    };
-    const register = (editor, toggleState) => {
-      const onAction = () => editor.execCommand('mceVisualChars');
-      editor.ui.registry.addToggleButton('visualchars', {
-        tooltip: 'Show invisible characters',
-        icon: 'visualchars',
-        onAction,
-        onSetup: toggleActiveState(editor, toggleState)
-      });
-      editor.ui.registry.addToggleMenuItem('visualchars', {
-        text: 'Show invisible characters',
-        icon: 'visualchars',
-        onAction,
-        onSetup: toggleActiveState(editor, toggleState)
-      });
-    };
-
-    var Plugin = () => {
-      global.add('visualchars', editor => {
-        register$1(editor);
-        const toggleState = Cell(isEnabledByDefault(editor));
-        register$2(editor, toggleState);
-        register(editor, toggleState);
-        setup(editor, toggleState);
-        setup$1(editor, toggleState);
-        return get$2(toggleState);
-      });
-    };
-
-    Plugin();
-
-})();

public/tiny/plugins/wordcount/index.js

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