@parcel/codeframe 2.0.0-dev.1430 → 2.0.0-dev.1431

package/lib/codeframe.js

@@ -2860,430 +2860,56 @@ module.exports = $af94cd74eed7763d$var$bash;
 
 });
 
-parcelRegister("cLsqx", function(module, exports) {
-/*
-Language: Julia
-Description: Julia is a high-level, high-performance, dynamic programming language.
-Author: Kenta Sato <bicycle1885@gmail.com>
-Contributors: Alex Arslan <ararslan@comcast.net>, Fredrik Ekre <ekrefredrik@gmail.com>
-Website: https://julialang.org
-*/ function $94afecd538db2fad$var$julia(hljs) {
-    // Since there are numerous special names in Julia, it is too much trouble
-    // to maintain them by hand. Hence these names (i.e. keywords, literals and
-    // built-ins) are automatically generated from Julia 1.5.2 itself through
-    // the following scripts for each.
-    // ref: https://docs.julialang.org/en/v1/manual/variables/#Allowed-Variable-Names
-    var VARIABLE_NAME_RE = "[A-Za-z_\\u00A1-\\uFFFF][A-Za-z_0-9\\u00A1-\\uFFFF]*";
-    // # keyword generator, multi-word keywords handled manually below (Julia 1.5.2)
-    // import REPL.REPLCompletions
-    // res = String["in", "isa", "where"]
-    // for kw in collect(x.keyword for x in REPLCompletions.complete_keyword(""))
-    //     if !(contains(kw, " ") || kw == "struct")
-    //         push!(res, kw)
-    //     end
-    // end
-    // sort!(unique!(res))
-    // foreach(x -> println("\'", x, "\',"), res)
-    var KEYWORD_LIST = [
-        "baremodule",
-        "begin",
-        "break",
-        "catch",
-        "ccall",
-        "const",
-        "continue",
-        "do",
-        "else",
-        "elseif",
-        "end",
-        "export",
-        "false",
-        "finally",
-        "for",
-        "function",
-        "global",
-        "if",
-        "import",
-        "in",
-        "isa",
-        "let",
-        "local",
-        "macro",
-        "module",
-        "quote",
-        "return",
-        "true",
-        "try",
-        "using",
-        "where",
-        "while"
-    ];
-    // # literal generator (Julia 1.5.2)
-    // import REPL.REPLCompletions
-    // res = String["true", "false"]
-    // for compl in filter!(x -> isa(x, REPLCompletions.ModuleCompletion) && (x.parent === Base || x.parent === Core),
-    //                     REPLCompletions.completions("", 0)[1])
-    //     try
-    //         v = eval(Symbol(compl.mod))
-    //         if !(v isa Function || v isa Type || v isa TypeVar || v isa Module || v isa Colon)
-    //             push!(res, compl.mod)
-    //         end
-    //     catch e
-    //     end
-    // end
-    // sort!(unique!(res))
-    // foreach(x -> println("\'", x, "\',"), res)
-    var LITERAL_LIST = [
-        "ARGS",
-        "C_NULL",
-        "DEPOT_PATH",
-        "ENDIAN_BOM",
-        "ENV",
-        "Inf",
-        "Inf16",
-        "Inf32",
-        "Inf64",
-        "InsertionSort",
-        "LOAD_PATH",
-        "MergeSort",
-        "NaN",
-        "NaN16",
-        "NaN32",
-        "NaN64",
-        "PROGRAM_FILE",
-        "QuickSort",
-        "RoundDown",
-        "RoundFromZero",
-        "RoundNearest",
-        "RoundNearestTiesAway",
-        "RoundNearestTiesUp",
-        "RoundToZero",
-        "RoundUp",
-        "VERSION|0",
-        "devnull",
-        "false",
-        "im",
-        "missing",
-        "nothing",
-        "pi",
-        "stderr",
-        "stdin",
-        "stdout",
-        "true",
-        "undef",
-        "\u03C0",
-        "\u212F"
-    ];
-    // # built_in generator (Julia 1.5.2)
-    // import REPL.REPLCompletions
-    // res = String[]
-    // for compl in filter!(x -> isa(x, REPLCompletions.ModuleCompletion) && (x.parent === Base || x.parent === Core),
-    //                     REPLCompletions.completions("", 0)[1])
-    //     try
-    //         v = eval(Symbol(compl.mod))
-    //         if (v isa Type || v isa TypeVar) && (compl.mod != "=>")
-    //             push!(res, compl.mod)
-    //         end
-    //     catch e
-    //     end
-    // end
-    // sort!(unique!(res))
-    // foreach(x -> println("\'", x, "\',"), res)
-    var BUILT_IN_LIST = [
-        "AbstractArray",
-        "AbstractChannel",
-        "AbstractChar",
-        "AbstractDict",
-        "AbstractDisplay",
-        "AbstractFloat",
-        "AbstractIrrational",
-        "AbstractMatrix",
-        "AbstractRange",
-        "AbstractSet",
-        "AbstractString",
-        "AbstractUnitRange",
-        "AbstractVecOrMat",
-        "AbstractVector",
-        "Any",
-        "ArgumentError",
-        "Array",
-        "AssertionError",
-        "BigFloat",
-        "BigInt",
-        "BitArray",
-        "BitMatrix",
-        "BitSet",
-        "BitVector",
-        "Bool",
-        "BoundsError",
-        "CapturedException",
-        "CartesianIndex",
-        "CartesianIndices",
-        "Cchar",
-        "Cdouble",
-        "Cfloat",
-        "Channel",
-        "Char",
-        "Cint",
-        "Cintmax_t",
-        "Clong",
-        "Clonglong",
-        "Cmd",
-        "Colon",
-        "Complex",
-        "ComplexF16",
-        "ComplexF32",
-        "ComplexF64",
-        "CompositeException",
-        "Condition",
-        "Cptrdiff_t",
-        "Cshort",
-        "Csize_t",
-        "Cssize_t",
-        "Cstring",
-        "Cuchar",
-        "Cuint",
-        "Cuintmax_t",
-        "Culong",
-        "Culonglong",
-        "Cushort",
-        "Cvoid",
-        "Cwchar_t",
-        "Cwstring",
-        "DataType",
-        "DenseArray",
-        "DenseMatrix",
-        "DenseVecOrMat",
-        "DenseVector",
-        "Dict",
-        "DimensionMismatch",
-        "Dims",
-        "DivideError",
-        "DomainError",
-        "EOFError",
-        "Enum",
-        "ErrorException",
-        "Exception",
-        "ExponentialBackOff",
-        "Expr",
-        "Float16",
-        "Float32",
-        "Float64",
-        "Function",
-        "GlobalRef",
-        "HTML",
-        "IO",
-        "IOBuffer",
-        "IOContext",
-        "IOStream",
-        "IdDict",
-        "IndexCartesian",
-        "IndexLinear",
-        "IndexStyle",
-        "InexactError",
-        "InitError",
-        "Int",
-        "Int128",
-        "Int16",
-        "Int32",
-        "Int64",
-        "Int8",
-        "Integer",
-        "InterruptException",
-        "InvalidStateException",
-        "Irrational",
-        "KeyError",
-        "LinRange",
-        "LineNumberNode",
-        "LinearIndices",
-        "LoadError",
-        "MIME",
-        "Matrix",
-        "Method",
-        "MethodError",
-        "Missing",
-        "MissingException",
-        "Module",
-        "NTuple",
-        "NamedTuple",
-        "Nothing",
-        "Number",
-        "OrdinalRange",
-        "OutOfMemoryError",
-        "OverflowError",
-        "Pair",
-        "PartialQuickSort",
-        "PermutedDimsArray",
-        "Pipe",
-        "ProcessFailedException",
-        "Ptr",
-        "QuoteNode",
-        "Rational",
-        "RawFD",
-        "ReadOnlyMemoryError",
-        "Real",
-        "ReentrantLock",
-        "Ref",
-        "Regex",
-        "RegexMatch",
-        "RoundingMode",
-        "SegmentationFault",
-        "Set",
-        "Signed",
-        "Some",
-        "StackOverflowError",
-        "StepRange",
-        "StepRangeLen",
-        "StridedArray",
-        "StridedMatrix",
-        "StridedVecOrMat",
-        "StridedVector",
-        "String",
-        "StringIndexError",
-        "SubArray",
-        "SubString",
-        "SubstitutionString",
-        "Symbol",
-        "SystemError",
-        "Task",
-        "TaskFailedException",
-        "Text",
-        "TextDisplay",
-        "Timer",
-        "Tuple",
-        "Type",
-        "TypeError",
-        "TypeVar",
-        "UInt",
-        "UInt128",
-        "UInt16",
-        "UInt32",
-        "UInt64",
-        "UInt8",
-        "UndefInitializer",
-        "UndefKeywordError",
-        "UndefRefError",
-        "UndefVarError",
-        "Union",
-        "UnionAll",
-        "UnitRange",
-        "Unsigned",
-        "Val",
-        "Vararg",
-        "VecElement",
-        "VecOrMat",
-        "Vector",
-        "VersionNumber",
-        "WeakKeyDict",
-        "WeakRef"
-    ];
-    var KEYWORDS = {
-        $pattern: VARIABLE_NAME_RE,
-        keyword: KEYWORD_LIST.join(" "),
-        literal: LITERAL_LIST.join(" "),
-        built_in: BUILT_IN_LIST.join(" ")
-    };
-    // placeholder for recursive self-reference
-    var DEFAULT = {
-        keywords: KEYWORDS,
-        illegal: /<\//
-    };
-    // ref: https://docs.julialang.org/en/v1/manual/integers-and-floating-point-numbers/
-    var NUMBER = {
-        className: "number",
-        // supported numeric literals:
-        //  * binary literal (e.g. 0x10)
-        //  * octal literal (e.g. 0o76543210)
-        //  * hexadecimal literal (e.g. 0xfedcba876543210)
-        //  * hexadecimal floating point literal (e.g. 0x1p0, 0x1.2p2)
-        //  * decimal literal (e.g. 9876543210, 100_000_000)
-        //  * floating pointe literal (e.g. 1.2, 1.2f, .2, 1., 1.2e10, 1.2e-10)
-        begin: /(\b0x[\d_]*(\.[\d_]*)?|0x\.\d[\d_]*)p[-+]?\d+|\b0[box][a-fA-F0-9][a-fA-F0-9_]*|(\b\d[\d_]*(\.[\d_]*)?|\.\d[\d_]*)([eEfF][-+]?\d+)?/,
-        relevance: 0
-    };
-    var CHAR = {
-        className: "string",
-        begin: /'(.|\\[xXuU][a-zA-Z0-9]+)'/
-    };
-    var INTERPOLATION = {
-        className: "subst",
-        begin: /\$\(/,
-        end: /\)/,
-        keywords: KEYWORDS
-    };
-    var INTERPOLATED_VARIABLE = {
-        className: "variable",
-        begin: "\\$" + VARIABLE_NAME_RE
-    };
-    // TODO: neatly escape normal code in string literal
-    var STRING = {
-        className: "string",
+parcelRegister("bXsnb", function(module, exports) {
+/*
+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
+*/ /** @type LanguageFn */ function $8b4b36a5b3894e20$var$basic(hljs) {
+    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: "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"
+        },
         contains: [
-            hljs.BACKSLASH_ESCAPE,
-            INTERPOLATION,
-            INTERPOLATED_VARIABLE
-        ],
-        variants: [
+            hljs.QUOTE_STRING_MODE,
+            hljs.COMMENT("REM", "$", {
+                relevance: 10
+            }),
+            hljs.COMMENT("'", "$", {
+                relevance: 0
+            }),
             {
-                begin: /\w*"""/,
-                end: /"""\w*/,
+                // Match line numbers
+                className: "symbol",
+                begin: "^[0-9]+ ",
                 relevance: 10
             },
             {
-                begin: /\w*"/,
-                end: /"\w*/
-            }
-        ]
-    };
-    var COMMAND = {
-        className: "string",
-        contains: [
-            hljs.BACKSLASH_ESCAPE,
-            INTERPOLATION,
-            INTERPOLATED_VARIABLE
-        ],
-        begin: "`",
-        end: "`"
-    };
-    var MACROCALL = {
-        className: "meta",
-        begin: "@" + VARIABLE_NAME_RE
-    };
-    var COMMENT = {
-        className: "comment",
-        variants: [
+                // Match typed numeric constants (1000, 12.34!, 1.2e5, 1.5#, 1.2D2)
+                className: "number",
+                begin: "\\b\\d+(\\.\\d+)?([edED]\\d+)?[#!]?",
+                relevance: 0
+            },
             {
-                begin: "#=",
-                end: "=#",
-                relevance: 10
+                // Match hexadecimal numbers (&Hxxxx)
+                className: "number",
+                begin: "(&[hH][0-9a-fA-F]{1,4})"
             },
             {
-                begin: "#",
-                end: "$"
+                // Match octal numbers (&Oxxxxxx)
+                className: "number",
+                begin: "(&[oO][0-7]{1,6})"
             }
         ]
     };
-    DEFAULT.name = "Julia";
-    DEFAULT.contains = [
-        NUMBER,
-        CHAR,
-        STRING,
-        COMMAND,
-        MACROCALL,
-        COMMENT,
-        hljs.HASH_COMMENT_MODE,
-        {
-            className: "keyword",
-            begin: "\\b(((abstract|primitive)\\s+)type|(mutable\\s+)?struct)\\b"
-        },
-        {
-            begin: /<:/
-        } // relevance booster
-    ];
-    INTERPOLATION.contains = DEFAULT.contains;
-    return DEFAULT;
 }
-module.exports = $94afecd538db2fad$var$julia;
+module.exports = $8b4b36a5b3894e20$var$basic;
 
 });
 
@@ -12171,108 +11797,535 @@ parcelRegister("jAmEG", function(module, exports) {
         ],
         relevance: 0
     };
-    const OPERATION = {
-        className: "function",
-        begin: /:[\w\-.]+/,
+    const OPERATION = {
+        className: "function",
+        begin: /:[\w\-.]+/,
+        relevance: 0
+    };
+    const PATH = {
+        className: "string",
+        begin: /\B([\/.])[\w\-.\/=]+/
+    };
+    const COMMAND_PARAMS = {
+        className: "params",
+        begin: /--[\w\-=\/]+/
+    };
+    return {
+        name: "JBoss CLI",
+        aliases: [
+            "wildfly-cli"
+        ],
+        keywords: {
+            $pattern: "[a-z-]+",
+            keyword: "alias batch cd clear command connect connection-factory connection-info data-source deploy deployment-info deployment-overlay echo echo-dmr help history if jdbc-driver-info jms-queue|20 jms-topic|20 ls patch pwd quit read-attribute read-operation reload rollout-plan run-batch set shutdown try unalias undeploy unset version xa-data-source",
+            literal: "true false"
+        },
+        contains: [
+            hljs.HASH_COMMENT_MODE,
+            hljs.QUOTE_STRING_MODE,
+            COMMAND_PARAMS,
+            OPERATION,
+            PATH,
+            PARAMSBLOCK
+        ]
+    };
+}
+module.exports = $e422f3f054f79256$var$jbossCli;
+
+});
+
+parcelRegister("2Vkcl", function(module, exports) {
+/*
+Language: JSON
+Description: JSON (JavaScript Object Notation) is a lightweight data-interchange format.
+Author: Ivan Sagalaev <maniac@softwaremaniacs.org>
+Website: http://www.json.org
+Category: common, protocols
+*/ function $2210928d4eb08ac7$var$json(hljs) {
+    const LITERALS = {
+        literal: "true false null"
+    };
+    const ALLOWED_COMMENTS = [
+        hljs.C_LINE_COMMENT_MODE,
+        hljs.C_BLOCK_COMMENT_MODE
+    ];
+    const TYPES = [
+        hljs.QUOTE_STRING_MODE,
+        hljs.C_NUMBER_MODE
+    ];
+    const VALUE_CONTAINER = {
+        end: ",",
+        endsWithParent: true,
+        excludeEnd: true,
+        contains: TYPES,
+        keywords: LITERALS
+    };
+    const OBJECT = {
+        begin: /\{/,
+        end: /\}/,
+        contains: [
+            {
+                className: "attr",
+                begin: /"/,
+                end: /"/,
+                contains: [
+                    hljs.BACKSLASH_ESCAPE
+                ],
+                illegal: "\\n"
+            },
+            hljs.inherit(VALUE_CONTAINER, {
+                begin: /:/
+            })
+        ].concat(ALLOWED_COMMENTS),
+        illegal: "\\S"
+    };
+    const ARRAY = {
+        begin: "\\[",
+        end: "\\]",
+        contains: [
+            hljs.inherit(VALUE_CONTAINER)
+        ],
+        illegal: "\\S"
+    };
+    TYPES.push(OBJECT, ARRAY);
+    ALLOWED_COMMENTS.forEach(function(rule) {
+        TYPES.push(rule);
+    });
+    return {
+        name: "JSON",
+        contains: TYPES,
+        keywords: LITERALS,
+        illegal: "\\S"
+    };
+}
+module.exports = $2210928d4eb08ac7$var$json;
+
+});
+
+parcelRegister("cLsqx", function(module, exports) {
+/*
+Language: Julia
+Description: Julia is a high-level, high-performance, dynamic programming language.
+Author: Kenta Sato <bicycle1885@gmail.com>
+Contributors: Alex Arslan <ararslan@comcast.net>, Fredrik Ekre <ekrefredrik@gmail.com>
+Website: https://julialang.org
+*/ function $94afecd538db2fad$var$julia(hljs) {
+    // Since there are numerous special names in Julia, it is too much trouble
+    // to maintain them by hand. Hence these names (i.e. keywords, literals and
+    // built-ins) are automatically generated from Julia 1.5.2 itself through
+    // the following scripts for each.
+    // ref: https://docs.julialang.org/en/v1/manual/variables/#Allowed-Variable-Names
+    var VARIABLE_NAME_RE = "[A-Za-z_\\u00A1-\\uFFFF][A-Za-z_0-9\\u00A1-\\uFFFF]*";
+    // # keyword generator, multi-word keywords handled manually below (Julia 1.5.2)
+    // import REPL.REPLCompletions
+    // res = String["in", "isa", "where"]
+    // for kw in collect(x.keyword for x in REPLCompletions.complete_keyword(""))
+    //     if !(contains(kw, " ") || kw == "struct")
+    //         push!(res, kw)
+    //     end
+    // end
+    // sort!(unique!(res))
+    // foreach(x -> println("\'", x, "\',"), res)
+    var KEYWORD_LIST = [
+        "baremodule",
+        "begin",
+        "break",
+        "catch",
+        "ccall",
+        "const",
+        "continue",
+        "do",
+        "else",
+        "elseif",
+        "end",
+        "export",
+        "false",
+        "finally",
+        "for",
+        "function",
+        "global",
+        "if",
+        "import",
+        "in",
+        "isa",
+        "let",
+        "local",
+        "macro",
+        "module",
+        "quote",
+        "return",
+        "true",
+        "try",
+        "using",
+        "where",
+        "while"
+    ];
+    // # literal generator (Julia 1.5.2)
+    // import REPL.REPLCompletions
+    // res = String["true", "false"]
+    // for compl in filter!(x -> isa(x, REPLCompletions.ModuleCompletion) && (x.parent === Base || x.parent === Core),
+    //                     REPLCompletions.completions("", 0)[1])
+    //     try
+    //         v = eval(Symbol(compl.mod))
+    //         if !(v isa Function || v isa Type || v isa TypeVar || v isa Module || v isa Colon)
+    //             push!(res, compl.mod)
+    //         end
+    //     catch e
+    //     end
+    // end
+    // sort!(unique!(res))
+    // foreach(x -> println("\'", x, "\',"), res)
+    var LITERAL_LIST = [
+        "ARGS",
+        "C_NULL",
+        "DEPOT_PATH",
+        "ENDIAN_BOM",
+        "ENV",
+        "Inf",
+        "Inf16",
+        "Inf32",
+        "Inf64",
+        "InsertionSort",
+        "LOAD_PATH",
+        "MergeSort",
+        "NaN",
+        "NaN16",
+        "NaN32",
+        "NaN64",
+        "PROGRAM_FILE",
+        "QuickSort",
+        "RoundDown",
+        "RoundFromZero",
+        "RoundNearest",
+        "RoundNearestTiesAway",
+        "RoundNearestTiesUp",
+        "RoundToZero",
+        "RoundUp",
+        "VERSION|0",
+        "devnull",
+        "false",
+        "im",
+        "missing",
+        "nothing",
+        "pi",
+        "stderr",
+        "stdin",
+        "stdout",
+        "true",
+        "undef",
+        "\u03C0",
+        "\u212F"
+    ];
+    // # built_in generator (Julia 1.5.2)
+    // import REPL.REPLCompletions
+    // res = String[]
+    // for compl in filter!(x -> isa(x, REPLCompletions.ModuleCompletion) && (x.parent === Base || x.parent === Core),
+    //                     REPLCompletions.completions("", 0)[1])
+    //     try
+    //         v = eval(Symbol(compl.mod))
+    //         if (v isa Type || v isa TypeVar) && (compl.mod != "=>")
+    //             push!(res, compl.mod)
+    //         end
+    //     catch e
+    //     end
+    // end
+    // sort!(unique!(res))
+    // foreach(x -> println("\'", x, "\',"), res)
+    var BUILT_IN_LIST = [
+        "AbstractArray",
+        "AbstractChannel",
+        "AbstractChar",
+        "AbstractDict",
+        "AbstractDisplay",
+        "AbstractFloat",
+        "AbstractIrrational",
+        "AbstractMatrix",
+        "AbstractRange",
+        "AbstractSet",
+        "AbstractString",
+        "AbstractUnitRange",
+        "AbstractVecOrMat",
+        "AbstractVector",
+        "Any",
+        "ArgumentError",
+        "Array",
+        "AssertionError",
+        "BigFloat",
+        "BigInt",
+        "BitArray",
+        "BitMatrix",
+        "BitSet",
+        "BitVector",
+        "Bool",
+        "BoundsError",
+        "CapturedException",
+        "CartesianIndex",
+        "CartesianIndices",
+        "Cchar",
+        "Cdouble",
+        "Cfloat",
+        "Channel",
+        "Char",
+        "Cint",
+        "Cintmax_t",
+        "Clong",
+        "Clonglong",
+        "Cmd",
+        "Colon",
+        "Complex",
+        "ComplexF16",
+        "ComplexF32",
+        "ComplexF64",
+        "CompositeException",
+        "Condition",
+        "Cptrdiff_t",
+        "Cshort",
+        "Csize_t",
+        "Cssize_t",
+        "Cstring",
+        "Cuchar",
+        "Cuint",
+        "Cuintmax_t",
+        "Culong",
+        "Culonglong",
+        "Cushort",
+        "Cvoid",
+        "Cwchar_t",
+        "Cwstring",
+        "DataType",
+        "DenseArray",
+        "DenseMatrix",
+        "DenseVecOrMat",
+        "DenseVector",
+        "Dict",
+        "DimensionMismatch",
+        "Dims",
+        "DivideError",
+        "DomainError",
+        "EOFError",
+        "Enum",
+        "ErrorException",
+        "Exception",
+        "ExponentialBackOff",
+        "Expr",
+        "Float16",
+        "Float32",
+        "Float64",
+        "Function",
+        "GlobalRef",
+        "HTML",
+        "IO",
+        "IOBuffer",
+        "IOContext",
+        "IOStream",
+        "IdDict",
+        "IndexCartesian",
+        "IndexLinear",
+        "IndexStyle",
+        "InexactError",
+        "InitError",
+        "Int",
+        "Int128",
+        "Int16",
+        "Int32",
+        "Int64",
+        "Int8",
+        "Integer",
+        "InterruptException",
+        "InvalidStateException",
+        "Irrational",
+        "KeyError",
+        "LinRange",
+        "LineNumberNode",
+        "LinearIndices",
+        "LoadError",
+        "MIME",
+        "Matrix",
+        "Method",
+        "MethodError",
+        "Missing",
+        "MissingException",
+        "Module",
+        "NTuple",
+        "NamedTuple",
+        "Nothing",
+        "Number",
+        "OrdinalRange",
+        "OutOfMemoryError",
+        "OverflowError",
+        "Pair",
+        "PartialQuickSort",
+        "PermutedDimsArray",
+        "Pipe",
+        "ProcessFailedException",
+        "Ptr",
+        "QuoteNode",
+        "Rational",
+        "RawFD",
+        "ReadOnlyMemoryError",
+        "Real",
+        "ReentrantLock",
+        "Ref",
+        "Regex",
+        "RegexMatch",
+        "RoundingMode",
+        "SegmentationFault",
+        "Set",
+        "Signed",
+        "Some",
+        "StackOverflowError",
+        "StepRange",
+        "StepRangeLen",
+        "StridedArray",
+        "StridedMatrix",
+        "StridedVecOrMat",
+        "StridedVector",
+        "String",
+        "StringIndexError",
+        "SubArray",
+        "SubString",
+        "SubstitutionString",
+        "Symbol",
+        "SystemError",
+        "Task",
+        "TaskFailedException",
+        "Text",
+        "TextDisplay",
+        "Timer",
+        "Tuple",
+        "Type",
+        "TypeError",
+        "TypeVar",
+        "UInt",
+        "UInt128",
+        "UInt16",
+        "UInt32",
+        "UInt64",
+        "UInt8",
+        "UndefInitializer",
+        "UndefKeywordError",
+        "UndefRefError",
+        "UndefVarError",
+        "Union",
+        "UnionAll",
+        "UnitRange",
+        "Unsigned",
+        "Val",
+        "Vararg",
+        "VecElement",
+        "VecOrMat",
+        "Vector",
+        "VersionNumber",
+        "WeakKeyDict",
+        "WeakRef"
+    ];
+    var KEYWORDS = {
+        $pattern: VARIABLE_NAME_RE,
+        keyword: KEYWORD_LIST.join(" "),
+        literal: LITERAL_LIST.join(" "),
+        built_in: BUILT_IN_LIST.join(" ")
+    };
+    // placeholder for recursive self-reference
+    var DEFAULT = {
+        keywords: KEYWORDS,
+        illegal: /<\//
+    };
+    // ref: https://docs.julialang.org/en/v1/manual/integers-and-floating-point-numbers/
+    var NUMBER = {
+        className: "number",
+        // supported numeric literals:
+        //  * binary literal (e.g. 0x10)
+        //  * octal literal (e.g. 0o76543210)
+        //  * hexadecimal literal (e.g. 0xfedcba876543210)
+        //  * hexadecimal floating point literal (e.g. 0x1p0, 0x1.2p2)
+        //  * decimal literal (e.g. 9876543210, 100_000_000)
+        //  * floating pointe literal (e.g. 1.2, 1.2f, .2, 1., 1.2e10, 1.2e-10)
+        begin: /(\b0x[\d_]*(\.[\d_]*)?|0x\.\d[\d_]*)p[-+]?\d+|\b0[box][a-fA-F0-9][a-fA-F0-9_]*|(\b\d[\d_]*(\.[\d_]*)?|\.\d[\d_]*)([eEfF][-+]?\d+)?/,
         relevance: 0
     };
-    const PATH = {
+    var CHAR = {
         className: "string",
-        begin: /\B([\/.])[\w\-.\/=]+/
-    };
-    const COMMAND_PARAMS = {
-        className: "params",
-        begin: /--[\w\-=\/]+/
-    };
-    return {
-        name: "JBoss CLI",
-        aliases: [
-            "wildfly-cli"
-        ],
-        keywords: {
-            $pattern: "[a-z-]+",
-            keyword: "alias batch cd clear command connect connection-factory connection-info data-source deploy deployment-info deployment-overlay echo echo-dmr help history if jdbc-driver-info jms-queue|20 jms-topic|20 ls patch pwd quit read-attribute read-operation reload rollout-plan run-batch set shutdown try unalias undeploy unset version xa-data-source",
-            literal: "true false"
-        },
-        contains: [
-            hljs.HASH_COMMENT_MODE,
-            hljs.QUOTE_STRING_MODE,
-            COMMAND_PARAMS,
-            OPERATION,
-            PATH,
-            PARAMSBLOCK
-        ]
+        begin: /'(.|\\[xXuU][a-zA-Z0-9]+)'/
     };
-}
-module.exports = $e422f3f054f79256$var$jbossCli;
-
-});
-
-parcelRegister("2Vkcl", function(module, exports) {
-/*
-Language: JSON
-Description: JSON (JavaScript Object Notation) is a lightweight data-interchange format.
-Author: Ivan Sagalaev <maniac@softwaremaniacs.org>
-Website: http://www.json.org
-Category: common, protocols
-*/ function $2210928d4eb08ac7$var$json(hljs) {
-    const LITERALS = {
-        literal: "true false null"
+    var INTERPOLATION = {
+        className: "subst",
+        begin: /\$\(/,
+        end: /\)/,
+        keywords: KEYWORDS
     };
-    const ALLOWED_COMMENTS = [
-        hljs.C_LINE_COMMENT_MODE,
-        hljs.C_BLOCK_COMMENT_MODE
-    ];
-    const TYPES = [
-        hljs.QUOTE_STRING_MODE,
-        hljs.C_NUMBER_MODE
-    ];
-    const VALUE_CONTAINER = {
-        end: ",",
-        endsWithParent: true,
-        excludeEnd: true,
-        contains: TYPES,
-        keywords: LITERALS
+    var INTERPOLATED_VARIABLE = {
+        className: "variable",
+        begin: "\\$" + VARIABLE_NAME_RE
     };
-    const OBJECT = {
-        begin: /\{/,
-        end: /\}/,
+    // TODO: neatly escape normal code in string literal
+    var STRING = {
+        className: "string",
         contains: [
+            hljs.BACKSLASH_ESCAPE,
+            INTERPOLATION,
+            INTERPOLATED_VARIABLE
+        ],
+        variants: [
             {
-                className: "attr",
-                begin: /"/,
-                end: /"/,
-                contains: [
-                    hljs.BACKSLASH_ESCAPE
-                ],
-                illegal: "\\n"
+                begin: /\w*"""/,
+                end: /"""\w*/,
+                relevance: 10
             },
-            hljs.inherit(VALUE_CONTAINER, {
-                begin: /:/
-            })
-        ].concat(ALLOWED_COMMENTS),
-        illegal: "\\S"
+            {
+                begin: /\w*"/,
+                end: /"\w*/
+            }
+        ]
     };
-    const ARRAY = {
-        begin: "\\[",
-        end: "\\]",
+    var COMMAND = {
+        className: "string",
         contains: [
-            hljs.inherit(VALUE_CONTAINER)
+            hljs.BACKSLASH_ESCAPE,
+            INTERPOLATION,
+            INTERPOLATED_VARIABLE
         ],
-        illegal: "\\S"
+        begin: "`",
+        end: "`"
     };
-    TYPES.push(OBJECT, ARRAY);
-    ALLOWED_COMMENTS.forEach(function(rule) {
-        TYPES.push(rule);
-    });
-    return {
-        name: "JSON",
-        contains: TYPES,
-        keywords: LITERALS,
-        illegal: "\\S"
+    var MACROCALL = {
+        className: "meta",
+        begin: "@" + VARIABLE_NAME_RE
+    };
+    var COMMENT = {
+        className: "comment",
+        variants: [
+            {
+                begin: "#=",
+                end: "=#",
+                relevance: 10
+            },
+            {
+                begin: "#",
+                end: "$"
+            }
+        ]
     };
+    DEFAULT.name = "Julia";
+    DEFAULT.contains = [
+        NUMBER,
+        CHAR,
+        STRING,
+        COMMAND,
+        MACROCALL,
+        COMMENT,
+        hljs.HASH_COMMENT_MODE,
+        {
+            className: "keyword",
+            begin: "\\b(((abstract|primitive)\\s+)type|(mutable\\s+)?struct)\\b"
+        },
+        {
+            begin: /<:/
+        } // relevance booster
+    ];
+    INTERPOLATION.contains = DEFAULT.contains;
+    return DEFAULT;
 }
-module.exports = $2210928d4eb08ac7$var$json;
+module.exports = $94afecd538db2fad$var$julia;
 
 });
 
@@ -12576,47 +12629,217 @@ var $99c6c365e621081e$var$NUMERIC = {
                 ]
             },
             {
-                className: "class",
-                beginKeywords: "class interface trait",
-                end: /[:\{(]|$/,
-                excludeEnd: true,
-                illegal: "extends implements",
-                contains: [
-                    {
-                        beginKeywords: "public protected internal private constructor"
-                    },
-                    hljs.UNDERSCORE_TITLE_MODE,
-                    {
-                        className: "type",
-                        begin: /</,
-                        end: />/,
-                        excludeBegin: true,
-                        excludeEnd: true,
-                        relevance: 0
-                    },
-                    {
-                        className: "type",
-                        begin: /[,:]\s*/,
-                        end: /[<\(,]|$/,
-                        excludeBegin: true,
-                        returnEnd: true
-                    },
-                    ANNOTATION_USE_SITE,
-                    ANNOTATION
-                ]
+                className: "class",
+                beginKeywords: "class interface trait",
+                end: /[:\{(]|$/,
+                excludeEnd: true,
+                illegal: "extends implements",
+                contains: [
+                    {
+                        beginKeywords: "public protected internal private constructor"
+                    },
+                    hljs.UNDERSCORE_TITLE_MODE,
+                    {
+                        className: "type",
+                        begin: /</,
+                        end: />/,
+                        excludeBegin: true,
+                        excludeEnd: true,
+                        relevance: 0
+                    },
+                    {
+                        className: "type",
+                        begin: /[,:]\s*/,
+                        end: /[<\(,]|$/,
+                        excludeBegin: true,
+                        returnEnd: true
+                    },
+                    ANNOTATION_USE_SITE,
+                    ANNOTATION
+                ]
+            },
+            STRING,
+            {
+                className: "meta",
+                begin: "^#!/usr/bin/env",
+                end: "$",
+                illegal: "\n"
+            },
+            KOTLIN_NUMBER_MODE
+        ]
+    };
+}
+module.exports = $99c6c365e621081e$var$kotlin;
+
+});
+
+parcelRegister("gQ9UJ", function(module, exports) {
+/*
+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
+*/ function $c4293165dc24b1d7$var$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: "`"
+        },
+        {
+            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: {
+                    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\\]",
+                    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)
+                }
             },
-            STRING,
             {
                 className: "meta",
-                begin: "^#!/usr/bin/env",
-                end: "$",
-                illegal: "\n"
+                begin: "\\[",
+                relevance: 0
             },
-            KOTLIN_NUMBER_MODE
-        ]
+            {
+                className: "meta",
+                begin: "^#!",
+                end: "lasso9$",
+                relevance: 10
+            }
+        ].concat(LASSO_CODE)
     };
 }
