完成世界书、骰子、apiconfig页面处理

frontend/node_modules/highlight.js/es/common.d.ts

@@ -0,0 +1,3 @@
+import hljs from "highlight.js";
+export default hljs;
+

frontend/node_modules/highlight.js/es/core.js

@@ -0,0 +1,4 @@
+// https://nodejs.org/api/packages.html#packages_writing_dual_packages_while_avoiding_or_minimizing_hazards
+import HighlightJS from '../lib/core.js';
+export { HighlightJS };
+export default HighlightJS;

frontend/node_modules/highlight.js/es/languages/accesslog.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/accesslog" instead of "highlight.js/lib/languages/accesslog.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './accesslog.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/actionscript.js

@@ -0,0 +1,153 @@
+/*
+Language: ActionScript
+Author: Alexander Myadzel <myadzel@gmail.com>
+Category: scripting
+Audit: 2020
+*/
+
+/** @type LanguageFn */
+function actionscript(hljs) {
+  const regex = hljs.regex;
+  const IDENT_RE = /[a-zA-Z_$][a-zA-Z0-9_$]*/;
+  const PKG_NAME_RE = regex.concat(
+    IDENT_RE,
+    regex.concat("(\\.", IDENT_RE, ")*")
+  );
+  const IDENT_FUNC_RETURN_TYPE_RE = /([*]|[a-zA-Z_$][a-zA-Z0-9_$]*)/;
+
+  const AS3_REST_ARG_MODE = {
+    className: 'rest_arg',
+    begin: /[.]{3}/,
+    end: IDENT_RE,
+    relevance: 10
+  };
+
+  const KEYWORDS = [
+    "as",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "default",
+    "delete",
+    "do",
+    "dynamic",
+    "each",
+    "else",
+    "extends",
+    "final",
+    "finally",
+    "for",
+    "function",
+    "get",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "include",
+    "instanceof",
+    "interface",
+    "internal",
+    "is",
+    "namespace",
+    "native",
+    "new",
+    "override",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "return",
+    "set",
+    "static",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "try",
+    "typeof",
+    "use",
+    "var",
+    "void",
+    "while",
+    "with"
+  ];
+  const LITERALS = [
+    "true",
+    "false",
+    "null",
+    "undefined"
+  ];
+
+  return {
+    name: 'ActionScript',
+    aliases: [ 'as' ],
+    keywords: {
+      keyword: KEYWORDS,
+      literal: LITERALS
+    },
+    contains: [
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE,
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      hljs.C_NUMBER_MODE,
+      {
+        match: [
+          /\bpackage/,
+          /\s+/,
+          PKG_NAME_RE
+        ],
+        className: {
+          1: "keyword",
+          3: "title.class"
+        }
+      },
+      {
+        match: [
+          /\b(?:class|interface|extends|implements)/,
+          /\s+/,
+          IDENT_RE
+        ],
+        className: {
+          1: "keyword",
+          3: "title.class"
+        }
+      },
+      {
+        className: 'meta',
+        beginKeywords: 'import include',
+        end: /;/,
+        keywords: { keyword: 'import include' }
+      },
+      {
+        beginKeywords: 'function',
+        end: /[{;]/,
+        excludeEnd: true,
+        illegal: /\S/,
+        contains: [
+          hljs.inherit(hljs.TITLE_MODE, { className: "title.function" }),
+          {
+            className: 'params',
+            begin: /\(/,
+            end: /\)/,
+            contains: [
+              hljs.APOS_STRING_MODE,
+              hljs.QUOTE_STRING_MODE,
+              hljs.C_LINE_COMMENT_MODE,
+              hljs.C_BLOCK_COMMENT_MODE,
+              AS3_REST_ARG_MODE
+            ]
+          },
+          { begin: regex.concat(/:\s*/, IDENT_FUNC_RETURN_TYPE_RE) }
+        ]
+      },
+      hljs.METHOD_GUARD
+    ],
+    illegal: /#/
+  };
+}
+
+export { actionscript as default };

frontend/node_modules/highlight.js/es/languages/ada.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/ada" instead of "highlight.js/lib/languages/ada.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './ada.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/angelscript.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/angelscript" instead of "highlight.js/lib/languages/angelscript.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './angelscript.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/applescript.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/applescript" instead of "highlight.js/lib/languages/applescript.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './applescript.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/arcade.js

@@ -0,0 +1,428 @@
+/*
+ Language: ArcGIS Arcade
+ Category: scripting
+ Website: https://developers.arcgis.com/arcade/
+ Description: ArcGIS Arcade is an expression language used in many Esri ArcGIS products such as Pro, Online, Server, Runtime, JavaScript, and Python
+*/
+
+/** @type LanguageFn */
+function arcade(hljs) {
+  const regex = hljs.regex;
+  const IDENT_RE = '[A-Za-z_][0-9A-Za-z_]*';
+  const KEYWORDS = {
+    keyword: [
+      "break",
+      "case",
+      "catch",
+      "continue",
+      "debugger",
+      "do",
+      "else",
+      "export",
+      "for",
+      "function",
+      "if",
+      "import",
+      "in",
+      "new",
+      "of",
+      "return",
+      "switch",
+      "try",
+      "var",
+      "void",
+      "while"
+    ],
+    literal: [
+      "BackSlash",
+      "DoubleQuote",
+      "ForwardSlash",
+      "Infinity",
+      "NaN",
+      "NewLine",
+      "PI",
+      "SingleQuote",
+      "Tab",
+      "TextFormatting",
+      "false",
+      "null",
+      "true",
+      "undefined"
+    ],
+    built_in: [
+      "Abs",
+      "Acos",
+      "All",
+      "Angle",
+      "Any",
+      "Area",
+      "AreaGeodetic",
+      "Array",
+      "Asin",
+      "Atan",
+      "Atan2",
+      "Attachments",
+      "Average",
+      "Back",
+      "Bearing",
+      "Boolean",
+      "Buffer",
+      "BufferGeodetic",
+      "Ceil",
+      "Centroid",
+      "ChangeTimeZone",
+      "Clip",
+      "Concatenate",
+      "Console",
+      "Constrain",
+      "Contains",
+      "ConvertDirection",
+      "ConvexHull",
+      "Cos",
+      "Count",
+      "Crosses",
+      "Cut",
+      "Date|0",
+      "DateAdd",
+      "DateDiff",
+      "DateOnly",
+      "Day",
+      "Decode",
+      "DefaultValue",
+      "Densify",
+      "DensifyGeodetic",
+      "Dictionary",
+      "Difference",
+      "Disjoint",
+      "Distance",
+      "DistanceGeodetic",
+      "DistanceToCoordinate",
+      "Distinct",
+      "Domain",
+      "DomainCode",
+      "DomainName",
+      "EnvelopeIntersects",
+      "Equals",
+      "Erase",
+      "Exp",
+      "Expects",
+      "Extent",
+      "Feature",
+      "FeatureInFilter",
+      "FeatureSet",
+      "FeatureSetByAssociation",
+      "FeatureSetById",
+      "FeatureSetByName",
+      "FeatureSetByPortalItem",
+      "FeatureSetByRelationshipClass",
+      "FeatureSetByRelationshipName",
+      "Filter",
+      "FilterBySubtypeCode",
+      "Find",
+      "First|0",
+      "Floor",
+      "FromCharCode",
+      "FromCodePoint",
+      "FromJSON",
+      "Front",
+      "GdbVersion",
+      "Generalize",
+      "Geometry",
+      "GetEnvironment",
+      "GetFeatureSet",
+      "GetFeatureSetInfo",
+      "GetUser",
+      "GroupBy",
+      "Guid",
+      "HasKey",
+      "HasValue",
+      "Hash",
+      "Hour",
+      "IIf",
+      "ISOMonth",
+      "ISOWeek",
+      "ISOWeekday",
+      "ISOYear",
+      "Includes",
+      "IndexOf",
+      "Insert",
+      "Intersection",
+      "Intersects",
+      "IsEmpty",
+      "IsNan",
+      "IsSelfIntersecting",
+      "IsSimple",
+      "KnowledgeGraphByPortalItem",
+      "Left|0",
+      "Length",
+      "Length3D",
+      "LengthGeodetic",
+      "Log",
+      "Lower",
+      "Map",
+      "Max",
+      "Mean",
+      "MeasureToCoordinate",
+      "Mid",
+      "Millisecond",
+      "Min",
+      "Minute",
+      "Month",
+      "MultiPartToSinglePart",
+      "Multipoint",
+      "NearestCoordinate",
+      "NearestVertex",
+      "NextSequenceValue",
+      "None",
+      "Now",
+      "Number",
+      "Offset",
+      "OrderBy",
+      "Overlaps",
+      "Point",
+      "PointToCoordinate",
+      "Polygon",
+      "Polyline",
+      "Pop",
+      "Portal",
+      "Pow",
+      "Proper",
+      "Push",
+      "QueryGraph",
+      "Random",
+      "Reduce",
+      "Relate",
+      "Replace",
+      "Resize",
+      "Reverse",
+      "Right|0",
+      "RingIsClockwise",
+      "Rotate",
+      "Round",
+      "Schema",
+      "Second",
+      "SetGeometry",
+      "Simplify",
+      "Sin",
+      "Slice",
+      "Sort",
+      "Splice",
+      "Split",
+      "Sqrt",
+      "StandardizeFilename",
+      "StandardizeGuid",
+      "Stdev",
+      "SubtypeCode",
+      "SubtypeName",
+      "Subtypes",
+      "Sum",
+      "SymmetricDifference",
+      "Tan",
+      "Text",
+      "Time",
+      "TimeZone",
+      "TimeZoneOffset",
+      "Timestamp",
+      "ToCharCode",
+      "ToCodePoint",
+      "ToHex",
+      "ToLocal",
+      "ToUTC",
+      "Today",
+      "Top|0",
+      "Touches",
+      "TrackAccelerationAt",
+      "TrackAccelerationWindow",
+      "TrackCurrentAcceleration",
+      "TrackCurrentDistance",
+      "TrackCurrentSpeed",
+      "TrackCurrentTime",
+      "TrackDistanceAt",
+      "TrackDistanceWindow",
+      "TrackDuration",
+      "TrackFieldWindow",
+      "TrackGeometryWindow",
+      "TrackIndex",
+      "TrackSpeedAt",
+      "TrackSpeedWindow",
+      "TrackStartTime",
+      "TrackWindow",
+      "Trim",
+      "TypeOf",
+      "Union",
+      "Upper",
+      "UrlEncode",
+      "Variance",
+      "Week",
+      "Weekday",
+      "When|0",
+      "Within",
+      "Year|0",
+    ]
+  };
+  const PROFILE_VARS = [
+    "aggregatedFeatures",
+    "analytic",
+    "config",
+    "datapoint",
+    "datastore",
+    "editcontext",
+    "feature",
+    "featureSet",
+    "feedfeature",
+    "fencefeature",
+    "fencenotificationtype",
+    "graph",
+    "join",
+    "layer",
+    "locationupdate",
+    "map",
+    "measure",
+    "measure",
+    "originalFeature",
+    "record",
+    "reference",
+    "rowindex",
+    "sourcedatastore",
+    "sourcefeature",
+    "sourcelayer",
+    "target",
+    "targetdatastore",
+    "targetfeature",
+    "targetlayer",
+    "userInput",
+    "value",
+    "variables",
+    "view"
+  ];
+  const SYMBOL = {
+    className: 'symbol',
+    begin: '\\$' + regex.either(...PROFILE_VARS)
+  };
+  const NUMBER = {
+    className: 'number',
+    variants: [
+      { begin: '\\b(0[bB][01]+)' },
+      { begin: '\\b(0[oO][0-7]+)' },
+      { begin: hljs.C_NUMBER_RE }
+    ],
+    relevance: 0
+  };
+  const SUBST = {
+    className: 'subst',
+    begin: '\\$\\{',
+    end: '\\}',
+    keywords: KEYWORDS,
+    contains: [] // defined later
+  };
+  const TEMPLATE_STRING = {
+    className: 'string',
+    begin: '`',
+    end: '`',
+    contains: [
+      hljs.BACKSLASH_ESCAPE,
+      SUBST
+    ]
+  };
+  SUBST.contains = [
+    hljs.APOS_STRING_MODE,
+    hljs.QUOTE_STRING_MODE,
+    TEMPLATE_STRING,
+    NUMBER,
+    hljs.REGEXP_MODE
+  ];
+  const PARAMS_CONTAINS = SUBST.contains.concat([
+    hljs.C_BLOCK_COMMENT_MODE,
+    hljs.C_LINE_COMMENT_MODE
+  ]);
+
+  return {
+    name: 'ArcGIS Arcade',
+    case_insensitive: true,
+    keywords: KEYWORDS,
+    contains: [
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE,
+      TEMPLATE_STRING,
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      SYMBOL,
+      NUMBER,
+      { // object attr container
+        begin: /[{,]\s*/,
+        relevance: 0,
+        contains: [
+          {
+            begin: IDENT_RE + '\\s*:',
+            returnBegin: true,
+            relevance: 0,
+            contains: [
+              {
+                className: 'attr',
+                begin: IDENT_RE,
+                relevance: 0
+              }
+            ]
+          }
+        ]
+      },
+      { // "value" container
+        begin: '(' + hljs.RE_STARTERS_RE + '|\\b(return)\\b)\\s*',
+        keywords: 'return',
+        contains: [
+          hljs.C_LINE_COMMENT_MODE,
+          hljs.C_BLOCK_COMMENT_MODE,
+          hljs.REGEXP_MODE,
+          {
+            className: 'function',
+            begin: '(\\(.*?\\)|' + IDENT_RE + ')\\s*=>',
+            returnBegin: true,
+            end: '\\s*=>',
+            contains: [
+              {
+                className: 'params',
+                variants: [
+                  { begin: IDENT_RE },
+                  { begin: /\(\s*\)/ },
+                  {
+                    begin: /\(/,
+                    end: /\)/,
+                    excludeBegin: true,
+                    excludeEnd: true,
+                    keywords: KEYWORDS,
+                    contains: PARAMS_CONTAINS
+                  }
+                ]
+              }
+            ]
+          }
+        ],
+        relevance: 0
+      },
+      {
+        beginKeywords: 'function',
+        end: /\{/,
+        excludeEnd: true,
+        contains: [
+          hljs.inherit(hljs.TITLE_MODE, {
+            className: "title.function",
+            begin: IDENT_RE
+          }),
+          {
+            className: 'params',
+            begin: /\(/,
+            end: /\)/,
+            excludeBegin: true,
+            excludeEnd: true,
+            contains: PARAMS_CONTAINS
+          }
+        ],
+        illegal: /\[|%/
+      },
+      { begin: /\$[(.]/ }
+    ],
+    illegal: /#(?!!)/
+  };
+}
+
+export { arcade as default };

frontend/node_modules/highlight.js/es/languages/autohotkey.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/autohotkey" instead of "highlight.js/lib/languages/autohotkey.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './autohotkey.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/avrasm.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/avrasm" instead of "highlight.js/lib/languages/avrasm.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './avrasm.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/awk.js

@@ -0,0 +1,68 @@
+/*
+Language: Awk
+Author: Matthew Daly <matthewbdaly@gmail.com>
+Website: https://www.gnu.org/software/gawk/manual/gawk.html
+Description: language definition for Awk scripts
+Category: scripting
+*/
+
+/** @type LanguageFn */
+function awk(hljs) {
+  const VARIABLE = {
+    className: 'variable',
+    variants: [
+      { begin: /\$[\w\d#@][\w\d_]*/ },
+      { begin: /\$\{(.*?)\}/ }
+    ]
+  };
+  const KEYWORDS = 'BEGIN END if else while do for in break continue delete next nextfile function func exit|10';
+  const STRING = {
+    className: 'string',
+    contains: [ hljs.BACKSLASH_ESCAPE ],
+    variants: [
+      {
+        begin: /(u|b)?r?'''/,
+        end: /'''/,
+        relevance: 10
+      },
+      {
+        begin: /(u|b)?r?"""/,
+        end: /"""/,
+        relevance: 10
+      },
+      {
+        begin: /(u|r|ur)'/,
+        end: /'/,
+        relevance: 10
+      },
+      {
+        begin: /(u|r|ur)"/,
+        end: /"/,
+        relevance: 10
+      },
+      {
+        begin: /(b|br)'/,
+        end: /'/
+      },
+      {
+        begin: /(b|br)"/,
+        end: /"/
+      },
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE
+    ]
+  };
+  return {
+    name: 'Awk',
+    keywords: { keyword: KEYWORDS },
+    contains: [
+      VARIABLE,
+      STRING,
+      hljs.REGEXP_MODE,
+      hljs.HASH_COMMENT_MODE,
+      hljs.NUMBER_MODE
+    ]
+  };
+}
+
+export { awk as default };

frontend/node_modules/highlight.js/es/languages/awk.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/awk" instead of "highlight.js/lib/languages/awk.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './awk.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/bash.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/bash" instead of "highlight.js/lib/languages/bash.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './bash.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/basic.js

@@ -0,0 +1,236 @@
+/*
+Language: BASIC
+Author: Raphaël Assénat <raph@raphnet.net>
+Description: Based on the BASIC reference from the Tandy 1000 guide
+Website: https://en.wikipedia.org/wiki/Tandy_1000
+Category: system
+*/
+
+/** @type LanguageFn */
+function basic(hljs) {
+  const KEYWORDS = [
+    "ABS",
+    "ASC",
+    "AND",
+    "ATN",
+    "AUTO|0",
+    "BEEP",
+    "BLOAD|10",
+    "BSAVE|10",
+    "CALL",
+    "CALLS",
+    "CDBL",
+    "CHAIN",
+    "CHDIR",
+    "CHR$|10",
+    "CINT",
+    "CIRCLE",
+    "CLEAR",
+    "CLOSE",
+    "CLS",
+    "COLOR",
+    "COM",
+    "COMMON",
+    "CONT",
+    "COS",
+    "CSNG",
+    "CSRLIN",
+    "CVD",
+    "CVI",
+    "CVS",
+    "DATA",
+    "DATE$",
+    "DEFDBL",
+    "DEFINT",
+    "DEFSNG",
+    "DEFSTR",
+    "DEF|0",
+    "SEG",
+    "USR",
+    "DELETE",
+    "DIM",
+    "DRAW",
+    "EDIT",
+    "END",
+    "ENVIRON",
+    "ENVIRON$",
+    "EOF",
+    "EQV",
+    "ERASE",
+    "ERDEV",
+    "ERDEV$",
+    "ERL",
+    "ERR",
+    "ERROR",
+    "EXP",
+    "FIELD",
+    "FILES",
+    "FIX",
+    "FOR|0",
+    "FRE",
+    "GET",
+    "GOSUB|10",
+    "GOTO",
+    "HEX$",
+    "IF",
+    "THEN",
+    "ELSE|0",
+    "INKEY$",
+    "INP",
+    "INPUT",
+    "INPUT#",
+    "INPUT$",
+    "INSTR",
+    "IMP",
+    "INT",
+    "IOCTL",
+    "IOCTL$",
+    "KEY",
+    "ON",
+    "OFF",
+    "LIST",
+    "KILL",
+    "LEFT$",
+    "LEN",
+    "LET",
+    "LINE",
+    "LLIST",
+    "LOAD",
+    "LOC",
+    "LOCATE",
+    "LOF",
+    "LOG",
+    "LPRINT",
+    "USING",
+    "LSET",
+    "MERGE",
+    "MID$",
+    "MKDIR",
+    "MKD$",
+    "MKI$",
+    "MKS$",
+    "MOD",
+    "NAME",
+    "NEW",
+    "NEXT",
+    "NOISE",
+    "NOT",
+    "OCT$",
+    "ON",
+    "OR",
+    "PEN",
+    "PLAY",
+    "STRIG",
+    "OPEN",
+    "OPTION",
+    "BASE",
+    "OUT",
+    "PAINT",
+    "PALETTE",
+    "PCOPY",
+    "PEEK",
+    "PMAP",
+    "POINT",
+    "POKE",
+    "POS",
+    "PRINT",
+    "PRINT]",
+    "PSET",
+    "PRESET",
+    "PUT",
+    "RANDOMIZE",
+    "READ",
+    "REM",
+    "RENUM",
+    "RESET|0",
+    "RESTORE",
+    "RESUME",
+    "RETURN|0",
+    "RIGHT$",
+    "RMDIR",
+    "RND",
+    "RSET",
+    "RUN",
+    "SAVE",
+    "SCREEN",
+    "SGN",
+    "SHELL",
+    "SIN",
+    "SOUND",
+    "SPACE$",
+    "SPC",
+    "SQR",
+    "STEP",
+    "STICK",
+    "STOP",
+    "STR$",
+    "STRING$",
+    "SWAP",
+    "SYSTEM",
+    "TAB",
+    "TAN",
+    "TIME$",
+    "TIMER",
+    "TROFF",
+    "TRON",
+    "TO",
+    "USR",
+    "VAL",
+    "VARPTR",
+    "VARPTR$",
+    "VIEW",
+    "WAIT",
+    "WHILE",
+    "WEND",
+    "WIDTH",
+    "WINDOW",
+    "WRITE",
+    "XOR"
+  ];
+
+  return {
+    name: 'BASIC',
+    case_insensitive: true,
+    illegal: '^\.',
+    // Support explicitly typed variables that end with $%! or #.
+    keywords: {
+      $pattern: '[a-zA-Z][a-zA-Z0-9_$%!#]*',
+      keyword: KEYWORDS
+    },
+    contains: [
+      {
+        // Match strings that start with " and end with " or a line break
+        scope: 'string',
+        begin: /"/,
+        end: /"|$/,
+        contains: [ hljs.BACKSLASH_ESCAPE ]
+      },
+      hljs.COMMENT('REM', '$', { relevance: 10 }),
+      hljs.COMMENT('\'', '$', { relevance: 0 }),
+      {
+        // Match line numbers
+        className: 'symbol',
+        begin: '^[0-9]+ ',
+        relevance: 10
+      },
+      {
+        // Match typed numeric constants (1000, 12.34!, 1.2e5, 1.5#, 1.2D2)
+        className: 'number',
+        begin: '\\b\\d+(\\.\\d+)?([edED]\\d+)?[#\!]?',
+        relevance: 0
+      },
+      {
+        // Match hexadecimal numbers (&Hxxxx)
+        className: 'number',
+        begin: '(&[hH][0-9a-fA-F]{1,4})'
+      },
+      {
+        // Match octal numbers (&Oxxxxxx)
+        className: 'number',
+        begin: '(&[oO][0-7]{1,6})'
+      }
+    ]
+  };
+}
+
+export { basic as default };

frontend/node_modules/highlight.js/es/languages/bnf.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/bnf" instead of "highlight.js/lib/languages/bnf.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './bnf.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/brainfuck.js

@@ -0,0 +1,54 @@
+/*
+Language: Brainfuck
+Author: Evgeny Stepanischev <imbolk@gmail.com>
+Website: https://esolangs.org/wiki/Brainfuck
+*/
+
+/** @type LanguageFn */
+function brainfuck(hljs) {
+  const LITERAL = {
+    className: 'literal',
+    begin: /[+-]+/,
+    relevance: 0
+  };
+  return {
+    name: 'Brainfuck',
+    aliases: [ 'bf' ],
+    contains: [
+      hljs.COMMENT(
+        /[^\[\]\.,\+\-<> \r\n]/,
+        /[\[\]\.,\+\-<> \r\n]/,
+        {
+          contains: [
+            {
+              match: /[ ]+[^\[\]\.,\+\-<> \r\n]/,
+              relevance: 0
+            }
+          ],
+          returnEnd: true,
+          relevance: 0
+        }
+      ),
+      {
+        className: 'title',
+        begin: '[\\[\\]]',
+        relevance: 0
+      },
+      {
+        className: 'string',
+        begin: '[\\.,]',
+        relevance: 0
+      },
+      {
+        // this mode works as the only relevance counter
+        // it looks ahead to find the start of a run of literals
+        // so only the runs are counted as relevant
+        begin: /(?=\+\+|--)/,
+        contains: [ LITERAL ]
+      },
+      LITERAL
+    ]
+  };
+}
+
+export { brainfuck as default };

frontend/node_modules/highlight.js/es/languages/cal.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/cal" instead of "highlight.js/lib/languages/cal.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './cal.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/clean.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/clean" instead of "highlight.js/lib/languages/clean.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './clean.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/clojure-repl.js

@@ -0,0 +1,27 @@
+/*
+Language: Clojure REPL
+Description: Clojure REPL sessions
+Author: Ivan Sagalaev <maniac@softwaremaniacs.org>
+Requires: clojure.js
+Website: https://clojure.org
+Category: lisp
+*/
+
+/** @type LanguageFn */
+function clojureRepl(hljs) {
+  return {
+    name: 'Clojure REPL',
+    contains: [
+      {
+        className: 'meta.prompt',
+        begin: /^([\w.-]+|\s*#_)?=>/,
+        starts: {
+          end: /$/,
+          subLanguage: 'clojure'
+        }
+      }
+    ]
+  };
+}
+
+export { clojureRepl as default };

frontend/node_modules/highlight.js/es/languages/clojure-repl.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/clojure-repl" instead of "highlight.js/lib/languages/clojure-repl.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './clojure-repl.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/clojure.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/clojure" instead of "highlight.js/lib/languages/clojure.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './clojure.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/cmake.js

@@ -0,0 +1,64 @@
+/*
+Language: CMake
+Description: CMake is an open-source cross-platform system for build automation.
+Author: Igor Kalnitsky <igor@kalnitsky.org>
+Website: https://cmake.org
+Category: build-system
+*/
+
+/** @type LanguageFn */
+function cmake(hljs) {
+  return {
+    name: 'CMake',
+    aliases: [ 'cmake.in' ],
+    case_insensitive: true,
+    keywords: { keyword:
+        // scripting commands
+        'break cmake_host_system_information cmake_minimum_required cmake_parse_arguments '
+        + 'cmake_policy configure_file continue elseif else endforeach endfunction endif endmacro '
+        + 'endwhile execute_process file find_file find_library find_package find_path '
+        + 'find_program foreach function get_cmake_property get_directory_property '
+        + 'get_filename_component get_property if include include_guard list macro '
+        + 'mark_as_advanced math message option return separate_arguments '
+        + 'set_directory_properties set_property set site_name string unset variable_watch while '
+        // project commands
+        + 'add_compile_definitions add_compile_options add_custom_command add_custom_target '
+        + 'add_definitions add_dependencies add_executable add_library add_link_options '
+        + 'add_subdirectory add_test aux_source_directory build_command create_test_sourcelist '
+        + 'define_property enable_language enable_testing export fltk_wrap_ui '
+        + 'get_source_file_property get_target_property get_test_property include_directories '
+        + 'include_external_msproject include_regular_expression install link_directories '
+        + 'link_libraries load_cache project qt_wrap_cpp qt_wrap_ui remove_definitions '
+        + 'set_source_files_properties set_target_properties set_tests_properties source_group '
+        + 'target_compile_definitions target_compile_features target_compile_options '
+        + 'target_include_directories target_link_directories target_link_libraries '
+        + 'target_link_options target_sources try_compile try_run '
+        // CTest commands
+        + 'ctest_build ctest_configure ctest_coverage ctest_empty_binary_directory ctest_memcheck '
+        + 'ctest_read_custom_files ctest_run_script ctest_sleep ctest_start ctest_submit '
+        + 'ctest_test ctest_update ctest_upload '
+        // deprecated commands
+        + 'build_name exec_program export_library_dependencies install_files install_programs '
+        + 'install_targets load_command make_directory output_required_files remove '
+        + 'subdir_depends subdirs use_mangled_mesa utility_source variable_requires write_file '
+        + 'qt5_use_modules qt5_use_package qt5_wrap_cpp '
+        // core keywords
+        + 'on off true false and or not command policy target test exists is_newer_than '
+        + 'is_directory is_symlink is_absolute matches less greater equal less_equal '
+        + 'greater_equal strless strgreater strequal strless_equal strgreater_equal version_less '
+        + 'version_greater version_equal version_less_equal version_greater_equal in_list defined' },
+    contains: [
+      {
+        className: 'variable',
+        begin: /\$\{/,
+        end: /\}/
+      },
+      hljs.COMMENT(/#\[\[/, /]]/),
+      hljs.HASH_COMMENT_MODE,
+      hljs.QUOTE_STRING_MODE,
+      hljs.NUMBER_MODE
+    ]
+  };
+}
+
+export { cmake as default };

frontend/node_modules/highlight.js/es/languages/crystal.js

@@ -0,0 +1,312 @@
+/*
+Language: Crystal
+Author: TSUYUSATO Kitsune <make.just.on@gmail.com>
+Website: https://crystal-lang.org
+Category: system
+*/
+
+/** @type LanguageFn */
+function crystal(hljs) {
+  const INT_SUFFIX = '(_?[ui](8|16|32|64|128))?';
+  const FLOAT_SUFFIX = '(_?f(32|64))?';
+  const CRYSTAL_IDENT_RE = '[a-zA-Z_]\\w*[!?=]?';
+  const CRYSTAL_METHOD_RE = '[a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|[=!]~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~|]|//|//=|&[-+*]=?|&\\*\\*|\\[\\][=?]?';
+  const CRYSTAL_PATH_RE = '[A-Za-z_]\\w*(::\\w+)*(\\?|!)?';
+  const CRYSTAL_KEYWORDS = {
+    $pattern: CRYSTAL_IDENT_RE,
+    keyword:
+      'abstract alias annotation as as? asm begin break case class def do else elsif end ensure enum extend for fun if '
+      + 'include instance_sizeof is_a? lib macro module next nil? of out pointerof private protected rescue responds_to? '
+      + 'return require select self sizeof struct super then type typeof union uninitialized unless until verbatim when while with yield '
+      + '__DIR__ __END_LINE__ __FILE__ __LINE__',
+    literal: 'false nil true'
+  };
+  const SUBST = {
+    className: 'subst',
+    begin: /#\{/,
+    end: /\}/,
+    keywords: CRYSTAL_KEYWORDS
+  };
+  // borrowed from Ruby
+  const VARIABLE = {
+    // negative-look forward attemps to prevent false matches like:
+    // @ident@ or $ident$ that might indicate this is not ruby at all
+    className: "variable",
+    begin: '(\\$\\W)|((\\$|@@?)(\\w+))(?=[^@$?])' + `(?![A-Za-z])(?![@$?'])`
+  };
+  const EXPANSION = {
+    className: 'template-variable',
+    variants: [
+      {
+        begin: '\\{\\{',
+        end: '\\}\\}'
+      },
+      {
+        begin: '\\{%',
+        end: '%\\}'
+      }
+    ],
+    keywords: CRYSTAL_KEYWORDS
+  };
+
+  function recursiveParen(begin, end) {
+    const
+        contains = [
+          {
+            begin: begin,
+            end: end
+          }
+        ];
+    contains[0].contains = contains;
+    return contains;
+  }
+  const STRING = {
+    className: 'string',
+    contains: [
+      hljs.BACKSLASH_ESCAPE,
+      SUBST
+    ],
+    variants: [
+      {
+        begin: /'/,
+        end: /'/
+      },
+      {
+        begin: /"/,
+        end: /"/
+      },
+      {
+        begin: /`/,
+        end: /`/
+      },
+      {
+        begin: '%[Qwi]?\\(',
+        end: '\\)',
+        contains: recursiveParen('\\(', '\\)')
+      },
+      {
+        begin: '%[Qwi]?\\[',
+        end: '\\]',
+        contains: recursiveParen('\\[', '\\]')
+      },
+      {
+        begin: '%[Qwi]?\\{',
+        end: /\}/,
+        contains: recursiveParen(/\{/, /\}/)
+      },
+      {
+        begin: '%[Qwi]?<',
+        end: '>',
+        contains: recursiveParen('<', '>')
+      },
+      {
+        begin: '%[Qwi]?\\|',
+        end: '\\|'
+      },
+      {
+        begin: /<<-\w+$/,
+        end: /^\s*\w+$/
+      }
+    ],
+    relevance: 0
+  };
+  const Q_STRING = {
+    className: 'string',
+    variants: [
+      {
+        begin: '%q\\(',
+        end: '\\)',
+        contains: recursiveParen('\\(', '\\)')
+      },
+      {
+        begin: '%q\\[',
+        end: '\\]',
+        contains: recursiveParen('\\[', '\\]')
+      },
+      {
+        begin: '%q\\{',
+        end: /\}/,
+        contains: recursiveParen(/\{/, /\}/)
+      },
+      {
+        begin: '%q<',
+        end: '>',
+        contains: recursiveParen('<', '>')
+      },
+      {
+        begin: '%q\\|',
+        end: '\\|'
+      },
+      {
+        begin: /<<-'\w+'$/,
+        end: /^\s*\w+$/
+      }
+    ],
+    relevance: 0
+  };
+  const REGEXP = {
+    begin: '(?!%\\})(' + hljs.RE_STARTERS_RE + '|\\n|\\b(case|if|select|unless|until|when|while)\\b)\\s*',
+    keywords: 'case if select unless until when while',
+    contains: [
+      {
+        className: 'regexp',
+        contains: [
+          hljs.BACKSLASH_ESCAPE,
+          SUBST
+        ],
+        variants: [
+          {
+            begin: '//[a-z]*',
+            relevance: 0
+          },
+          {
+            begin: '/(?!\\/)',
+            end: '/[a-z]*'
+          }
+        ]
+      }
+    ],
+    relevance: 0
+  };
+  const REGEXP2 = {
+    className: 'regexp',
+    contains: [
+      hljs.BACKSLASH_ESCAPE,
+      SUBST
+    ],
+    variants: [
+      {
+        begin: '%r\\(',
+        end: '\\)',
+        contains: recursiveParen('\\(', '\\)')
+      },
+      {
+        begin: '%r\\[',
+        end: '\\]',
+        contains: recursiveParen('\\[', '\\]')
+      },
+      {
+        begin: '%r\\{',
+        end: /\}/,
+        contains: recursiveParen(/\{/, /\}/)
+      },
+      {
+        begin: '%r<',
+        end: '>',
+        contains: recursiveParen('<', '>')
+      },
+      {
+        begin: '%r\\|',
+        end: '\\|'
+      }
+    ],
+    relevance: 0
+  };
+  const ATTRIBUTE = {
+    className: 'meta',
+    begin: '@\\[',
+    end: '\\]',
+    contains: [ hljs.inherit(hljs.QUOTE_STRING_MODE, { className: 'string' }) ]
+  };
+  const CRYSTAL_DEFAULT_CONTAINS = [
+    EXPANSION,
+    STRING,
+    Q_STRING,
+    REGEXP2,
+    REGEXP,
+    ATTRIBUTE,
+    VARIABLE,
+    hljs.HASH_COMMENT_MODE,
+    {
+      className: 'class',
+      beginKeywords: 'class module struct',
+      end: '$|;',
+      illegal: /=/,
+      contains: [
+        hljs.HASH_COMMENT_MODE,
+        hljs.inherit(hljs.TITLE_MODE, { begin: CRYSTAL_PATH_RE }),
+        { // relevance booster for inheritance
+          begin: '<' }
+      ]
+    },
+    {
+      className: 'class',
+      beginKeywords: 'lib enum union',
+      end: '$|;',
+      illegal: /=/,
+      contains: [
+        hljs.HASH_COMMENT_MODE,
+        hljs.inherit(hljs.TITLE_MODE, { begin: CRYSTAL_PATH_RE })
+      ]
+    },
+    {
+      beginKeywords: 'annotation',
+      end: '$|;',
+      illegal: /=/,
+      contains: [
+        hljs.HASH_COMMENT_MODE,
+        hljs.inherit(hljs.TITLE_MODE, { begin: CRYSTAL_PATH_RE })
+      ],
+      relevance: 2
+    },
+    {
+      className: 'function',
+      beginKeywords: 'def',
+      end: /\B\b/,
+      contains: [
+        hljs.inherit(hljs.TITLE_MODE, {
+          begin: CRYSTAL_METHOD_RE,
+          endsParent: true
+        })
+      ]
+    },
+    {
+      className: 'function',
+      beginKeywords: 'fun macro',
+      end: /\B\b/,
+      contains: [
+        hljs.inherit(hljs.TITLE_MODE, {
+          begin: CRYSTAL_METHOD_RE,
+          endsParent: true
+        })
+      ],
+      relevance: 2
+    },
+    {
+      className: 'symbol',
+      begin: hljs.UNDERSCORE_IDENT_RE + '(!|\\?)?:',
+      relevance: 0
+    },
+    {
+      className: 'symbol',
+      begin: ':',
+      contains: [
+        STRING,
+        { begin: CRYSTAL_METHOD_RE }
+      ],
+      relevance: 0
+    },
+    {
+      className: 'number',
+      variants: [
+        { begin: '\\b0b([01_]+)' + INT_SUFFIX },
+        { begin: '\\b0o([0-7_]+)' + INT_SUFFIX },
+        { begin: '\\b0x([A-Fa-f0-9_]+)' + INT_SUFFIX },
+        { begin: '\\b([1-9][0-9_]*[0-9]|[0-9])(\\.[0-9][0-9_]*)?([eE]_?[-+]?[0-9_]*)?' + FLOAT_SUFFIX + '(?!_)' },
+        { begin: '\\b([1-9][0-9_]*|0)' + INT_SUFFIX }
+      ],
+      relevance: 0
+    }
+  ];
+  SUBST.contains = CRYSTAL_DEFAULT_CONTAINS;
+  EXPANSION.contains = CRYSTAL_DEFAULT_CONTAINS.slice(1); // without EXPANSION
+
+  return {
+    name: 'Crystal',
+    aliases: [ 'cr' ],
+    keywords: CRYSTAL_KEYWORDS,
+    contains: CRYSTAL_DEFAULT_CONTAINS
+  };
+}
+
+export { crystal as default };

frontend/node_modules/highlight.js/es/languages/csharp.js

@@ -0,0 +1,412 @@
+/*
+Language: C#
+Author: Jason Diamond <jason@diamond.name>
+Contributor: Nicolas LLOBERA <nllobera@gmail.com>, Pieter Vantorre <pietervantorre@gmail.com>, David Pine <david.pine@microsoft.com>
+Website: https://docs.microsoft.com/dotnet/csharp/
+Category: common
+*/
+
+/** @type LanguageFn */
+function csharp(hljs) {
+  const BUILT_IN_KEYWORDS = [
+    'bool',
+    'byte',
+    'char',
+    'decimal',
+    'delegate',
+    'double',
+    'dynamic',
+    'enum',
+    'float',
+    'int',
+    'long',
+    'nint',
+    'nuint',
+    'object',
+    'sbyte',
+    'short',
+    'string',
+    'ulong',
+    'uint',
+    'ushort'
+  ];
+  const FUNCTION_MODIFIERS = [
+    'public',
+    'private',
+    'protected',
+    'static',
+    'internal',
+    'protected',
+    'abstract',
+    'async',
+    'extern',
+    'override',
+    'unsafe',
+    'virtual',
+    'new',
+    'sealed',
+    'partial'
+  ];
+  const LITERAL_KEYWORDS = [
+    'default',
+    'false',
+    'null',
+    'true'
+  ];
+  const NORMAL_KEYWORDS = [
+    'abstract',
+    'as',
+    'base',
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'do',
+    'else',
+    'event',
+    'explicit',
+    'extern',
+    'finally',
+    'fixed',
+    'for',
+    'foreach',
+    'goto',
+    'if',
+    'implicit',
+    'in',
+    'interface',
+    'internal',
+    'is',
+    'lock',
+    'namespace',
+    'new',
+    'operator',
+    'out',
+    'override',
+    'params',
+    'private',
+    'protected',
+    'public',
+    'readonly',
+    'record',
+    'ref',
+    'return',
+    'scoped',
+    'sealed',
+    'sizeof',
+    'stackalloc',
+    'static',
+    'struct',
+    'switch',
+    'this',
+    'throw',
+    'try',
+    'typeof',
+    'unchecked',
+    'unsafe',
+    'using',
+    'virtual',
+    'void',
+    'volatile',
+    'while'
+  ];
+  const CONTEXTUAL_KEYWORDS = [
+    'add',
+    'alias',
+    'and',
+    'ascending',
+    'args',
+    'async',
+    'await',
+    'by',
+    'descending',
+    'dynamic',
+    'equals',
+    'file',
+    'from',
+    'get',
+    'global',
+    'group',
+    'init',
+    'into',
+    'join',
+    'let',
+    'nameof',
+    'not',
+    'notnull',
+    'on',
+    'or',
+    'orderby',
+    'partial',
+    'record',
+    'remove',
+    'required',
+    'scoped',
+    'select',
+    'set',
+    'unmanaged',
+    'value|0',
+    'var',
+    'when',
+    'where',
+    'with',
+    'yield'
+  ];
+
+  const KEYWORDS = {
+    keyword: NORMAL_KEYWORDS.concat(CONTEXTUAL_KEYWORDS),
+    built_in: BUILT_IN_KEYWORDS,
+    literal: LITERAL_KEYWORDS
+  };
+  const TITLE_MODE = hljs.inherit(hljs.TITLE_MODE, { begin: '[a-zA-Z](\\.?\\w)*' });
+  const NUMBERS = {
+    className: 'number',
+    variants: [
+      { begin: '\\b(0b[01\']+)' },
+      { begin: '(-?)\\b([\\d\']+(\\.[\\d\']*)?|\\.[\\d\']+)(u|U|l|L|ul|UL|f|F|b|B)' },
+      { begin: '(-?)(\\b0[xX][a-fA-F0-9\']+|(\\b[\\d\']+(\\.[\\d\']*)?|\\.[\\d\']+)([eE][-+]?[\\d\']+)?)' }
+    ],
+    relevance: 0
+  };
+  const RAW_STRING = {
+    className: 'string',
+    begin: /"""("*)(?!")(.|\n)*?"""\1/,
+    relevance: 1
+  };
+  const VERBATIM_STRING = {
+    className: 'string',
+    begin: '@"',
+    end: '"',
+    contains: [ { begin: '""' } ]
+  };
+  const VERBATIM_STRING_NO_LF = hljs.inherit(VERBATIM_STRING, { illegal: /\n/ });
+  const SUBST = {
+    className: 'subst',
+    begin: /\{/,
+    end: /\}/,
+    keywords: KEYWORDS
+  };
+  const SUBST_NO_LF = hljs.inherit(SUBST, { illegal: /\n/ });
+  const INTERPOLATED_STRING = {
+    className: 'string',
+    begin: /\$"/,
+    end: '"',
+    illegal: /\n/,
+    contains: [
+      { begin: /\{\{/ },
+      { begin: /\}\}/ },
+      hljs.BACKSLASH_ESCAPE,
+      SUBST_NO_LF
+    ]
+  };
+  const INTERPOLATED_VERBATIM_STRING = {
+    className: 'string',
+    begin: /\$@"/,
+    end: '"',
+    contains: [
+      { begin: /\{\{/ },
+      { begin: /\}\}/ },
+      { begin: '""' },
+      SUBST
+    ]
+  };
+  const INTERPOLATED_VERBATIM_STRING_NO_LF = hljs.inherit(INTERPOLATED_VERBATIM_STRING, {
+    illegal: /\n/,
+    contains: [
+      { begin: /\{\{/ },
+      { begin: /\}\}/ },
+      { begin: '""' },
+      SUBST_NO_LF
+    ]
+  });
+  SUBST.contains = [
+    INTERPOLATED_VERBATIM_STRING,
+    INTERPOLATED_STRING,
+    VERBATIM_STRING,
+    hljs.APOS_STRING_MODE,
+    hljs.QUOTE_STRING_MODE,
+    NUMBERS,
+    hljs.C_BLOCK_COMMENT_MODE
+  ];
+  SUBST_NO_LF.contains = [
+    INTERPOLATED_VERBATIM_STRING_NO_LF,
+    INTERPOLATED_STRING,
+    VERBATIM_STRING_NO_LF,
+    hljs.APOS_STRING_MODE,
+    hljs.QUOTE_STRING_MODE,
+    NUMBERS,
+    hljs.inherit(hljs.C_BLOCK_COMMENT_MODE, { illegal: /\n/ })
+  ];
+  const STRING = { variants: [
+    RAW_STRING,
+    INTERPOLATED_VERBATIM_STRING,
+    INTERPOLATED_STRING,
+    VERBATIM_STRING,
+    hljs.APOS_STRING_MODE,
+    hljs.QUOTE_STRING_MODE
+  ] };
+
+  const GENERIC_MODIFIER = {
+    begin: "<",
+    end: ">",
+    contains: [
+      { beginKeywords: "in out" },
+      TITLE_MODE
+    ]
+  };
+  const TYPE_IDENT_RE = hljs.IDENT_RE + '(<' + hljs.IDENT_RE + '(\\s*,\\s*' + hljs.IDENT_RE + ')*>)?(\\[\\])?';
+  const AT_IDENTIFIER = {
+    // prevents expressions like `@class` from incorrect flagging
+    // `class` as a keyword
+    begin: "@" + hljs.IDENT_RE,
+    relevance: 0
+  };
+
+  return {
+    name: 'C#',
+    aliases: [
+      'cs',
+      'c#'
+    ],
+    keywords: KEYWORDS,
+    illegal: /::/,
+    contains: [
+      hljs.COMMENT(
+        '///',
+        '$',
+        {
+          returnBegin: true,
+          contains: [
+            {
+              className: 'doctag',
+              variants: [
+                {
+                  begin: '///',
+                  relevance: 0
+                },
+                { begin: '<!--|-->' },
+                {
+                  begin: '</?',
+                  end: '>'
+                }
+              ]
+            }
+          ]
+        }
+      ),
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      {
+        className: 'meta',
+        begin: '#',
+        end: '$',
+        keywords: { keyword: 'if else elif endif define undef warning error line region endregion pragma checksum' }
+      },
+      STRING,
+      NUMBERS,
+      {
+        beginKeywords: 'class interface',
+        relevance: 0,
+        end: /[{;=]/,
+        illegal: /[^\s:,]/,
+        contains: [
+          { beginKeywords: "where class" },
+          TITLE_MODE,
+          GENERIC_MODIFIER,
+          hljs.C_LINE_COMMENT_MODE,
+          hljs.C_BLOCK_COMMENT_MODE
+        ]
+      },
+      {
+        beginKeywords: 'namespace',
+        relevance: 0,
+        end: /[{;=]/,
+        illegal: /[^\s:]/,
+        contains: [
+          TITLE_MODE,
+          hljs.C_LINE_COMMENT_MODE,
+          hljs.C_BLOCK_COMMENT_MODE
+        ]
+      },
+      {
+        beginKeywords: 'record',
+        relevance: 0,
+        end: /[{;=]/,
+        illegal: /[^\s:]/,
+        contains: [
+          TITLE_MODE,
+          GENERIC_MODIFIER,
+          hljs.C_LINE_COMMENT_MODE,
+          hljs.C_BLOCK_COMMENT_MODE
+        ]
+      },
+      {
+        // [Attributes("")]
+        className: 'meta',
+        begin: '^\\s*\\[(?=[\\w])',
+        excludeBegin: true,
+        end: '\\]',
+        excludeEnd: true,
+        contains: [
+          {
+            className: 'string',
+            begin: /"/,
+            end: /"/
+          }
+        ]
+      },
+      {
+        // Expression keywords prevent 'keyword Name(...)' from being
+        // recognized as a function definition
+        beginKeywords: 'new return throw await else',
+        relevance: 0
+      },
+      {
+        className: 'function',
+        begin: '(' + TYPE_IDENT_RE + '\\s+)+' + hljs.IDENT_RE + '\\s*(<[^=]+>\\s*)?\\(',
+        returnBegin: true,
+        end: /\s*[{;=]/,
+        excludeEnd: true,
+        keywords: KEYWORDS,
+        contains: [
+          // prevents these from being highlighted `title`
+          {
+            beginKeywords: FUNCTION_MODIFIERS.join(" "),
+            relevance: 0
+          },
+          {
+            begin: hljs.IDENT_RE + '\\s*(<[^=]+>\\s*)?\\(',
+            returnBegin: true,
+            contains: [
+              hljs.TITLE_MODE,
+              GENERIC_MODIFIER
+            ],
+            relevance: 0
+          },
+          { match: /\(\)/ },
+          {
+            className: 'params',
+            begin: /\(/,
+            end: /\)/,
+            excludeBegin: true,
+            excludeEnd: true,
+            keywords: KEYWORDS,
+            relevance: 0,
+            contains: [
+              STRING,
+              NUMBERS,
+              hljs.C_BLOCK_COMMENT_MODE
+            ]
+          },
+          hljs.C_LINE_COMMENT_MODE,
+          hljs.C_BLOCK_COMMENT_MODE
+        ]
+      },
+      AT_IDENTIFIER
+    ]
+  };
+}
+
+export { csharp as default };

frontend/node_modules/highlight.js/es/languages/csp.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/csp" instead of "highlight.js/lib/languages/csp.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './csp.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/css.js

@@ -0,0 +1,949 @@
+const MODES = (hljs) => {
+  return {
+    IMPORTANT: {
+      scope: 'meta',
+      begin: '!important'
+    },
+    BLOCK_COMMENT: hljs.C_BLOCK_COMMENT_MODE,
+    HEXCOLOR: {
+      scope: 'number',
+      begin: /#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/
+    },
+    FUNCTION_DISPATCH: {
+      className: "built_in",
+      begin: /[\w-]+(?=\()/
+    },
+    ATTRIBUTE_SELECTOR_MODE: {
+      scope: 'selector-attr',
+      begin: /\[/,
+      end: /\]/,
+      illegal: '$',
+      contains: [
+        hljs.APOS_STRING_MODE,
+        hljs.QUOTE_STRING_MODE
+      ]
+    },
+    CSS_NUMBER_MODE: {
+      scope: 'number',
+      begin: hljs.NUMBER_RE + '(' +
+        '%|em|ex|ch|rem' +
+        '|vw|vh|vmin|vmax' +
+        '|cm|mm|in|pt|pc|px' +
+        '|deg|grad|rad|turn' +
+        '|s|ms' +
+        '|Hz|kHz' +
+        '|dpi|dpcm|dppx' +
+        ')?',
+      relevance: 0
+    },
+    CSS_VARIABLE: {
+      className: "attr",
+      begin: /--[A-Za-z_][A-Za-z0-9_-]*/
+    }
+  };
+};
+
+const HTML_TAGS = [
+  'a',
+  'abbr',
+  'address',
+  'article',
+  'aside',
+  'audio',
+  'b',
+  'blockquote',
+  'body',
+  'button',
+  'canvas',
+  'caption',
+  'cite',
+  'code',
+  'dd',
+  'del',
+  'details',
+  'dfn',
+  'div',
+  'dl',
+  'dt',
+  'em',
+  'fieldset',
+  'figcaption',
+  'figure',
+  'footer',
+  'form',
+  'h1',
+  'h2',
+  'h3',
+  'h4',
+  'h5',
+  'h6',
+  'header',
+  'hgroup',
+  'html',
+  'i',
+  'iframe',
+  'img',
+  'input',
+  'ins',
+  'kbd',
+  'label',
+  'legend',
+  'li',
+  'main',
+  'mark',
+  'menu',
+  'nav',
+  'object',
+  'ol',
+  'optgroup',
+  'option',
+  'p',
+  'picture',
+  'q',
+  'quote',
+  'samp',
+  'section',
+  'select',
+  'source',
+  'span',
+  'strong',
+  'summary',
+  'sup',
+  'table',
+  'tbody',
+  'td',
+  'textarea',
+  'tfoot',
+  'th',
+  'thead',
+  'time',
+  'tr',
+  'ul',
+  'var',
+  'video'
+];
+
+const SVG_TAGS = [
+  'defs',
+  'g',
+  'marker',
+  'mask',
+  'pattern',
+  'svg',
+  'switch',
+  'symbol',
+  'feBlend',
+  'feColorMatrix',
+  'feComponentTransfer',
+  'feComposite',
+  'feConvolveMatrix',
+  'feDiffuseLighting',
+  'feDisplacementMap',
+  'feFlood',
+  'feGaussianBlur',
+  'feImage',
+  'feMerge',
+  'feMorphology',
+  'feOffset',
+  'feSpecularLighting',
+  'feTile',
+  'feTurbulence',
+  'linearGradient',
+  'radialGradient',
+  'stop',
+  'circle',
+  'ellipse',
+  'image',
+  'line',
+  'path',
+  'polygon',
+  'polyline',
+  'rect',
+  'text',
+  'use',
+  'textPath',
+  'tspan',
+  'foreignObject',
+  'clipPath'
+];
+
+const TAGS = [
+  ...HTML_TAGS,
+  ...SVG_TAGS,
+];
+
+// Sorting, then reversing makes sure longer attributes/elements like
+// `font-weight` are matched fully instead of getting false positives on say `font`
+
+const MEDIA_FEATURES = [
+  'any-hover',
+  'any-pointer',
+  'aspect-ratio',
+  'color',
+  'color-gamut',
+  'color-index',
+  'device-aspect-ratio',
+  'device-height',
+  'device-width',
+  'display-mode',
+  'forced-colors',
+  'grid',
+  'height',
+  'hover',
+  'inverted-colors',
+  'monochrome',
+  'orientation',
+  'overflow-block',
+  'overflow-inline',
+  'pointer',
+  'prefers-color-scheme',
+  'prefers-contrast',
+  'prefers-reduced-motion',
+  'prefers-reduced-transparency',
+  'resolution',
+  'scan',
+  'scripting',
+  'update',
+  'width',
+  // TODO: find a better solution?
+  'min-width',
+  'max-width',
+  'min-height',
+  'max-height'
+].sort().reverse();
+
+// https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-classes
+const PSEUDO_CLASSES = [
+  'active',
+  'any-link',
+  'blank',
+  'checked',
+  'current',
+  'default',
+  'defined',
+  'dir', // dir()
+  'disabled',
+  'drop',
+  'empty',
+  'enabled',
+  'first',
+  'first-child',
+  'first-of-type',
+  'fullscreen',
+  'future',
+  'focus',
+  'focus-visible',
+  'focus-within',
+  'has', // has()
+  'host', // host or host()
+  'host-context', // host-context()
+  'hover',
+  'indeterminate',
+  'in-range',
+  'invalid',
+  'is', // is()
+  'lang', // lang()
+  'last-child',
+  'last-of-type',
+  'left',
+  'link',
+  'local-link',
+  'not', // not()
+  'nth-child', // nth-child()
+  'nth-col', // nth-col()
+  'nth-last-child', // nth-last-child()
+  'nth-last-col', // nth-last-col()
+  'nth-last-of-type', //nth-last-of-type()
+  'nth-of-type', //nth-of-type()
+  'only-child',
+  'only-of-type',
+  'optional',
+  'out-of-range',
+  'past',
+  'placeholder-shown',
+  'read-only',
+  'read-write',
+  'required',
+  'right',
+  'root',
+  'scope',
+  'target',
+  'target-within',
+  'user-invalid',
+  'valid',
+  'visited',
+  'where' // where()
+].sort().reverse();
+
+// https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-elements
+const PSEUDO_ELEMENTS = [
+  'after',
+  'backdrop',
+  'before',
+  'cue',
+  'cue-region',
+  'first-letter',
+  'first-line',
+  'grammar-error',
+  'marker',
+  'part',
+  'placeholder',
+  'selection',
+  'slotted',
+  'spelling-error'
+].sort().reverse();
+
+const ATTRIBUTES = [
+  'accent-color',
+  'align-content',
+  'align-items',
+  'align-self',
+  'alignment-baseline',
+  'all',
+  'anchor-name',
+  'animation',
+  'animation-composition',
+  'animation-delay',
+  'animation-direction',
+  'animation-duration',
+  'animation-fill-mode',
+  'animation-iteration-count',
+  'animation-name',
+  'animation-play-state',
+  'animation-range',
+  'animation-range-end',
+  'animation-range-start',
+  'animation-timeline',
+  'animation-timing-function',
+  'appearance',
+  'aspect-ratio',
+  'backdrop-filter',
+  'backface-visibility',
+  'background',
+  'background-attachment',
+  'background-blend-mode',
+  'background-clip',
+  'background-color',
+  'background-image',
+  'background-origin',
+  'background-position',
+  'background-position-x',
+  'background-position-y',
+  'background-repeat',
+  'background-size',
+  'baseline-shift',
+  'block-size',
+  'border',
+  'border-block',
+  'border-block-color',
+  'border-block-end',
+  'border-block-end-color',
+  'border-block-end-style',
+  'border-block-end-width',
+  'border-block-start',
+  'border-block-start-color',
+  'border-block-start-style',
+  'border-block-start-width',
+  'border-block-style',
+  'border-block-width',
+  'border-bottom',
+  'border-bottom-color',
+  'border-bottom-left-radius',
+  'border-bottom-right-radius',
+  'border-bottom-style',
+  'border-bottom-width',
+  'border-collapse',
+  'border-color',
+  'border-end-end-radius',
+  'border-end-start-radius',
+  'border-image',
+  'border-image-outset',
+  'border-image-repeat',
+  'border-image-slice',
+  'border-image-source',
+  'border-image-width',
+  'border-inline',
+  'border-inline-color',
+  'border-inline-end',
+  'border-inline-end-color',
+  'border-inline-end-style',
+  'border-inline-end-width',
+  'border-inline-start',
+  'border-inline-start-color',
+  'border-inline-start-style',
+  'border-inline-start-width',
+  'border-inline-style',
+  'border-inline-width',
+  'border-left',
+  'border-left-color',
+  'border-left-style',
+  'border-left-width',
+  'border-radius',
+  'border-right',
+  'border-right-color',
+  'border-right-style',
+  'border-right-width',
+  'border-spacing',
+  'border-start-end-radius',
+  'border-start-start-radius',
+  'border-style',
+  'border-top',
+  'border-top-color',
+  'border-top-left-radius',
+  'border-top-right-radius',
+  'border-top-style',
+  'border-top-width',
+  'border-width',
+  'bottom',
+  'box-align',
+  'box-decoration-break',
+  'box-direction',
+  'box-flex',
+  'box-flex-group',
+  'box-lines',
+  'box-ordinal-group',
+  'box-orient',
+  'box-pack',
+  'box-shadow',
+  'box-sizing',
+  'break-after',
+  'break-before',
+  'break-inside',
+  'caption-side',
+  'caret-color',
+  'clear',
+  'clip',
+  'clip-path',
+  'clip-rule',
+  'color',
+  'color-interpolation',
+  'color-interpolation-filters',
+  'color-profile',
+  'color-rendering',
+  'color-scheme',
+  'column-count',
+  'column-fill',
+  'column-gap',
+  'column-rule',
+  'column-rule-color',
+  'column-rule-style',
+  'column-rule-width',
+  'column-span',
+  'column-width',
+  'columns',
+  'contain',
+  'contain-intrinsic-block-size',
+  'contain-intrinsic-height',
+  'contain-intrinsic-inline-size',
+  'contain-intrinsic-size',
+  'contain-intrinsic-width',
+  'container',
+  'container-name',
+  'container-type',
+  'content',
+  'content-visibility',
+  'counter-increment',
+  'counter-reset',
+  'counter-set',
+  'cue',
+  'cue-after',
+  'cue-before',
+  'cursor',
+  'cx',
+  'cy',
+  'direction',
+  'display',
+  'dominant-baseline',
+  'empty-cells',
+  'enable-background',
+  'field-sizing',
+  'fill',
+  'fill-opacity',
+  'fill-rule',
+  'filter',
+  'flex',
+  'flex-basis',
+  'flex-direction',
+  'flex-flow',
+  'flex-grow',
+  'flex-shrink',
+  'flex-wrap',
+  'float',
+  'flood-color',
+  'flood-opacity',
+  'flow',
+  'font',
+  'font-display',
+  'font-family',
+  'font-feature-settings',
+  'font-kerning',
+  'font-language-override',
+  'font-optical-sizing',
+  'font-palette',
+  'font-size',
+  'font-size-adjust',
+  'font-smooth',
+  'font-smoothing',
+  'font-stretch',
+  'font-style',
+  'font-synthesis',
+  'font-synthesis-position',
+  'font-synthesis-small-caps',
+  'font-synthesis-style',
+  'font-synthesis-weight',
+  'font-variant',
+  'font-variant-alternates',
+  'font-variant-caps',
+  'font-variant-east-asian',
+  'font-variant-emoji',
+  'font-variant-ligatures',
+  'font-variant-numeric',
+  'font-variant-position',
+  'font-variation-settings',
+  'font-weight',
+  'forced-color-adjust',
+  'gap',
+  'glyph-orientation-horizontal',
+  'glyph-orientation-vertical',
+  'grid',
+  'grid-area',
+  'grid-auto-columns',
+  'grid-auto-flow',
+  'grid-auto-rows',
+  'grid-column',
+  'grid-column-end',
+  'grid-column-start',
+  'grid-gap',
+  'grid-row',
+  'grid-row-end',
+  'grid-row-start',
+  'grid-template',
+  'grid-template-areas',
+  'grid-template-columns',
+  'grid-template-rows',
+  'hanging-punctuation',
+  'height',
+  'hyphenate-character',
+  'hyphenate-limit-chars',
+  'hyphens',
+  'icon',
+  'image-orientation',
+  'image-rendering',
+  'image-resolution',
+  'ime-mode',
+  'initial-letter',
+  'initial-letter-align',
+  'inline-size',
+  'inset',
+  'inset-area',
+  'inset-block',
+  'inset-block-end',
+  'inset-block-start',
+  'inset-inline',
+  'inset-inline-end',
+  'inset-inline-start',
+  'isolation',
+  'justify-content',
+  'justify-items',
+  'justify-self',
+  'kerning',
+  'left',
+  'letter-spacing',
+  'lighting-color',
+  'line-break',
+  'line-height',
+  'line-height-step',
+  'list-style',
+  'list-style-image',
+  'list-style-position',
+  'list-style-type',
+  'margin',
+  'margin-block',
+  'margin-block-end',
+  'margin-block-start',
+  'margin-bottom',
+  'margin-inline',
+  'margin-inline-end',
+  'margin-inline-start',
+  'margin-left',
+  'margin-right',
+  'margin-top',
+  'margin-trim',
+  'marker',
+  'marker-end',
+  'marker-mid',
+  'marker-start',
+  'marks',
+  'mask',
+  'mask-border',
+  'mask-border-mode',
+  'mask-border-outset',
+  'mask-border-repeat',
+  'mask-border-slice',
+  'mask-border-source',
+  'mask-border-width',
+  'mask-clip',
+  'mask-composite',
+  'mask-image',
+  'mask-mode',
+  'mask-origin',
+  'mask-position',
+  'mask-repeat',
+  'mask-size',
+  'mask-type',
+  'masonry-auto-flow',
+  'math-depth',
+  'math-shift',
+  'math-style',
+  'max-block-size',
+  'max-height',
+  'max-inline-size',
+  'max-width',
+  'min-block-size',
+  'min-height',
+  'min-inline-size',
+  'min-width',
+  'mix-blend-mode',
+  'nav-down',
+  'nav-index',
+  'nav-left',
+  'nav-right',
+  'nav-up',
+  'none',
+  'normal',
+  'object-fit',
+  'object-position',
+  'offset',
+  'offset-anchor',
+  'offset-distance',
+  'offset-path',
+  'offset-position',
+  'offset-rotate',
+  'opacity',
+  'order',
+  'orphans',
+  'outline',
+  'outline-color',
+  'outline-offset',
+  'outline-style',
+  'outline-width',
+  'overflow',
+  'overflow-anchor',
+  'overflow-block',
+  'overflow-clip-margin',
+  'overflow-inline',
+  'overflow-wrap',
+  'overflow-x',
+  'overflow-y',
+  'overlay',
+  'overscroll-behavior',
+  'overscroll-behavior-block',
+  'overscroll-behavior-inline',
+  'overscroll-behavior-x',
+  'overscroll-behavior-y',
+  'padding',
+  'padding-block',
+  'padding-block-end',
+  'padding-block-start',
+  'padding-bottom',
+  'padding-inline',
+  'padding-inline-end',
+  'padding-inline-start',
+  'padding-left',
+  'padding-right',
+  'padding-top',
+  'page',
+  'page-break-after',
+  'page-break-before',
+  'page-break-inside',
+  'paint-order',
+  'pause',
+  'pause-after',
+  'pause-before',
+  'perspective',
+  'perspective-origin',
+  'place-content',
+  'place-items',
+  'place-self',
+  'pointer-events',
+  'position',
+  'position-anchor',
+  'position-visibility',
+  'print-color-adjust',
+  'quotes',
+  'r',
+  'resize',
+  'rest',
+  'rest-after',
+  'rest-before',
+  'right',
+  'rotate',
+  'row-gap',
+  'ruby-align',
+  'ruby-position',
+  'scale',
+  'scroll-behavior',
+  'scroll-margin',
+  'scroll-margin-block',
+  'scroll-margin-block-end',
+  'scroll-margin-block-start',
+  'scroll-margin-bottom',
+  'scroll-margin-inline',
+  'scroll-margin-inline-end',
+  'scroll-margin-inline-start',
+  'scroll-margin-left',
+  'scroll-margin-right',
+  'scroll-margin-top',
+  'scroll-padding',
+  'scroll-padding-block',
+  'scroll-padding-block-end',
+  'scroll-padding-block-start',
+  'scroll-padding-bottom',
+  'scroll-padding-inline',
+  'scroll-padding-inline-end',
+  'scroll-padding-inline-start',
+  'scroll-padding-left',
+  'scroll-padding-right',
+  'scroll-padding-top',
+  'scroll-snap-align',
+  'scroll-snap-stop',
+  'scroll-snap-type',
+  'scroll-timeline',
+  'scroll-timeline-axis',
+  'scroll-timeline-name',
+  'scrollbar-color',
+  'scrollbar-gutter',
+  'scrollbar-width',
+  'shape-image-threshold',
+  'shape-margin',
+  'shape-outside',
+  'shape-rendering',
+  'speak',
+  'speak-as',
+  'src', // @font-face
+  'stop-color',
+  'stop-opacity',
+  'stroke',
+  'stroke-dasharray',
+  'stroke-dashoffset',
+  'stroke-linecap',
+  'stroke-linejoin',
+  'stroke-miterlimit',
+  'stroke-opacity',
+  'stroke-width',
+  'tab-size',
+  'table-layout',
+  'text-align',
+  'text-align-all',
+  'text-align-last',
+  'text-anchor',
+  'text-combine-upright',
+  'text-decoration',
+  'text-decoration-color',
+  'text-decoration-line',
+  'text-decoration-skip',
+  'text-decoration-skip-ink',
+  'text-decoration-style',
+  'text-decoration-thickness',
+  'text-emphasis',
+  'text-emphasis-color',
+  'text-emphasis-position',
+  'text-emphasis-style',
+  'text-indent',
+  'text-justify',
+  'text-orientation',
+  'text-overflow',
+  'text-rendering',
+  'text-shadow',
+  'text-size-adjust',
+  'text-transform',
+  'text-underline-offset',
+  'text-underline-position',
+  'text-wrap',
+  'text-wrap-mode',
+  'text-wrap-style',
+  'timeline-scope',
+  'top',
+  'touch-action',
+  'transform',
+  'transform-box',
+  'transform-origin',
+  'transform-style',
+  'transition',
+  'transition-behavior',
+  'transition-delay',
+  'transition-duration',
+  'transition-property',
+  'transition-timing-function',
+  'translate',
+  'unicode-bidi',
+  'user-modify',
+  'user-select',
+  'vector-effect',
+  'vertical-align',
+  'view-timeline',
+  'view-timeline-axis',
+  'view-timeline-inset',
+  'view-timeline-name',
+  'view-transition-name',
+  'visibility',
+  'voice-balance',
+  'voice-duration',
+  'voice-family',
+  'voice-pitch',
+  'voice-range',
+  'voice-rate',
+  'voice-stress',
+  'voice-volume',
+  'white-space',
+  'white-space-collapse',
+  'widows',
+  'width',
+  'will-change',
+  'word-break',
+  'word-spacing',
+  'word-wrap',
+  'writing-mode',
+  'x',
+  'y',
+  'z-index',
+  'zoom'
+].sort().reverse();
+
+/*
+Language: CSS
+Category: common, css, web
+Website: https://developer.mozilla.org/en-US/docs/Web/CSS
+*/
+
+
+/** @type LanguageFn */
+function css(hljs) {
+  const regex = hljs.regex;
+  const modes = MODES(hljs);
+  const VENDOR_PREFIX = { begin: /-(webkit|moz|ms|o)-(?=[a-z])/ };
+  const AT_MODIFIERS = "and or not only";
+  const AT_PROPERTY_RE = /@-?\w[\w]*(-\w+)*/; // @-webkit-keyframes
+  const IDENT_RE = '[a-zA-Z-][a-zA-Z0-9_-]*';
+  const STRINGS = [
+    hljs.APOS_STRING_MODE,
+    hljs.QUOTE_STRING_MODE
+  ];
+
+  return {
+    name: 'CSS',
+    case_insensitive: true,
+    illegal: /[=|'\$]/,
+    keywords: { keyframePosition: "from to" },
+    classNameAliases: {
+      // for visual continuity with `tag {}` and because we
+      // don't have a great class for this?
+      keyframePosition: "selector-tag" },
+    contains: [
+      modes.BLOCK_COMMENT,
+      VENDOR_PREFIX,
+      // to recognize keyframe 40% etc which are outside the scope of our
+      // attribute value mode
+      modes.CSS_NUMBER_MODE,
+      {
+        className: 'selector-id',
+        begin: /#[A-Za-z0-9_-]+/,
+        relevance: 0
+      },
+      {
+        className: 'selector-class',
+        begin: '\\.' + IDENT_RE,
+        relevance: 0
+      },
+      modes.ATTRIBUTE_SELECTOR_MODE,
+      {
+        className: 'selector-pseudo',
+        variants: [
+          { begin: ':(' + PSEUDO_CLASSES.join('|') + ')' },
+          { begin: ':(:)?(' + PSEUDO_ELEMENTS.join('|') + ')' }
+        ]
+      },
+      // we may actually need this (12/2020)
+      // { // pseudo-selector params
+      //   begin: /\(/,
+      //   end: /\)/,
+      //   contains: [ hljs.CSS_NUMBER_MODE ]
+      // },
+      modes.CSS_VARIABLE,
+      {
+        className: 'attribute',
+        begin: '\\b(' + ATTRIBUTES.join('|') + ')\\b'
+      },
+      // attribute values
+      {
+        begin: /:/,
+        end: /[;}{]/,
+        contains: [
+          modes.BLOCK_COMMENT,
+          modes.HEXCOLOR,
+          modes.IMPORTANT,
+          modes.CSS_NUMBER_MODE,
+          ...STRINGS,
+          // needed to highlight these as strings and to avoid issues with
+          // illegal characters that might be inside urls that would tigger the
+          // languages illegal stack
+          {
+            begin: /(url|data-uri)\(/,
+            end: /\)/,
+            relevance: 0, // from keywords
+            keywords: { built_in: "url data-uri" },
+            contains: [
+              ...STRINGS,
+              {
+                className: "string",
+                // any character other than `)` as in `url()` will be the start
+                // of a string, which ends with `)` (from the parent mode)
+                begin: /[^)]/,
+                endsWithParent: true,
+                excludeEnd: true
+              }
+            ]
+          },
+          modes.FUNCTION_DISPATCH
+        ]
+      },
+      {
+        begin: regex.lookahead(/@/),
+        end: '[{;]',
+        relevance: 0,
+        illegal: /:/, // break on Less variables @var: ...
+        contains: [
+          {
+            className: 'keyword',
+            begin: AT_PROPERTY_RE
+          },
+          {
+            begin: /\s/,
+            endsWithParent: true,
+            excludeEnd: true,
+            relevance: 0,
+            keywords: {
+              $pattern: /[a-z-]+/,
+              keyword: AT_MODIFIERS,
+              attribute: MEDIA_FEATURES.join(" ")
+            },
+            contains: [
+              {
+                begin: /[a-z-]+(?=:)/,
+                className: "attribute"
+              },
+              ...STRINGS,
+              modes.CSS_NUMBER_MODE
+            ]
+          }
+        ]
+      },
+      {
+        className: 'selector-tag',
+        begin: '\\b(' + TAGS.join('|') + ')\\b'
+      }
+    ]
+  };
+}
+
+export { css as default };

frontend/node_modules/highlight.js/es/languages/d.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/d" instead of "highlight.js/lib/languages/d.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './d.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/django.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/django" instead of "highlight.js/lib/languages/django.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './django.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/dockerfile.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/dockerfile" instead of "highlight.js/lib/languages/dockerfile.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './dockerfile.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/dust.js

@@ -0,0 +1,47 @@
+/*
+Language: Dust
+Requires: xml.js
+Author: Michael Allen <michael.allen@benefitfocus.com>
+Description: Matcher for dust.js templates.
+Website: https://www.dustjs.com
+Category: template
+*/
+
+/** @type LanguageFn */
+function dust(hljs) {
+  const EXPRESSION_KEYWORDS = 'if eq ne lt lte gt gte select default math sep';
+  return {
+    name: 'Dust',
+    aliases: [ 'dst' ],
+    case_insensitive: true,
+    subLanguage: 'xml',
+    contains: [
+      {
+        className: 'template-tag',
+        begin: /\{[#\/]/,
+        end: /\}/,
+        illegal: /;/,
+        contains: [
+          {
+            className: 'name',
+            begin: /[a-zA-Z\.-]+/,
+            starts: {
+              endsWithParent: true,
+              relevance: 0,
+              contains: [ hljs.QUOTE_STRING_MODE ]
+            }
+          }
+        ]
+      },
+      {
+        className: 'template-variable',
+        begin: /\{/,
+        end: /\}/,
+        illegal: /;/,
+        keywords: EXPRESSION_KEYWORDS
+      }
+    ]
+  };
+}
+
+export { dust as default };

frontend/node_modules/highlight.js/es/languages/ebnf.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/ebnf" instead of "highlight.js/lib/languages/ebnf.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './ebnf.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/elm.js

@@ -0,0 +1,143 @@
+/*
+Language: Elm
+Author: Janis Voigtlaender <janis.voigtlaender@gmail.com>
+Website: https://elm-lang.org
+Category: functional
+*/
+
+/** @type LanguageFn */
+function elm(hljs) {
+  const COMMENT = { variants: [
+    hljs.COMMENT('--', '$'),
+    hljs.COMMENT(
+      /\{-/,
+      /-\}/,
+      { contains: [ 'self' ] }
+    )
+  ] };
+
+  const CONSTRUCTOR = {
+    className: 'type',
+    begin: '\\b[A-Z][\\w\']*', // TODO: other constructors (built-in, infix).
+    relevance: 0
+  };
+
+  const LIST = {
+    begin: '\\(',
+    end: '\\)',
+    illegal: '"',
+    contains: [
+      {
+        className: 'type',
+        begin: '\\b[A-Z][\\w]*(\\((\\.\\.|,|\\w+)\\))?'
+      },
+      COMMENT
+    ]
+  };
+
+  const RECORD = {
+    begin: /\{/,
+    end: /\}/,
+    contains: LIST.contains
+  };
+
+  const CHARACTER = {
+    className: 'string',
+    begin: '\'\\\\?.',
+    end: '\'',
+    illegal: '.'
+  };
+
+  const KEYWORDS = [
+    "let",
+    "in",
+    "if",
+    "then",
+    "else",
+    "case",
+    "of",
+    "where",
+    "module",
+    "import",
+    "exposing",
+    "type",
+    "alias",
+    "as",
+    "infix",
+    "infixl",
+    "infixr",
+    "port",
+    "effect",
+    "command",
+    "subscription"
+  ];
+
+  return {
+    name: 'Elm',
+    keywords: KEYWORDS,
+    contains: [
+
+      // Top-level constructions.
+
+      {
+        beginKeywords: 'port effect module',
+        end: 'exposing',
+        keywords: 'port effect module where command subscription exposing',
+        contains: [
+          LIST,
+          COMMENT
+        ],
+        illegal: '\\W\\.|;'
+      },
+      {
+        begin: 'import',
+        end: '$',
+        keywords: 'import as exposing',
+        contains: [
+          LIST,
+          COMMENT
+        ],
+        illegal: '\\W\\.|;'
+      },
+      {
+        begin: 'type',
+        end: '$',
+        keywords: 'type alias',
+        contains: [
+          CONSTRUCTOR,
+          LIST,
+          RECORD,
+          COMMENT
+        ]
+      },
+      {
+        beginKeywords: 'infix infixl infixr',
+        end: '$',
+        contains: [
+          hljs.C_NUMBER_MODE,
+          COMMENT
+        ]
+      },
+      {
+        begin: 'port',
+        end: '$',
+        keywords: 'port',
+        contains: [ COMMENT ]
+      },
+
+      // Literals and names.
+      CHARACTER,
+      hljs.QUOTE_STRING_MODE,
+      hljs.C_NUMBER_MODE,
+      CONSTRUCTOR,
+      hljs.inherit(hljs.TITLE_MODE, { begin: '^[_a-z][\\w\']*' }),
+      COMMENT,
+
+      { // No markup, relevance booster
+        begin: '->|<-' }
+    ],
+    illegal: /;/
+  };
+}
+
+export { elm as default };

frontend/node_modules/highlight.js/es/languages/erlang-repl.js

@@ -0,0 +1,54 @@
+/*
+Language: Erlang REPL
+Author: Sergey Ignatov <sergey@ignatov.spb.su>
+Website: https://www.erlang.org
+Category: functional
+*/
+
+/** @type LanguageFn */
+function erlangRepl(hljs) {
+  const regex = hljs.regex;
+  return {
+    name: 'Erlang REPL',
+    keywords: {
+      built_in:
+        'spawn spawn_link self',
+      keyword:
+        'after and andalso|10 band begin bnot bor bsl bsr bxor case catch cond div end fun if '
+        + 'let not of or orelse|10 query receive rem try when xor'
+    },
+    contains: [
+      {
+        className: 'meta.prompt',
+        begin: '^[0-9]+> ',
+        relevance: 10
+      },
+      hljs.COMMENT('%', '$'),
+      {
+        className: 'number',
+        begin: '\\b(\\d+(_\\d+)*#[a-fA-F0-9]+(_[a-fA-F0-9]+)*|\\d+(_\\d+)*(\\.\\d+(_\\d+)*)?([eE][-+]?\\d+)?)',
+        relevance: 0
+      },
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE,
+      { begin: regex.concat(
+        /\?(::)?/,
+        /([A-Z]\w*)/, // at least one identifier
+        /((::)[A-Z]\w*)*/ // perhaps more
+      ) },
+      { begin: '->' },
+      { begin: 'ok' },
+      { begin: '!' },
+      {
+        begin: '(\\b[a-z\'][a-zA-Z0-9_\']*:[a-z\'][a-zA-Z0-9_\']*)|(\\b[a-z\'][a-zA-Z0-9_\']*)',
+        relevance: 0
+      },
+      {
+        begin: '[A-Z][a-zA-Z0-9_\']*',
+        relevance: 0
+      }
+    ]
+  };
+}
+
+export { erlangRepl as default };

frontend/node_modules/highlight.js/es/languages/erlang.js

@@ -0,0 +1,235 @@
+/*
+Language: Erlang
+Description: Erlang is a general-purpose functional language, with strict evaluation, single assignment, and dynamic typing.
+Author: Nikolay Zakharov <nikolay.desh@gmail.com>, Dmitry Kovega <arhibot@gmail.com>
+Website: https://www.erlang.org
+Category: functional
+*/
+
+/** @type LanguageFn */
+function erlang(hljs) {
+  const BASIC_ATOM_RE = '[a-z\'][a-zA-Z0-9_\']*';
+  const FUNCTION_NAME_RE = '(' + BASIC_ATOM_RE + ':' + BASIC_ATOM_RE + '|' + BASIC_ATOM_RE + ')';
+  const ERLANG_RESERVED = {
+    keyword:
+      'after and andalso|10 band begin bnot bor bsl bzr bxor case catch cond div end fun if '
+      + 'let not of orelse|10 query receive rem try when xor maybe else',
+    literal:
+      'false true'
+  };
+
+  const COMMENT = hljs.COMMENT('%', '$');
+  const NUMBER = {
+    className: 'number',
+    begin: '\\b(\\d+(_\\d+)*#[a-fA-F0-9]+(_[a-fA-F0-9]+)*|\\d+(_\\d+)*(\\.\\d+(_\\d+)*)?([eE][-+]?\\d+)?)',
+    relevance: 0
+  };
+  const NAMED_FUN = { begin: 'fun\\s+' + BASIC_ATOM_RE + '/\\d+' };
+  const FUNCTION_CALL = {
+    begin: FUNCTION_NAME_RE + '\\(',
+    end: '\\)',
+    returnBegin: true,
+    relevance: 0,
+    contains: [
+      {
+        begin: FUNCTION_NAME_RE,
+        relevance: 0
+      },
+      {
+        begin: '\\(',
+        end: '\\)',
+        endsWithParent: true,
+        returnEnd: true,
+        relevance: 0
+        // "contains" defined later
+      }
+    ]
+  };
+  const TUPLE = {
+    begin: /\{/,
+    end: /\}/,
+    relevance: 0
+    // "contains" defined later
+  };
+  const VAR1 = {
+    begin: '\\b_([A-Z][A-Za-z0-9_]*)?',
+    relevance: 0
+  };
+  const VAR2 = {
+    begin: '[A-Z][a-zA-Z0-9_]*',
+    relevance: 0
+  };
+  const RECORD_ACCESS = {
+    begin: '#' + hljs.UNDERSCORE_IDENT_RE,
+    relevance: 0,
+    returnBegin: true,
+    contains: [
+      {
+        begin: '#' + hljs.UNDERSCORE_IDENT_RE,
+        relevance: 0
+      },
+      {
+        begin: /\{/,
+        end: /\}/,
+        relevance: 0
+        // "contains" defined later
+      }
+    ]
+  };
+  const CHAR_LITERAL = {
+    scope: 'string',
+    match: /\$(\\([^0-9]|[0-9]{1,3}|)|.)/,
+  };
+  const TRIPLE_QUOTE = {
+    scope: 'string',
+    match: /"""("*)(?!")[\s\S]*?"""\1/,
+  };
+
+  const SIGIL = {
+    scope: 'string',
+    contains: [ hljs.BACKSLASH_ESCAPE ],
+    variants: [
+      {match: /~\w?"""("*)(?!")[\s\S]*?"""\1/},
+      {begin: /~\w?\(/, end: /\)/},
+      {begin: /~\w?\[/, end: /\]/},
+      {begin: /~\w?{/, end: /}/},
+      {begin: /~\w?</, end: />/},
+      {begin: /~\w?\//, end: /\//},
+      {begin: /~\w?\|/, end: /\|/},
+      {begin: /~\w?'/, end: /'/},
+      {begin: /~\w?"/, end: /"/},
+      {begin: /~\w?`/, end: /`/},
+      {begin: /~\w?#/, end: /#/},
+    ],
+  };
+
+  const BLOCK_STATEMENTS = {
+    beginKeywords: 'fun receive if try case maybe',
+    end: 'end',
+    keywords: ERLANG_RESERVED
+  };
+  BLOCK_STATEMENTS.contains = [
+    COMMENT,
+    NAMED_FUN,
+    hljs.inherit(hljs.APOS_STRING_MODE, { className: '' }),
+    BLOCK_STATEMENTS,
+    FUNCTION_CALL,
+    SIGIL,
+    TRIPLE_QUOTE,
+    hljs.QUOTE_STRING_MODE,
+    NUMBER,
+    TUPLE,
+    VAR1,
+    VAR2,
+    RECORD_ACCESS,
+    CHAR_LITERAL
+  ];
+
+  const BASIC_MODES = [
+    COMMENT,
+    NAMED_FUN,
+    BLOCK_STATEMENTS,
+    FUNCTION_CALL,
+    SIGIL,
+    TRIPLE_QUOTE,
+    hljs.QUOTE_STRING_MODE,
+    NUMBER,
+    TUPLE,
+    VAR1,
+    VAR2,
+    RECORD_ACCESS,
+    CHAR_LITERAL
+  ];
+  FUNCTION_CALL.contains[1].contains = BASIC_MODES;
+  TUPLE.contains = BASIC_MODES;
+  RECORD_ACCESS.contains[1].contains = BASIC_MODES;
+
+  const DIRECTIVES = [
+    "-module",
+    "-record",
+    "-undef",
+    "-export",
+    "-ifdef",
+    "-ifndef",
+    "-author",
+    "-copyright",
+    "-doc",
+    "-moduledoc",
+    "-vsn",
+    "-import",
+    "-include",
+    "-include_lib",
+    "-compile",
+    "-define",
+    "-else",
+    "-endif",
+    "-file",
+    "-behaviour",
+    "-behavior",
+    "-spec",
+    "-on_load",
+    "-nifs",
+  ];
+
+  const PARAMS = {
+    className: 'params',
+    begin: '\\(',
+    end: '\\)',
+    contains: BASIC_MODES
+  };
+
+  return {
+    name: 'Erlang',
+    aliases: [ 'erl' ],
+    keywords: ERLANG_RESERVED,
+    illegal: '(</|\\*=|\\+=|-=|/\\*|\\*/|\\(\\*|\\*\\))',
+    contains: [
+      {
+        className: 'function',
+        begin: '^' + BASIC_ATOM_RE + '\\s*\\(',
+        end: '->',
+        returnBegin: true,
+        illegal: '\\(|#|//|/\\*|\\\\|:|;',
+        contains: [
+          PARAMS,
+          hljs.inherit(hljs.TITLE_MODE, { begin: BASIC_ATOM_RE })
+        ],
+        starts: {
+          end: ';|\\.',
+          keywords: ERLANG_RESERVED,
+          contains: BASIC_MODES
+        }
+      },
+      COMMENT,
+      {
+        begin: '^-',
+        end: '\\.',
+        relevance: 0,
+        excludeEnd: true,
+        returnBegin: true,
+        keywords: {
+          $pattern: '-' + hljs.IDENT_RE,
+          keyword: DIRECTIVES.map(x => `${x}|1.5`).join(" ")
+        },
+        contains: [
+          PARAMS,
+          SIGIL,
+          TRIPLE_QUOTE,
+          hljs.QUOTE_STRING_MODE
+        ]
+      },
+      NUMBER,
+      SIGIL,
+      TRIPLE_QUOTE,
+      hljs.QUOTE_STRING_MODE,
+      RECORD_ACCESS,
+      VAR1,
+      VAR2,
+      TUPLE,
+      CHAR_LITERAL,
+      { begin: /\.$/ } // relevance booster
+    ]
+  };
+}
+
+export { erlang as default };

frontend/node_modules/highlight.js/es/languages/fix.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/fix" instead of "highlight.js/lib/languages/fix.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './fix.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/flix.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/flix" instead of "highlight.js/lib/languages/flix.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './flix.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/fortran.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/fortran" instead of "highlight.js/lib/languages/fortran.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './fortran.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/gams.js

@@ -0,0 +1,181 @@
+/*
+ Language: GAMS
+ Author: Stefan Bechert <stefan.bechert@gmx.net>
+ Contributors: Oleg Efimov <efimovov@gmail.com>, Mikko Kouhia <mikko.kouhia@iki.fi>
+ Description: The General Algebraic Modeling System language
+ Website: https://www.gams.com
+ Category: scientific
+ */
+
+/** @type LanguageFn */
+function gams(hljs) {
+  const regex = hljs.regex;
+  const KEYWORDS = {
+    keyword:
+      'abort acronym acronyms alias all and assign binary card diag display '
+      + 'else eq file files for free ge gt if integer le loop lt maximizing '
+      + 'minimizing model models ne negative no not option options or ord '
+      + 'positive prod put putpage puttl repeat sameas semicont semiint smax '
+      + 'smin solve sos1 sos2 sum system table then until using while xor yes',
+    literal:
+      'eps inf na',
+    built_in:
+      'abs arccos arcsin arctan arctan2 Beta betaReg binomial ceil centropy '
+      + 'cos cosh cvPower div div0 eDist entropy errorf execSeed exp fact '
+      + 'floor frac gamma gammaReg log logBeta logGamma log10 log2 mapVal max '
+      + 'min mod ncpCM ncpF ncpVUpow ncpVUsin normal pi poly power '
+      + 'randBinomial randLinear randTriangle round rPower sigmoid sign '
+      + 'signPower sin sinh slexp sllog10 slrec sqexp sqlog10 sqr sqrec sqrt '
+      + 'tan tanh trunc uniform uniformInt vcPower bool_and bool_eqv bool_imp '
+      + 'bool_not bool_or bool_xor ifThen rel_eq rel_ge rel_gt rel_le rel_lt '
+      + 'rel_ne gday gdow ghour gleap gmillisec gminute gmonth gsecond gyear '
+      + 'jdate jnow jstart jtime errorLevel execError gamsRelease gamsVersion '
+      + 'handleCollect handleDelete handleStatus handleSubmit heapFree '
+      + 'heapLimit heapSize jobHandle jobKill jobStatus jobTerminate '
+      + 'licenseLevel licenseStatus maxExecError sleep timeClose timeComp '
+      + 'timeElapsed timeExec timeStart'
+  };
+  const PARAMS = {
+    className: 'params',
+    begin: /\(/,
+    end: /\)/,
+    excludeBegin: true,
+    excludeEnd: true
+  };
+  const SYMBOLS = {
+    className: 'symbol',
+    variants: [
+      { begin: /=[lgenxc]=/ },
+      { begin: /\$/ }
+    ]
+  };
+  const QSTR = { // One-line quoted comment string
+    className: 'comment',
+    variants: [
+      {
+        begin: '\'',
+        end: '\''
+      },
+      {
+        begin: '"',
+        end: '"'
+      }
+    ],
+    illegal: '\\n',
+    contains: [ hljs.BACKSLASH_ESCAPE ]
+  };
+  const ASSIGNMENT = {
+    begin: '/',
+    end: '/',
+    keywords: KEYWORDS,
+    contains: [
+      QSTR,
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      hljs.QUOTE_STRING_MODE,
+      hljs.APOS_STRING_MODE,
+      hljs.C_NUMBER_MODE
+    ]
+  };
+  const COMMENT_WORD = /[a-z0-9&#*=?@\\><:,()$[\]_.{}!+%^-]+/;
+  const DESCTEXT = { // Parameter/set/variable description text
+    begin: /[a-z][a-z0-9_]*(\([a-z0-9_, ]*\))?[ \t]+/,
+    excludeBegin: true,
+    end: '$',
+    endsWithParent: true,
+    contains: [
+      QSTR,
+      ASSIGNMENT,
+      {
+        className: 'comment',
+        // one comment word, then possibly more
+        begin: regex.concat(
+          COMMENT_WORD,
+          // [ ] because \s would be too broad (matching newlines)
+          regex.anyNumberOfTimes(regex.concat(/[ ]+/, COMMENT_WORD))
+        ),
+        relevance: 0
+      }
+    ]
+  };
+
+  return {
+    name: 'GAMS',
+    aliases: [ 'gms' ],
+    case_insensitive: true,
+    keywords: KEYWORDS,
+    contains: [
+      hljs.COMMENT(/^\$ontext/, /^\$offtext/),
+      {
+        className: 'meta',
+        begin: '^\\$[a-z0-9]+',
+        end: '$',
+        returnBegin: true,
+        contains: [
+          {
+            className: 'keyword',
+            begin: '^\\$[a-z0-9]+'
+          }
+        ]
+      },
+      hljs.COMMENT('^\\*', '$'),
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      hljs.QUOTE_STRING_MODE,
+      hljs.APOS_STRING_MODE,
+      // Declarations
+      {
+        beginKeywords:
+          'set sets parameter parameters variable variables '
+          + 'scalar scalars equation equations',
+        end: ';',
+        contains: [
+          hljs.COMMENT('^\\*', '$'),
+          hljs.C_LINE_COMMENT_MODE,
+          hljs.C_BLOCK_COMMENT_MODE,
+          hljs.QUOTE_STRING_MODE,
+          hljs.APOS_STRING_MODE,
+          ASSIGNMENT,
+          DESCTEXT
+        ]
+      },
+      { // table environment
+        beginKeywords: 'table',
+        end: ';',
+        returnBegin: true,
+        contains: [
+          { // table header row
+            beginKeywords: 'table',
+            end: '$',
+            contains: [ DESCTEXT ]
+          },
+          hljs.COMMENT('^\\*', '$'),
+          hljs.C_LINE_COMMENT_MODE,
+          hljs.C_BLOCK_COMMENT_MODE,
+          hljs.QUOTE_STRING_MODE,
+          hljs.APOS_STRING_MODE,
+          hljs.C_NUMBER_MODE
+          // Table does not contain DESCTEXT or ASSIGNMENT
+        ]
+      },
+      // Function definitions
+      {
+        className: 'function',
+        begin: /^[a-z][a-z0-9_,\-+' ()$]+\.{2}/,
+        returnBegin: true,
+        contains: [
+          { // Function title
+            className: 'title',
+            begin: /^[a-z0-9_]+/
+          },
+          PARAMS,
+          SYMBOLS
+        ]
+      },
+      hljs.C_NUMBER_MODE,
+      SYMBOLS
+    ]
+  };
+}
+
+export { gams as default };

frontend/node_modules/highlight.js/es/languages/gams.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/gams" instead of "highlight.js/lib/languages/gams.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './gams.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/gcode.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/gcode" instead of "highlight.js/lib/languages/gcode.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './gcode.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/gherkin.js

@@ -0,0 +1,49 @@
+/*
+ Language: Gherkin
+ Author: Sam Pikesley (@pikesley) <sam.pikesley@theodi.org>
+ Description: Gherkin is the format for cucumber specifications. It is a domain specific language which helps you to describe business behavior without the need to go into detail of implementation.
+ Website: https://cucumber.io/docs/gherkin/
+ */
+
+function gherkin(hljs) {
+  return {
+    name: 'Gherkin',
+    aliases: [ 'feature' ],
+    keywords: 'Feature Background Ability Business\ Need Scenario Scenarios Scenario\ Outline Scenario\ Template Examples Given And Then But When',
+    contains: [
+      {
+        className: 'symbol',
+        begin: '\\*',
+        relevance: 0
+      },
+      {
+        className: 'meta',
+        begin: '@[^@\\s]+'
+      },
+      {
+        begin: '\\|',
+        end: '\\|\\w*$',
+        contains: [
+          {
+            className: 'string',
+            begin: '[^|]+'
+          }
+        ]
+      },
+      {
+        className: 'variable',
+        begin: '<',
+        end: '>'
+      },
+      hljs.HASH_COMMENT_MODE,
+      {
+        className: 'string',
+        begin: '"""',
+        end: '"""'
+      },
+      hljs.QUOTE_STRING_MODE
+    ]
+  };
+}
+
+export { gherkin as default };

frontend/node_modules/highlight.js/es/languages/gherkin.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/gherkin" instead of "highlight.js/lib/languages/gherkin.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './gherkin.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/glsl.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/glsl" instead of "highlight.js/lib/languages/glsl.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './glsl.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/go.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/go" instead of "highlight.js/lib/languages/go.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './go.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/graphql.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/graphql" instead of "highlight.js/lib/languages/graphql.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './graphql.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/groovy.js

@@ -0,0 +1,190 @@
+/*
+ Language: Groovy
+ Author: Guillaume Laforge <glaforge@gmail.com>
+ Description: Groovy programming language implementation inspired from Vsevolod's Java mode
+ Website: https://groovy-lang.org
+ Category: system
+ */
+
+function variants(variants, obj = {}) {
+  obj.variants = variants;
+  return obj;
+}
+
+function groovy(hljs) {
+  const regex = hljs.regex;
+  const IDENT_RE = '[A-Za-z0-9_$]+';
+  const COMMENT = variants([
+    hljs.C_LINE_COMMENT_MODE,
+    hljs.C_BLOCK_COMMENT_MODE,
+    hljs.COMMENT(
+      '/\\*\\*',
+      '\\*/',
+      {
+        relevance: 0,
+        contains: [
+          {
+            // eat up @'s in emails to prevent them to be recognized as doctags
+            begin: /\w+@/,
+            relevance: 0
+          },
+          {
+            className: 'doctag',
+            begin: '@[A-Za-z]+'
+          }
+        ]
+      }
+    )
+  ]);
+  const REGEXP = {
+    className: 'regexp',
+    begin: /~?\/[^\/\n]+\//,
+    contains: [ hljs.BACKSLASH_ESCAPE ]
+  };
+  const NUMBER = variants([
+    hljs.BINARY_NUMBER_MODE,
+    hljs.C_NUMBER_MODE
+  ]);
+  const STRING = variants([
+    {
+      begin: /"""/,
+      end: /"""/
+    },
+    {
+      begin: /'''/,
+      end: /'''/
+    },
+    {
+      begin: "\\$/",
+      end: "/\\$",
+      relevance: 10
+    },
+    hljs.APOS_STRING_MODE,
+    hljs.QUOTE_STRING_MODE
+  ],
+  { className: "string" }
+  );
+
+  const CLASS_DEFINITION = {
+    match: [
+      /(class|interface|trait|enum|record|extends|implements)/,
+      /\s+/,
+      hljs.UNDERSCORE_IDENT_RE
+    ],
+    scope: {
+      1: "keyword",
+      3: "title.class",
+    }
+  };
+  const TYPES = [
+    "byte",
+    "short",
+    "char",
+    "int",
+    "long",
+    "boolean",
+    "float",
+    "double",
+    "void"
+  ];
+  const KEYWORDS = [
+    // groovy specific keywords
+    "def",
+    "as",
+    "in",
+    "assert",
+    "trait",
+    // common keywords with Java
+    "abstract",
+    "static",
+    "volatile",
+    "transient",
+    "public",
+    "private",
+    "protected",
+    "synchronized",
+    "final",
+    "class",
+    "interface",
+    "enum",
+    "if",
+    "else",
+    "for",
+    "while",
+    "switch",
+    "case",
+    "break",
+    "default",
+    "continue",
+    "throw",
+    "throws",
+    "try",
+    "catch",
+    "finally",
+    "implements",
+    "extends",
+    "new",
+    "import",
+    "package",
+    "return",
+    "instanceof",
+    "var"
+  ];
+
+  return {
+    name: 'Groovy',
+    keywords: {
+      "variable.language": 'this super',
+      literal: 'true false null',
+      type: TYPES,
+      keyword: KEYWORDS
+    },
+    contains: [
+      hljs.SHEBANG({
+        binary: "groovy",
+        relevance: 10
+      }),
+      COMMENT,
+      STRING,
+      REGEXP,
+      NUMBER,
+      CLASS_DEFINITION,
+      {
+        className: 'meta',
+        begin: '@[A-Za-z]+',
+        relevance: 0
+      },
+      {
+        // highlight map keys and named parameters as attrs
+        className: 'attr',
+        begin: IDENT_RE + '[ \t]*:',
+        relevance: 0
+      },
+      {
+        // catch middle element of the ternary operator
+        // to avoid highlight it as a label, named parameter, or map key
+        begin: /\?/,
+        end: /:/,
+        relevance: 0,
+        contains: [
+          COMMENT,
+          STRING,
+          REGEXP,
+          NUMBER,
+          'self'
+        ]
+      },
+      {
+        // highlight labeled statements
+        className: 'symbol',
+        begin: '^[ \t]*' + regex.lookahead(IDENT_RE + ':'),
+        excludeBegin: true,
+        end: IDENT_RE + ':',
+        relevance: 0
+      }
+    ],
+    illegal: /#|<\//
+  };
+}
+
+export { groovy as default };

frontend/node_modules/highlight.js/es/languages/handlebars.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/handlebars" instead of "highlight.js/lib/languages/handlebars.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './handlebars.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/haskell.js

@@ -0,0 +1,217 @@
+/*
+Language: Haskell
+Author: Jeremy Hull <sourdrums@gmail.com>
+Contributors: Zena Treep <zena.treep@gmail.com>
+Website: https://www.haskell.org
+Category: functional
+*/
+
+function haskell(hljs) {
+
+  /* See:
+     - https://www.haskell.org/onlinereport/lexemes.html
+     - https://downloads.haskell.org/ghc/9.0.1/docs/html/users_guide/exts/binary_literals.html
+     - https://downloads.haskell.org/ghc/9.0.1/docs/html/users_guide/exts/numeric_underscores.html
+     - https://downloads.haskell.org/ghc/9.0.1/docs/html/users_guide/exts/hex_float_literals.html
+  */
+  const decimalDigits = '([0-9]_*)+';
+  const hexDigits = '([0-9a-fA-F]_*)+';
+  const binaryDigits = '([01]_*)+';
+  const octalDigits = '([0-7]_*)+';
+  const ascSymbol = '[!#$%&*+.\\/<=>?@\\\\^~-]';
+  const uniSymbol = '(\\p{S}|\\p{P})'; // Symbol or Punctuation
+  const special = '[(),;\\[\\]`|{}]';
+  const symbol = `(${ascSymbol}|(?!(${special}|[_:"']))${uniSymbol})`;
+
+  const COMMENT = { variants: [
+    // Double dash forms a valid comment only if it's not part of legal lexeme.
+    // See: Haskell 98 report: https://www.haskell.org/onlinereport/lexemes.html
+    //
+    // The commented code does the job, but we can't use negative lookbehind,
+    // due to poor support by Safari browser.
+    // > hljs.COMMENT(`(?<!${symbol})--+(?!${symbol})`, '$'),
+    // So instead, we'll add a no-markup rule before the COMMENT rule in the rules list
+    // to match the problematic infix operators that contain double dash.
+    hljs.COMMENT('--+', '$'),
+    hljs.COMMENT(
+      /\{-/,
+      /-\}/,
+      { contains: [ 'self' ] }
+    )
+  ] };
+
+  const PRAGMA = {
+    className: 'meta',
+    begin: /\{-#/,
+    end: /#-\}/
+  };
+
+  const PREPROCESSOR = {
+    className: 'meta',
+    begin: '^#',
+    end: '$'
+  };
+
+  const CONSTRUCTOR = {
+    className: 'type',
+    begin: '\\b[A-Z][\\w\']*', // TODO: other constructors (build-in, infix).
+    relevance: 0
+  };
+
+  const LIST = {
+    begin: '\\(',
+    end: '\\)',
+    illegal: '"',
+    contains: [
+      PRAGMA,
+      PREPROCESSOR,
+      {
+        className: 'type',
+        begin: '\\b[A-Z][\\w]*(\\((\\.\\.|,|\\w+)\\))?'
+      },
+      hljs.inherit(hljs.TITLE_MODE, { begin: '[_a-z][\\w\']*' }),
+      COMMENT
+    ]
+  };
+
+  const RECORD = {
+    begin: /\{/,
+    end: /\}/,
+    contains: LIST.contains
+  };
+
+  const NUMBER = {
+    className: 'number',
+    relevance: 0,
+    variants: [
+      // decimal floating-point-literal (subsumes decimal-literal)
+      { match: `\\b(${decimalDigits})(\\.(${decimalDigits}))?` + `([eE][+-]?(${decimalDigits}))?\\b` },
+      // hexadecimal floating-point-literal (subsumes hexadecimal-literal)
+      { match: `\\b0[xX]_*(${hexDigits})(\\.(${hexDigits}))?` + `([pP][+-]?(${decimalDigits}))?\\b` },
+      // octal-literal
+      { match: `\\b0[oO](${octalDigits})\\b` },
+      // binary-literal
+      { match: `\\b0[bB](${binaryDigits})\\b` }
+    ]
+  };
+
+  return {
+    name: 'Haskell',
+    aliases: [ 'hs' ],
+    keywords:
+      'let in if then else case of where do module import hiding '
+      + 'qualified type data newtype deriving class instance as default '
+      + 'infix infixl infixr foreign export ccall stdcall cplusplus '
+      + 'jvm dotnet safe unsafe family forall mdo proc rec',
+    unicodeRegex: true,
+    contains: [
+      // Top-level constructions.
+      {
+        beginKeywords: 'module',
+        end: 'where',
+        keywords: 'module where',
+        contains: [
+          LIST,
+          COMMENT
+        ],
+        illegal: '\\W\\.|;'
+      },
+      {
+        begin: '\\bimport\\b',
+        end: '$',
+        keywords: 'import qualified as hiding',
+        contains: [
+          LIST,
+          COMMENT
+        ],
+        illegal: '\\W\\.|;'
+      },
+      {
+        className: 'class',
+        begin: '^(\\s*)?(class|instance)\\b',
+        end: 'where',
+        keywords: 'class family instance where',
+        contains: [
+          CONSTRUCTOR,
+          LIST,
+          COMMENT
+        ]
+      },
+      {
+        className: 'class',
+        begin: '\\b(data|(new)?type)\\b',
+        end: '$',
+        keywords: 'data family type newtype deriving',
+        contains: [
+          PRAGMA,
+          CONSTRUCTOR,
+          LIST,
+          RECORD,
+          COMMENT
+        ]
+      },
+      {
+        beginKeywords: 'default',
+        end: '$',
+        contains: [
+          CONSTRUCTOR,
+          LIST,
+          COMMENT
+        ]
+      },
+      {
+        beginKeywords: 'infix infixl infixr',
+        end: '$',
+        contains: [
+          hljs.C_NUMBER_MODE,
+          COMMENT
+        ]
+      },
+      {
+        begin: '\\bforeign\\b',
+        end: '$',
+        keywords: 'foreign import export ccall stdcall cplusplus jvm '
+                  + 'dotnet safe unsafe',
+        contains: [
+          CONSTRUCTOR,
+          hljs.QUOTE_STRING_MODE,
+          COMMENT
+        ]
+      },
+      {
+        className: 'meta',
+        begin: '#!\\/usr\\/bin\\/env\ runhaskell',
+        end: '$'
+      },
+      // "Whitespaces".
+      PRAGMA,
+      PREPROCESSOR,
+
+      // Literals and names.
+
+      // Single characters.
+      {
+        scope: 'string',
+        begin: /'(?=\\?.')/,
+        end: /'/,
+        contains: [
+          {
+            scope: 'char.escape',
+            match: /\\./,
+          },
+        ]
+      },
+      hljs.QUOTE_STRING_MODE,
+      NUMBER,
+      CONSTRUCTOR,
+      hljs.inherit(hljs.TITLE_MODE, { begin: '^[_a-z][\\w\']*' }),
+      // No markup, prevents infix operators from being recognized as comments.
+      { begin: `(?!-)${symbol}--+|--+(?!-)${symbol}`},
+      COMMENT,
+      { // No markup, relevance booster
+        begin: '->|<-' }
+    ]
+  };
+}
+
+export { haskell as default };

frontend/node_modules/highlight.js/es/languages/http.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/http" instead of "highlight.js/lib/languages/http.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './http.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/inform7.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/inform7" instead of "highlight.js/lib/languages/inform7.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './inform7.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/javascript.js

@@ -0,0 +1,769 @@
+const IDENT_RE = '[A-Za-z$_][0-9A-Za-z$_]*';
+const KEYWORDS = [
+  "as", // for exports
+  "in",
+  "of",
+  "if",
+  "for",
+  "while",
+  "finally",
+  "var",
+  "new",
+  "function",
+  "do",
+  "return",
+  "void",
+  "else",
+  "break",
+  "catch",
+  "instanceof",
+  "with",
+  "throw",
+  "case",
+  "default",
+  "try",
+  "switch",
+  "continue",
+  "typeof",
+  "delete",
+  "let",
+  "yield",
+  "const",
+  "class",
+  // JS handles these with a special rule
+  // "get",
+  // "set",
+  "debugger",
+  "async",
+  "await",
+  "static",
+  "import",
+  "from",
+  "export",
+  "extends",
+  // It's reached stage 3, which is "recommended for implementation":
+  "using"
+];
+const LITERALS = [
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "NaN",
+  "Infinity"
+];
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
+const TYPES = [
+  // Fundamental objects
+  "Object",
+  "Function",
+  "Boolean",
+  "Symbol",
+  // numbers and dates
+  "Math",
+  "Date",
+  "Number",
+  "BigInt",
+  // text
+  "String",
+  "RegExp",
+  // Indexed collections
+  "Array",
+  "Float32Array",
+  "Float64Array",
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Int32Array",
+  "Uint16Array",
+  "Uint32Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  // Keyed collections
+  "Set",
+  "Map",
+  "WeakSet",
+  "WeakMap",
+  // Structured data
+  "ArrayBuffer",
+  "SharedArrayBuffer",
+  "Atomics",
+  "DataView",
+  "JSON",
+  // Control abstraction objects
+  "Promise",
+  "Generator",
+  "GeneratorFunction",
+  "AsyncFunction",
+  // Reflection
+  "Reflect",
+  "Proxy",
+  // Internationalization
+  "Intl",
+  // WebAssembly
+  "WebAssembly"
+];
+
+const ERROR_TYPES = [
+  "Error",
+  "EvalError",
+  "InternalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError"
+];
+
+const BUILT_IN_GLOBALS = [
+  "setInterval",
+  "setTimeout",
+  "clearInterval",
+  "clearTimeout",
+
+  "require",
+  "exports",
+
+  "eval",
+  "isFinite",
+  "isNaN",
+  "parseFloat",
+  "parseInt",
+  "decodeURI",
+  "decodeURIComponent",
+  "encodeURI",
+  "encodeURIComponent",
+  "escape",
+  "unescape"
+];
+
+const BUILT_IN_VARIABLES = [
+  "arguments",
+  "this",
+  "super",
+  "console",
+  "window",
+  "document",
+  "localStorage",
+  "sessionStorage",
+  "module",
+  "global" // Node.js
+];
+
+const BUILT_INS = [].concat(
+  BUILT_IN_GLOBALS,
+  TYPES,
+  ERROR_TYPES
+);
+
+/*
+Language: JavaScript
+Description: JavaScript (JS) is a lightweight, interpreted, or just-in-time compiled programming language with first-class functions.
+Category: common, scripting, web
+Website: https://developer.mozilla.org/en-US/docs/Web/JavaScript
+*/
+
+
+/** @type LanguageFn */
+function javascript(hljs) {
+  const regex = hljs.regex;
+  /**
+   * Takes a string like "<Booger" and checks to see
+   * if we can find a matching "</Booger" later in the
+   * content.
+   * @param {RegExpMatchArray} match
+   * @param {{after:number}} param1
+   */
+  const hasClosingTag = (match, { after }) => {
+    const tag = "</" + match[0].slice(1);
+    const pos = match.input.indexOf(tag, after);
+    return pos !== -1;
+  };
+
+  const IDENT_RE$1 = IDENT_RE;
+  const FRAGMENT = {
+    begin: '<>',
+    end: '</>'
+  };
+  // to avoid some special cases inside isTrulyOpeningTag
+  const XML_SELF_CLOSING = /<[A-Za-z0-9\\._:-]+\s*\/>/;
+  const XML_TAG = {
+    begin: /<[A-Za-z0-9\\._:-]+/,
+    end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
+    /**
+     * @param {RegExpMatchArray} match
+     * @param {CallbackResponse} response
+     */
+    isTrulyOpeningTag: (match, response) => {
+      const afterMatchIndex = match[0].length + match.index;
+      const nextChar = match.input[afterMatchIndex];
+      if (
+        // HTML should not include another raw `<` inside a tag
+        // nested type?
+        // `<Array<Array<number>>`, etc.
+        nextChar === "<" ||
+        // the , gives away that this is not HTML
+        // `<T, A extends keyof T, V>`
+        nextChar === ","
+        ) {
+        response.ignoreMatch();
+        return;
+      }
+
+      // `<something>`
+      // Quite possibly a tag, lets look for a matching closing tag...
+      if (nextChar === ">") {
+        // if we cannot find a matching closing tag, then we
+        // will ignore it
+        if (!hasClosingTag(match, { after: afterMatchIndex })) {
+          response.ignoreMatch();
+        }
+      }
+
+      // `<blah />` (self-closing)
+      // handled by simpleSelfClosing rule
+
+      let m;
+      const afterMatch = match.input.substring(afterMatchIndex);
+
+      // some more template typing stuff
+      //  <T = any>(key?: string) => Modify<
+      if ((m = afterMatch.match(/^\s*=/))) {
+        response.ignoreMatch();
+        return;
+      }
+
+      // `<From extends string>`
+      // technically this could be HTML, but it smells like a type
+      // NOTE: This is ugh, but added specifically for https://github.com/highlightjs/highlight.js/issues/3276
+      if ((m = afterMatch.match(/^\s+extends\s+/))) {
+        if (m.index === 0) {
+          response.ignoreMatch();
+          // eslint-disable-next-line no-useless-return
+          return;
+        }
+      }
+    }
+  };
+  const KEYWORDS$1 = {
+    $pattern: IDENT_RE,
+    keyword: KEYWORDS,
+    literal: LITERALS,
+    built_in: BUILT_INS,
+    "variable.language": BUILT_IN_VARIABLES
+  };
+
+  // https://tc39.es/ecma262/#sec-literals-numeric-literals
+  const decimalDigits = '[0-9](_?[0-9])*';
+  const frac = `\\.(${decimalDigits})`;
+  // DecimalIntegerLiteral, including Annex B NonOctalDecimalIntegerLiteral
+  // https://tc39.es/ecma262/#sec-additional-syntax-numeric-literals
+  const decimalInteger = `0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*`;
+  const NUMBER = {
+    className: 'number',
+    variants: [
+      // DecimalLiteral
+      { begin: `(\\b(${decimalInteger})((${frac})|\\.)?|(${frac}))` +
+        `[eE][+-]?(${decimalDigits})\\b` },
+      { begin: `\\b(${decimalInteger})\\b((${frac})\\b|\\.)?|(${frac})\\b` },
+
+      // DecimalBigIntegerLiteral
+      { begin: `\\b(0|[1-9](_?[0-9])*)n\\b` },
+
+      // NonDecimalIntegerLiteral
+      { begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b" },
+      { begin: "\\b0[bB][0-1](_?[0-1])*n?\\b" },
+      { begin: "\\b0[oO][0-7](_?[0-7])*n?\\b" },
+
+      // LegacyOctalIntegerLiteral (does not include underscore separators)
+      // https://tc39.es/ecma262/#sec-additional-syntax-numeric-literals
+      { begin: "\\b0[0-7]+n?\\b" },
+    ],
+    relevance: 0
+  };
+
+  const SUBST = {
+    className: 'subst',
+    begin: '\\$\\{',
+    end: '\\}',
+    keywords: KEYWORDS$1,
+    contains: [] // defined later
+  };
+  const HTML_TEMPLATE = {
+    begin: '\.?html`',
+    end: '',
+    starts: {
+      end: '`',
+      returnEnd: false,
+      contains: [
+        hljs.BACKSLASH_ESCAPE,
+        SUBST
+      ],
+      subLanguage: 'xml'
+    }
+  };
+  const CSS_TEMPLATE = {
+    begin: '\.?css`',
+    end: '',
+    starts: {
+      end: '`',
+      returnEnd: false,
+      contains: [
+        hljs.BACKSLASH_ESCAPE,
+        SUBST
+      ],
+      subLanguage: 'css'
+    }
+  };
+  const GRAPHQL_TEMPLATE = {
+    begin: '\.?gql`',
+    end: '',
+    starts: {
+      end: '`',
+      returnEnd: false,
+      contains: [
+        hljs.BACKSLASH_ESCAPE,
+        SUBST
+      ],
+      subLanguage: 'graphql'
+    }
+  };
+  const TEMPLATE_STRING = {
+    className: 'string',
+    begin: '`',
+    end: '`',
+    contains: [
+      hljs.BACKSLASH_ESCAPE,
+      SUBST
+    ]
+  };
+  const JSDOC_COMMENT = hljs.COMMENT(
+    /\/\*\*(?!\/)/,
+    '\\*/',
+    {
+      relevance: 0,
+      contains: [
+        {
+          begin: '(?=@[A-Za-z]+)',
+          relevance: 0,
+          contains: [
+            {
+              className: 'doctag',
+              begin: '@[A-Za-z]+'
+            },
+            {
+              className: 'type',
+              begin: '\\{',
+              end: '\\}',
+              excludeEnd: true,
+              excludeBegin: true,
+              relevance: 0
+            },
+            {
+              className: 'variable',
+              begin: IDENT_RE$1 + '(?=\\s*(-)|$)',
+              endsParent: true,
+              relevance: 0
+            },
+            // eat spaces (not newlines) so we can find
+            // types or variables
+            {
+              begin: /(?=[^\n])\s/,
+              relevance: 0
+            }
+          ]
+        }
+      ]
+    }
+  );
+  const COMMENT = {
+    className: "comment",
+    variants: [
+      JSDOC_COMMENT,
+      hljs.C_BLOCK_COMMENT_MODE,
+      hljs.C_LINE_COMMENT_MODE
+    ]
+  };
+  const SUBST_INTERNALS = [
+    hljs.APOS_STRING_MODE,
+    hljs.QUOTE_STRING_MODE,
+    HTML_TEMPLATE,
+    CSS_TEMPLATE,
+    GRAPHQL_TEMPLATE,
+    TEMPLATE_STRING,
+    // Skip numbers when they are part of a variable name
+    { match: /\$\d+/ },
+    NUMBER,
+    // This is intentional:
+    // See https://github.com/highlightjs/highlight.js/issues/3288
+    // hljs.REGEXP_MODE
+  ];
+  SUBST.contains = SUBST_INTERNALS
+    .concat({
+      // we need to pair up {} inside our subst to prevent
+      // it from ending too early by matching another }
+      begin: /\{/,
+      end: /\}/,
+      keywords: KEYWORDS$1,
+      contains: [
+        "self"
+      ].concat(SUBST_INTERNALS)
+    });
+  const SUBST_AND_COMMENTS = [].concat(COMMENT, SUBST.contains);
+  const PARAMS_CONTAINS = SUBST_AND_COMMENTS.concat([
+    // eat recursive parens in sub expressions
+    {
+      begin: /(\s*)\(/,
+      end: /\)/,
+      keywords: KEYWORDS$1,
+      contains: ["self"].concat(SUBST_AND_COMMENTS)
+    }
+  ]);
+  const PARAMS = {
+    className: 'params',
+    // convert this to negative lookbehind in v12
+    begin: /(\s*)\(/, // to match the parms with
+    end: /\)/,
+    excludeBegin: true,
+    excludeEnd: true,
+    keywords: KEYWORDS$1,
+    contains: PARAMS_CONTAINS
+  };
+
+  // ES6 classes
+  const CLASS_OR_EXTENDS = {
+    variants: [
+      // class Car extends vehicle
+      {
+        match: [
+          /class/,
+          /\s+/,
+          IDENT_RE$1,
+          /\s+/,
+          /extends/,
+          /\s+/,
+          regex.concat(IDENT_RE$1, "(", regex.concat(/\./, IDENT_RE$1), ")*")
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.class",
+          5: "keyword",
+          7: "title.class.inherited"
+        }
+      },
+      // class Car
+      {
+        match: [
+          /class/,
+          /\s+/,
+          IDENT_RE$1
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.class"
+        }
+      },
+
+    ]
+  };
+
+  const CLASS_REFERENCE = {
+    relevance: 0,
+    match:
+    regex.either(
+      // Hard coded exceptions
+      /\bJSON/,
+      // Float32Array, OutT
+      /\b[A-Z][a-z]+([A-Z][a-z]*|\d)*/,
+      // CSSFactory, CSSFactoryT
+      /\b[A-Z]{2,}([A-Z][a-z]+|\d)+([A-Z][a-z]*)*/,
+      // FPs, FPsT
+      /\b[A-Z]{2,}[a-z]+([A-Z][a-z]+|\d)*([A-Z][a-z]*)*/,
+      // P
+      // single letters are not highlighted
+      // BLAH
+      // this will be flagged as a UPPER_CASE_CONSTANT instead
+    ),
+    className: "title.class",
+    keywords: {
+      _: [
+        // se we still get relevance credit for JS library classes
+        ...TYPES,
+        ...ERROR_TYPES
+      ]
+    }
+  };
+
+  const USE_STRICT = {
+    label: "use_strict",
+    className: 'meta',
+    relevance: 10,
+    begin: /^\s*['"]use (strict|asm)['"]/
+  };
+
+  const FUNCTION_DEFINITION = {
+    variants: [
+      {
+        match: [
+          /function/,
+          /\s+/,
+          IDENT_RE$1,
+          /(?=\s*\()/
+        ]
+      },
+      // anonymous function
+      {
+        match: [
+          /function/,
+          /\s*(?=\()/
+        ]
+      }
+    ],
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    label: "func.def",
+    contains: [ PARAMS ],
+    illegal: /%/
+  };
+
+  const UPPER_CASE_CONSTANT = {
+    relevance: 0,
+    match: /\b[A-Z][A-Z_0-9]+\b/,
+    className: "variable.constant"
+  };
+
+  function noneOf(list) {
+    return regex.concat("(?!", list.join("|"), ")");
+  }
+
+  const FUNCTION_CALL = {
+    match: regex.concat(
+      /\b/,
+      noneOf([
+        ...BUILT_IN_GLOBALS,
+        "super",
+        "import"
+      ].map(x => `${x}\\s*\\(`)),
+      IDENT_RE$1, regex.lookahead(/\s*\(/)),
+    className: "title.function",
+    relevance: 0
+  };
+
+  const PROPERTY_ACCESS = {
+    begin: regex.concat(/\./, regex.lookahead(
+      regex.concat(IDENT_RE$1, /(?![0-9A-Za-z$_(])/)
+    )),
+    end: IDENT_RE$1,
+    excludeBegin: true,
+    keywords: "prototype",
+    className: "property",
+    relevance: 0
+  };
+
+  const GETTER_OR_SETTER = {
+    match: [
+      /get|set/,
+      /\s+/,
+      IDENT_RE$1,
+      /(?=\()/
+    ],
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    contains: [
+      { // eat to avoid empty params
+        begin: /\(\)/
+      },
+      PARAMS
+    ]
+  };
+
+  const FUNC_LEAD_IN_RE = '(\\(' +
+    '[^()]*(\\(' +
+    '[^()]*(\\(' +
+    '[^()]*' +
+    '\\)[^()]*)*' +
+    '\\)[^()]*)*' +
+    '\\)|' + hljs.UNDERSCORE_IDENT_RE + ')\\s*=>';
+
+  const FUNCTION_VARIABLE = {
+    match: [
+      /const|var|let/, /\s+/,
+      IDENT_RE$1, /\s*/,
+      /=\s*/,
+      /(async\s*)?/, // async is optional
+      regex.lookahead(FUNC_LEAD_IN_RE)
+    ],
+    keywords: "async",
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    contains: [
+      PARAMS
+    ]
+  };
+
+  return {
+    name: 'JavaScript',
+    aliases: ['js', 'jsx', 'mjs', 'cjs'],
+    keywords: KEYWORDS$1,
+    // this will be extended by TypeScript
+    exports: { PARAMS_CONTAINS, CLASS_REFERENCE },
+    illegal: /#(?![$_A-z])/,
+    contains: [
+      hljs.SHEBANG({
+        label: "shebang",
+        binary: "node",
+        relevance: 5
+      }),
+      USE_STRICT,
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE,
+      HTML_TEMPLATE,
+      CSS_TEMPLATE,
+      GRAPHQL_TEMPLATE,
+      TEMPLATE_STRING,
+      COMMENT,
+      // Skip numbers when they are part of a variable name
+      { match: /\$\d+/ },
+      NUMBER,
+      CLASS_REFERENCE,
+      {
+        scope: 'attr',
+        match: IDENT_RE$1 + regex.lookahead(':'),
+        relevance: 0
+      },
+      FUNCTION_VARIABLE,
+      { // "value" container
+        begin: '(' + hljs.RE_STARTERS_RE + '|\\b(case|return|throw)\\b)\\s*',
+        keywords: 'return throw case',
+        relevance: 0,
+        contains: [
+          COMMENT,
+          hljs.REGEXP_MODE,
+          {
+            className: 'function',
+            // we have to count the parens to make sure we actually have the
+            // correct bounding ( ) before the =>.  There could be any number of
+            // sub-expressions inside also surrounded by parens.
+            begin: FUNC_LEAD_IN_RE,
+            returnBegin: true,
+            end: '\\s*=>',
+            contains: [
+              {
+                className: 'params',
+                variants: [
+                  {
+                    begin: hljs.UNDERSCORE_IDENT_RE,
+                    relevance: 0
+                  },
+                  {
+                    className: null,
+                    begin: /\(\s*\)/,
+                    skip: true
+                  },
+                  {
+                    begin: /(\s*)\(/,
+                    end: /\)/,
+                    excludeBegin: true,
+                    excludeEnd: true,
+                    keywords: KEYWORDS$1,
+                    contains: PARAMS_CONTAINS
+                  }
+                ]
+              }
+            ]
+          },
+          { // could be a comma delimited list of params to a function call
+            begin: /,/,
+            relevance: 0
+          },
+          {
+            match: /\s+/,
+            relevance: 0
+          },
+          { // JSX
+            variants: [
+              { begin: FRAGMENT.begin, end: FRAGMENT.end },
+              { match: XML_SELF_CLOSING },
+              {
+                begin: XML_TAG.begin,
+                // we carefully check the opening tag to see if it truly
+                // is a tag and not a false positive
+                'on:begin': XML_TAG.isTrulyOpeningTag,
+                end: XML_TAG.end
+              }
+            ],
+            subLanguage: 'xml',
+            contains: [
+              {
+                begin: XML_TAG.begin,
+                end: XML_TAG.end,
+                skip: true,
+                contains: ['self']
+              }
+            ]
+          }
+        ],
+      },
+      FUNCTION_DEFINITION,
+      {
+        // prevent this from getting swallowed up by function
+        // since they appear "function like"
+        beginKeywords: "while if switch catch for"
+      },
+      {
+        // we have to count the parens to make sure we actually have the correct
+        // bounding ( ).  There could be any number of sub-expressions inside
+        // also surrounded by parens.
+        begin: '\\b(?!function)' + hljs.UNDERSCORE_IDENT_RE +
+          '\\(' + // first parens
+          '[^()]*(\\(' +
+            '[^()]*(\\(' +
+              '[^()]*' +
+            '\\)[^()]*)*' +
+          '\\)[^()]*)*' +
+          '\\)\\s*\\{', // end parens
+        returnBegin:true,
+        label: "func.def",
+        contains: [
+          PARAMS,
+          hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1, className: "title.function" })
+        ]
+      },
+      // catch ... so it won't trigger the property rule below
+      {
+        match: /\.\.\./,
+        relevance: 0
+      },
+      PROPERTY_ACCESS,
+      // hack: prevents detection of keywords in some circumstances
+      // .keyword()
+      // $keyword = x
+      {
+        match: '\\$' + IDENT_RE$1,
+        relevance: 0
+      },
+      {
+        match: [ /\bconstructor(?=\s*\()/ ],
+        className: { 1: "title.function" },
+        contains: [ PARAMS ]
+      },
+      FUNCTION_CALL,
+      UPPER_CASE_CONSTANT,
+      CLASS_OR_EXTENDS,
+      GETTER_OR_SETTER,
+      {
+        match: /\$[(.]/ // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`
+      }
+    ]
+  };
+}
+
+export { javascript as default };

frontend/node_modules/highlight.js/es/languages/json.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/json" instead of "highlight.js/lib/languages/json.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './json.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/julia-repl.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/julia-repl" instead of "highlight.js/lib/languages/julia-repl.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './julia-repl.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/lasso.js

@@ -0,0 +1,171 @@
+/*
+Language: Lasso
+Author: Eric Knibbe <eric@lassosoft.com>
+Description: Lasso is a language and server platform for database-driven web applications. This definition handles Lasso 9 syntax and LassoScript for Lasso 8.6 and earlier.
+Website: http://www.lassosoft.com/What-Is-Lasso
+Category: database, web
+*/
+
+function lasso(hljs) {
+  const LASSO_IDENT_RE = '[a-zA-Z_][\\w.]*';
+  const LASSO_ANGLE_RE = '<\\?(lasso(script)?|=)';
+  const LASSO_CLOSE_RE = '\\]|\\?>';
+  const LASSO_KEYWORDS = {
+    $pattern: LASSO_IDENT_RE + '|&[lg]t;',
+    literal:
+      'true false none minimal full all void and or not '
+      + 'bw nbw ew new cn ncn lt lte gt gte eq neq rx nrx ft',
+    built_in:
+      'array date decimal duration integer map pair string tag xml null '
+      + 'boolean bytes keyword list locale queue set stack staticarray '
+      + 'local var variable global data self inherited currentcapture givenblock',
+    keyword:
+      'cache database_names database_schemanames database_tablenames '
+      + 'define_tag define_type email_batch encode_set html_comment handle '
+      + 'handle_error header if inline iterate ljax_target link '
+      + 'link_currentaction link_currentgroup link_currentrecord link_detail '
+      + 'link_firstgroup link_firstrecord link_lastgroup link_lastrecord '
+      + 'link_nextgroup link_nextrecord link_prevgroup link_prevrecord log '
+      + 'loop namespace_using output_none portal private protect records '
+      + 'referer referrer repeating resultset rows search_args '
+      + 'search_arguments select sort_args sort_arguments thread_atomic '
+      + 'value_list while abort case else fail_if fail_ifnot fail if_empty '
+      + 'if_false if_null if_true loop_abort loop_continue loop_count params '
+      + 'params_up return return_value run_children soap_definetag '
+      + 'soap_lastrequest soap_lastresponse tag_name ascending average by '
+      + 'define descending do equals frozen group handle_failure import in '
+      + 'into join let match max min on order parent protected provide public '
+      + 'require returnhome skip split_thread sum take thread to trait type '
+      + 'where with yield yieldhome'
+  };
+  const HTML_COMMENT = hljs.COMMENT(
+    '<!--',
+    '-->',
+    { relevance: 0 }
+  );
+  const LASSO_NOPROCESS = {
+    className: 'meta',
+    begin: '\\[noprocess\\]',
+    starts: {
+      end: '\\[/noprocess\\]',
+      returnEnd: true,
+      contains: [ HTML_COMMENT ]
+    }
+  };
+  const LASSO_START = {
+    className: 'meta',
+    begin: '\\[/noprocess|' + LASSO_ANGLE_RE
+  };
+  const LASSO_DATAMEMBER = {
+    className: 'symbol',
+    begin: '\'' + LASSO_IDENT_RE + '\''
+  };
+  const LASSO_CODE = [
+    hljs.C_LINE_COMMENT_MODE,
+    hljs.C_BLOCK_COMMENT_MODE,
+    hljs.inherit(hljs.C_NUMBER_MODE, { begin: hljs.C_NUMBER_RE + '|(-?infinity|NaN)\\b' }),
+    hljs.inherit(hljs.APOS_STRING_MODE, { illegal: null }),
+    hljs.inherit(hljs.QUOTE_STRING_MODE, { illegal: null }),
+    {
+      className: 'string',
+      begin: '`',
+      end: '`'
+    },
+    { // variables
+      variants: [
+        { begin: '[#$]' + LASSO_IDENT_RE },
+        {
+          begin: '#',
+          end: '\\d+',
+          illegal: '\\W'
+        }
+      ] },
+    {
+      className: 'type',
+      begin: '::\\s*',
+      end: LASSO_IDENT_RE,
+      illegal: '\\W'
+    },
+    {
+      className: 'params',
+      variants: [
+        {
+          begin: '-(?!infinity)' + LASSO_IDENT_RE,
+          relevance: 0
+        },
+        { begin: '(\\.\\.\\.)' }
+      ]
+    },
+    {
+      begin: /(->|\.)\s*/,
+      relevance: 0,
+      contains: [ LASSO_DATAMEMBER ]
+    },
+    {
+      className: 'class',
+      beginKeywords: 'define',
+      returnEnd: true,
+      end: '\\(|=>',
+      contains: [ hljs.inherit(hljs.TITLE_MODE, { begin: LASSO_IDENT_RE + '(=(?!>))?|[-+*/%](?!>)' }) ]
+    }
+  ];
+  return {
+    name: 'Lasso',
+    aliases: [
+      'ls',
+      'lassoscript'
+    ],
+    case_insensitive: true,
+    keywords: LASSO_KEYWORDS,
+    contains: [
+      {
+        className: 'meta',
+        begin: LASSO_CLOSE_RE,
+        relevance: 0,
+        starts: { // markup
+          end: '\\[|' + LASSO_ANGLE_RE,
+          returnEnd: true,
+          relevance: 0,
+          contains: [ HTML_COMMENT ]
+        }
+      },
+      LASSO_NOPROCESS,
+      LASSO_START,
+      {
+        className: 'meta',
+        begin: '\\[no_square_brackets',
+        starts: {
+          end: '\\[/no_square_brackets\\]', // not implemented in the language
+          keywords: LASSO_KEYWORDS,
+          contains: [
+            {
+              className: 'meta',
+              begin: LASSO_CLOSE_RE,
+              relevance: 0,
+              starts: {
+                end: '\\[noprocess\\]|' + LASSO_ANGLE_RE,
+                returnEnd: true,
+                contains: [ HTML_COMMENT ]
+              }
+            },
+            LASSO_NOPROCESS,
+            LASSO_START
+          ].concat(LASSO_CODE)
+        }
+      },
+      {
+        className: 'meta',
+        begin: '\\[',
+        relevance: 0
+      },
+      {
+        className: 'meta',
+        begin: '^#!',
+        end: 'lasso9$',
+        relevance: 10
+      }
+    ].concat(LASSO_CODE)
+  };
+}
+
+export { lasso as default };

frontend/node_modules/highlight.js/es/languages/less.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/less" instead of "highlight.js/lib/languages/less.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './less.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/lisp.js

@@ -0,0 +1,139 @@
+/*
+Language: Lisp
+Description: Generic lisp syntax
+Author: Vasily Polovnyov <vast@whiteants.net>
+Category: lisp
+*/
+
+function lisp(hljs) {
+  const LISP_IDENT_RE = '[a-zA-Z_\\-+\\*\\/<=>&#][a-zA-Z0-9_\\-+*\\/<=>&#!]*';
+  const MEC_RE = '\\|[^]*?\\|';
+  const LISP_SIMPLE_NUMBER_RE = '(-|\\+)?\\d+(\\.\\d+|\\/\\d+)?((d|e|f|l|s|D|E|F|L|S)(\\+|-)?\\d+)?';
+  const LITERAL = {
+    className: 'literal',
+    begin: '\\b(t{1}|nil)\\b'
+  };
+  const NUMBER = {
+    className: 'number',
+    variants: [
+      {
+        begin: LISP_SIMPLE_NUMBER_RE,
+        relevance: 0
+      },
+      { begin: '#(b|B)[0-1]+(/[0-1]+)?' },
+      { begin: '#(o|O)[0-7]+(/[0-7]+)?' },
+      { begin: '#(x|X)[0-9a-fA-F]+(/[0-9a-fA-F]+)?' },
+      {
+        begin: '#(c|C)\\(' + LISP_SIMPLE_NUMBER_RE + ' +' + LISP_SIMPLE_NUMBER_RE,
+        end: '\\)'
+      }
+    ]
+  };
+  const STRING = hljs.inherit(hljs.QUOTE_STRING_MODE, { illegal: null });
+  const COMMENT = hljs.COMMENT(
+    ';', '$',
+    { relevance: 0 }
+  );
+  const VARIABLE = {
+    begin: '\\*',
+    end: '\\*'
+  };
+  const KEYWORD = {
+    className: 'symbol',
+    begin: '[:&]' + LISP_IDENT_RE
+  };
+  const IDENT = {
+    begin: LISP_IDENT_RE,
+    relevance: 0
+  };
+  const MEC = { begin: MEC_RE };
+  const QUOTED_LIST = {
+    begin: '\\(',
+    end: '\\)',
+    contains: [
+      'self',
+      LITERAL,
+      STRING,
+      NUMBER,
+      IDENT
+    ]
+  };
+  const QUOTED = {
+    contains: [
+      NUMBER,
+      STRING,
+      VARIABLE,
+      KEYWORD,
+      QUOTED_LIST,
+      IDENT
+    ],
+    variants: [
+      {
+        begin: '[\'`]\\(',
+        end: '\\)'
+      },
+      {
+        begin: '\\(quote ',
+        end: '\\)',
+        keywords: { name: 'quote' }
+      },
+      { begin: '\'' + MEC_RE }
+    ]
+  };
+  const QUOTED_ATOM = { variants: [
+    { begin: '\'' + LISP_IDENT_RE },
+    { begin: '#\'' + LISP_IDENT_RE + '(::' + LISP_IDENT_RE + ')*' }
+  ] };
+  const LIST = {
+    begin: '\\(\\s*',
+    end: '\\)'
+  };
+  const BODY = {
+    endsWithParent: true,
+    relevance: 0
+  };
+  LIST.contains = [
+    {
+      className: 'name',
+      variants: [
+        {
+          begin: LISP_IDENT_RE,
+          relevance: 0,
+        },
+        { begin: MEC_RE }
+      ]
+    },
+    BODY
+  ];
+  BODY.contains = [
+    QUOTED,
+    QUOTED_ATOM,
+    LIST,
+    LITERAL,
+    NUMBER,
+    STRING,
+    COMMENT,
+    VARIABLE,
+    KEYWORD,
+    MEC,
+    IDENT
+  ];
+
+  return {
+    name: 'Lisp',
+    illegal: /\S/,
+    contains: [
+      NUMBER,
+      hljs.SHEBANG(),
+      LITERAL,
+      STRING,
+      COMMENT,
+      QUOTED,
+      QUOTED_ATOM,
+      LIST,
+      IDENT
+    ]
+  };
+}
+
+export { lisp as default };

frontend/node_modules/highlight.js/es/languages/llvm.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/llvm" instead of "highlight.js/lib/languages/llvm.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './llvm.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/makefile.js

@@ -0,0 +1,89 @@
+/*
+Language: Makefile
+Author: Ivan Sagalaev <maniac@softwaremaniacs.org>
+Contributors: Joël Porquet <joel@porquet.org>
+Website: https://www.gnu.org/software/make/manual/html_node/Introduction.html
+Category: common, build-system
+*/
+
+function makefile(hljs) {
+  /* Variables: simple (eg $(var)) and special (eg $@) */
+  const VARIABLE = {
+    className: 'variable',
+    variants: [
+      {
+        begin: '\\$\\(' + hljs.UNDERSCORE_IDENT_RE + '\\)',
+        contains: [ hljs.BACKSLASH_ESCAPE ]
+      },
+      { begin: /\$[@%<?\^\+\*]/ }
+    ]
+  };
+  /* Quoted string with variables inside */
+  const QUOTE_STRING = {
+    className: 'string',
+    begin: /"/,
+    end: /"/,
+    contains: [
+      hljs.BACKSLASH_ESCAPE,
+      VARIABLE
+    ]
+  };
+  /* Function: $(func arg,...) */
+  const FUNC = {
+    className: 'variable',
+    begin: /\$\([\w-]+\s/,
+    end: /\)/,
+    keywords: { built_in:
+        'subst patsubst strip findstring filter filter-out sort '
+        + 'word wordlist firstword lastword dir notdir suffix basename '
+        + 'addsuffix addprefix join wildcard realpath abspath error warning '
+        + 'shell origin flavor foreach if or and call eval file value' },
+    contains: [ 
+      VARIABLE,
+      QUOTE_STRING // Added QUOTE_STRING as they can be a part of functions
+    ]
+  };
+  /* Variable assignment */
+  const ASSIGNMENT = { begin: '^' + hljs.UNDERSCORE_IDENT_RE + '\\s*(?=[:+?]?=)' };
+  /* Meta targets (.PHONY) */
+  const META = {
+    className: 'meta',
+    begin: /^\.PHONY:/,
+    end: /$/,
+    keywords: {
+      $pattern: /[\.\w]+/,
+      keyword: '.PHONY'
+    }
+  };
+  /* Targets */
+  const TARGET = {
+    className: 'section',
+    begin: /^[^\s]+:/,
+    end: /$/,
+    contains: [ VARIABLE ]
+  };
+  return {
+    name: 'Makefile',
+    aliases: [
+      'mk',
+      'mak',
+      'make',
+    ],
+    keywords: {
+      $pattern: /[\w-]+/,
+      keyword: 'define endef undefine ifdef ifndef ifeq ifneq else endif '
+      + 'include -include sinclude override export unexport private vpath'
+    },
+    contains: [
+      hljs.HASH_COMMENT_MODE,
+      VARIABLE,
+      QUOTE_STRING,
+      FUNC,
+      ASSIGNMENT,
+      META,
+      TARGET
+    ]
+  };
+}
+
+export { makefile as default };

frontend/node_modules/highlight.js/es/languages/makefile.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/makefile" instead of "highlight.js/lib/languages/makefile.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './makefile.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/markdown.js

@@ -0,0 +1,248 @@
+/*
+Language: Markdown
+Requires: xml.js
+Author: John Crepezzi <john.crepezzi@gmail.com>
+Website: https://daringfireball.net/projects/markdown/
+Category: common, markup
+*/
+
+function markdown(hljs) {
+  const regex = hljs.regex;
+  const INLINE_HTML = {
+    begin: /<\/?[A-Za-z_]/,
+    end: '>',
+    subLanguage: 'xml',
+    relevance: 0
+  };
+  const HORIZONTAL_RULE = {
+    begin: '^[-\\*]{3,}',
+    end: '$'
+  };
+  const CODE = {
+    className: 'code',
+    variants: [
+      // TODO: fix to allow these to work with sublanguage also
+      { begin: '(`{3,})[^`](.|\\n)*?\\1`*[ ]*' },
+      { begin: '(~{3,})[^~](.|\\n)*?\\1~*[ ]*' },
+      // needed to allow markdown as a sublanguage to work
+      {
+        begin: '```',
+        end: '```+[ ]*$'
+      },
+      {
+        begin: '~~~',
+        end: '~~~+[ ]*$'
+      },
+      { begin: '`.+?`' },
+      {
+        begin: '(?=^( {4}|\\t))',
+        // use contains to gobble up multiple lines to allow the block to be whatever size
+        // but only have a single open/close tag vs one per line
+        contains: [
+          {
+            begin: '^( {4}|\\t)',
+            end: '(\\n)$'
+          }
+        ],
+        relevance: 0
+      }
+    ]
+  };
+  const LIST = {
+    className: 'bullet',
+    begin: '^[ \t]*([*+-]|(\\d+\\.))(?=\\s+)',
+    end: '\\s+',
+    excludeEnd: true
+  };
+  const LINK_REFERENCE = {
+    begin: /^\[[^\n]+\]:/,
+    returnBegin: true,
+    contains: [
+      {
+        className: 'symbol',
+        begin: /\[/,
+        end: /\]/,
+        excludeBegin: true,
+        excludeEnd: true
+      },
+      {
+        className: 'link',
+        begin: /:\s*/,
+        end: /$/,
+        excludeBegin: true
+      }
+    ]
+  };
+  const URL_SCHEME = /[A-Za-z][A-Za-z0-9+.-]*/;
+  const LINK = {
+    variants: [
+      // too much like nested array access in so many languages
+      // to have any real relevance
+      {
+        begin: /\[.+?\]\[.*?\]/,
+        relevance: 0
+      },
+      // popular internet URLs
+      {
+        begin: /\[.+?\]\(((data|javascript|mailto):|(?:http|ftp)s?:\/\/).*?\)/,
+        relevance: 2
+      },
+      {
+        begin: regex.concat(/\[.+?\]\(/, URL_SCHEME, /:\/\/.*?\)/),
+        relevance: 2
+      },
+      // relative urls
+      {
+        begin: /\[.+?\]\([./?&#].*?\)/,
+        relevance: 1
+      },
+      // whatever else, lower relevance (might not be a link at all)
+      {
+        begin: /\[.*?\]\(.*?\)/,
+        relevance: 0
+      }
+    ],
+    returnBegin: true,
+    contains: [
+      {
+        // empty strings for alt or link text
+        match: /\[(?=\])/ },
+      {
+        className: 'string',
+        relevance: 0,
+        begin: '\\[',
+        end: '\\]',
+        excludeBegin: true,
+        returnEnd: true
+      },
+      {
+        className: 'link',
+        relevance: 0,
+        begin: '\\]\\(',
+        end: '\\)',
+        excludeBegin: true,
+        excludeEnd: true
+      },
+      {
+        className: 'symbol',
+        relevance: 0,
+        begin: '\\]\\[',
+        end: '\\]',
+        excludeBegin: true,
+        excludeEnd: true
+      }
+    ]
+  };
+  const BOLD = {
+    className: 'strong',
+    contains: [], // defined later
+    variants: [
+      {
+        begin: /_{2}(?!\s)/,
+        end: /_{2}/
+      },
+      {
+        begin: /\*{2}(?!\s)/,
+        end: /\*{2}/
+      }
+    ]
+  };
+  const ITALIC = {
+    className: 'emphasis',
+    contains: [], // defined later
+    variants: [
+      {
+        begin: /\*(?![*\s])/,
+        end: /\*/
+      },
+      {
+        begin: /_(?![_\s])/,
+        end: /_/,
+        relevance: 0
+      }
+    ]
+  };
+
+  // 3 level deep nesting is not allowed because it would create confusion
+  // in cases like `***testing***` because where we don't know if the last
+  // `***` is starting a new bold/italic or finishing the last one
+  const BOLD_WITHOUT_ITALIC = hljs.inherit(BOLD, { contains: [] });
+  const ITALIC_WITHOUT_BOLD = hljs.inherit(ITALIC, { contains: [] });
+  BOLD.contains.push(ITALIC_WITHOUT_BOLD);
+  ITALIC.contains.push(BOLD_WITHOUT_ITALIC);
+
+  let CONTAINABLE = [
+    INLINE_HTML,
+    LINK
+  ];
+
+  [
+    BOLD,
+    ITALIC,
+    BOLD_WITHOUT_ITALIC,
+    ITALIC_WITHOUT_BOLD
+  ].forEach(m => {
+    m.contains = m.contains.concat(CONTAINABLE);
+  });
+
+  CONTAINABLE = CONTAINABLE.concat(BOLD, ITALIC);
+
+  const HEADER = {
+    className: 'section',
+    variants: [
+      {
+        begin: '^#{1,6}',
+        end: '$',
+        contains: CONTAINABLE
+      },
+      {
+        begin: '(?=^.+?\\n[=-]{2,}$)',
+        contains: [
+          { begin: '^[=-]*$' },
+          {
+            begin: '^',
+            end: "\\n",
+            contains: CONTAINABLE
+          }
+        ]
+      }
+    ]
+  };
+
+  const BLOCKQUOTE = {
+    className: 'quote',
+    begin: '^>\\s+',
+    contains: CONTAINABLE,
+    end: '$'
+  };
+
+  const ENTITY = {
+    //https://spec.commonmark.org/0.31.2/#entity-references
+    scope: 'literal',
+    match: /&([a-zA-Z0-9]+|#[0-9]{1,7}|#[Xx][0-9a-fA-F]{1,6});/
+  };
+
+  return {
+    name: 'Markdown',
+    aliases: [
+      'md',
+      'mkdown',
+      'mkd'
+    ],
+    contains: [
+      HEADER,
+      INLINE_HTML,
+      LIST,
+      BOLD,
+      ITALIC,
+      BLOCKQUOTE,
+      CODE,
+      HORIZONTAL_RULE,
+      LINK,
+      LINK_REFERENCE,
+      ENTITY
+    ]
+  };
+}
+
+export { markdown as default };

frontend/node_modules/highlight.js/es/languages/mathematica.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/mathematica" instead of "highlight.js/lib/languages/mathematica.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './mathematica.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/matlab.js

@@ -0,0 +1,107 @@
+/*
+Language: Matlab
+Author: Denis Bardadym <bardadymchik@gmail.com>
+Contributors: Eugene Nizhibitsky <nizhibitsky@ya.ru>, Egor Rogov <e.rogov@postgrespro.ru>
+Website: https://www.mathworks.com/products/matlab.html
+Category: scientific
+*/
+
+/*
+  Formal syntax is not published, helpful link:
+  https://github.com/kornilova-l/matlab-IntelliJ-plugin/blob/master/src/main/grammar/Matlab.bnf
+*/
+function matlab(hljs) {
+  const TRANSPOSE_RE = '(\'|\\.\')+';
+  const TRANSPOSE = {
+    relevance: 0,
+    contains: [ { begin: TRANSPOSE_RE } ]
+  };
+
+  return {
+    name: 'Matlab',
+    keywords: {
+      keyword:
+        'arguments break case catch classdef continue else elseif end enumeration events for function '
+        + 'global if methods otherwise parfor persistent properties return spmd switch try while',
+      built_in:
+        'sin sind sinh asin asind asinh cos cosd cosh acos acosd acosh tan tand tanh atan '
+        + 'atand atan2 atanh sec secd sech asec asecd asech csc cscd csch acsc acscd acsch cot '
+        + 'cotd coth acot acotd acoth hypot exp expm1 log log1p log10 log2 pow2 realpow reallog '
+        + 'realsqrt sqrt nthroot nextpow2 abs angle complex conj imag real unwrap isreal '
+        + 'cplxpair fix floor ceil round mod rem sign airy besselj bessely besselh besseli '
+        + 'besselk beta betainc betaln ellipj ellipke erf erfc erfcx erfinv expint gamma '
+        + 'gammainc gammaln psi legendre cross dot factor isprime primes gcd lcm rat rats perms '
+        + 'nchoosek factorial cart2sph cart2pol pol2cart sph2cart hsv2rgb rgb2hsv zeros ones '
+        + 'eye repmat rand randn linspace logspace freqspace meshgrid accumarray size length '
+        + 'ndims numel disp isempty isequal isequalwithequalnans cat reshape diag blkdiag tril '
+        + 'triu fliplr flipud flipdim rot90 find sub2ind ind2sub bsxfun ndgrid permute ipermute '
+        + 'shiftdim circshift squeeze isscalar isvector ans eps realmax realmin pi i|0 inf nan '
+        + 'isnan isinf isfinite j|0 why compan gallery hadamard hankel hilb invhilb magic pascal '
+        + 'rosser toeplitz vander wilkinson max min nanmax nanmin mean nanmean type table '
+        + 'readtable writetable sortrows sort figure plot plot3 scatter scatter3 cellfun '
+        + 'legend intersect ismember procrustes hold num2cell '
+    },
+    illegal: '(//|"|#|/\\*|\\s+/\\w+)',
+    contains: [
+      {
+        className: 'function',
+        beginKeywords: 'function',
+        end: '$',
+        contains: [
+          hljs.UNDERSCORE_TITLE_MODE,
+          {
+            className: 'params',
+            variants: [
+              {
+                begin: '\\(',
+                end: '\\)'
+              },
+              {
+                begin: '\\[',
+                end: '\\]'
+              }
+            ]
+          }
+        ]
+      },
+      {
+        className: 'built_in',
+        begin: /true|false/,
+        relevance: 0,
+        starts: TRANSPOSE
+      },
+      {
+        begin: '[a-zA-Z][a-zA-Z_0-9]*' + TRANSPOSE_RE,
+        relevance: 0
+      },
+      {
+        className: 'number',
+        begin: hljs.C_NUMBER_RE,
+        relevance: 0,
+        starts: TRANSPOSE
+      },
+      {
+        className: 'string',
+        begin: '\'',
+        end: '\'',
+        contains: [ { begin: '\'\'' } ]
+      },
+      {
+        begin: /\]|\}|\)/,
+        relevance: 0,
+        starts: TRANSPOSE
+      },
+      {
+        className: 'string',
+        begin: '"',
+        end: '"',
+        contains: [ { begin: '""' } ],
+        starts: TRANSPOSE
+      },
+      hljs.COMMENT('^\\s*%\\{\\s*$', '^\\s*%\\}\\s*$'),
+      hljs.COMMENT('%', '$')
+    ]
+  };
+}
+
+export { matlab as default };

frontend/node_modules/highlight.js/es/languages/mipsasm.js

@@ -0,0 +1,104 @@
+/*
+Language: MIPS Assembly
+Author: Nebuleon Fumika <nebuleon.fumika@gmail.com>
+Description: MIPS Assembly (up to MIPS32R2)
+Website: https://en.wikipedia.org/wiki/MIPS_architecture
+Category: assembler
+*/
+
+function mipsasm(hljs) {
+  // local labels: %?[FB]?[AT]?\d{1,2}\w+
+  return {
+    name: 'MIPS Assembly',
+    case_insensitive: true,
+    aliases: [ 'mips' ],
+    keywords: {
+      $pattern: '\\.?' + hljs.IDENT_RE,
+      meta:
+        // GNU preprocs
+        '.2byte .4byte .align .ascii .asciz .balign .byte .code .data .else .end .endif .endm .endr .equ .err .exitm .extern .global .hword .if .ifdef .ifndef .include .irp .long .macro .rept .req .section .set .skip .space .text .word .ltorg ',
+      built_in:
+        '$0 $1 $2 $3 $4 $5 $6 $7 $8 $9 $10 $11 $12 $13 $14 $15 ' // integer registers
+        + '$16 $17 $18 $19 $20 $21 $22 $23 $24 $25 $26 $27 $28 $29 $30 $31 ' // integer registers
+        + 'zero at v0 v1 a0 a1 a2 a3 a4 a5 a6 a7 ' // integer register aliases
+        + 't0 t1 t2 t3 t4 t5 t6 t7 t8 t9 s0 s1 s2 s3 s4 s5 s6 s7 s8 ' // integer register aliases
+        + 'k0 k1 gp sp fp ra ' // integer register aliases
+        + '$f0 $f1 $f2 $f2 $f4 $f5 $f6 $f7 $f8 $f9 $f10 $f11 $f12 $f13 $f14 $f15 ' // floating-point registers
+        + '$f16 $f17 $f18 $f19 $f20 $f21 $f22 $f23 $f24 $f25 $f26 $f27 $f28 $f29 $f30 $f31 ' // floating-point registers
+        + 'Context Random EntryLo0 EntryLo1 Context PageMask Wired EntryHi ' // Coprocessor 0 registers
+        + 'HWREna BadVAddr Count Compare SR IntCtl SRSCtl SRSMap Cause EPC PRId ' // Coprocessor 0 registers
+        + 'EBase Config Config1 Config2 Config3 LLAddr Debug DEPC DESAVE CacheErr ' // Coprocessor 0 registers
+        + 'ECC ErrorEPC TagLo DataLo TagHi DataHi WatchLo WatchHi PerfCtl PerfCnt ' // Coprocessor 0 registers
+    },
+    contains: [
+      {
+        className: 'keyword',
+        begin: '\\b(' // mnemonics
+            // 32-bit integer instructions
+            + 'addi?u?|andi?|b(al)?|beql?|bgez(al)?l?|bgtzl?|blezl?|bltz(al)?l?|'
+            + 'bnel?|cl[oz]|divu?|ext|ins|j(al)?|jalr(\\.hb)?|jr(\\.hb)?|lbu?|lhu?|'
+            + 'll|lui|lw[lr]?|maddu?|mfhi|mflo|movn|movz|move|msubu?|mthi|mtlo|mul|'
+            + 'multu?|nop|nor|ori?|rotrv?|sb|sc|se[bh]|sh|sllv?|slti?u?|srav?|'
+            + 'srlv?|subu?|sw[lr]?|xori?|wsbh|'
+            // floating-point instructions
+            + 'abs\\.[sd]|add\\.[sd]|alnv.ps|bc1[ft]l?|'
+            + 'c\\.(s?f|un|u?eq|[ou]lt|[ou]le|ngle?|seq|l[et]|ng[et])\\.[sd]|'
+            + '(ceil|floor|round|trunc)\\.[lw]\\.[sd]|cfc1|cvt\\.d\\.[lsw]|'
+            + 'cvt\\.l\\.[dsw]|cvt\\.ps\\.s|cvt\\.s\\.[dlw]|cvt\\.s\\.p[lu]|cvt\\.w\\.[dls]|'
+            + 'div\\.[ds]|ldx?c1|luxc1|lwx?c1|madd\\.[sd]|mfc1|mov[fntz]?\\.[ds]|'
+            + 'msub\\.[sd]|mth?c1|mul\\.[ds]|neg\\.[ds]|nmadd\\.[ds]|nmsub\\.[ds]|'
+            + 'p[lu][lu]\\.ps|recip\\.fmt|r?sqrt\\.[ds]|sdx?c1|sub\\.[ds]|suxc1|'
+            + 'swx?c1|'
+            // system control instructions
+            + 'break|cache|d?eret|[de]i|ehb|mfc0|mtc0|pause|prefx?|rdhwr|'
+            + 'rdpgpr|sdbbp|ssnop|synci?|syscall|teqi?|tgei?u?|tlb(p|r|w[ir])|'
+            + 'tlti?u?|tnei?|wait|wrpgpr'
+        + ')',
+        end: '\\s'
+      },
+      // lines ending with ; or # aren't really comments, probably auto-detect fail
+      hljs.COMMENT('[;#](?!\\s*$)', '$'),
+      hljs.C_BLOCK_COMMENT_MODE,
+      hljs.QUOTE_STRING_MODE,
+      {
+        className: 'string',
+        begin: '\'',
+        end: '[^\\\\]\'',
+        relevance: 0
+      },
+      {
+        className: 'title',
+        begin: '\\|',
+        end: '\\|',
+        illegal: '\\n',
+        relevance: 0
+      },
+      {
+        className: 'number',
+        variants: [
+          { // hex
+            begin: '0x[0-9a-f]+' },
+          { // bare number
+            begin: '\\b-?\\d+' }
+        ],
+        relevance: 0
+      },
+      {
+        className: 'symbol',
+        variants: [
+          { // GNU MIPS syntax
+            begin: '^\\s*[a-z_\\.\\$][a-z0-9_\\.\\$]+:' },
+          { // numbered local labels
+            begin: '^\\s*[0-9]+:' },
+          { // number local label reference (backwards, forwards)
+            begin: '[0-9]+[bf]' }
+        ],
+        relevance: 0
+      }
+    ],
+    // forward slashes are not allowed
+    illegal: /\//
+  };
+}
+
+export { mipsasm as default };

frontend/node_modules/highlight.js/es/languages/mojolicious.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/mojolicious" instead of "highlight.js/lib/languages/mojolicious.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './mojolicious.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/moonscript.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/moonscript" instead of "highlight.js/lib/languages/moonscript.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './moonscript.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/n1ql.js

@@ -0,0 +1,365 @@
+/*
+ Language: N1QL
+ Author: Andres Täht <andres.taht@gmail.com>
+ Contributors: Rene Saarsoo <nene@triin.net>
+ Description: Couchbase query language
+ Website: https://www.couchbase.com/products/n1ql
+ Category: database
+ */
+
+function n1ql(hljs) {
+  // Taken from http://developer.couchbase.com/documentation/server/current/n1ql/n1ql-language-reference/reservedwords.html
+  const KEYWORDS = [
+    "all",
+    "alter",
+    "analyze",
+    "and",
+    "any",
+    "array",
+    "as",
+    "asc",
+    "begin",
+    "between",
+    "binary",
+    "boolean",
+    "break",
+    "bucket",
+    "build",
+    "by",
+    "call",
+    "case",
+    "cast",
+    "cluster",
+    "collate",
+    "collection",
+    "commit",
+    "connect",
+    "continue",
+    "correlate",
+    "cover",
+    "create",
+    "database",
+    "dataset",
+    "datastore",
+    "declare",
+    "decrement",
+    "delete",
+    "derived",
+    "desc",
+    "describe",
+    "distinct",
+    "do",
+    "drop",
+    "each",
+    "element",
+    "else",
+    "end",
+    "every",
+    "except",
+    "exclude",
+    "execute",
+    "exists",
+    "explain",
+    "fetch",
+    "first",
+    "flatten",
+    "for",
+    "force",
+    "from",
+    "function",
+    "grant",
+    "group",
+    "gsi",
+    "having",
+    "if",
+    "ignore",
+    "ilike",
+    "in",
+    "include",
+    "increment",
+    "index",
+    "infer",
+    "inline",
+    "inner",
+    "insert",
+    "intersect",
+    "into",
+    "is",
+    "join",
+    "key",
+    "keys",
+    "keyspace",
+    "known",
+    "last",
+    "left",
+    "let",
+    "letting",
+    "like",
+    "limit",
+    "lsm",
+    "map",
+    "mapping",
+    "matched",
+    "materialized",
+    "merge",
+    "minus",
+    "namespace",
+    "nest",
+    "not",
+    "number",
+    "object",
+    "offset",
+    "on",
+    "option",
+    "or",
+    "order",
+    "outer",
+    "over",
+    "parse",
+    "partition",
+    "password",
+    "path",
+    "pool",
+    "prepare",
+    "primary",
+    "private",
+    "privilege",
+    "procedure",
+    "public",
+    "raw",
+    "realm",
+    "reduce",
+    "rename",
+    "return",
+    "returning",
+    "revoke",
+    "right",
+    "role",
+    "rollback",
+    "satisfies",
+    "schema",
+    "select",
+    "self",
+    "semi",
+    "set",
+    "show",
+    "some",
+    "start",
+    "statistics",
+    "string",
+    "system",
+    "then",
+    "to",
+    "transaction",
+    "trigger",
+    "truncate",
+    "under",
+    "union",
+    "unique",
+    "unknown",
+    "unnest",
+    "unset",
+    "update",
+    "upsert",
+    "use",
+    "user",
+    "using",
+    "validate",
+    "value",
+    "valued",
+    "values",
+    "via",
+    "view",
+    "when",
+    "where",
+    "while",
+    "with",
+    "within",
+    "work",
+    "xor"
+  ];
+  // Taken from http://developer.couchbase.com/documentation/server/4.5/n1ql/n1ql-language-reference/literals.html
+  const LITERALS = [
+    "true",
+    "false",
+    "null",
+    "missing|5"
+  ];
+  // Taken from http://developer.couchbase.com/documentation/server/4.5/n1ql/n1ql-language-reference/functions.html
+  const BUILT_INS = [
+    "array_agg",
+    "array_append",
+    "array_concat",
+    "array_contains",
+    "array_count",
+    "array_distinct",
+    "array_ifnull",
+    "array_length",
+    "array_max",
+    "array_min",
+    "array_position",
+    "array_prepend",
+    "array_put",
+    "array_range",
+    "array_remove",
+    "array_repeat",
+    "array_replace",
+    "array_reverse",
+    "array_sort",
+    "array_sum",
+    "avg",
+    "count",
+    "max",
+    "min",
+    "sum",
+    "greatest",
+    "least",
+    "ifmissing",
+    "ifmissingornull",
+    "ifnull",
+    "missingif",
+    "nullif",
+    "ifinf",
+    "ifnan",
+    "ifnanorinf",
+    "naninf",
+    "neginfif",
+    "posinfif",
+    "clock_millis",
+    "clock_str",
+    "date_add_millis",
+    "date_add_str",
+    "date_diff_millis",
+    "date_diff_str",
+    "date_part_millis",
+    "date_part_str",
+    "date_trunc_millis",
+    "date_trunc_str",
+    "duration_to_str",
+    "millis",
+    "str_to_millis",
+    "millis_to_str",
+    "millis_to_utc",
+    "millis_to_zone_name",
+    "now_millis",
+    "now_str",
+    "str_to_duration",
+    "str_to_utc",
+    "str_to_zone_name",
+    "decode_json",
+    "encode_json",
+    "encoded_size",
+    "poly_length",
+    "base64",
+    "base64_encode",
+    "base64_decode",
+    "meta",
+    "uuid",
+    "abs",
+    "acos",
+    "asin",
+    "atan",
+    "atan2",
+    "ceil",
+    "cos",
+    "degrees",
+    "e",
+    "exp",
+    "ln",
+    "log",
+    "floor",
+    "pi",
+    "power",
+    "radians",
+    "random",
+    "round",
+    "sign",
+    "sin",
+    "sqrt",
+    "tan",
+    "trunc",
+    "object_length",
+    "object_names",
+    "object_pairs",
+    "object_inner_pairs",
+    "object_values",
+    "object_inner_values",
+    "object_add",
+    "object_put",
+    "object_remove",
+    "object_unwrap",
+    "regexp_contains",
+    "regexp_like",
+    "regexp_position",
+    "regexp_replace",
+    "contains",
+    "initcap",
+    "length",
+    "lower",
+    "ltrim",
+    "position",
+    "repeat",
+    "replace",
+    "rtrim",
+    "split",
+    "substr",
+    "title",
+    "trim",
+    "upper",
+    "isarray",
+    "isatom",
+    "isboolean",
+    "isnumber",
+    "isobject",
+    "isstring",
+    "type",
+    "toarray",
+    "toatom",
+    "toboolean",
+    "tonumber",
+    "toobject",
+    "tostring"
+  ];
+
+  return {
+    name: 'N1QL',
+    case_insensitive: true,
+    contains: [
+      {
+        beginKeywords:
+          'build create index delete drop explain infer|10 insert merge prepare select update upsert|10',
+        end: /;/,
+        keywords: {
+          keyword: KEYWORDS,
+          literal: LITERALS,
+          built_in: BUILT_INS
+        },
+        contains: [
+          {
+            className: 'string',
+            begin: '\'',
+            end: '\'',
+            contains: [ hljs.BACKSLASH_ESCAPE ]
+          },
+          {
+            className: 'string',
+            begin: '"',
+            end: '"',
+            contains: [ hljs.BACKSLASH_ESCAPE ]
+          },
+          {
+            className: 'symbol',
+            begin: '`',
+            end: '`',
+            contains: [ hljs.BACKSLASH_ESCAPE ]
+          },
+          hljs.C_NUMBER_MODE,
+          hljs.C_BLOCK_COMMENT_MODE
+        ]
+      },
+      hljs.C_BLOCK_COMMENT_MODE
+    ]
+  };
+}
+
+export { n1ql as default };

frontend/node_modules/highlight.js/es/languages/nestedtext.js

@@ -0,0 +1,83 @@
+/*
+Language: NestedText
+Description: NestedText is a file format for holding data that is to be entered, edited, or viewed by people.
+Website: https://nestedtext.org/
+Category: config
+*/
+
+/** @type LanguageFn */
+function nestedtext(hljs) {
+  const NESTED = {
+    match: [
+      /^\s*(?=\S)/, // have to look forward here to avoid polynomial backtracking
+      /[^:]+/,
+      /:\s*/,
+      /$/
+    ],
+    className: {
+      2: "attribute",
+      3: "punctuation"
+    }
+  };
+  const DICTIONARY_ITEM = {
+    match: [
+      /^\s*(?=\S)/, // have to look forward here to avoid polynomial backtracking
+      /[^:]*[^: ]/,
+      /[ ]*:/,
+      /[ ]/,
+      /.*$/
+    ],
+    className: {
+      2: "attribute",
+      3: "punctuation",
+      5: "string"
+    }
+  };
+  const STRING = {
+    match: [
+      /^\s*/,
+      />/,
+      /[ ]/,
+      /.*$/
+    ],
+    className: {
+      2: "punctuation",
+      4: "string"
+    }
+  };
+  const LIST_ITEM = {
+    variants: [
+      { match: [
+        /^\s*/,
+        /-/,
+        /[ ]/,
+        /.*$/
+      ] },
+      { match: [
+        /^\s*/,
+        /-$/
+      ] }
+    ],
+    className: {
+      2: "bullet",
+      4: "string"
+    }
+  };
+
+  return {
+    name: 'Nested Text',
+    aliases: [ 'nt' ],
+    contains: [
+      hljs.inherit(hljs.HASH_COMMENT_MODE, {
+        begin: /^\s*(?=#)/,
+        excludeBegin: true
+      }),
+      LIST_ITEM,
+      STRING,
+      NESTED,
+      DICTIONARY_ITEM
+    ]
+  };
+}
+
+export { nestedtext as default };

frontend/node_modules/highlight.js/es/languages/nim.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/nim" instead of "highlight.js/lib/languages/nim.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './nim.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/node-repl.js

@@ -0,0 +1,33 @@
+/*
+Language: Node REPL
+Requires: javascript.js
+Author: Marat Nagayev <nagaevmt@yandex.ru>
+Category: scripting
+*/
+
+/** @type LanguageFn */
+function nodeRepl(hljs) {
+  return {
+    name: 'Node REPL',
+    contains: [
+      {
+        className: 'meta.prompt',
+        starts: {
+          // a space separates the REPL prefix from the actual code
+          // this is purely for cleaner HTML output
+          end: / |$/,
+          starts: {
+            end: '$',
+            subLanguage: 'javascript'
+          }
+        },
+        variants: [
+          { begin: /^>(?=[ ]|$)/ },
+          { begin: /^\.\.\.(?=[ ]|$)/ }
+        ]
+      }
+    ]
+  };
+}
+
+export { nodeRepl as default };

frontend/node_modules/highlight.js/es/languages/nsis.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/nsis" instead of "highlight.js/lib/languages/nsis.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './nsis.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/objectivec.js

@@ -0,0 +1,253 @@
+/*
+Language: Objective-C
+Author: Valerii Hiora <valerii.hiora@gmail.com>
+Contributors: Angel G. Olloqui <angelgarcia.mail@gmail.com>, Matt Diephouse <matt@diephouse.com>, Andrew Farmer <ahfarmer@gmail.com>, Minh Nguyễn <mxn@1ec5.org>
+Website: https://developer.apple.com/documentation/objectivec
+Category: common
+*/
+
+function objectivec(hljs) {
+  const API_CLASS = {
+    className: 'built_in',
+    begin: '\\b(AV|CA|CF|CG|CI|CL|CM|CN|CT|MK|MP|MTK|MTL|NS|SCN|SK|UI|WK|XC)\\w+'
+  };
+  const IDENTIFIER_RE = /[a-zA-Z@][a-zA-Z0-9_]*/;
+  const TYPES = [
+    "int",
+    "float",
+    "char",
+    "unsigned",
+    "signed",
+    "short",
+    "long",
+    "double",
+    "wchar_t",
+    "unichar",
+    "void",
+    "bool",
+    "BOOL",
+    "id|0",
+    "_Bool"
+  ];
+  const KWS = [
+    "while",
+    "export",
+    "sizeof",
+    "typedef",
+    "const",
+    "struct",
+    "for",
+    "union",
+    "volatile",
+    "static",
+    "mutable",
+    "if",
+    "do",
+    "return",
+    "goto",
+    "enum",
+    "else",
+    "break",
+    "extern",
+    "asm",
+    "case",
+    "default",
+    "register",
+    "explicit",
+    "typename",
+    "switch",
+    "continue",
+    "inline",
+    "readonly",
+    "assign",
+    "readwrite",
+    "self",
+    "@synchronized",
+    "id",
+    "typeof",
+    "nonatomic",
+    "IBOutlet",
+    "IBAction",
+    "strong",
+    "weak",
+    "copy",
+    "in",
+    "out",
+    "inout",
+    "bycopy",
+    "byref",
+    "oneway",
+    "__strong",
+    "__weak",
+    "__block",
+    "__autoreleasing",
+    "@private",
+    "@protected",
+    "@public",
+    "@try",
+    "@property",
+    "@end",
+    "@throw",
+    "@catch",
+    "@finally",
+    "@autoreleasepool",
+    "@synthesize",
+    "@dynamic",
+    "@selector",
+    "@optional",
+    "@required",
+    "@encode",
+    "@package",
+    "@import",
+    "@defs",
+    "@compatibility_alias",
+    "__bridge",
+    "__bridge_transfer",
+    "__bridge_retained",
+    "__bridge_retain",
+    "__covariant",
+    "__contravariant",
+    "__kindof",
+    "_Nonnull",
+    "_Nullable",
+    "_Null_unspecified",
+    "__FUNCTION__",
+    "__PRETTY_FUNCTION__",
+    "__attribute__",
+    "getter",
+    "setter",
+    "retain",
+    "unsafe_unretained",
+    "nonnull",
+    "nullable",
+    "null_unspecified",
+    "null_resettable",
+    "class",
+    "instancetype",
+    "NS_DESIGNATED_INITIALIZER",
+    "NS_UNAVAILABLE",
+    "NS_REQUIRES_SUPER",
+    "NS_RETURNS_INNER_POINTER",
+    "NS_INLINE",
+    "NS_AVAILABLE",
+    "NS_DEPRECATED",
+    "NS_ENUM",
+    "NS_OPTIONS",
+    "NS_SWIFT_UNAVAILABLE",
+    "NS_ASSUME_NONNULL_BEGIN",
+    "NS_ASSUME_NONNULL_END",
+    "NS_REFINED_FOR_SWIFT",
+    "NS_SWIFT_NAME",
+    "NS_SWIFT_NOTHROW",
+    "NS_DURING",
+    "NS_HANDLER",
+    "NS_ENDHANDLER",
+    "NS_VALUERETURN",
+    "NS_VOIDRETURN"
+  ];
+  const LITERALS = [
+    "false",
+    "true",
+    "FALSE",
+    "TRUE",
+    "nil",
+    "YES",
+    "NO",
+    "NULL"
+  ];
+  const BUILT_INS = [
+    "dispatch_once_t",
+    "dispatch_queue_t",
+    "dispatch_sync",
+    "dispatch_async",
+    "dispatch_once"
+  ];
+  const KEYWORDS = {
+    "variable.language": [
+      "this",
+      "super"
+    ],
+    $pattern: IDENTIFIER_RE,
+    keyword: KWS,
+    literal: LITERALS,
+    built_in: BUILT_INS,
+    type: TYPES
+  };
+  const CLASS_KEYWORDS = {
+    $pattern: IDENTIFIER_RE,
+    keyword: [
+      "@interface",
+      "@class",
+      "@protocol",
+      "@implementation"
+    ]
+  };
+  return {
+    name: 'Objective-C',
+    aliases: [
+      'mm',
+      'objc',
+      'obj-c',
+      'obj-c++',
+      'objective-c++'
+    ],
+    keywords: KEYWORDS,
+    illegal: '</',
+    contains: [
+      API_CLASS,
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      hljs.C_NUMBER_MODE,
+      hljs.QUOTE_STRING_MODE,
+      hljs.APOS_STRING_MODE,
+      {
+        className: 'string',
+        variants: [
+          {
+            begin: '@"',
+            end: '"',
+            illegal: '\\n',
+            contains: [ hljs.BACKSLASH_ESCAPE ]
+          }
+        ]
+      },
+      {
+        className: 'meta',
+        begin: /#\s*[a-z]+\b/,
+        end: /$/,
+        keywords: { keyword:
+            'if else elif endif define undef warning error line '
+            + 'pragma ifdef ifndef include' },
+        contains: [
+          {
+            begin: /\\\n/,
+            relevance: 0
+          },
+          hljs.inherit(hljs.QUOTE_STRING_MODE, { className: 'string' }),
+          {
+            className: 'string',
+            begin: /<.*?>/,
+            end: /$/,
+            illegal: '\\n'
+          },
+          hljs.C_LINE_COMMENT_MODE,
+          hljs.C_BLOCK_COMMENT_MODE
+        ]
+      },
+      {
+        className: 'class',
+        begin: '(' + CLASS_KEYWORDS.keyword.join('|') + ')\\b',
+        end: /(\{|$)/,
+        excludeEnd: true,
+        keywords: CLASS_KEYWORDS,
+        contains: [ hljs.UNDERSCORE_TITLE_MODE ]
+      },
+      {
+        begin: '\\.' + hljs.UNDERSCORE_IDENT_RE,
+        relevance: 0
+      }
+    ]
+  };
+}
+
+export { objectivec as default };

frontend/node_modules/highlight.js/es/languages/objectivec.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/objectivec" instead of "highlight.js/lib/languages/objectivec.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './objectivec.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/oxygene.js

@@ -0,0 +1,87 @@
+/*
+Language: Oxygene
+Author: Carlo Kok <ck@remobjects.com>
+Description: Oxygene is built on the foundation of Object Pascal, revamped and extended to be a modern language for the twenty-first century.
+Website: https://www.elementscompiler.com/elements/default.aspx
+Category: build-system
+*/
+
+function oxygene(hljs) {
+  const OXYGENE_KEYWORDS = {
+    $pattern: /\.?\w+/,
+    keyword:
+      'abstract add and array as asc aspect assembly async begin break block by case class concat const copy constructor continue '
+      + 'create default delegate desc distinct div do downto dynamic each else empty end ensure enum equals event except exit extension external false '
+      + 'final finalize finalizer finally flags for forward from function future global group has if implementation implements implies in index inherited '
+      + 'inline interface into invariants is iterator join locked locking loop matching method mod module namespace nested new nil not notify nullable of '
+      + 'old on operator or order out override parallel params partial pinned private procedure property protected public queryable raise read readonly '
+      + 'record reintroduce remove repeat require result reverse sealed select self sequence set shl shr skip static step soft take then to true try tuple '
+      + 'type union unit unsafe until uses using var virtual raises volatile where while with write xor yield await mapped deprecated stdcall cdecl pascal '
+      + 'register safecall overload library platform reference packed strict published autoreleasepool selector strong weak unretained'
+  };
+  const CURLY_COMMENT = hljs.COMMENT(
+    /\{/,
+    /\}/,
+    { relevance: 0 }
+  );
+  const PAREN_COMMENT = hljs.COMMENT(
+    '\\(\\*',
+    '\\*\\)',
+    { relevance: 10 }
+  );
+  const STRING = {
+    className: 'string',
+    begin: '\'',
+    end: '\'',
+    contains: [ { begin: '\'\'' } ]
+  };
+  const CHAR_STRING = {
+    className: 'string',
+    begin: '(#\\d+)+'
+  };
+  const FUNCTION = {
+    beginKeywords: 'function constructor destructor procedure method',
+    end: '[:;]',
+    keywords: 'function constructor|10 destructor|10 procedure|10 method|10',
+    contains: [
+      hljs.inherit(hljs.TITLE_MODE, { scope: "title.function" }),
+      {
+        className: 'params',
+        begin: '\\(',
+        end: '\\)',
+        keywords: OXYGENE_KEYWORDS,
+        contains: [
+          STRING,
+          CHAR_STRING
+        ]
+      },
+      CURLY_COMMENT,
+      PAREN_COMMENT
+    ]
+  };
+
+  const SEMICOLON = {
+    scope: "punctuation",
+    match: /;/,
+    relevance: 0
+  };
+
+  return {
+    name: 'Oxygene',
+    case_insensitive: true,
+    keywords: OXYGENE_KEYWORDS,
+    illegal: '("|\\$[G-Zg-z]|\\/\\*|</|=>|->)',
+    contains: [
+      CURLY_COMMENT,
+      PAREN_COMMENT,
+      hljs.C_LINE_COMMENT_MODE,
+      STRING,
+      CHAR_STRING,
+      hljs.NUMBER_MODE,
+      FUNCTION,
+      SEMICOLON
+    ]
+  };
+}
+
+export { oxygene as default };

frontend/node_modules/highlight.js/es/languages/parser3.js

@@ -0,0 +1,55 @@
+/*
+Language: Parser3
+Requires: xml.js
+Author: Oleg Volchkov <oleg@volchkov.net>
+Website: https://www.parser.ru/en/
+Category: template
+*/
+
+function parser3(hljs) {
+  const CURLY_SUBCOMMENT = hljs.COMMENT(
+    /\{/,
+    /\}/,
+    { contains: [ 'self' ] }
+  );
+  return {
+    name: 'Parser3',
+    subLanguage: 'xml',
+    relevance: 0,
+    contains: [
+      hljs.COMMENT('^#', '$'),
+      hljs.COMMENT(
+        /\^rem\{/,
+        /\}/,
+        {
+          relevance: 10,
+          contains: [ CURLY_SUBCOMMENT ]
+        }
+      ),
+      {
+        className: 'meta',
+        begin: '^@(?:BASE|USE|CLASS|OPTIONS)$',
+        relevance: 10
+      },
+      {
+        className: 'title',
+        begin: '@[\\w\\-]+\\[[\\w^;\\-]*\\](?:\\[[\\w^;\\-]*\\])?(?:.*)$'
+      },
+      {
+        className: 'variable',
+        begin: /\$\{?[\w\-.:]+\}?/
+      },
+      {
+        className: 'keyword',
+        begin: /\^[\w\-.:]+/
+      },
+      {
+        className: 'number',
+        begin: '\\^#[0-9a-fA-F]+'
+      },
+      hljs.C_NUMBER_MODE
+    ]
+  };
+}
+
+export { parser3 as default };

frontend/node_modules/highlight.js/es/languages/php-template.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/php-template" instead of "highlight.js/lib/languages/php-template.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './php-template.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/powershell.js

@@ -0,0 +1,317 @@
+/*
+Language: PowerShell
+Description: PowerShell is a task-based command-line shell and scripting language built on .NET.
+Author: David Mohundro <david@mohundro.com>
+Contributors: Nicholas Blumhardt <nblumhardt@nblumhardt.com>, Victor Zhou <OiCMudkips@users.noreply.github.com>, Nicolas Le Gall <contact@nlegall.fr>
+Website: https://docs.microsoft.com/en-us/powershell/
+Category: scripting
+*/
+
+function powershell(hljs) {
+  const TYPES = [
+    "string",
+    "char",
+    "byte",
+    "int",
+    "long",
+    "bool",
+    "decimal",
+    "single",
+    "double",
+    "DateTime",
+    "xml",
+    "array",
+    "hashtable",
+    "void"
+  ];
+
+  // https://docs.microsoft.com/en-us/powershell/scripting/developer/cmdlet/approved-verbs-for-windows-powershell-commands
+  const VALID_VERBS =
+    'Add|Clear|Close|Copy|Enter|Exit|Find|Format|Get|Hide|Join|Lock|'
+    + 'Move|New|Open|Optimize|Pop|Push|Redo|Remove|Rename|Reset|Resize|'
+    + 'Search|Select|Set|Show|Skip|Split|Step|Switch|Undo|Unlock|'
+    + 'Watch|Backup|Checkpoint|Compare|Compress|Convert|ConvertFrom|'
+    + 'ConvertTo|Dismount|Edit|Expand|Export|Group|Import|Initialize|'
+    + 'Limit|Merge|Mount|Out|Publish|Restore|Save|Sync|Unpublish|Update|'
+    + 'Approve|Assert|Build|Complete|Confirm|Deny|Deploy|Disable|Enable|Install|Invoke|'
+    + 'Register|Request|Restart|Resume|Start|Stop|Submit|Suspend|Uninstall|'
+    + 'Unregister|Wait|Debug|Measure|Ping|Repair|Resolve|Test|Trace|Connect|'
+    + 'Disconnect|Read|Receive|Send|Write|Block|Grant|Protect|Revoke|Unblock|'
+    + 'Unprotect|Use|ForEach|Sort|Tee|Where';
+
+  const COMPARISON_OPERATORS =
+    '-and|-as|-band|-bnot|-bor|-bxor|-casesensitive|-ccontains|-ceq|-cge|-cgt|'
+    + '-cle|-clike|-clt|-cmatch|-cne|-cnotcontains|-cnotlike|-cnotmatch|-contains|'
+    + '-creplace|-csplit|-eq|-exact|-f|-file|-ge|-gt|-icontains|-ieq|-ige|-igt|'
+    + '-ile|-ilike|-ilt|-imatch|-in|-ine|-inotcontains|-inotlike|-inotmatch|'
+    + '-ireplace|-is|-isnot|-isplit|-join|-le|-like|-lt|-match|-ne|-not|'
+    + '-notcontains|-notin|-notlike|-notmatch|-or|-regex|-replace|-shl|-shr|'
+    + '-split|-wildcard|-xor';
+
+  const KEYWORDS = {
+    $pattern: /-?[A-z\.\-]+\b/,
+    keyword:
+      'if else foreach return do while until elseif begin for trap data dynamicparam '
+      + 'end break throw param continue finally in switch exit filter try process catch '
+      + 'hidden static parameter',
+    // "echo" relevance has been set to 0 to avoid auto-detect conflicts with shell transcripts
+    built_in:
+      'ac asnp cat cd CFS chdir clc clear clhy cli clp cls clv cnsn compare copy cp '
+      + 'cpi cpp curl cvpa dbp del diff dir dnsn ebp echo|0 epal epcsv epsn erase etsn exsn fc fhx '
+      + 'fl ft fw gal gbp gc gcb gci gcm gcs gdr gerr ghy gi gin gjb gl gm gmo gp gps gpv group '
+      + 'gsn gsnp gsv gtz gu gv gwmi h history icm iex ihy ii ipal ipcsv ipmo ipsn irm ise iwmi '
+      + 'iwr kill lp ls man md measure mi mount move mp mv nal ndr ni nmo npssc nsn nv ogv oh '
+      + 'popd ps pushd pwd r rbp rcjb rcsn rd rdr ren ri rjb rm rmdir rmo rni rnp rp rsn rsnp '
+      + 'rujb rv rvpa rwmi sajb sal saps sasv sbp sc scb select set shcm si sl sleep sls sort sp '
+      + 'spjb spps spsv start stz sujb sv swmi tee trcm type wget where wjb write'
+    // TODO: 'validate[A-Z]+' can't work in keywords
+  };
+
+  const TITLE_NAME_RE = /\w[\w\d]*((-)[\w\d]+)*/;
+
+  const BACKTICK_ESCAPE = {
+    begin: '`[\\s\\S]',
+    relevance: 0
+  };
+
+  const VAR = {
+    className: 'variable',
+    variants: [
+      { begin: /\$\B/ },
+      {
+        className: 'keyword',
+        begin: /\$this/
+      },
+      { begin: /\$[\w\d][\w\d_:]*/ }
+    ]
+  };
+
+  const LITERAL = {
+    className: 'literal',
+    begin: /\$(null|true|false)\b/
+  };
+
+  const QUOTE_STRING = {
+    className: "string",
+    variants: [
+      {
+        begin: /"/,
+        end: /"/
+      },
+      {
+        begin: /@"/,
+        end: /^"@/
+      }
+    ],
+    contains: [
+      BACKTICK_ESCAPE,
+      VAR,
+      {
+        className: 'variable',
+        begin: /\$[A-z]/,
+        end: /[^A-z]/
+      }
+    ]
+  };
+
+  const APOS_STRING = {
+    className: 'string',
+    variants: [
+      {
+        begin: /'/,
+        end: /'/
+      },
+      {
+        begin: /@'/,
+        end: /^'@/
+      }
+    ]
+  };
+
+  const PS_HELPTAGS = {
+    className: "doctag",
+    variants: [
+      /* no paramater help tags */
+      { begin: /\.(synopsis|description|example|inputs|outputs|notes|link|component|role|functionality)/ },
+      /* one parameter help tags */
+      { begin: /\.(parameter|forwardhelptargetname|forwardhelpcategory|remotehelprunspace|externalhelp)\s+\S+/ }
+    ]
+  };
+
+  const PS_COMMENT = hljs.inherit(
+    hljs.COMMENT(null, null),
+    {
+      variants: [
+        /* single-line comment */
+        {
+          begin: /#/,
+          end: /$/
+        },
+        /* multi-line comment */
+        {
+          begin: /<#/,
+          end: /#>/
+        }
+      ],
+      contains: [ PS_HELPTAGS ]
+    }
+  );
+
+  const CMDLETS = {
+    className: 'built_in',
+    variants: [ { begin: '('.concat(VALID_VERBS, ')+(-)[\\w\\d]+') } ]
+  };
+
+  const PS_CLASS = {
+    className: 'class',
+    beginKeywords: 'class enum',
+    end: /\s*[{]/,
+    excludeEnd: true,
+    relevance: 0,
+    contains: [ hljs.TITLE_MODE ]
+  };
+
+  const PS_FUNCTION = {
+    className: 'function',
+    begin: /function\s+/,
+    end: /\s*\{|$/,
+    excludeEnd: true,
+    returnBegin: true,
+    relevance: 0,
+    contains: [
+      {
+        begin: "function",
+        relevance: 0,
+        className: "keyword"
+      },
+      {
+        className: "title",
+        begin: TITLE_NAME_RE,
+        relevance: 0
+      },
+      {
+        begin: /\(/,
+        end: /\)/,
+        className: "params",
+        relevance: 0,
+        contains: [ VAR ]
+      }
+      // CMDLETS
+    ]
+  };
+
+  // Using statment, plus type, plus assembly name.
+  const PS_USING = {
+    begin: /using\s/,
+    end: /$/,
+    returnBegin: true,
+    contains: [
+      QUOTE_STRING,
+      APOS_STRING,
+      {
+        className: 'keyword',
+        begin: /(using|assembly|command|module|namespace|type)/
+      }
+    ]
+  };
+
+  // Comperison operators & function named parameters.
+  const PS_ARGUMENTS = { variants: [
+    // PS literals are pretty verbose so it's a good idea to accent them a bit.
+    {
+      className: 'operator',
+      begin: '('.concat(COMPARISON_OPERATORS, ')\\b')
+    },
+    {
+      className: 'literal',
+      begin: /(-){1,2}[\w\d-]+/,
+      relevance: 0
+    }
+  ] };
+
+  const HASH_SIGNS = {
+    className: 'selector-tag',
+    begin: /@\B/,
+    relevance: 0
+  };
+
+  // It's a very general rule so I'll narrow it a bit with some strict boundaries
+  // to avoid any possible false-positive collisions!
+  const PS_METHODS = {
+    className: 'function',
+    begin: /\[.*\]\s*[\w]+[ ]??\(/,
+    end: /$/,
+    returnBegin: true,
+    relevance: 0,
+    contains: [
+      {
+        className: 'keyword',
+        begin: '('.concat(
+          KEYWORDS.keyword.toString().replace(/\s/g, '|'
+          ), ')\\b'),
+        endsParent: true,
+        relevance: 0
+      },
+      hljs.inherit(hljs.TITLE_MODE, { endsParent: true })
+    ]
+  };
+
+  const GENTLEMANS_SET = [
+    // STATIC_MEMBER,
+    PS_METHODS,
+    PS_COMMENT,
+    BACKTICK_ESCAPE,
+    hljs.NUMBER_MODE,
+    QUOTE_STRING,
+    APOS_STRING,
+    // PS_NEW_OBJECT_TYPE,
+    CMDLETS,
+    VAR,
+    LITERAL,
+    HASH_SIGNS
+  ];
+
+  const PS_TYPE = {
+    begin: /\[/,
+    end: /\]/,
+    excludeBegin: true,
+    excludeEnd: true,
+    relevance: 0,
+    contains: [].concat(
+      'self',
+      GENTLEMANS_SET,
+      {
+        begin: "(" + TYPES.join("|") + ")",
+        className: "built_in",
+        relevance: 0
+      },
+      {
+        className: 'type',
+        begin: /[\.\w\d]+/,
+        relevance: 0
+      }
+    )
+  };
+
+  PS_METHODS.contains.unshift(PS_TYPE);
+
+  return {
+    name: 'PowerShell',
+    aliases: [
+      "pwsh",
+      "ps",
+      "ps1"
+    ],
+    case_insensitive: true,
+    keywords: KEYWORDS,
+    contains: GENTLEMANS_SET.concat(
+      PS_CLASS,
+      PS_FUNCTION,
+      PS_USING,
+      PS_ARGUMENTS,
+      PS_TYPE
+    )
+  };
+}
+
+export { powershell as default };

frontend/node_modules/highlight.js/es/languages/processing.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/processing" instead of "highlight.js/lib/languages/processing.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './processing.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/profile.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/profile" instead of "highlight.js/lib/languages/profile.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './profile.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/protobuf.js

@@ -0,0 +1,79 @@
+/*
+Language: Protocol Buffers
+Author: Dan Tao <daniel.tao@gmail.com>
+Description: Protocol buffer message definition format
+Website: https://developers.google.com/protocol-buffers/docs/proto3
+Category: protocols
+*/
+
+function protobuf(hljs) {
+  const KEYWORDS = [
+    "package",
+    "import",
+    "option",
+    "optional",
+    "required",
+    "repeated",
+    "group",
+    "oneof"
+  ];
+  const TYPES = [
+    "double",
+    "float",
+    "int32",
+    "int64",
+    "uint32",
+    "uint64",
+    "sint32",
+    "sint64",
+    "fixed32",
+    "fixed64",
+    "sfixed32",
+    "sfixed64",
+    "bool",
+    "string",
+    "bytes"
+  ];
+  const CLASS_DEFINITION = {
+    match: [
+      /(message|enum|service)\s+/,
+      hljs.IDENT_RE
+    ],
+    scope: {
+      1: "keyword",
+      2: "title.class"
+    }
+  };
+
+  return {
+    name: 'Protocol Buffers',
+    aliases: ['proto'],
+    keywords: {
+      keyword: KEYWORDS,
+      type: TYPES,
+      literal: [
+        'true',
+        'false'
+      ]
+    },
+    contains: [
+      hljs.QUOTE_STRING_MODE,
+      hljs.NUMBER_MODE,
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      CLASS_DEFINITION,
+      {
+        className: 'function',
+        beginKeywords: 'rpc',
+        end: /[{;]/,
+        excludeEnd: true,
+        keywords: 'rpc returns'
+      },
+      { // match enum items (relevance)
+        // BLAH = ...;
+        begin: /^\s*[A-Z_]+(?=\s*=[^\n]+;$)/ }
+    ]
+  };
+}
+
+export { protobuf as default };

frontend/node_modules/highlight.js/es/languages/puppet.js

@@ -0,0 +1,146 @@
+/*
+Language: Puppet
+Author: Jose Molina Colmenero <gaudy41@gmail.com>
+Website: https://puppet.com/docs
+Category: config
+*/
+
+function puppet(hljs) {
+  const PUPPET_KEYWORDS = {
+    keyword:
+    /* language keywords */
+      'and case default else elsif false if in import enherits node or true undef unless main settings $string ',
+    literal:
+    /* metaparameters */
+      'alias audit before loglevel noop require subscribe tag '
+      /* normal attributes */
+      + 'owner ensure group mode name|0 changes context force incl lens load_path onlyif provider returns root show_diff type_check '
+      + 'en_address ip_address realname command environment hour monute month monthday special target weekday '
+      + 'creates cwd ogoutput refresh refreshonly tries try_sleep umask backup checksum content ctime force ignore '
+      + 'links mtime purge recurse recurselimit replace selinux_ignore_defaults selrange selrole seltype seluser source '
+      + 'souirce_permissions sourceselect validate_cmd validate_replacement allowdupe attribute_membership auth_membership forcelocal gid '
+      + 'ia_load_module members system host_aliases ip allowed_trunk_vlans description device_url duplex encapsulation etherchannel '
+      + 'native_vlan speed principals allow_root auth_class auth_type authenticate_user k_of_n mechanisms rule session_owner shared options '
+      + 'device fstype enable hasrestart directory present absent link atboot blockdevice device dump pass remounts poller_tag use '
+      + 'message withpath adminfile allow_virtual allowcdrom category configfiles flavor install_options instance package_settings platform '
+      + 'responsefile status uninstall_options vendor unless_system_user unless_uid binary control flags hasstatus manifest pattern restart running '
+      + 'start stop allowdupe auths expiry gid groups home iterations key_membership keys managehome membership password password_max_age '
+      + 'password_min_age profile_membership profiles project purge_ssh_keys role_membership roles salt shell uid baseurl cost descr enabled '
+      + 'enablegroups exclude failovermethod gpgcheck gpgkey http_caching include includepkgs keepalive metadata_expire metalink mirrorlist '
+      + 'priority protect proxy proxy_password proxy_username repo_gpgcheck s3_enabled skip_if_unavailable sslcacert sslclientcert sslclientkey '
+      + 'sslverify mounted',
+    built_in:
+    /* core facts */
+      'architecture augeasversion blockdevices boardmanufacturer boardproductname boardserialnumber cfkey dhcp_servers '
+      + 'domain ec2_ ec2_userdata facterversion filesystems ldom fqdn gid hardwareisa hardwaremodel hostname id|0 interfaces '
+      + 'ipaddress ipaddress_ ipaddress6 ipaddress6_ iphostnumber is_virtual kernel kernelmajversion kernelrelease kernelversion '
+      + 'kernelrelease kernelversion lsbdistcodename lsbdistdescription lsbdistid lsbdistrelease lsbmajdistrelease lsbminordistrelease '
+      + 'lsbrelease macaddress macaddress_ macosx_buildversion macosx_productname macosx_productversion macosx_productverson_major '
+      + 'macosx_productversion_minor manufacturer memoryfree memorysize netmask metmask_ network_ operatingsystem operatingsystemmajrelease '
+      + 'operatingsystemrelease osfamily partitions path physicalprocessorcount processor processorcount productname ps puppetversion '
+      + 'rubysitedir rubyversion selinux selinux_config_mode selinux_config_policy selinux_current_mode selinux_current_mode selinux_enforced '
+      + 'selinux_policyversion serialnumber sp_ sshdsakey sshecdsakey sshrsakey swapencrypted swapfree swapsize timezone type uniqueid uptime '
+      + 'uptime_days uptime_hours uptime_seconds uuid virtual vlans xendomains zfs_version zonenae zones zpool_version'
+  };
+
+  const COMMENT = hljs.COMMENT('#', '$');
+
+  const IDENT_RE = '([A-Za-z_]|::)(\\w|::)*';
+
+  const TITLE = hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE });
+
+  const VARIABLE = {
+    className: 'variable',
+    begin: '\\$' + IDENT_RE
+  };
+
+  const STRING = {
+    className: 'string',
+    contains: [
+      hljs.BACKSLASH_ESCAPE,
+      VARIABLE
+    ],
+    variants: [
+      {
+        begin: /'/,
+        end: /'/
+      },
+      {
+        begin: /"/,
+        end: /"/
+      }
+    ]
+  };
+
+  return {
+    name: 'Puppet',
+    aliases: [ 'pp' ],
+    contains: [
+      COMMENT,
+      VARIABLE,
+      STRING,
+      {
+        beginKeywords: 'class',
+        end: '\\{|;',
+        illegal: /=/,
+        contains: [
+          TITLE,
+          COMMENT
+        ]
+      },
+      {
+        beginKeywords: 'define',
+        end: /\{/,
+        contains: [
+          {
+            className: 'section',
+            begin: hljs.IDENT_RE,
+            endsParent: true
+          }
+        ]
+      },
+      {
+        begin: hljs.IDENT_RE + '\\s+\\{',
+        returnBegin: true,
+        end: /\S/,
+        contains: [
+          {
+            className: 'keyword',
+            begin: hljs.IDENT_RE,
+            relevance: 0.2
+          },
+          {
+            begin: /\{/,
+            end: /\}/,
+            keywords: PUPPET_KEYWORDS,
+            relevance: 0,
+            contains: [
+              STRING,
+              COMMENT,
+              {
+                begin: '[a-zA-Z_]+\\s*=>',
+                returnBegin: true,
+                end: '=>',
+                contains: [
+                  {
+                    className: 'attr',
+                    begin: hljs.IDENT_RE
+                  }
+                ]
+              },
+              {
+                className: 'number',
+                begin: '(\\b0[0-7_]+)|(\\b0x[0-9a-fA-F_]+)|(\\b[1-9][0-9_]*(\\.[0-9_]+)?)|[0_]\\b',
+                relevance: 0
+              },
+              VARIABLE
+            ]
+          }
+        ],
+        relevance: 0
+      }
+    ]
+  };
+}
+
+export { puppet as default };

frontend/node_modules/highlight.js/es/languages/q.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/q" instead of "highlight.js/lib/languages/q.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './q.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/r.js

@@ -0,0 +1,257 @@
+/*
+Language: R
+Description: R is a free software environment for statistical computing and graphics.
+Author: Joe Cheng <joe@rstudio.org>
+Contributors: Konrad Rudolph <konrad.rudolph@gmail.com>
+Website: https://www.r-project.org
+Category: common,scientific
+*/
+
+/** @type LanguageFn */
+function r(hljs) {
+  const regex = hljs.regex;
+  // Identifiers in R cannot start with `_`, but they can start with `.` if it
+  // is not immediately followed by a digit.
+  // R also supports quoted identifiers, which are near-arbitrary sequences
+  // delimited by backticks (`…`), which may contain escape sequences. These are
+  // handled in a separate mode. See `test/markup/r/names.txt` for examples.
+  // FIXME: Support Unicode identifiers.
+  const IDENT_RE = /(?:(?:[a-zA-Z]|\.[._a-zA-Z])[._a-zA-Z0-9]*)|\.(?!\d)/;
+  const NUMBER_TYPES_RE = regex.either(
+    // Special case: only hexadecimal binary powers can contain fractions
+    /0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*[pP][+-]?\d+i?/,
+    // Hexadecimal numbers without fraction and optional binary power
+    /0[xX][0-9a-fA-F]+(?:[pP][+-]?\d+)?[Li]?/,
+    // Decimal numbers
+    /(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?[Li]?/
+  );
+  const OPERATORS_RE = /[=!<>:]=|\|\||&&|:::?|<-|<<-|->>|->|\|>|[-+*\/?!$&|:<=>@^~]|\*\*/;
+  const PUNCTUATION_RE = regex.either(
+    /[()]/,
+    /[{}]/,
+    /\[\[/,
+    /[[\]]/,
+    /\\/,
+    /,/
+  );
+
+  return {
+    name: 'R',
+
+    keywords: {
+      $pattern: IDENT_RE,
+      keyword:
+        'function if in break next repeat else for while',
+      literal:
+        'NULL NA TRUE FALSE Inf NaN NA_integer_|10 NA_real_|10 '
+        + 'NA_character_|10 NA_complex_|10',
+      built_in:
+        // Builtin constants
+        'LETTERS letters month.abb month.name pi T F '
+        // Primitive functions
+        // These are all the functions in `base` that are implemented as a
+        // `.Primitive`, minus those functions that are also keywords.
+        + 'abs acos acosh all any anyNA Arg as.call as.character '
+        + 'as.complex as.double as.environment as.integer as.logical '
+        + 'as.null.default as.numeric as.raw asin asinh atan atanh attr '
+        + 'attributes baseenv browser c call ceiling class Conj cos cosh '
+        + 'cospi cummax cummin cumprod cumsum digamma dim dimnames '
+        + 'emptyenv exp expression floor forceAndCall gamma gc.time '
+        + 'globalenv Im interactive invisible is.array is.atomic is.call '
+        + 'is.character is.complex is.double is.environment is.expression '
+        + 'is.finite is.function is.infinite is.integer is.language '
+        + 'is.list is.logical is.matrix is.na is.name is.nan is.null '
+        + 'is.numeric is.object is.pairlist is.raw is.recursive is.single '
+        + 'is.symbol lazyLoadDBfetch length lgamma list log max min '
+        + 'missing Mod names nargs nzchar oldClass on.exit pos.to.env '
+        + 'proc.time prod quote range Re rep retracemem return round '
+        + 'seq_along seq_len seq.int sign signif sin sinh sinpi sqrt '
+        + 'standardGeneric substitute sum switch tan tanh tanpi tracemem '
+        + 'trigamma trunc unclass untracemem UseMethod xtfrm',
+    },
+
+    contains: [
+      // Roxygen comments
+      hljs.COMMENT(
+        /#'/,
+        /$/,
+        { contains: [
+          {
+            // Handle `@examples` separately to cause all subsequent code
+            // until the next `@`-tag on its own line to be kept as-is,
+            // preventing highlighting. This code is example R code, so nested
+            // doctags shouldn’t be treated as such. See
+            // `test/markup/r/roxygen.txt` for an example.
+            scope: 'doctag',
+            match: /@examples/,
+            starts: {
+              end: regex.lookahead(regex.either(
+                // end if another doc comment
+                /\n^#'\s*(?=@[a-zA-Z]+)/,
+                // or a line with no comment
+                /\n^(?!#')/
+              )),
+              endsParent: true
+            }
+          },
+          {
+            // Handle `@param` to highlight the parameter name following
+            // after.
+            scope: 'doctag',
+            begin: '@param',
+            end: /$/,
+            contains: [
+              {
+                scope: 'variable',
+                variants: [
+                  { match: IDENT_RE },
+                  { match: /`(?:\\.|[^`\\])+`/ }
+                ],
+                endsParent: true
+              }
+            ]
+          },
+          {
+            scope: 'doctag',
+            match: /@[a-zA-Z]+/
+          },
+          {
+            scope: 'keyword',
+            match: /\\[a-zA-Z]+/
+          }
+        ] }
+      ),
+
+      hljs.HASH_COMMENT_MODE,
+
+      {
+        scope: 'string',
+        contains: [ hljs.BACKSLASH_ESCAPE ],
+        variants: [
+          hljs.END_SAME_AS_BEGIN({
+            begin: /[rR]"(-*)\(/,
+            end: /\)(-*)"/
+          }),
+          hljs.END_SAME_AS_BEGIN({
+            begin: /[rR]"(-*)\{/,
+            end: /\}(-*)"/
+          }),
+          hljs.END_SAME_AS_BEGIN({
+            begin: /[rR]"(-*)\[/,
+            end: /\](-*)"/
+          }),
+          hljs.END_SAME_AS_BEGIN({
+            begin: /[rR]'(-*)\(/,
+            end: /\)(-*)'/
+          }),
+          hljs.END_SAME_AS_BEGIN({
+            begin: /[rR]'(-*)\{/,
+            end: /\}(-*)'/
+          }),
+          hljs.END_SAME_AS_BEGIN({
+            begin: /[rR]'(-*)\[/,
+            end: /\](-*)'/
+          }),
+          {
+            begin: '"',
+            end: '"',
+            relevance: 0
+          },
+          {
+            begin: "'",
+            end: "'",
+            relevance: 0
+          }
+        ],
+      },
+
+      // Matching numbers immediately following punctuation and operators is
+      // tricky since we need to look at the character ahead of a number to
+      // ensure the number is not part of an identifier, and we cannot use
+      // negative look-behind assertions. So instead we explicitly handle all
+      // possible combinations of (operator|punctuation), number.
+      // TODO: replace with negative look-behind when available
+      // { begin: /(?<![a-zA-Z0-9._])0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*[pP][+-]?\d+i?/ },
+      // { begin: /(?<![a-zA-Z0-9._])0[xX][0-9a-fA-F]+([pP][+-]?\d+)?[Li]?/ },
+      // { begin: /(?<![a-zA-Z0-9._])(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?[Li]?/ }
+      {
+        relevance: 0,
+        variants: [
+          {
+            scope: {
+              1: 'operator',
+              2: 'number'
+            },
+            match: [
+              OPERATORS_RE,
+              NUMBER_TYPES_RE
+            ]
+          },
+          {
+            scope: {
+              1: 'operator',
+              2: 'number'
+            },
+            match: [
+              /%[^%]*%/,
+              NUMBER_TYPES_RE
+            ]
+          },
+          {
+            scope: {
+              1: 'punctuation',
+              2: 'number'
+            },
+            match: [
+              PUNCTUATION_RE,
+              NUMBER_TYPES_RE
+            ]
+          },
+          {
+            scope: { 2: 'number' },
+            match: [
+              /[^a-zA-Z0-9._]|^/, // not part of an identifier, or start of document
+              NUMBER_TYPES_RE
+            ]
+          }
+        ]
+      },
+
+      // Operators/punctuation when they're not directly followed by numbers
+      {
+        // Relevance boost for the most common assignment form.
+        scope: { 3: 'operator' },
+        match: [
+          IDENT_RE,
+          /\s+/,
+          /<-/,
+          /\s+/
+        ]
+      },
+
+      {
+        scope: 'operator',
+        relevance: 0,
+        variants: [
+          { match: OPERATORS_RE },
+          { match: /%[^%]*%/ }
+        ]
+      },
+
+      {
+        scope: 'punctuation',
+        relevance: 0,
+        match: PUNCTUATION_RE
+      },
+
+      {
+        // Escaped identifier
+        begin: '`',
+        end: '`',
+        contains: [ { begin: /\\./ } ]
+      }
+    ]
+  };
+}
+
+export { r as default };

frontend/node_modules/highlight.js/es/languages/roboconf.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/roboconf" instead of "highlight.js/lib/languages/roboconf.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './roboconf.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/scheme.js

@@ -0,0 +1,196 @@
+/*
+Language: Scheme
+Description: Scheme is a programming language in the Lisp family.
+             (keywords based on http://community.schemewiki.org/?scheme-keywords)
+Author: JP Verkamp <me@jverkamp.com>
+Contributors: Ivan Sagalaev <maniac@softwaremaniacs.org>
+Origin: clojure.js
+Website: http://community.schemewiki.org/?what-is-scheme
+Category: lisp
+*/
+
+function scheme(hljs) {
+  const SCHEME_IDENT_RE = '[^\\(\\)\\[\\]\\{\\}",\'`;#|\\\\\\s]+';
+  const SCHEME_SIMPLE_NUMBER_RE = '(-|\\+)?\\d+([./]\\d+)?';
+  const SCHEME_COMPLEX_NUMBER_RE = SCHEME_SIMPLE_NUMBER_RE + '[+\\-]' + SCHEME_SIMPLE_NUMBER_RE + 'i';
+  const KEYWORDS = {
+    $pattern: SCHEME_IDENT_RE,
+    built_in:
+      'case-lambda call/cc class define-class exit-handler field import '
+      + 'inherit init-field interface let*-values let-values let/ec mixin '
+      + 'opt-lambda override protect provide public rename require '
+      + 'require-for-syntax syntax syntax-case syntax-error unit/sig unless '
+      + 'when with-syntax and begin call-with-current-continuation '
+      + 'call-with-input-file call-with-output-file case cond define '
+      + 'define-syntax delay do dynamic-wind else for-each if lambda let let* '
+      + 'let-syntax letrec letrec-syntax map or syntax-rules \' * + , ,@ - ... / '
+      + '; < <= = => > >= ` abs acos angle append apply asin assoc assq assv atan '
+      + 'boolean? caar cadr call-with-input-file call-with-output-file '
+      + 'call-with-values car cdddar cddddr cdr ceiling char->integer '
+      + 'char-alphabetic? char-ci<=? char-ci<? char-ci=? char-ci>=? char-ci>? '
+      + 'char-downcase char-lower-case? char-numeric? char-ready? char-upcase '
+      + 'char-upper-case? char-whitespace? char<=? char<? char=? char>=? char>? '
+      + 'char? close-input-port close-output-port complex? cons cos '
+      + 'current-input-port current-output-port denominator display eof-object? '
+      + 'eq? equal? eqv? eval even? exact->inexact exact? exp expt floor '
+      + 'force gcd imag-part inexact->exact inexact? input-port? integer->char '
+      + 'integer? interaction-environment lcm length list list->string '
+      + 'list->vector list-ref list-tail list? load log magnitude make-polar '
+      + 'make-rectangular make-string make-vector max member memq memv min '
+      + 'modulo negative? newline not null-environment null? number->string '
+      + 'number? numerator odd? open-input-file open-output-file output-port? '
+      + 'pair? peek-char port? positive? procedure? quasiquote quote quotient '
+      + 'rational? rationalize read read-char real-part real? remainder reverse '
+      + 'round scheme-report-environment set! set-car! set-cdr! sin sqrt string '
+      + 'string->list string->number string->symbol string-append string-ci<=? '
+      + 'string-ci<? string-ci=? string-ci>=? string-ci>? string-copy '
+      + 'string-fill! string-length string-ref string-set! string<=? string<? '
+      + 'string=? string>=? string>? string? substring symbol->string symbol? '
+      + 'tan transcript-off transcript-on truncate values vector '
+      + 'vector->list vector-fill! vector-length vector-ref vector-set! '
+      + 'with-input-from-file with-output-to-file write write-char zero?'
+  };
+
+  const LITERAL = {
+    className: 'literal',
+    begin: '(#t|#f|#\\\\' + SCHEME_IDENT_RE + '|#\\\\.)'
+  };
+
+  const NUMBER = {
+    className: 'number',
+    variants: [
+      {
+        begin: SCHEME_SIMPLE_NUMBER_RE,
+        relevance: 0
+      },
+      {
+        begin: SCHEME_COMPLEX_NUMBER_RE,
+        relevance: 0
+      },
+      { begin: '#b[0-1]+(/[0-1]+)?' },
+      { begin: '#o[0-7]+(/[0-7]+)?' },
+      { begin: '#x[0-9a-f]+(/[0-9a-f]+)?' }
+    ]
+  };
+
+  const STRING = hljs.QUOTE_STRING_MODE;
+
+  const COMMENT_MODES = [
+    hljs.COMMENT(
+      ';',
+      '$',
+      { relevance: 0 }
+    ),
+    hljs.COMMENT('#\\|', '\\|#')
+  ];
+
+  const IDENT = {
+    begin: SCHEME_IDENT_RE,
+    relevance: 0
+  };
+
+  const QUOTED_IDENT = {
+    className: 'symbol',
+    begin: '\'' + SCHEME_IDENT_RE
+  };
+
+  const BODY = {
+    endsWithParent: true,
+    relevance: 0
+  };
+
+  const QUOTED_LIST = {
+    variants: [
+      { begin: /'/ },
+      { begin: '`' }
+    ],
+    contains: [
+      {
+        begin: '\\(',
+        end: '\\)',
+        contains: [
+          'self',
+          LITERAL,
+          STRING,
+          NUMBER,
+          IDENT,
+          QUOTED_IDENT
+        ]
+      }
+    ]
+  };
+
+  const NAME = {
+    className: 'name',
+    relevance: 0,
+    begin: SCHEME_IDENT_RE,
+    keywords: KEYWORDS
+  };
+
+  const LAMBDA = {
+    begin: /lambda/,
+    endsWithParent: true,
+    returnBegin: true,
+    contains: [
+      NAME,
+      {
+        endsParent: true,
+        variants: [
+          {
+            begin: /\(/,
+            end: /\)/
+          },
+          {
+            begin: /\[/,
+            end: /\]/
+          }
+        ],
+        contains: [ IDENT ]
+      }
+    ]
+  };
+
+  const LIST = {
+    variants: [
+      {
+        begin: '\\(',
+        end: '\\)'
+      },
+      {
+        begin: '\\[',
+        end: '\\]'
+      }
+    ],
+    contains: [
+      LAMBDA,
+      NAME,
+      BODY
+    ]
+  };
+
+  BODY.contains = [
+    LITERAL,
+    NUMBER,
+    STRING,
+    IDENT,
+    QUOTED_IDENT,
+    QUOTED_LIST,
+    LIST
+  ].concat(COMMENT_MODES);
+
+  return {
+    name: 'Scheme',
+    aliases: ['scm'],
+    illegal: /\S/,
+    contains: [
+      hljs.SHEBANG(),
+      NUMBER,
+      STRING,
+      QUOTED_IDENT,
+      QUOTED_LIST,
+      LIST
+    ].concat(COMMENT_MODES)
+  };
+}
+
+export { scheme as default };

frontend/node_modules/highlight.js/es/languages/scilab.js

@@ -0,0 +1,73 @@
+/*
+Language: Scilab
+Author: Sylvestre Ledru <sylvestre.ledru@scilab-enterprises.com>
+Origin: matlab.js
+Description: Scilab is a port from Matlab
+Website: https://www.scilab.org
+Category: scientific
+*/
+
+function scilab(hljs) {
+  const COMMON_CONTAINS = [
+    hljs.C_NUMBER_MODE,
+    {
+      className: 'string',
+      begin: '\'|\"',
+      end: '\'|\"',
+      contains: [
+        hljs.BACKSLASH_ESCAPE,
+        { begin: '\'\'' }
+      ]
+    }
+  ];
+
+  return {
+    name: 'Scilab',
+    aliases: [ 'sci' ],
+    keywords: {
+      $pattern: /%?\w+/,
+      keyword: 'abort break case clear catch continue do elseif else endfunction end for function '
+        + 'global if pause return resume select try then while',
+      literal:
+        '%f %F %t %T %pi %eps %inf %nan %e %i %z %s',
+      built_in: // Scilab has more than 2000 functions. Just list the most commons
+       'abs and acos asin atan ceil cd chdir clearglobal cosh cos cumprod deff disp error '
+       + 'exec execstr exists exp eye gettext floor fprintf fread fsolve imag isdef isempty '
+       + 'isinfisnan isvector lasterror length load linspace list listfiles log10 log2 log '
+       + 'max min msprintf mclose mopen ones or pathconvert poly printf prod pwd rand real '
+       + 'round sinh sin size gsort sprintf sqrt strcat strcmps tring sum system tanh tan '
+       + 'type typename warning zeros matrix'
+    },
+    illegal: '("|#|/\\*|\\s+/\\w+)',
+    contains: [
+      {
+        className: 'function',
+        beginKeywords: 'function',
+        end: '$',
+        contains: [
+          hljs.UNDERSCORE_TITLE_MODE,
+          {
+            className: 'params',
+            begin: '\\(',
+            end: '\\)'
+          }
+        ]
+      },
+      // seems to be a guard against [ident]' or [ident].
+      // perhaps to prevent attributes from flagging as keywords?
+      {
+        begin: '[a-zA-Z_][a-zA-Z_0-9]*[\\.\']+',
+        relevance: 0
+      },
+      {
+        begin: '\\[',
+        end: '\\][\\.\']*',
+        relevance: 0,
+        contains: COMMON_CONTAINS
+      },
+      hljs.COMMENT('//', '$')
+    ].concat(COMMON_CONTAINS)
+  };
+}
+
+export { scilab as default };

frontend/node_modules/highlight.js/es/languages/scss.js

@@ -0,0 +1,939 @@
+const MODES = (hljs) => {
+  return {
+    IMPORTANT: {
+      scope: 'meta',
+      begin: '!important'
+    },
+    BLOCK_COMMENT: hljs.C_BLOCK_COMMENT_MODE,
+    HEXCOLOR: {
+      scope: 'number',
+      begin: /#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/
+    },
+    FUNCTION_DISPATCH: {
+      className: "built_in",
+      begin: /[\w-]+(?=\()/
+    },
+    ATTRIBUTE_SELECTOR_MODE: {
+      scope: 'selector-attr',
+      begin: /\[/,
+      end: /\]/,
+      illegal: '$',
+      contains: [
+        hljs.APOS_STRING_MODE,
+        hljs.QUOTE_STRING_MODE
+      ]
+    },
+    CSS_NUMBER_MODE: {
+      scope: 'number',
+      begin: hljs.NUMBER_RE + '(' +
+        '%|em|ex|ch|rem' +
+        '|vw|vh|vmin|vmax' +
+        '|cm|mm|in|pt|pc|px' +
+        '|deg|grad|rad|turn' +
+        '|s|ms' +
+        '|Hz|kHz' +
+        '|dpi|dpcm|dppx' +
+        ')?',
+      relevance: 0
+    },
+    CSS_VARIABLE: {
+      className: "attr",
+      begin: /--[A-Za-z_][A-Za-z0-9_-]*/
+    }
+  };
+};
+
+const HTML_TAGS = [
+  'a',
+  'abbr',
+  'address',
+  'article',
+  'aside',
+  'audio',
+  'b',
+  'blockquote',
+  'body',
+  'button',
+  'canvas',
+  'caption',
+  'cite',
+  'code',
+  'dd',
+  'del',
+  'details',
+  'dfn',
+  'div',
+  'dl',
+  'dt',
+  'em',
+  'fieldset',
+  'figcaption',
+  'figure',
+  'footer',
+  'form',
+  'h1',
+  'h2',
+  'h3',
+  'h4',
+  'h5',
+  'h6',
+  'header',
+  'hgroup',
+  'html',
+  'i',
+  'iframe',
+  'img',
+  'input',
+  'ins',
+  'kbd',
+  'label',
+  'legend',
+  'li',
+  'main',
+  'mark',
+  'menu',
+  'nav',
+  'object',
+  'ol',
+  'optgroup',
+  'option',
+  'p',
+  'picture',
+  'q',
+  'quote',
+  'samp',
+  'section',
+  'select',
+  'source',
+  'span',
+  'strong',
+  'summary',
+  'sup',
+  'table',
+  'tbody',
+  'td',
+  'textarea',
+  'tfoot',
+  'th',
+  'thead',
+  'time',
+  'tr',
+  'ul',
+  'var',
+  'video'
+];
+
+const SVG_TAGS = [
+  'defs',
+  'g',
+  'marker',
+  'mask',
+  'pattern',
+  'svg',
+  'switch',
+  'symbol',
+  'feBlend',
+  'feColorMatrix',
+  'feComponentTransfer',
+  'feComposite',
+  'feConvolveMatrix',
+  'feDiffuseLighting',
+  'feDisplacementMap',
+  'feFlood',
+  'feGaussianBlur',
+  'feImage',
+  'feMerge',
+  'feMorphology',
+  'feOffset',
+  'feSpecularLighting',
+  'feTile',
+  'feTurbulence',
+  'linearGradient',
+  'radialGradient',
+  'stop',
+  'circle',
+  'ellipse',
+  'image',
+  'line',
+  'path',
+  'polygon',
+  'polyline',
+  'rect',
+  'text',
+  'use',
+  'textPath',
+  'tspan',
+  'foreignObject',
+  'clipPath'
+];
+
+const TAGS = [
+  ...HTML_TAGS,
+  ...SVG_TAGS,
+];
+
+// Sorting, then reversing makes sure longer attributes/elements like
+// `font-weight` are matched fully instead of getting false positives on say `font`
+
+const MEDIA_FEATURES = [
+  'any-hover',
+  'any-pointer',
+  'aspect-ratio',
+  'color',
+  'color-gamut',
+  'color-index',
+  'device-aspect-ratio',
+  'device-height',
+  'device-width',
+  'display-mode',
+  'forced-colors',
+  'grid',
+  'height',
+  'hover',
+  'inverted-colors',
+  'monochrome',
+  'orientation',
+  'overflow-block',
+  'overflow-inline',
+  'pointer',
+  'prefers-color-scheme',
+  'prefers-contrast',
+  'prefers-reduced-motion',
+  'prefers-reduced-transparency',
+  'resolution',
+  'scan',
+  'scripting',
+  'update',
+  'width',
+  // TODO: find a better solution?
+  'min-width',
+  'max-width',
+  'min-height',
+  'max-height'
+].sort().reverse();
+
+// https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-classes
+const PSEUDO_CLASSES = [
+  'active',
+  'any-link',
+  'blank',
+  'checked',
+  'current',
+  'default',
+  'defined',
+  'dir', // dir()
+  'disabled',
+  'drop',
+  'empty',
+  'enabled',
+  'first',
+  'first-child',
+  'first-of-type',
+  'fullscreen',
+  'future',
+  'focus',
+  'focus-visible',
+  'focus-within',
+  'has', // has()
+  'host', // host or host()
+  'host-context', // host-context()
+  'hover',
+  'indeterminate',
+  'in-range',
+  'invalid',
+  'is', // is()
+  'lang', // lang()
+  'last-child',
+  'last-of-type',
+  'left',
+  'link',
+  'local-link',
+  'not', // not()
+  'nth-child', // nth-child()
+  'nth-col', // nth-col()
+  'nth-last-child', // nth-last-child()
+  'nth-last-col', // nth-last-col()
+  'nth-last-of-type', //nth-last-of-type()
+  'nth-of-type', //nth-of-type()
+  'only-child',
+  'only-of-type',
+  'optional',
+  'out-of-range',
+  'past',
+  'placeholder-shown',
+  'read-only',
+  'read-write',
+  'required',
+  'right',
+  'root',
+  'scope',
+  'target',
+  'target-within',
+  'user-invalid',
+  'valid',
+  'visited',
+  'where' // where()
+].sort().reverse();
+
+// https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-elements
+const PSEUDO_ELEMENTS = [
+  'after',
+  'backdrop',
+  'before',
+  'cue',
+  'cue-region',
+  'first-letter',
+  'first-line',
+  'grammar-error',
+  'marker',
+  'part',
+  'placeholder',
+  'selection',
+  'slotted',
+  'spelling-error'
+].sort().reverse();
+
+const ATTRIBUTES = [
+  'accent-color',
+  'align-content',
+  'align-items',
+  'align-self',
+  'alignment-baseline',
+  'all',
+  'anchor-name',
+  'animation',
+  'animation-composition',
+  'animation-delay',
+  'animation-direction',
+  'animation-duration',
+  'animation-fill-mode',
+  'animation-iteration-count',
+  'animation-name',
+  'animation-play-state',
+  'animation-range',
+  'animation-range-end',
+  'animation-range-start',
+  'animation-timeline',
+  'animation-timing-function',
+  'appearance',
+  'aspect-ratio',
+  'backdrop-filter',
+  'backface-visibility',
+  'background',
+  'background-attachment',
+  'background-blend-mode',
+  'background-clip',
+  'background-color',
+  'background-image',
+  'background-origin',
+  'background-position',
+  'background-position-x',
+  'background-position-y',
+  'background-repeat',
+  'background-size',
+  'baseline-shift',
+  'block-size',
+  'border',
+  'border-block',
+  'border-block-color',
+  'border-block-end',
+  'border-block-end-color',
+  'border-block-end-style',
+  'border-block-end-width',
+  'border-block-start',
+  'border-block-start-color',
+  'border-block-start-style',
+  'border-block-start-width',
+  'border-block-style',
+  'border-block-width',
+  'border-bottom',
+  'border-bottom-color',
+  'border-bottom-left-radius',
+  'border-bottom-right-radius',
+  'border-bottom-style',
+  'border-bottom-width',
+  'border-collapse',
+  'border-color',
+  'border-end-end-radius',
+  'border-end-start-radius',
+  'border-image',
+  'border-image-outset',
+  'border-image-repeat',
+  'border-image-slice',
+  'border-image-source',
+  'border-image-width',
+  'border-inline',
+  'border-inline-color',
+  'border-inline-end',
+  'border-inline-end-color',
+  'border-inline-end-style',
+  'border-inline-end-width',
+  'border-inline-start',
+  'border-inline-start-color',
+  'border-inline-start-style',
+  'border-inline-start-width',
+  'border-inline-style',
+  'border-inline-width',
+  'border-left',
+  'border-left-color',
+  'border-left-style',
+  'border-left-width',
+  'border-radius',
+  'border-right',
+  'border-right-color',
+  'border-right-style',
+  'border-right-width',
+  'border-spacing',
+  'border-start-end-radius',
+  'border-start-start-radius',
+  'border-style',
+  'border-top',
+  'border-top-color',
+  'border-top-left-radius',
+  'border-top-right-radius',
+  'border-top-style',
+  'border-top-width',
+  'border-width',
+  'bottom',
+  'box-align',
+  'box-decoration-break',
+  'box-direction',
+  'box-flex',
+  'box-flex-group',
+  'box-lines',
+  'box-ordinal-group',
+  'box-orient',
+  'box-pack',
+  'box-shadow',
+  'box-sizing',
+  'break-after',
+  'break-before',
+  'break-inside',
+  'caption-side',
+  'caret-color',
+  'clear',
+  'clip',
+  'clip-path',
+  'clip-rule',
+  'color',
+  'color-interpolation',
+  'color-interpolation-filters',
+  'color-profile',
+  'color-rendering',
+  'color-scheme',
+  'column-count',
+  'column-fill',
+  'column-gap',
+  'column-rule',
+  'column-rule-color',
+  'column-rule-style',
+  'column-rule-width',
+  'column-span',
+  'column-width',
+  'columns',
+  'contain',
+  'contain-intrinsic-block-size',
+  'contain-intrinsic-height',
+  'contain-intrinsic-inline-size',
+  'contain-intrinsic-size',
+  'contain-intrinsic-width',
+  'container',
+  'container-name',
+  'container-type',
+  'content',
+  'content-visibility',
+  'counter-increment',
+  'counter-reset',
+  'counter-set',
+  'cue',
+  'cue-after',
+  'cue-before',
+  'cursor',
+  'cx',
+  'cy',
+  'direction',
+  'display',
+  'dominant-baseline',
+  'empty-cells',
+  'enable-background',
+  'field-sizing',
+  'fill',
+  'fill-opacity',
+  'fill-rule',
+  'filter',
+  'flex',
+  'flex-basis',
+  'flex-direction',
+  'flex-flow',
+  'flex-grow',
+  'flex-shrink',
+  'flex-wrap',
+  'float',
+  'flood-color',
+  'flood-opacity',
+  'flow',
+  'font',
+  'font-display',
+  'font-family',
+  'font-feature-settings',
+  'font-kerning',
+  'font-language-override',
+  'font-optical-sizing',
+  'font-palette',
+  'font-size',
+  'font-size-adjust',
+  'font-smooth',
+  'font-smoothing',
+  'font-stretch',
+  'font-style',
+  'font-synthesis',
+  'font-synthesis-position',
+  'font-synthesis-small-caps',
+  'font-synthesis-style',
+  'font-synthesis-weight',
+  'font-variant',
+  'font-variant-alternates',
+  'font-variant-caps',
+  'font-variant-east-asian',
+  'font-variant-emoji',
+  'font-variant-ligatures',
+  'font-variant-numeric',
+  'font-variant-position',
+  'font-variation-settings',
+  'font-weight',
+  'forced-color-adjust',
+  'gap',
+  'glyph-orientation-horizontal',
+  'glyph-orientation-vertical',
+  'grid',
+  'grid-area',
+  'grid-auto-columns',
+  'grid-auto-flow',
+  'grid-auto-rows',
+  'grid-column',
+  'grid-column-end',
+  'grid-column-start',
+  'grid-gap',
+  'grid-row',
+  'grid-row-end',
+  'grid-row-start',
+  'grid-template',
+  'grid-template-areas',
+  'grid-template-columns',
+  'grid-template-rows',
+  'hanging-punctuation',
+  'height',
+  'hyphenate-character',
+  'hyphenate-limit-chars',
+  'hyphens',
+  'icon',
+  'image-orientation',
+  'image-rendering',
+  'image-resolution',
+  'ime-mode',
+  'initial-letter',
+  'initial-letter-align',
+  'inline-size',
+  'inset',
+  'inset-area',
+  'inset-block',
+  'inset-block-end',
+  'inset-block-start',
+  'inset-inline',
+  'inset-inline-end',
+  'inset-inline-start',
+  'isolation',
+  'justify-content',
+  'justify-items',
+  'justify-self',
+  'kerning',
+  'left',
+  'letter-spacing',
+  'lighting-color',
+  'line-break',
+  'line-height',
+  'line-height-step',
+  'list-style',
+  'list-style-image',
+  'list-style-position',
+  'list-style-type',
+  'margin',
+  'margin-block',
+  'margin-block-end',
+  'margin-block-start',
+  'margin-bottom',
+  'margin-inline',
+  'margin-inline-end',
+  'margin-inline-start',
+  'margin-left',
+  'margin-right',
+  'margin-top',
+  'margin-trim',
+  'marker',
+  'marker-end',
+  'marker-mid',
+  'marker-start',
+  'marks',
+  'mask',
+  'mask-border',
+  'mask-border-mode',
+  'mask-border-outset',
+  'mask-border-repeat',
+  'mask-border-slice',
+  'mask-border-source',
+  'mask-border-width',
+  'mask-clip',
+  'mask-composite',
+  'mask-image',
+  'mask-mode',
+  'mask-origin',
+  'mask-position',
+  'mask-repeat',
+  'mask-size',
+  'mask-type',
+  'masonry-auto-flow',
+  'math-depth',
+  'math-shift',
+  'math-style',
+  'max-block-size',
+  'max-height',
+  'max-inline-size',
+  'max-width',
+  'min-block-size',
+  'min-height',
+  'min-inline-size',
+  'min-width',
+  'mix-blend-mode',
+  'nav-down',
+  'nav-index',
+  'nav-left',
+  'nav-right',
+  'nav-up',
+  'none',
+  'normal',
+  'object-fit',
+  'object-position',
+  'offset',
+  'offset-anchor',
+  'offset-distance',
+  'offset-path',
+  'offset-position',
+  'offset-rotate',
+  'opacity',
+  'order',
+  'orphans',
+  'outline',
+  'outline-color',
+  'outline-offset',
+  'outline-style',
+  'outline-width',
+  'overflow',
+  'overflow-anchor',
+  'overflow-block',
+  'overflow-clip-margin',
+  'overflow-inline',
+  'overflow-wrap',
+  'overflow-x',
+  'overflow-y',
+  'overlay',
+  'overscroll-behavior',
+  'overscroll-behavior-block',
+  'overscroll-behavior-inline',
+  'overscroll-behavior-x',
+  'overscroll-behavior-y',
+  'padding',
+  'padding-block',
+  'padding-block-end',
+  'padding-block-start',
+  'padding-bottom',
+  'padding-inline',
+  'padding-inline-end',
+  'padding-inline-start',
+  'padding-left',
+  'padding-right',
+  'padding-top',
+  'page',
+  'page-break-after',
+  'page-break-before',
+  'page-break-inside',
+  'paint-order',
+  'pause',
+  'pause-after',
+  'pause-before',
+  'perspective',
+  'perspective-origin',
+  'place-content',
+  'place-items',
+  'place-self',
+  'pointer-events',
+  'position',
+  'position-anchor',
+  'position-visibility',
+  'print-color-adjust',
+  'quotes',
+  'r',
+  'resize',
+  'rest',
+  'rest-after',
+  'rest-before',
+  'right',
+  'rotate',
+  'row-gap',
+  'ruby-align',
+  'ruby-position',
+  'scale',
+  'scroll-behavior',
+  'scroll-margin',
+  'scroll-margin-block',
+  'scroll-margin-block-end',
+  'scroll-margin-block-start',
+  'scroll-margin-bottom',
+  'scroll-margin-inline',
+  'scroll-margin-inline-end',
+  'scroll-margin-inline-start',
+  'scroll-margin-left',
+  'scroll-margin-right',
+  'scroll-margin-top',
+  'scroll-padding',
+  'scroll-padding-block',
+  'scroll-padding-block-end',
+  'scroll-padding-block-start',
+  'scroll-padding-bottom',
+  'scroll-padding-inline',
+  'scroll-padding-inline-end',
+  'scroll-padding-inline-start',
+  'scroll-padding-left',
+  'scroll-padding-right',
+  'scroll-padding-top',
+  'scroll-snap-align',
+  'scroll-snap-stop',
+  'scroll-snap-type',
+  'scroll-timeline',
+  'scroll-timeline-axis',
+  'scroll-timeline-name',
+  'scrollbar-color',
+  'scrollbar-gutter',
+  'scrollbar-width',
+  'shape-image-threshold',
+  'shape-margin',
+  'shape-outside',
+  'shape-rendering',
+  'speak',
+  'speak-as',
+  'src', // @font-face
+  'stop-color',
+  'stop-opacity',
+  'stroke',
+  'stroke-dasharray',
+  'stroke-dashoffset',
+  'stroke-linecap',
+  'stroke-linejoin',
+  'stroke-miterlimit',
+  'stroke-opacity',
+  'stroke-width',
+  'tab-size',
+  'table-layout',
+  'text-align',
+  'text-align-all',
+  'text-align-last',
+  'text-anchor',
+  'text-combine-upright',
+  'text-decoration',
+  'text-decoration-color',
+  'text-decoration-line',
+  'text-decoration-skip',
+  'text-decoration-skip-ink',
+  'text-decoration-style',
+  'text-decoration-thickness',
+  'text-emphasis',
+  'text-emphasis-color',
+  'text-emphasis-position',
+  'text-emphasis-style',
+  'text-indent',
+  'text-justify',
+  'text-orientation',
+  'text-overflow',
+  'text-rendering',
+  'text-shadow',
+  'text-size-adjust',
+  'text-transform',
+  'text-underline-offset',
+  'text-underline-position',
+  'text-wrap',
+  'text-wrap-mode',
+  'text-wrap-style',
+  'timeline-scope',
+  'top',
+  'touch-action',
+  'transform',
+  'transform-box',
+  'transform-origin',
+  'transform-style',
+  'transition',
+  'transition-behavior',
+  'transition-delay',
+  'transition-duration',
+  'transition-property',
+  'transition-timing-function',
+  'translate',
+  'unicode-bidi',
+  'user-modify',
+  'user-select',
+  'vector-effect',
+  'vertical-align',
+  'view-timeline',
+  'view-timeline-axis',
+  'view-timeline-inset',
+  'view-timeline-name',
+  'view-transition-name',
+  'visibility',
+  'voice-balance',
+  'voice-duration',
+  'voice-family',
+  'voice-pitch',
+  'voice-range',
+  'voice-rate',
+  'voice-stress',
+  'voice-volume',
+  'white-space',
+  'white-space-collapse',
+  'widows',
+  'width',
+  'will-change',
+  'word-break',
+  'word-spacing',
+  'word-wrap',
+  'writing-mode',
+  'x',
+  'y',
+  'z-index',
+  'zoom'
+].sort().reverse();
+
+/*
+Language: SCSS
+Description: Scss is an extension of the syntax of CSS.
+Author: Kurt Emch <kurt@kurtemch.com>
+Website: https://sass-lang.com
+Category: common, css, web
+*/
+
+
+/** @type LanguageFn */
+function scss(hljs) {
+  const modes = MODES(hljs);
+  const PSEUDO_ELEMENTS$1 = PSEUDO_ELEMENTS;
+  const PSEUDO_CLASSES$1 = PSEUDO_CLASSES;
+
+  const AT_IDENTIFIER = '@[a-z-]+'; // @font-face
+  const AT_MODIFIERS = "and or not only";
+  const IDENT_RE = '[a-zA-Z-][a-zA-Z0-9_-]*';
+  const VARIABLE = {
+    className: 'variable',
+    begin: '(\\$' + IDENT_RE + ')\\b',
+    relevance: 0
+  };
+
+  return {
+    name: 'SCSS',
+    case_insensitive: true,
+    illegal: '[=/|\']',
+    contains: [
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      // to recognize keyframe 40% etc which are outside the scope of our
+      // attribute value mode
+      modes.CSS_NUMBER_MODE,
+      {
+        className: 'selector-id',
+        begin: '#[A-Za-z0-9_-]+',
+        relevance: 0
+      },
+      {
+        className: 'selector-class',
+        begin: '\\.[A-Za-z0-9_-]+',
+        relevance: 0
+      },
+      modes.ATTRIBUTE_SELECTOR_MODE,
+      {
+        className: 'selector-tag',
+        begin: '\\b(' + TAGS.join('|') + ')\\b',
+        // was there, before, but why?
+        relevance: 0
+      },
+      {
+        className: 'selector-pseudo',
+        begin: ':(' + PSEUDO_CLASSES$1.join('|') + ')'
+      },
+      {
+        className: 'selector-pseudo',
+        begin: ':(:)?(' + PSEUDO_ELEMENTS$1.join('|') + ')'
+      },
+      VARIABLE,
+      { // pseudo-selector params
+        begin: /\(/,
+        end: /\)/,
+        contains: [ modes.CSS_NUMBER_MODE ]
+      },
+      modes.CSS_VARIABLE,
+      {
+        className: 'attribute',
+        begin: '\\b(' + ATTRIBUTES.join('|') + ')\\b'
+      },
+      { begin: '\\b(whitespace|wait|w-resize|visible|vertical-text|vertical-ideographic|uppercase|upper-roman|upper-alpha|underline|transparent|top|thin|thick|text|text-top|text-bottom|tb-rl|table-header-group|table-footer-group|sw-resize|super|strict|static|square|solid|small-caps|separate|se-resize|scroll|s-resize|rtl|row-resize|ridge|right|repeat|repeat-y|repeat-x|relative|progress|pointer|overline|outside|outset|oblique|nowrap|not-allowed|normal|none|nw-resize|no-repeat|no-drop|newspaper|ne-resize|n-resize|move|middle|medium|ltr|lr-tb|lowercase|lower-roman|lower-alpha|loose|list-item|line|line-through|line-edge|lighter|left|keep-all|justify|italic|inter-word|inter-ideograph|inside|inset|inline|inline-block|inherit|inactive|ideograph-space|ideograph-parenthesis|ideograph-numeric|ideograph-alpha|horizontal|hidden|help|hand|groove|fixed|ellipsis|e-resize|double|dotted|distribute|distribute-space|distribute-letter|distribute-all-lines|disc|disabled|default|decimal|dashed|crosshair|collapse|col-resize|circle|char|center|capitalize|break-word|break-all|bottom|both|bolder|bold|block|bidi-override|below|baseline|auto|always|all-scroll|absolute|table|table-cell)\\b' },
+      {
+        begin: /:/,
+        end: /[;}{]/,
+        relevance: 0,
+        contains: [
+          modes.BLOCK_COMMENT,
+          VARIABLE,
+          modes.HEXCOLOR,
+          modes.CSS_NUMBER_MODE,
+          hljs.QUOTE_STRING_MODE,
+          hljs.APOS_STRING_MODE,
+          modes.IMPORTANT,
+          modes.FUNCTION_DISPATCH
+        ]
+      },
+      // matching these here allows us to treat them more like regular CSS
+      // rules so everything between the {} gets regular rule highlighting,
+      // which is what we want for page and font-face
+      {
+        begin: '@(page|font-face)',
+        keywords: {
+          $pattern: AT_IDENTIFIER,
+          keyword: '@page @font-face'
+        }
+      },
+      {
+        begin: '@',
+        end: '[{;]',
+        returnBegin: true,
+        keywords: {
+          $pattern: /[a-z-]+/,
+          keyword: AT_MODIFIERS,
+          attribute: MEDIA_FEATURES.join(" ")
+        },
+        contains: [
+          {
+            begin: AT_IDENTIFIER,
+            className: "keyword"
+          },
+          {
+            begin: /[a-z-]+(?=:)/,
+            className: "attribute"
+          },
+          VARIABLE,
+          hljs.QUOTE_STRING_MODE,
+          hljs.APOS_STRING_MODE,
+          modes.HEXCOLOR,
+          modes.CSS_NUMBER_MODE
+        ]
+      },
+      modes.FUNCTION_DISPATCH
+    ]
+  };
+}
+
+export { scss as default };

frontend/node_modules/highlight.js/es/languages/smalltalk.js

@@ -0,0 +1,69 @@
+/*
+Language: Smalltalk
+Description: Smalltalk is an object-oriented, dynamically typed reflective programming language.
+Author: Vladimir Gubarkov <xonixx@gmail.com>
+Website: https://en.wikipedia.org/wiki/Smalltalk
+Category: system
+*/
+
+function smalltalk(hljs) {
+  const VAR_IDENT_RE = '[a-z][a-zA-Z0-9_]*';
+  const CHAR = {
+    className: 'string',
+    begin: '\\$.{1}'
+  };
+  const SYMBOL = {
+    className: 'symbol',
+    begin: '#' + hljs.UNDERSCORE_IDENT_RE
+  };
+  return {
+    name: 'Smalltalk',
+    aliases: [ 'st' ],
+    keywords: [
+      "self",
+      "super",
+      "nil",
+      "true",
+      "false",
+      "thisContext"
+    ],
+    contains: [
+      hljs.COMMENT('"', '"'),
+      hljs.APOS_STRING_MODE,
+      {
+        className: 'type',
+        begin: '\\b[A-Z][A-Za-z0-9_]*',
+        relevance: 0
+      },
+      {
+        begin: VAR_IDENT_RE + ':',
+        relevance: 0
+      },
+      hljs.C_NUMBER_MODE,
+      SYMBOL,
+      CHAR,
+      {
+        // This looks more complicated than needed to avoid combinatorial
+        // explosion under V8. It effectively means `| var1 var2 ... |` with
+        // whitespace adjacent to `|` being optional.
+        begin: '\\|[ ]*' + VAR_IDENT_RE + '([ ]+' + VAR_IDENT_RE + ')*[ ]*\\|',
+        returnBegin: true,
+        end: /\|/,
+        illegal: /\S/,
+        contains: [ { begin: '(\\|[ ]*)?' + VAR_IDENT_RE } ]
+      },
+      {
+        begin: '#\\(',
+        end: '\\)',
+        contains: [
+          hljs.APOS_STRING_MODE,
+          CHAR,
+          hljs.C_NUMBER_MODE,
+          SYMBOL
+        ]
+      }
+    ]
+  };
+}
+
+export { smalltalk as default };

frontend/node_modules/highlight.js/es/languages/sml.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/sml" instead of "highlight.js/lib/languages/sml.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './sml.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/sql.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/sql" instead of "highlight.js/lib/languages/sql.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './sql.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/stan.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/stan" instead of "highlight.js/lib/languages/stan.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './stan.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/stata.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/stata" instead of "highlight.js/lib/languages/stata.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './stata.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/step21.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/step21" instead of "highlight.js/lib/languages/step21.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './step21.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/subunit.js

@@ -0,0 +1,44 @@
+/*
+Language: SubUnit
+Author: Sergey Bronnikov <sergeyb@bronevichok.ru>
+Website: https://pypi.org/project/python-subunit/
+Category: protocols
+*/
+
+function subunit(hljs) {
+  const DETAILS = {
+    className: 'string',
+    begin: '\\[\n(multipart)?',
+    end: '\\]\n'
+  };
+  const TIME = {
+    className: 'string',
+    begin: '\\d{4}-\\d{2}-\\d{2}(\\s+)\\d{2}:\\d{2}:\\d{2}\.\\d+Z'
+  };
+  const PROGRESSVALUE = {
+    className: 'string',
+    begin: '(\\+|-)\\d+'
+  };
+  const KEYWORDS = {
+    className: 'keyword',
+    relevance: 10,
+    variants: [
+      { begin: '^(test|testing|success|successful|failure|error|skip|xfail|uxsuccess)(:?)\\s+(test)?' },
+      { begin: '^progress(:?)(\\s+)?(pop|push)?' },
+      { begin: '^tags:' },
+      { begin: '^time:' }
+    ]
+  };
+  return {
+    name: 'SubUnit',
+    case_insensitive: true,
+    contains: [
+      DETAILS,
+      TIME,
+      PROGRESSVALUE,
+      KEYWORDS
+    ]
+  };
+}
+
+export { subunit as default };

frontend/node_modules/highlight.js/es/languages/swift.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/swift" instead of "highlight.js/lib/languages/swift.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './swift.js';
+    export default lang;

frontend/node_modules/highlight.js/es/languages/tap.js

@@ -0,0 +1,47 @@
+/*
+Language: Test Anything Protocol
+Description: TAP, the Test Anything Protocol, is a simple text-based interface between testing modules in a test harness.
+Requires: yaml.js
+Author: Sergey Bronnikov <sergeyb@bronevichok.ru>
+Website: https://testanything.org
+*/
+
+function tap(hljs) {
+  return {
+    name: 'Test Anything Protocol',
+    case_insensitive: true,
+    contains: [
+      hljs.HASH_COMMENT_MODE,
+      // version of format and total amount of testcases
+      {
+        className: 'meta',
+        variants: [
+          { begin: '^TAP version (\\d+)$' },
+          { begin: '^1\\.\\.(\\d+)$' }
+        ]
+      },
+      // YAML block
+      {
+        begin: /---$/,
+        end: '\\.\\.\\.$',
+        subLanguage: 'yaml',
+        relevance: 0
+      },
+      // testcase number
+      {
+        className: 'number',
+        begin: ' (\\d+) '
+      },
+      // testcase status and description
+      {
+        className: 'symbol',
+        variants: [
+          { begin: '^ok' },
+          { begin: '^not ok' }
+        ]
+      }
+    ]
+  };
+}
+
+export { tap as default };

frontend/node_modules/highlight.js/es/languages/tcl.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/tcl" instead of "highlight.js/lib/languages/tcl.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './tcl.js';
+    export default lang;