zyAdmin/node_modules/monaco-editor/dev/vs/basic-languages/julia/julia.js

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define('vs/basic-languages/julia/julia',["require", "exports"], function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.language = exports.conf = void 0;
    exports.conf = {
        brackets: [
            ['{', '}'],
            ['[', ']'],
            ['(', ')']
        ],
        autoClosingPairs: [
            { open: '{', close: '}' },
            { open: '[', close: ']' },
            { open: '(', close: ')' },
            { open: '"', close: '"' },
            { open: "'", close: "'" }
        ],
        surroundingPairs: [
            { open: '{', close: '}' },
            { open: '[', close: ']' },
            { open: '(', close: ')' },
            { open: '"', close: '"' },
            { open: "'", close: "'" }
        ]
    };
    exports.language = {
        tokenPostfix: '.julia',
        keywords: [
            'begin',
            'while',
            'if',
            'for',
            'try',
            'return',
            'break',
            'continue',
            'function',
            'macro',
            'quote',
            'let',
            'local',
            'global',
            'const',
            'do',
            'struct',
            'module',
            'baremodule',
            'using',
            'import',
            'export',
            'end',
            'else',
            'elseif',
            'catch',
            'finally',
            'mutable',
            'primitive',
            'abstract',
            'type',
            'in',
            'isa',
            'where',
            'new'
        ],
        types: [
            'LinRange',
            'LineNumberNode',
            'LinearIndices',
            'LoadError',
            'MIME',
            'Matrix',
            'Method',
            'MethodError',
            'Missing',
            'MissingException',
            'Module',
            'NTuple',
            'NamedTuple',
            'Nothing',
            'Number',
            'OrdinalRange',
            'OutOfMemoryError',
            'OverflowError',
            'Pair',
            'PartialQuickSort',
            'PermutedDimsArray',
            'Pipe',
            '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',
            'Text',
            'TextDisplay',
            'Timer',
            'Tuple',
            'Type',
            'TypeError',
            'TypeVar',
            'UInt',
            'UInt128',
            'UInt16',
            'UInt32',
            'UInt64',
            'UInt8',
            'UndefInitializer',
            'AbstractArray',
            'UndefKeywordError',
            'AbstractChannel',
            'UndefRefError',
            'AbstractChar',
            'UndefVarError',
            'AbstractDict',
            'Union',
            'AbstractDisplay',
            'UnionAll',
            'AbstractFloat',
            'UnitRange',
            'AbstractIrrational',
            'Unsigned',
            'AbstractMatrix',
            'AbstractRange',
            'Val',
            'AbstractSet',
            'Vararg',
            'AbstractString',
            'VecElement',
            'AbstractUnitRange',
            'VecOrMat',
            'AbstractVecOrMat',
            'Vector',
            'AbstractVector',
            'VersionNumber',
            'Any',
            'WeakKeyDict',
            'ArgumentError',
            'WeakRef',
            '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'
        ],
        keywordops: ['<:', '>:', ':', '=>', '...', '.', '->', '?'],
        allops: /[^\w\d\s()\[\]{}"'#]+/,
        constants: [
            'true',
            'false',
            'nothing',
            'missing',
            'undef',
            'Inf',
            'pi',
            'NaN',
            'π',
            'ℯ',
            'ans',
            'PROGRAM_FILE',
            'ARGS',
            'C_NULL',
            'VERSION',
            'DEPOT_PATH',
            'LOAD_PATH'
        ],
        operators: [
            '!',
            '!=',
            '!==',
            '%',
            '&',
            '*',
            '+',
            '-',
            '/',
            '//',
            '<',
            '<<',
            '<=',
            '==',
            '===',
            '=>',
            '>',
            '>=',
            '>>',
            '>>>',
            '\\',
            '^',
            '|',
            '|>',
            '~',
            '÷',
            '∈',
            '∉',
            '∋',
            '∌',
            '∘',
            '√',
            '∛',
            '∩',
            '∪',
            '≈',
            '≉',
            '≠',
            '≡',
            '≢',
            '≤',
            '≥',
            '⊆',
            '⊇',
            '⊈',
            '⊉',
            '⊊',
            '⊋',
            '⊻'
        ],
        brackets: [
            { open: '(', close: ')', token: 'delimiter.parenthesis' },
            { open: '{', close: '}', token: 'delimiter.curly' },
            { open: '[', close: ']', token: 'delimiter.square' }
        ],
        ident: /π|ℯ|\b(?!\d)\w+\b/,
        // escape sequences
        escape: /(?:[abefnrstv\\"'\n\r]|[0-7]{1,3}|x[0-9A-Fa-f]{1,2}|u[0-9A-Fa-f]{4})/,
        escapes: /\\(?:C\-(@escape|.)|c(@escape|.)|@escape)/,
        // The main tokenizer for our languages
        tokenizer: {
            root: [
                [/(::)\s*|\b(isa)\s+/, 'keyword', '@typeanno'],
                [/\b(isa)(\s*\(@ident\s*,\s*)/, ['keyword', { token: '', next: '@typeanno' }]],
                [/\b(type|struct)[ \t]+/, 'keyword', '@typeanno'],
                // symbols
                [/^\s*:@ident[!?]?/, 'metatag'],
                [/(return)(\s*:@ident[!?]?)/, ['keyword', 'metatag']],
                [/(\(|\[|\{|@allops)(\s*:@ident[!?]?)/, ['', 'metatag']],
                [/:\(/, 'metatag', '@quote'],
                // regular expressions
                [/r"""/, 'regexp.delim', '@tregexp'],
                [/r"/, 'regexp.delim', '@sregexp'],
                // strings
                [/raw"""/, 'string.delim', '@rtstring'],
                [/[bv]?"""/, 'string.delim', '@dtstring'],
                [/raw"/, 'string.delim', '@rsstring'],
                [/[bv]?"/, 'string.delim', '@dsstring'],
                [
                    /(@ident)\{/,
                    {
                        cases: {
                            '$1@types': { token: 'type', next: '@gen' },
                            '@default': { token: 'type', next: '@gen' }
                        }
                    }
                ],
                [
                    /@ident[!?'']?(?=\.?\()/,
                    {
                        cases: {
                            '@types': 'type',
                            '@keywords': 'keyword',
                            '@constants': 'variable',
                            '@default': 'keyword.flow'
                        }
                    }
                ],
                [
                    /@ident[!?']?/,
                    {
                        cases: {
                            '@types': 'type',
                            '@keywords': 'keyword',
                            '@constants': 'variable',
                            '@default': 'identifier'
                        }
                    }
                ],
                [/\$\w+/, 'key'],
                [/\$\(/, 'key', '@paste'],
                [/@@@ident/, 'annotation'],
                // whitespace
                { include: '@whitespace' },
                // characters
                [/'(?:@escapes|.)'/, 'string.character'],
                // delimiters and operators
                [/[()\[\]{}]/, '@brackets'],
                [
                    /@allops/,
                    {
                        cases: {
                            '@keywordops': 'keyword',
                            '@operators': 'operator'
                        }
                    }
                ],
                [/[;,]/, 'delimiter'],
                // numbers
                [/0[xX][0-9a-fA-F](_?[0-9a-fA-F])*/, 'number.hex'],
                [/0[_oO][0-7](_?[0-7])*/, 'number.octal'],
                [/0[bB][01](_?[01])*/, 'number.binary'],
                [/[+\-]?\d+(\.\d+)?(im?|[eE][+\-]?\d+(\.\d+)?)?/, 'number']
            ],
            // type
            typeanno: [
                [/[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*\{/, 'type', '@gen'],
                [/([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)(\s*<:\s*)/, ['type', 'keyword']],
                [/[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*/, 'type', '@pop'],
                ['', '', '@pop']
            ],
            // generic type
            gen: [
                [/[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*\{/, 'type', '@push'],
                [/[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*/, 'type'],
                [/<:/, 'keyword'],
                [/(\})(\s*<:\s*)/, ['type', { token: 'keyword', next: '@pop' }]],
                [/\}/, 'type', '@pop'],
                { include: '@root' }
            ],
            // $(...)
            quote: [
                [/\$\(/, 'key', '@paste'],
                [/\(/, '@brackets', '@paren'],
                [/\)/, 'metatag', '@pop'],
                { include: '@root' }
            ],
            // :(...)
            paste: [
                [/:\(/, 'metatag', '@quote'],
                [/\(/, '@brackets', '@paren'],
                [/\)/, 'key', '@pop'],
                { include: '@root' }
            ],
            // (...)
            paren: [
                [/\$\(/, 'key', '@paste'],
                [/:\(/, 'metatag', '@quote'],
                [/\(/, '@brackets', '@push'],
                [/\)/, '@brackets', '@pop'],
                { include: '@root' }
            ],
            // r"egex string"
            sregexp: [
                [/^.*/, 'invalid'],
                [/[^\\"()\[\]{}]/, 'regexp'],
                [/[()\[\]{}]/, '@brackets'],
                [/\\./, 'operator.scss'],
                [/"[imsx]*/, 'regexp.delim', '@pop']
            ],
            tregexp: [
                [/[^\\"()\[\]{}]/, 'regexp'],
                [/[()\[\]{}]/, '@brackets'],
                [/\\./, 'operator.scss'],
                [/"(?!"")/, 'string'],
                [/"""[imsx]*/, 'regexp.delim', '@pop']
            ],
            // raw"string"
            rsstring: [
                [/^.*/, 'invalid'],
                [/[^\\"]/, 'string'],
                [/\\./, 'string.escape'],
                [/"/, 'string.delim', '@pop']
            ],
            rtstring: [
                [/[^\\"]/, 'string'],
                [/\\./, 'string.escape'],
                [/"(?!"")/, 'string'],
                [/"""/, 'string.delim', '@pop']
            ],
            // "string".
            dsstring: [
                [/^.*/, 'invalid'],
                [/[^\\"\$]/, 'string'],
                [/\$/, '', '@interpolated'],
                [/@escapes/, 'string.escape'],
                [/\\./, 'string.escape.invalid'],
                [/"/, 'string.delim', '@pop']
            ],
            dtstring: [
                [/[^\\"\$]/, 'string'],
                [/\$/, '', '@interpolated'],
                [/@escapes/, 'string.escape'],
                [/\\./, 'string.escape.invalid'],
                [/"(?!"")/, 'string'],
                [/"""/, 'string.delim', '@pop']
            ],
            // interpolated sequence
            interpolated: [
                [/\(/, { token: '', switchTo: '@interpolated_compound' }],
                [/[a-zA-Z_]\w*/, 'identifier'],
                ['', '', '@pop'] // just a $ is interpreted as a $
            ],
            // any code
            interpolated_compound: [[/\)/, '', '@pop'], { include: '@root' }],
            // whitespace & comments
            whitespace: [
                [/[ \t\r\n]+/, ''],
                [/#=/, 'comment', '@multi_comment'],
                [/#.*$/, 'comment']
            ],
            multi_comment: [
                [/#=/, 'comment', '@push'],
                [/=#/, 'comment', '@pop'],
                [/=(?!#)|#(?!=)/, 'comment'],
                [/[^#=]+/, 'comment']
            ]
        }
    };
});