-module.exports = $99c6c365e621081e$var$kotlin;
+module.exports = $c4293165dc24b1d7$var$lasso;
 
 });
 
@@ -25920,35 +26143,146 @@ module.exports = $bd2e259dd188e4ad$var$sas;
 
 });
 
-parcelRegister("4y9fC", function(module, exports) {
+parcelRegister("gd4OW", function(module, exports) {
 /*
-Language: Shell Session
-Requires: bash.js
-Author: TSUYUSATO Kitsune <make.just.on@gmail.com>
-Category: common
-Audit: 2020
-*/ /** @type LanguageFn */ function $3501837396ea252e$var$shell(hljs) {
-    return {
-        name: "Shell Session",
-        aliases: [
-            "console"
-        ],
-        contains: [
+Language: Scala
+Category: functional
+Author: Jan Berkel <jan.berkel@gmail.com>
+Contributors: Erik Osheim <d_m@plastic-idolatry.com>
+Website: https://www.scala-lang.org
+*/ function $bcd19983c3eb4916$var$scala(hljs) {
+    const ANNOTATION = {
+        className: "meta",
+        begin: "@[A-Za-z]+"
+    };
+    // used in strings for escaping/interpolation/substitution
+    const SUBST = {
+        className: "subst",
+        variants: [
             {
-                className: "meta",
-                // We cannot add \s (spaces) in the regular expression otherwise it will be too broad and produce unexpected result.
-                // For instance, in the following example, it would match "echo /path/to/home >" as a prompt:
-                // echo /path/to/home > t.exe
-                begin: /^\s{0,3}[/~\w\d[\]()@-]*[>%$#]/,
-                starts: {
-                    end: /[^\\](?=\s*$)/,
-                    subLanguage: "bash"
-                }
+                begin: "\\$[A-Za-z0-9_]+"
+            },
+            {
+                begin: /\$\{/,
+                end: /\}/
+            }
+        ]
+    };
+    const STRING = {
+        className: "string",
+        variants: [
+            {
+                begin: '"',
+                end: '"',
+                illegal: "\\n",
+                contains: [
+                    hljs.BACKSLASH_ESCAPE
+                ]
+            },
+            {
+                begin: '"""',
+                end: '"""',
+                relevance: 10
+            },
+            {
+                begin: '[a-z]+"',
+                end: '"',
+                illegal: "\\n",
+                contains: [
+                    hljs.BACKSLASH_ESCAPE,
+                    SUBST
+                ]
+            },
+            {
+                className: "string",
+                begin: '[a-z]+"""',
+                end: '"""',
+                contains: [
+                    SUBST
+                ],
+                relevance: 10
             }
         ]
     };
+    const SYMBOL = {
+        className: "symbol",
+        begin: "'\\w[\\w\\d_]*(?!')"
+    };
+    const TYPE = {
+        className: "type",
+        begin: "\\b[A-Z][A-Za-z0-9_]*",
+        relevance: 0
+    };
+    const NAME = {
+        className: "title",
+        begin: /[^0-9\n\t "'(),.`{}\[\]:;][^\n\t "'(),.`{}\[\]:;]+|[^0-9\n\t "'(),.`{}\[\]:;=]/,
+        relevance: 0
+    };
+    const CLASS = {
+        className: "class",
+        beginKeywords: "class object trait type",
+        end: /[:={\[\n;]/,
+        excludeEnd: true,
+        contains: [
+            hljs.C_LINE_COMMENT_MODE,
+            hljs.C_BLOCK_COMMENT_MODE,
+            {
+                beginKeywords: "extends with",
+                relevance: 10
+            },
+            {
+                begin: /\[/,
+                end: /\]/,
+                excludeBegin: true,
+                excludeEnd: true,
+                relevance: 0,
+                contains: [
+                    TYPE
+                ]
+            },
+            {
+                className: "params",
+                begin: /\(/,
+                end: /\)/,
+                excludeBegin: true,
+                excludeEnd: true,
+                relevance: 0,
+                contains: [
+                    TYPE
+                ]
+            },
+            NAME
+        ]
+    };
+    const METHOD = {
+        className: "function",
+        beginKeywords: "def",
+        end: /[:={\[(\n;]/,
+        excludeEnd: true,
+        contains: [
+            NAME
+        ]
+    };
+    return {
+        name: "Scala",
+        keywords: {
+            literal: "true false null",
+            keyword: "type yield lazy override def with val var sealed abstract private trait object if forSome for while throw finally protected extends import final return else break new catch super class case package default try this match continue throws implicit"
+        },
+        contains: [
+            hljs.C_LINE_COMMENT_MODE,
+            hljs.C_BLOCK_COMMENT_MODE,
+            STRING,
+            SYMBOL,
+            TYPE,
+            METHOD,
+            CLASS,
+            hljs.C_NUMBER_MODE,
+            ANNOTATION
+        ]
+    };
 }
-module.exports = $3501837396ea252e$var$shell;
+module.exports = $bcd19983c3eb4916$var$scala;
 
 });
 
@@ -26306,6 +26640,38 @@ module.exports = $9be3819e1d7933c2$var$scss;
 
 });
 
+parcelRegister("4y9fC", function(module, exports) {
+/*
+Language: Shell Session
+Requires: bash.js
+Author: TSUYUSATO Kitsune <make.just.on@gmail.com>
+Category: common
+Audit: 2020
+*/ /** @type LanguageFn */ function $3501837396ea252e$var$shell(hljs) {
+    return {
+        name: "Shell Session",
+        aliases: [
+            "console"
+        ],
+        contains: [
+            {
+                className: "meta",
+                // We cannot add \s (spaces) in the regular expression otherwise it will be too broad and produce unexpected result.
+                // For instance, in the following example, it would match "echo /path/to/home >" as a prompt:
+                // echo /path/to/home > t.exe
+                begin: /^\s{0,3}[/~\w\d[\]()@-]*[>%$#]/,
+                starts: {
+                    end: /[^\\](?=\s*$)/,
+                    subLanguage: "bash"
+                }
+            }
+        ]
+    };
+}
+module.exports = $3501837396ea252e$var$shell;
+
+});
+
 parcelRegister("g3mE4", function(module, exports) {
 /*
 Language: Smali
@@ -34397,7 +34763,7 @@ $9baaebd05a4e0c25$exports.registerLanguage("axapta", (parcelRequire("2kyoL")));
 
 $9baaebd05a4e0c25$exports.registerLanguage("bash", (parcelRequire("f4C7M")));
 
-$9baaebd05a4e0c25$exports.registerLanguage("basic", $c2e98e78b0affb4c$import$d3af507014bccb08);
+$9baaebd05a4e0c25$exports.registerLanguage("basic", (parcelRequire("bXsnb")));
 
 $9baaebd05a4e0c25$exports.registerLanguage("bnf", (parcelRequire("kbrFI")));
 
@@ -34543,7 +34909,7 @@ $9baaebd05a4e0c25$exports.registerLanguage("julia-repl", (parcelRequire("dut0F")
 
 $9baaebd05a4e0c25$exports.registerLanguage("kotlin", (parcelRequire("dcxZy")));
 
-$9baaebd05a4e0c25$exports.registerLanguage("lasso", $c2e98e78b0affb4c$import$ff18e155da20a110);
+$9baaebd05a4e0c25$exports.registerLanguage("lasso", (parcelRequire("gQ9UJ")));
 
 $9baaebd05a4e0c25$exports.registerLanguage("latex", (parcelRequire("Hvsp9")));
 
@@ -34664,7 +35030,7 @@ $9baaebd05a4e0c25$exports.registerLanguage("rust", (parcelRequire("5ve2q")));
 
 $9baaebd05a4e0c25$exports.registerLanguage("sas", (parcelRequire("gf082")));
 
-$9baaebd05a4e0c25$exports.registerLanguage("scala", $c2e98e78b0affb4c$import$f30d2cb50052b6e9);
+$9baaebd05a4e0c25$exports.registerLanguage("scala", (parcelRequire("gd4OW")));
 
 $9baaebd05a4e0c25$exports.registerLanguage("scheme", (parcelRequire("ceY6a")));