update route and bug“

This commit is contained in:
caishi 2024-05-16 16:05:42 +08:00
parent 41c7db9ca1
commit 97f09f9562
82 changed files with 616728 additions and 3 deletions

271
24.97d25b5f.async.js Normal file
View File

@ -0,0 +1,271 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[24,82],{
/***/ "7Xl7":
/*!************************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/javascript/javascript.js ***!
\************************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/javascript/javascript.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/* harmony import */ var _typescript_typescript_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../typescript/typescript.js */ "87dK");
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
// Allow for running under nodejs/requirejs in tests
var _monaco = (typeof monaco === 'undefined' ? self.monaco : monaco);
var conf = _typescript_typescript_js__WEBPACK_IMPORTED_MODULE_0__["conf"];
var language = {
// Set defaultToken to invalid to see what you do not tokenize yet
defaultToken: 'invalid',
tokenPostfix: '.js',
keywords: [
'break', 'case', 'catch', 'class', 'continue', 'const',
'constructor', 'debugger', 'default', 'delete', 'do', 'else',
'export', 'extends', 'false', 'finally', 'for', 'from', 'function',
'get', 'if', 'import', 'in', 'instanceof', 'let', 'new', 'null',
'return', 'set', 'super', 'switch', 'symbol', 'this', 'throw', 'true',
'try', 'typeof', 'undefined', 'var', 'void', 'while', 'with', 'yield',
'async', 'await', 'of'
],
typeKeywords: [],
operators: _typescript_typescript_js__WEBPACK_IMPORTED_MODULE_0__["language"].operators,
symbols: _typescript_typescript_js__WEBPACK_IMPORTED_MODULE_0__["language"].symbols,
escapes: _typescript_typescript_js__WEBPACK_IMPORTED_MODULE_0__["language"].escapes,
digits: _typescript_typescript_js__WEBPACK_IMPORTED_MODULE_0__["language"].digits,
octaldigits: _typescript_typescript_js__WEBPACK_IMPORTED_MODULE_0__["language"].octaldigits,
binarydigits: _typescript_typescript_js__WEBPACK_IMPORTED_MODULE_0__["language"].binarydigits,
hexdigits: _typescript_typescript_js__WEBPACK_IMPORTED_MODULE_0__["language"].hexdigits,
regexpctl: _typescript_typescript_js__WEBPACK_IMPORTED_MODULE_0__["language"].regexpctl,
regexpesc: _typescript_typescript_js__WEBPACK_IMPORTED_MODULE_0__["language"].regexpesc,
tokenizer: _typescript_typescript_js__WEBPACK_IMPORTED_MODULE_0__["language"].tokenizer,
};
/***/ }),
/***/ "87dK":
/*!************************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/typescript/typescript.js ***!
\************************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/typescript/typescript.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
// Allow for running under nodejs/requirejs in tests
var _monaco = (typeof monaco === 'undefined' ? self.monaco : monaco);
var conf = {
wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
comments: {
lineComment: '//',
blockComment: ['/*', '*/']
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
onEnterRules: [
{
// e.g. /** | */
beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
afterText: /^\s*\*\/$/,
action: { indentAction: _monaco.languages.IndentAction.IndentOutdent, appendText: ' * ' }
},
{
// e.g. /** ...|
beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
action: { indentAction: _monaco.languages.IndentAction.None, appendText: ' * ' }
},
{
// e.g. * ...|
beforeText: /^(\t|(\ \ ))*\ \*(\ ([^\*]|\*(?!\/))*)?$/,
action: { indentAction: _monaco.languages.IndentAction.None, appendText: '* ' }
},
{
// e.g. */|
beforeText: /^(\t|(\ \ ))*\ \*\/\s*$/,
action: { indentAction: _monaco.languages.IndentAction.None, removeText: 1 }
}
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"', notIn: ['string'] },
{ open: '\'', close: '\'', notIn: ['string', 'comment'] },
{ open: '`', close: '`', notIn: ['string', 'comment'] },
{ open: "/**", close: " */", notIn: ["string"] }
],
folding: {
markers: {
start: new RegExp("^\\s*//\\s*#?region\\b"),
end: new RegExp("^\\s*//\\s*#?endregion\\b")
}
}
};
var language = {
// Set defaultToken to invalid to see what you do not tokenize yet
defaultToken: 'invalid',
tokenPostfix: '.ts',
keywords: [
'abstract', 'as', 'break', 'case', 'catch', 'class', 'continue', 'const',
'constructor', 'debugger', 'declare', 'default', 'delete', 'do', 'else',
'enum', 'export', 'extends', 'false', 'finally', 'for', 'from', 'function',
'get', 'if', 'implements', 'import', 'in', 'infer', 'instanceof', 'interface',
'is', 'keyof', 'let', 'module', 'namespace', 'never', 'new', 'null', 'package',
'private', 'protected', 'public', 'readonly', 'require', 'global', 'return',
'set', 'static', 'super', 'switch', 'symbol', 'this', 'throw', 'true', 'try',
'type', 'typeof', 'unique', 'var', 'void', 'while', 'with', 'yield', 'async',
'await', 'of'
],
typeKeywords: [
'any', 'boolean', 'number', 'object', 'string', 'undefined'
],
operators: [
'<=', '>=', '==', '!=', '===', '!==', '=>', '+', '-', '**',
'*', '/', '%', '++', '--', '<<', '</', '>>', '>>>', '&',
'|', '^', '!', '~', '&&', '||', '??', '?', ':', '=', '+=', '-=',
'*=', '**=', '/=', '%=', '<<=', '>>=', '>>>=', '&=', '|=',
'^=', '@',
],
// we include these common regular expressions
symbols: /[=><!~?:&|+\-*\/\^%]+/,
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
digits: /\d+(_+\d+)*/,
octaldigits: /[0-7]+(_+[0-7]+)*/,
binarydigits: /[0-1]+(_+[0-1]+)*/,
hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
regexpesc: /\\(?:[bBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})/,
// The main tokenizer for our languages
tokenizer: {
root: [
[/[{}]/, 'delimiter.bracket'],
{ include: 'common' }
],
common: [
// identifiers and keywords
[/[a-z_$][\w$]*/, {
cases: {
'@typeKeywords': 'keyword',
'@keywords': 'keyword',
'@default': 'identifier'
}
}],
[/[A-Z][\w\$]*/, 'type.identifier'],
// [/[A-Z][\w\$]*/, 'identifier'],
// whitespace
{ include: '@whitespace' },
// regular expression: ensure it is terminated before beginning (otherwise it is an opeator)
[/\/(?=([^\\\/]|\\.)+\/([gimsuy]*)(\s*)(\.|;|,|\)|\]|\}|$))/, { token: 'regexp', bracket: '@open', next: '@regexp' }],
// delimiters and operators
[/[()\[\]]/, '@brackets'],
[/[<>](?!@symbols)/, '@brackets'],
[/!(?=([^=]|$))/, 'delimiter'],
[/@symbols/, {
cases: {
'@operators': 'delimiter',
'@default': ''
}
}],
// numbers
[/(@digits)[eE]([\-+]?(@digits))?/, 'number.float'],
[/(@digits)\.(@digits)([eE][\-+]?(@digits))?/, 'number.float'],
[/0[xX](@hexdigits)n?/, 'number.hex'],
[/0[oO]?(@octaldigits)n?/, 'number.octal'],
[/0[bB](@binarydigits)n?/, 'number.binary'],
[/(@digits)n?/, 'number'],
// delimiter: after number because of .\d floats
[/[;,.]/, 'delimiter'],
// strings
[/"([^"\\]|\\.)*$/, 'string.invalid'],
[/'([^'\\]|\\.)*$/, 'string.invalid'],
[/"/, 'string', '@string_double'],
[/'/, 'string', '@string_single'],
[/`/, 'string', '@string_backtick'],
],
whitespace: [
[/[ \t\r\n]+/, ''],
[/\/\*\*(?!\/)/, 'comment.doc', '@jsdoc'],
[/\/\*/, 'comment', '@comment'],
[/\/\/.*$/, 'comment'],
],
comment: [
[/[^\/*]+/, 'comment'],
[/\*\//, 'comment', '@pop'],
[/[\/*]/, 'comment']
],
jsdoc: [
[/[^\/*]+/, 'comment.doc'],
[/\*\//, 'comment.doc', '@pop'],
[/[\/*]/, 'comment.doc']
],
// We match regular expression quite precisely
regexp: [
[/(\{)(\d+(?:,\d*)?)(\})/, ['regexp.escape.control', 'regexp.escape.control', 'regexp.escape.control']],
[/(\[)(\^?)(?=(?:[^\]\\\/]|\\.)+)/, ['regexp.escape.control', { token: 'regexp.escape.control', next: '@regexrange' }]],
[/(\()(\?:|\?=|\?!)/, ['regexp.escape.control', 'regexp.escape.control']],
[/[()]/, 'regexp.escape.control'],
[/@regexpctl/, 'regexp.escape.control'],
[/[^\\\/]/, 'regexp'],
[/@regexpesc/, 'regexp.escape'],
[/\\\./, 'regexp.invalid'],
[/(\/)([gimsuy]*)/, [{ token: 'regexp', bracket: '@close', next: '@pop' }, 'keyword.other']],
],
regexrange: [
[/-/, 'regexp.escape.control'],
[/\^/, 'regexp.invalid'],
[/@regexpesc/, 'regexp.escape'],
[/[^\]]/, 'regexp'],
[/\]/, { token: 'regexp.escape.control', next: '@pop', bracket: '@close' }]
],
string_double: [
[/[^\\"]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/"/, 'string', '@pop']
],
string_single: [
[/[^\\']+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/'/, 'string', '@pop']
],
string_backtick: [
[/\$\{/, { token: 'delimiter.bracket', next: '@bracketCounting' }],
[/[^\\`$]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/`/, 'string', '@pop']
],
bracketCounting: [
[/\{/, 'delimiter.bracket', '@bracketCounting'],
[/\}/, 'delimiter.bracket', '@pop'],
{ include: 'common' }
],
},
};
/***/ })
}]);

34999
25.104e44fd.async.js Normal file

File diff suppressed because it is too large Load Diff

18533
26.503de7ed.async.js Normal file

File diff suppressed because one or more lines are too long

8878
27.1a3bc7c7.async.js Normal file

File diff suppressed because it is too large Load Diff

114
28.943cc97a.async.js Normal file
View File

@ -0,0 +1,114 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[28],{
/***/ "6Xso":
/*!************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/abap/abap.js ***!
\************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/abap/abap.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '*',
},
brackets: [
['[', ']'],
['(', ')']
],
};
var abapKeywords = [
'abstract', 'add', 'add-corresponding', 'adjacent', 'alias', 'aliases', 'all', 'append', 'appending', 'ascending', 'as', 'assert', 'assign', 'assigned', 'assigning', 'association', 'authority-check',
'back', 'begin', 'binary', 'block', 'bound', 'break-point', 'by', 'byte',
'class', 'call', 'cast', 'changing', 'check', 'class-data', 'class-method', 'class-methods', 'clear', 'close', 'cnt', 'collect', 'commit', 'cond', 'character',
'corresponding', 'communication', 'component', 'compute', 'concatenate', 'condense', 'constants', 'conv', 'count',
'controls', 'convert', 'create', 'currency',
'data', 'descending', 'default', 'define', 'deferred', 'delete', 'describe', 'detail', 'display', 'divide', 'divide-corresponding', 'display-mode', 'duplicates',
'deleting',
'editor-call', 'end', 'endexec', 'endfunction', 'ending', 'endmodule', 'end-of-definition', 'end-of-page', 'end-of-selection', 'end-test-injection', 'end-test-seam', 'exit-command', 'endclass', 'endmethod', 'endform', 'endinterface',
'endprovide', 'endselect', 'endtry', 'endwhile', 'enum', 'event', 'events', 'exec', 'exit', 'export',
'exporting', 'extract', 'exception', 'exceptions',
'field-symbols', 'field-groups', 'field', 'first', 'fetch', 'fields', 'format', 'frame', 'free', 'from', 'function', 'find', 'for', 'found', 'function-pool',
'generate', 'get',
'handle', 'hide', 'hashed',
'include', 'import', 'importing', 'index', 'infotypes', 'initial', 'initialization',
'id', 'is', 'in', 'interface', 'interfaces', 'init', 'input', 'insert', 'instance', 'into',
'key',
'left-justified', 'leave', 'like', 'line', 'line-count', 'line-size', 'load', 'local', 'log-point', 'length', 'left', 'leading', 'lower',
'matchcode', 'method', 'mesh', 'message', 'message-id', 'methods', 'modify', 'module', 'move', 'move-corresponding', 'multiply', 'multiply-corresponding', 'match',
'new', 'new-line', 'new-page', 'new-section', 'next', 'no', 'no-gap', 'no-gaps', 'no-sign', 'no-zero', 'non-unique', 'number',
'occurrence', 'object', 'obligatory', 'of', 'output', 'overlay', 'optional', 'others', 'occurrences', 'occurs', 'offset', 'options',
'pack', 'parameters', 'perform', 'places', 'position', 'print-control', 'private', 'program', 'protected', 'provide', 'public', 'put',
'radiobutton', 'raising', 'ranges', 'receive', 'receiving', 'redefinition', 'reduce', 'reference', 'refresh', 'regex', 'reject', 'results', 'requested',
'ref', 'replace', 'report', 'reserve', 'restore', 'result', 'return', 'returning', 'right-justified', 'rollback', 'read', 'read-only', 'rp-provide-from-last', 'run',
'scan', 'screen', 'scroll', 'search', 'select', 'select-options', 'selection-screen', 'stamp', 'source', 'subkey',
'separated', 'set', 'shift', 'single', 'skip', 'sort', 'sorted', 'split', 'standard', 'stamp', 'starting', 'start-of-selection', 'sum', 'subtract-corresponding', 'statics', 'step', 'stop', 'structure', 'submatches', 'submit', 'subtract', 'summary', 'supplied', 'suppress', 'section', 'syntax-check', 'syntax-trace', 'system-call', 'switch',
'tables', 'table', 'task', 'testing', 'test-seam', 'test-injection', 'then', 'time', 'times', 'title', 'titlebar', 'to', 'top-of-page', 'trailing', 'transfer', 'transformation', 'translate', 'transporting', 'types', 'type', 'type-pool', 'type-pools',
'unassign', 'unique', 'uline', 'unpack', 'update', 'upper', 'using',
'value',
'when', 'while', 'window', 'write', 'where', 'with', 'work',
'at', 'case', 'catch', 'continue', 'do', 'elseif', 'else', 'endat', 'endcase', 'enddo', 'endif', 'endloop', 'endon', 'if', 'loop', 'on', 'raise', 'try',
'abs', 'sign', 'ceil', 'floor', 'trunc', 'frac', 'acos', 'asin', 'atan', 'cos', 'sin', 'tan', 'cosh', 'sinh', 'tanh', 'exp', 'log', 'log10', 'sqrt', 'strlen', 'xstrlen', 'charlen', 'lines', 'numofchar', 'dbmaxlen', 'round', 'rescale', 'nmax', 'nmin', 'cmax', 'cmin', 'boolc', 'boolx', 'xsdbool', 'contains', 'contains_any_of', 'contains_any_not_of', 'matches', 'line_exists', 'ipow', 'char_off', 'count', 'count_any_of', 'count_any_not_of', 'distance', 'condense', 'concat_lines_of', 'escape', 'find', 'find_end', 'find_any_of', 'find_any_not_of', 'insert', 'match', 'repeat', 'replace', 'reverse', 'segment', 'shift_left', 'shift_right', 'substring', 'substring_after', 'substring_from', 'substring_before', 'substring_to', 'to_upper', 'to_lower', 'to_mixed', 'from_mixed', 'translate', 'bit-set', 'line_index',
'definition', 'implementation', 'public', 'inheriting', 'final'
];
var language = {
defaultToken: 'invalid',
ignoreCase: true,
tokenPostfix: '.abap',
keywords: abapKeywords,
typeKeywords: [
'abap_bool', 'string', 'xstring', 'any', 'clike', 'csequence', 'numeric',
'xsequence', 'c', 'n', 'i', 'p', 'f', 'd', 't', 'x'
],
operators: [
'+', '-', '/', '*',
'=', '<', '>', '<=', '>=', '<>', '><', '=<', '=>',
'EQ', 'NE', 'GE', 'LE',
'CS', 'CN', 'CA', 'CO', 'CP', 'NS', 'NA', 'NP',
],
symbols: /[=><!~?&+\-*\/\^%]+/,
tokenizer: {
root: [
[/[a-z_$][\w$]*/, { cases: { '@typeKeywords': 'keyword',
'@keywords': 'keyword',
'@default': 'identifier' } }],
{ include: '@whitespace' },
[/[:,.]/, 'delimiter'],
[/[{}()\[\]]/, '@brackets'],
[/@symbols/, { cases: { '@operators': 'operator',
'@default': '' } }],
[/'/, { token: 'string', bracket: '@open', next: '@stringquote' }],
[/\|/, { token: 'string', bracket: '@open', next: '@stringtemplate' }],
[/\d+/, 'number'],
],
stringtemplate: [
[/[^\\\|]+/, 'string'],
[/\\\|/, 'string'],
[/\|/, { token: 'string', bracket: '@close', next: '@pop' }]
],
stringquote: [
[/[^\\']+/, 'string'],
[/'/, { token: 'string', bracket: '@close', next: '@pop' }]
],
whitespace: [
[/[ \t\r\n]+/, ''],
[/^\*.*$/, 'comment'],
[/\".*$/, 'comment'],
],
},
};
/***/ })
}]);

304
29.ced3058a.async.js Normal file
View File

@ -0,0 +1,304 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[29],{
/***/ "aA7r":
/*!************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/apex/apex.js ***!
\************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/apex/apex.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
// the default separators except `@$`
wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
comments: {
lineComment: '//',
blockComment: ['/*', '*/'],
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')'],
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
{ open: '<', close: '>' },
],
folding: {
markers: {
start: new RegExp("^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))"),
end: new RegExp("^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))")
}
}
};
var keywords = [
'abstract',
'activate',
'and',
'any',
'array',
'as',
'asc',
'assert',
'autonomous',
'begin',
'bigdecimal',
'blob',
'boolean',
'break',
'bulk',
'by',
'case',
'cast',
'catch',
'char',
'class',
'collect',
'commit',
'const',
'continue',
'convertcurrency',
'decimal',
'default',
'delete',
'desc',
'do',
'double',
'else',
'end',
'enum',
'exception',
'exit',
'export',
'extends',
'false',
'final',
'finally',
'float',
'for',
'from',
'future',
'get',
'global',
'goto',
'group',
'having',
'hint',
'if',
'implements',
'import',
'in',
'inner',
'insert',
'instanceof',
'int',
'interface',
'into',
'join',
'last_90_days',
'last_month',
'last_n_days',
'last_week',
'like',
'limit',
'list',
'long',
'loop',
'map',
'merge',
'native',
'new',
'next_90_days',
'next_month',
'next_n_days',
'next_week',
'not',
'null',
'nulls',
'number',
'object',
'of',
'on',
'or',
'outer',
'override',
'package',
'parallel',
'pragma',
'private',
'protected',
'public',
'retrieve',
'return',
'returning',
'rollback',
'savepoint',
'search',
'select',
'set',
'short',
'sort',
'stat',
'static',
'strictfp',
'super',
'switch',
'synchronized',
'system',
'testmethod',
'then',
'this',
'this_month',
'this_week',
'throw',
'throws',
'today',
'tolabel',
'tomorrow',
'transaction',
'transient',
'trigger',
'true',
'try',
'type',
'undelete',
'update',
'upsert',
'using',
'virtual',
'void',
'volatile',
'webservice',
'when',
'where',
'while',
'yesterday'
];
// create case variations of the keywords - apex is case insensitive, but we can't make the highlighter case insensitive
// because we use a heuristic to assume that identifiers starting with an upper case letter are types.
var uppercaseFirstLetter = function (lowercase) { return lowercase.charAt(0).toUpperCase() + lowercase.substr(1); };
var keywordsWithCaseVariations = [];
keywords.forEach(function (lowercase) {
keywordsWithCaseVariations.push(lowercase);
keywordsWithCaseVariations.push(lowercase.toUpperCase());
keywordsWithCaseVariations.push(uppercaseFirstLetter(lowercase));
});
var language = {
defaultToken: '',
tokenPostfix: '.apex',
keywords: keywordsWithCaseVariations,
operators: [
'=', '>', '<', '!', '~', '?', ':',
'==', '<=', '>=', '!=', '&&', '||', '++', '--',
'+', '-', '*', '/', '&', '|', '^', '%', '<<',
'>>', '>>>', '+=', '-=', '*=', '/=', '&=', '|=',
'^=', '%=', '<<=', '>>=', '>>>='
],
// we include these common regular expressions
symbols: /[=><!~?:&|+\-*\/\^%]+/,
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
digits: /\d+(_+\d+)*/,
octaldigits: /[0-7]+(_+[0-7]+)*/,
binarydigits: /[0-1]+(_+[0-1]+)*/,
hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
// The main tokenizer for our languages
tokenizer: {
root: [
// identifiers and keywords
[/[a-z_$][\w$]*/, {
cases: {
'@keywords': { token: 'keyword.$0' },
'@default': 'identifier'
}
}],
// assume that identifiers starting with an uppercase letter are types
[/[A-Z][\w\$]*/, {
cases: {
'@keywords': { token: 'keyword.$0' },
'@default': 'type.identifier'
}
}],
// whitespace
{ include: '@whitespace' },
// delimiters and operators
[/[{}()\[\]]/, '@brackets'],
[/[<>](?!@symbols)/, '@brackets'],
[/@symbols/, {
cases: {
'@operators': 'delimiter',
'@default': ''
}
}],
// @ annotations.
[/@\s*[a-zA-Z_\$][\w\$]*/, 'annotation'],
// numbers
[/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/, 'number.float'],
[/(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/, 'number.float'],
[/(@digits)[fFdD]/, 'number.float'],
[/(@digits)[lL]?/, 'number'],
// delimiter: after number because of .\d floats
[/[;,.]/, 'delimiter'],
// strings
[/"([^"\\]|\\.)*$/, 'string.invalid'],
[/'([^'\\]|\\.)*$/, 'string.invalid'],
[/"/, 'string', '@string."'],
[/'/, 'string', '@string.\''],
// characters
[/'[^\\']'/, 'string'],
[/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
[/'/, 'string.invalid']
],
whitespace: [
[/[ \t\r\n]+/, ''],
[/\/\*\*(?!\/)/, 'comment.doc', '@apexdoc'],
[/\/\*/, 'comment', '@comment'],
[/\/\/.*$/, 'comment'],
],
comment: [
[/[^\/*]+/, 'comment'],
// [/\/\*/, 'comment', '@push' ], // nested comment not allowed :-(
// [/\/\*/, 'comment.invalid' ], // this breaks block comments in the shape of /* //*/
[/\*\//, 'comment', '@pop'],
[/[\/*]/, 'comment']
],
//Identical copy of comment above, except for the addition of .doc
apexdoc: [
[/[^\/*]+/, 'comment.doc'],
[/\*\//, 'comment.doc', '@pop'],
[/[\/*]/, 'comment.doc']
],
string: [
[/[^\\"']+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/["']/, { cases: { '$#==$S2': { token: 'string', next: '@pop' },
'@default': 'string' } }]
],
},
};
/***/ })
}]);

75
30.68211da4.async.js Normal file
View File

@ -0,0 +1,75 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[30],{
/***/ "NlLO":
/*!**************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/azcli/azcli.js ***!
\**************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/azcli/azcli.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '#',
}
};
var language = {
defaultToken: 'keyword',
ignoreCase: true,
tokenPostfix: '.azcli',
str: /[^#\s]/,
tokenizer: {
root: [
{ include: '@comment' },
[/\s-+@str*\s*/, {
cases: {
'@eos': { token: 'key.identifier', next: '@popall' },
'@default': { token: 'key.identifier', next: '@type' }
}
}],
[/^-+@str*\s*/, {
cases: {
'@eos': { token: 'key.identifier', next: '@popall' },
'@default': { token: 'key.identifier', next: '@type' }
}
}]
],
type: [
{ include: '@comment' },
[/-+@str*\s*/, {
cases: {
'@eos': { token: 'key.identifier', next: '@popall' },
'@default': 'key.identifier'
}
}],
[/@str+\s*/, {
cases: {
'@eos': { token: 'string', next: '@popall' },
'@default': 'string'
}
}]
],
comment: [
[/#.*$/, {
cases: {
'@eos': { token: 'comment', next: '@popall' }
}
}]
]
}
};
/***/ })
}]);

116
31.50d3aabc.async.js Normal file
View File

@ -0,0 +1,116 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[31],{
/***/ "7s2V":
/*!**********************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/bat/bat.js ***!
\**********************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/bat/bat.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: 'REM'
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
],
surroundingPairs: [
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
],
folding: {
markers: {
start: new RegExp("^\\s*(::\\s*|REM\\s+)#region"),
end: new RegExp("^\\s*(::\\s*|REM\\s+)#endregion")
}
}
};
var language = {
defaultToken: '',
ignoreCase: true,
tokenPostfix: '.bat',
brackets: [
{ token: 'delimiter.bracket', open: '{', close: '}' },
{ token: 'delimiter.parenthesis', open: '(', close: ')' },
{ token: 'delimiter.square', open: '[', close: ']' }
],
keywords: /call|defined|echo|errorlevel|exist|for|goto|if|pause|set|shift|start|title|not|pushd|popd/,
// we include these common regular expressions
symbols: /[=><!~?&|+\-*\/\^;\.,]+/,
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
// The main tokenizer for our languages
tokenizer: {
root: [
[/^(\s*)(rem(?:\s.*|))$/, ['', 'comment']],
[/(\@?)(@keywords)(?!\w)/, [{ token: 'keyword' }, { token: 'keyword.$2' }]],
// whitespace
[/[ \t\r\n]+/, ''],
// blocks
[/setlocal(?!\w)/, 'keyword.tag-setlocal'],
[/endlocal(?!\w)/, 'keyword.tag-setlocal'],
// words
[/[a-zA-Z_]\w*/, ''],
// labels
[/:\w*/, 'metatag'],
// variables
[/%[^%]+%/, 'variable'],
[/%%[\w]+(?!\w)/, 'variable'],
// punctuations
[/[{}()\[\]]/, '@brackets'],
[/@symbols/, 'delimiter'],
// numbers
[/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
[/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, 'number.hex'],
[/\d+/, 'number'],
// punctuation: after number because of .\d floats
[/[;,.]/, 'delimiter'],
// strings:
[/"/, 'string', '@string."'],
[/'/, 'string', '@string.\''],
],
string: [
[/[^\\"'%]+/, {
cases: {
'@eos': { token: 'string', next: '@popall' },
'@default': 'string'
}
}],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/%[\w ]+%/, 'variable'],
[/%%[\w]+(?!\w)/, 'variable'],
[/["']/, {
cases: {
'$#==$S2': { token: 'string', next: '@pop' },
'@default': 'string'
}
}],
[/$/, 'string', '@popall']
],
}
};
/***/ })
}]);

130
32.a24c1207.async.js Normal file
View File

@ -0,0 +1,130 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[32],{
/***/ "3VBA":
/*!********************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/cameligo/cameligo.js ***!
\********************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/cameligo/cameligo.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '//',
blockComment: ['(*', '*)'],
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')'],
['<', '>'],
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '<', close: '>' },
{ open: '\'', close: '\'' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '<', close: '>' },
{ open: '\'', close: '\'' },
]
};
var language = {
defaultToken: '',
tokenPostfix: '.cameligo',
ignoreCase: true,
brackets: [
{ open: '{', close: '}', token: 'delimiter.curly' },
{ open: '[', close: ']', token: 'delimiter.square' },
{ open: '(', close: ')', token: 'delimiter.parenthesis' },
{ open: '<', close: '>', token: 'delimiter.angle' }
],
keywords: [
'abs', 'begin', 'Bytes', 'Crypto', 'Current', 'else', 'end', 'failwith',
'false', 'fun', 'if', 'in', 'let', 'let%entry', 'let%init', 'List', 'list',
'Map', 'map', 'match', 'match%nat', 'mod', 'not', 'operation', 'Operation', 'of',
'Set', 'set', 'sender', 'source', 'String', 'then', 'true', 'type', 'with',
],
typeKeywords: [
'int', 'unit', 'string', 'tz',
],
operators: [
'=', '>', '<', '<=', '>=', '<>', ':', ':=', 'and', 'mod', 'or',
'+', '-', '*', '/', '@', '&', '^', '%', '->', '<-'
],
// we include these common regular expressions
symbols: /[=><:@\^&|+\-*\/\^%]+/,
// The main tokenizer for our languages
tokenizer: {
root: [
// identifiers and keywords
[/[a-zA-Z_][\w]*/, {
cases: {
'@keywords': { token: 'keyword.$0' },
'@default': 'identifier'
}
}],
// whitespace
{ include: '@whitespace' },
// delimiters and operators
[/[{}()\[\]]/, '@brackets'],
[/[<>](?!@symbols)/, '@brackets'],
[/@symbols/, {
cases: {
'@operators': 'delimiter',
'@default': ''
}
}],
// numbers
[/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
[/\$[0-9a-fA-F]{1,16}/, 'number.hex'],
[/\d+/, 'number'],
// delimiter: after number because of .\d floats
[/[;,.]/, 'delimiter'],
// strings
[/'([^'\\]|\\.)*$/, 'string.invalid'],
[/'/, 'string', '@string'],
// characters
[/'[^\\']'/, 'string'],
[/'/, 'string.invalid'],
[/\#\d+/, 'string']
],
/* */
comment: [
[/[^\(\*]+/, 'comment'],
//[/\(\*/, 'comment', '@push' ], // nested comment not allowed :-(
[/\*\)/, 'comment', '@pop'],
[/\(\*/, 'comment']
],
string: [
[/[^\\']+/, 'string'],
[/\\./, 'string.escape.invalid'],
[/'/, { token: 'string.quote', bracket: '@close', next: '@pop' }]
],
whitespace: [
[/[ \t\r\n]+/, 'white'],
[/\(\*/, 'comment', '@comment'],
[/\/\/.*$/, 'comment'],
],
},
};
/***/ })
}]);

782
33.d1265227.async.js Normal file
View File

@ -0,0 +1,782 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[33],{
/***/ "AoeA":
/*!******************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/clojure/clojure.js ***!
\******************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/clojure/clojure.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: ';;',
},
brackets: [
['[', ']'],
['(', ')'],
['{', '}']
],
autoClosingPairs: [
{ open: '[', close: ']' },
{ open: '"', close: '"' },
{ open: '(', close: ')' },
{ open: '{', close: '}' },
],
surroundingPairs: [
{ open: '[', close: ']' },
{ open: '"', close: '"' },
{ open: '(', close: ')' },
{ open: '{', close: '}' },
],
};
var language = {
defaultToken: '',
ignoreCase: true,
tokenPostfix: '.clj',
brackets: [
{ open: '[', close: ']', token: 'delimiter.square' },
{ open: '(', close: ')', token: 'delimiter.parenthesis' },
{ open: '{', close: '}', token: 'delimiter.curly' },
],
constants: ['true', 'false', 'nil'],
// delimiters: /[\\\[\]\s"#'(),;@^`{}~]|$/,
numbers: /^(?:[+\-]?\d+(?:(?:N|(?:[eE][+\-]?\d+))|(?:\.?\d*(?:M|(?:[eE][+\-]?\d+))?)|\/\d+|[xX][0-9a-fA-F]+|r[0-9a-zA-Z]+)?(?=[\\\[\]\s"#'(),;@^`{}~]|$))/,
characters: /^(?:\\(?:backspace|formfeed|newline|return|space|tab|o[0-7]{3}|u[0-9A-Fa-f]{4}|x[0-9A-Fa-f]{4}|.)?(?=[\\\[\]\s"(),;@^`{}~]|$))/,
escapes: /^\\(?:["'\\bfnrt]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
// simple-namespace := /^[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*/
// simple-symbol := /^(?:\/|[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*)/
// qualified-symbol := (<simple-namespace>(<.><simple-namespace>)*</>)?<simple-symbol>
qualifiedSymbols: /^(?:(?:[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*(?:\.[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*)*\/)?(?:\/|[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*)*(?=[\\\[\]\s"(),;@^`{}~]|$))/,
specialForms: [
'.',
'catch',
'def',
'do',
'if',
'monitor-enter',
'monitor-exit',
'new',
'quote',
'recur',
'set!',
'throw',
'try',
'var',
],
coreSymbols: [
'*',
'*\'',
'*1',
'*2',
'*3',
'*agent*',
'*allow-unresolved-vars*',
'*assert*',
'*clojure-version*',
'*command-line-args*',
'*compile-files*',
'*compile-path*',
'*compiler-options*',
'*data-readers*',
'*default-data-reader-fn*',
'*e',
'*err*',
'*file*',
'*flush-on-newline*',
'*fn-loader*',
'*in*',
'*math-context*',
'*ns*',
'*out*',
'*print-dup*',
'*print-length*',
'*print-level*',
'*print-meta*',
'*print-namespace-maps*',
'*print-readably*',
'*read-eval*',
'*reader-resolver*',
'*source-path*',
'*suppress-read*',
'*unchecked-math*',
'*use-context-classloader*',
'*verbose-defrecords*',
'*warn-on-reflection*',
'+',
'+\'',
'-',
'-\'',
'->',
'->>',
'->ArrayChunk',
'->Eduction',
'->Vec',
'->VecNode',
'->VecSeq',
'-cache-protocol-fn',
'-reset-methods',
'..',
'/',
'<',
'<=',
'=',
'==',
'>',
'>=',
'EMPTY-NODE',
'Inst',
'StackTraceElement->vec',
'Throwable->map',
'accessor',
'aclone',
'add-classpath',
'add-watch',
'agent',
'agent-error',
'agent-errors',
'aget',
'alength',
'alias',
'all-ns',
'alter',
'alter-meta!',
'alter-var-root',
'amap',
'ancestors',
'and',
'any?',
'apply',
'areduce',
'array-map',
'as->',
'aset',
'aset-boolean',
'aset-byte',
'aset-char',
'aset-double',
'aset-float',
'aset-int',
'aset-long',
'aset-short',
'assert',
'assoc',
'assoc!',
'assoc-in',
'associative?',
'atom',
'await',
'await-for',
'await1',
'bases',
'bean',
'bigdec',
'bigint',
'biginteger',
'binding',
'bit-and',
'bit-and-not',
'bit-clear',
'bit-flip',
'bit-not',
'bit-or',
'bit-set',
'bit-shift-left',
'bit-shift-right',
'bit-test',
'bit-xor',
'boolean',
'boolean-array',
'boolean?',
'booleans',
'bound-fn',
'bound-fn*',
'bound?',
'bounded-count',
'butlast',
'byte',
'byte-array',
'bytes',
'bytes?',
'case',
'cast',
'cat',
'char',
'char-array',
'char-escape-string',
'char-name-string',
'char?',
'chars',
'chunk',
'chunk-append',
'chunk-buffer',
'chunk-cons',
'chunk-first',
'chunk-next',
'chunk-rest',
'chunked-seq?',
'class',
'class?',
'clear-agent-errors',
'clojure-version',
'coll?',
'comment',
'commute',
'comp',
'comparator',
'compare',
'compare-and-set!',
'compile',
'complement',
'completing',
'concat',
'cond',
'cond->',
'cond->>',
'condp',
'conj',
'conj!',
'cons',
'constantly',
'construct-proxy',
'contains?',
'count',
'counted?',
'create-ns',
'create-struct',
'cycle',
'dec',
'dec\'',
'decimal?',
'declare',
'dedupe',
'default-data-readers',
'definline',
'definterface',
'defmacro',
'defmethod',
'defmulti',
'defn',
'defn-',
'defonce',
'defprotocol',
'defrecord',
'defstruct',
'deftype',
'delay',
'delay?',
'deliver',
'denominator',
'deref',
'derive',
'descendants',
'destructure',
'disj',
'disj!',
'dissoc',
'dissoc!',
'distinct',
'distinct?',
'doall',
'dorun',
'doseq',
'dosync',
'dotimes',
'doto',
'double',
'double-array',
'double?',
'doubles',
'drop',
'drop-last',
'drop-while',
'eduction',
'empty',
'empty?',
'ensure',
'ensure-reduced',
'enumeration-seq',
'error-handler',
'error-mode',
'eval',
'even?',
'every-pred',
'every?',
'ex-data',
'ex-info',
'extend',
'extend-protocol',
'extend-type',
'extenders',
'extends?',
'false?',
'ffirst',
'file-seq',
'filter',
'filterv',
'find',
'find-keyword',
'find-ns',
'find-protocol-impl',
'find-protocol-method',
'find-var',
'first',
'flatten',
'float',
'float-array',
'float?',
'floats',
'flush',
'fn',
'fn?',
'fnext',
'fnil',
'for',
'force',
'format',
'frequencies',
'future',
'future-call',
'future-cancel',
'future-cancelled?',
'future-done?',
'future?',
'gen-class',
'gen-interface',
'gensym',
'get',
'get-in',
'get-method',
'get-proxy-class',
'get-thread-bindings',
'get-validator',
'group-by',
'halt-when',
'hash',
'hash-combine',
'hash-map',
'hash-ordered-coll',
'hash-set',
'hash-unordered-coll',
'ident?',
'identical?',
'identity',
'if-let',
'if-not',
'if-some',
'ifn?',
'import',
'in-ns',
'inc',
'inc\'',
'indexed?',
'init-proxy',
'inst-ms',
'inst-ms*',
'inst?',
'instance?',
'int',
'int-array',
'int?',
'integer?',
'interleave',
'intern',
'interpose',
'into',
'into-array',
'ints',
'io!',
'isa?',
'iterate',
'iterator-seq',
'juxt',
'keep',
'keep-indexed',
'key',
'keys',
'keyword',
'keyword?',
'last',
'lazy-cat',
'lazy-seq',
'let',
'letfn',
'line-seq',
'list',
'list*',
'list?',
'load',
'load-file',
'load-reader',
'load-string',
'loaded-libs',
'locking',
'long',
'long-array',
'longs',
'loop',
'macroexpand',
'macroexpand-1',
'make-array',
'make-hierarchy',
'map',
'map-entry?',
'map-indexed',
'map?',
'mapcat',
'mapv',
'max',
'max-key',
'memfn',
'memoize',
'merge',
'merge-with',
'meta',
'method-sig',
'methods',
'min',
'min-key',
'mix-collection-hash',
'mod',
'munge',
'name',
'namespace',
'namespace-munge',
'nat-int?',
'neg-int?',
'neg?',
'newline',
'next',
'nfirst',
'nil?',
'nnext',
'not',
'not-any?',
'not-empty',
'not-every?',
'not=',
'ns',
'ns-aliases',
'ns-imports',
'ns-interns',
'ns-map',
'ns-name',
'ns-publics',
'ns-refers',
'ns-resolve',
'ns-unalias',
'ns-unmap',
'nth',
'nthnext',
'nthrest',
'num',
'number?',
'numerator',
'object-array',
'odd?',
'or',
'parents',
'partial',
'partition',
'partition-all',
'partition-by',
'pcalls',
'peek',
'persistent!',
'pmap',
'pop',
'pop!',
'pop-thread-bindings',
'pos-int?',
'pos?',
'pr',
'pr-str',
'prefer-method',
'prefers',
'primitives-classnames',
'print',
'print-ctor',
'print-dup',
'print-method',
'print-simple',
'print-str',
'printf',
'println',
'println-str',
'prn',
'prn-str',
'promise',
'proxy',
'proxy-call-with-super',
'proxy-mappings',
'proxy-name',
'proxy-super',
'push-thread-bindings',
'pvalues',
'qualified-ident?',
'qualified-keyword?',
'qualified-symbol?',
'quot',
'rand',
'rand-int',
'rand-nth',
'random-sample',
'range',
'ratio?',
'rational?',
'rationalize',
're-find',
're-groups',
're-matcher',
're-matches',
're-pattern',
're-seq',
'read',
'read-line',
'read-string',
'reader-conditional',
'reader-conditional?',
'realized?',
'record?',
'reduce',
'reduce-kv',
'reduced',
'reduced?',
'reductions',
'ref',
'ref-history-count',
'ref-max-history',
'ref-min-history',
'ref-set',
'refer',
'refer-clojure',
'reify',
'release-pending-sends',
'rem',
'remove',
'remove-all-methods',
'remove-method',
'remove-ns',
'remove-watch',
'repeat',
'repeatedly',
'replace',
'replicate',
'require',
'reset!',
'reset-meta!',
'reset-vals!',
'resolve',
'rest',
'restart-agent',
'resultset-seq',
'reverse',
'reversible?',
'rseq',
'rsubseq',
'run!',
'satisfies?',
'second',
'select-keys',
'send',
'send-off',
'send-via',
'seq',
'seq?',
'seqable?',
'seque',
'sequence',
'sequential?',
'set',
'set-agent-send-executor!',
'set-agent-send-off-executor!',
'set-error-handler!',
'set-error-mode!',
'set-validator!',
'set?',
'short',
'short-array',
'shorts',
'shuffle',
'shutdown-agents',
'simple-ident?',
'simple-keyword?',
'simple-symbol?',
'slurp',
'some',
'some->',
'some->>',
'some-fn',
'some?',
'sort',
'sort-by',
'sorted-map',
'sorted-map-by',
'sorted-set',
'sorted-set-by',
'sorted?',
'special-symbol?',
'spit',
'split-at',
'split-with',
'str',
'string?',
'struct',
'struct-map',
'subs',
'subseq',
'subvec',
'supers',
'swap!',
'swap-vals!',
'symbol',
'symbol?',
'sync',
'tagged-literal',
'tagged-literal?',
'take',
'take-last',
'take-nth',
'take-while',
'test',
'the-ns',
'thread-bound?',
'time',
'to-array',
'to-array-2d',
'trampoline',
'transduce',
'transient',
'tree-seq',
'true?',
'type',
'unchecked-add',
'unchecked-add-int',
'unchecked-byte',
'unchecked-char',
'unchecked-dec',
'unchecked-dec-int',
'unchecked-divide-int',
'unchecked-double',
'unchecked-float',
'unchecked-inc',
'unchecked-inc-int',
'unchecked-int',
'unchecked-long',
'unchecked-multiply',
'unchecked-multiply-int',
'unchecked-negate',
'unchecked-negate-int',
'unchecked-remainder-int',
'unchecked-short',
'unchecked-subtract',
'unchecked-subtract-int',
'underive',
'unquote',
'unquote-splicing',
'unreduced',
'unsigned-bit-shift-right',
'update',
'update-in',
'update-proxy',
'uri?',
'use',
'uuid?',
'val',
'vals',
'var-get',
'var-set',
'var?',
'vary-meta',
'vec',
'vector',
'vector-of',
'vector?',
'volatile!',
'volatile?',
'vreset!',
'vswap!',
'when',
'when-first',
'when-let',
'when-not',
'when-some',
'while',
'with-bindings',
'with-bindings*',
'with-in-str',
'with-loading-context',
'with-local-vars',
'with-meta',
'with-open',
'with-out-str',
'with-precision',
'with-redefs',
'with-redefs-fn',
'xml-seq',
'zero?',
'zipmap',
],
tokenizer: {
root: [
// whitespaces and comments
{ include: '@whitespace' },
// numbers
[/@numbers/, 'number'],
// characters
[/@characters/, 'string'],
// strings
{ include: '@string' },
// brackets
[/[()\[\]{}]/, '@brackets'],
// regular expressions
[/\/#"(?:\.|(?:")|[^"\n])*"\/g/, 'regexp'],
// reader macro characters
[/[#'@^`~]/, 'meta'],
// symbols
[/@qualifiedSymbols/, {
cases: {
'^:.+$': 'constant',
'@specialForms': 'keyword',
'@coreSymbols': 'keyword',
'@constants': 'constant',
'@default': 'identifier',
},
},
],
],
whitespace: [
[/[\s,]+/, 'white'],
[/;.*$/, 'comment'],
[/\(comment\b/, 'comment', '@comment'],
],
comment: [
[/\(/, 'comment', '@push'],
[/\)/, 'comment', '@pop'],
[/[^()]/, 'comment'],
],
string: [
[/"/, 'string', '@multiLineString'],
],
multiLineString: [
[/"/, 'string', '@popall'],
[/@escapes/, 'string.escape'],
[/./, 'string']
],
},
};
/***/ })
}]);

190
34.c9a118f7.async.js Normal file
View File

@ -0,0 +1,190 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[34],{
/***/ "2ZXa":
/*!****************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/coffee/coffee.js ***!
\****************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/coffee/coffee.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\$\-\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
comments: {
blockComment: ['###', '###'],
lineComment: '#'
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
folding: {
markers: {
start: new RegExp("^\\s*#region\\b"),
end: new RegExp("^\\s*#endregion\\b")
}
}
};
var language = {
defaultToken: '',
ignoreCase: true,
tokenPostfix: '.coffee',
brackets: [
{ open: '{', close: '}', token: 'delimiter.curly' },
{ open: '[', close: ']', token: 'delimiter.square' },
{ open: '(', close: ')', token: 'delimiter.parenthesis' }
],
regEx: /\/(?!\/\/)(?:[^\/\\]|\\.)*\/[igm]*/,
keywords: [
'and', 'or', 'is', 'isnt', 'not', 'on', 'yes', '@', 'no', 'off',
'true', 'false', 'null', 'this',
'new', 'delete', 'typeof', 'in', 'instanceof',
'return', 'throw', 'break', 'continue', 'debugger',
'if', 'else', 'switch', 'for', 'while', 'do', 'try', 'catch', 'finally',
'class', 'extends', 'super',
'undefined', 'then', 'unless', 'until', 'loop', 'of', 'by', 'when'
],
// we include these common regular expressions
symbols: /[=><!~?&%|+\-*\/\^\.,\:]+/,
escapes: /\\(?:[abfnrtv\\"'$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
// The main tokenizer for our languages
tokenizer: {
root: [
// identifiers and keywords
[/\@[a-zA-Z_]\w*/, 'variable.predefined'],
[/[a-zA-Z_]\w*/, {
cases: {
'this': 'variable.predefined',
'@keywords': { token: 'keyword.$0' },
'@default': ''
}
}],
// whitespace
[/[ \t\r\n]+/, ''],
// Comments
[/###/, 'comment', '@comment'],
[/#.*$/, 'comment'],
// regular expressions
['///', { token: 'regexp', next: '@hereregexp' }],
[/^(\s*)(@regEx)/, ['', 'regexp']],
[/(\()(\s*)(@regEx)/, ['@brackets', '', 'regexp']],
[/(\,)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
[/(\=)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
[/(\:)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
[/(\[)(\s*)(@regEx)/, ['@brackets', '', 'regexp']],
[/(\!)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
[/(\&)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
[/(\|)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
[/(\?)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
[/(\{)(\s*)(@regEx)/, ['@brackets', '', 'regexp']],
[/(\;)(\s*)(@regEx)/, ['', '', 'regexp']],
// delimiters
[/}/, {
cases: {
'$S2==interpolatedstring': { token: 'string', next: '@pop' },
'@default': '@brackets'
}
}],
[/[{}()\[\]]/, '@brackets'],
[/@symbols/, 'delimiter'],
// numbers
[/\d+[eE]([\-+]?\d+)?/, 'number.float'],
[/\d+\.\d+([eE][\-+]?\d+)?/, 'number.float'],
[/0[xX][0-9a-fA-F]+/, 'number.hex'],
[/0[0-7]+(?!\d)/, 'number.octal'],
[/\d+/, 'number'],
// delimiter: after number because of .\d floats
[/[,.]/, 'delimiter'],
// strings:
[/"""/, 'string', '@herestring."""'],
[/'''/, 'string', '@herestring.\'\'\''],
[/"/, {
cases: {
'@eos': 'string',
'@default': { token: 'string', next: '@string."' }
}
}],
[/'/, {
cases: {
'@eos': 'string',
'@default': { token: 'string', next: '@string.\'' }
}
}],
],
string: [
[/[^"'\#\\]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\./, 'string.escape.invalid'],
[/\./, 'string.escape.invalid'],
[/#{/, {
cases: {
'$S2=="': { token: 'string', next: 'root.interpolatedstring' },
'@default': 'string'
}
}],
[/["']/, {
cases: {
'$#==$S2': { token: 'string', next: '@pop' },
'@default': 'string'
}
}],
[/#/, 'string']
],
herestring: [
[/("""|''')/, {
cases: {
'$1==$S2': { token: 'string', next: '@pop' },
'@default': 'string'
}
}],
[/[^#\\'"]+/, 'string'],
[/['"]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\./, 'string.escape.invalid'],
[/#{/, { token: 'string.quote', next: 'root.interpolatedstring' }],
[/#/, 'string']
],
comment: [
[/[^#]+/, 'comment',],
[/###/, 'comment', '@pop'],
[/#/, 'comment'],
],
hereregexp: [
[/[^\\\/#]+/, 'regexp'],
[/\\./, 'regexp'],
[/#.*$/, 'comment'],
['///[igm]*', { token: 'regexp', next: '@pop' }],
[/\//, 'regexp'],
],
},
};
/***/ })
}]);

204
35.1bfe2dd7.async.js Normal file
View File

@ -0,0 +1,204 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[35],{
/***/ "/Om3":
/*!****************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/csharp/csharp.js ***!
\****************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/csharp/csharp.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\$\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
comments: {
lineComment: '//',
blockComment: ['/*', '*/'],
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')'],
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '\'', close: '\'', notIn: ['string', 'comment'] },
{ open: '"', close: '"', notIn: ['string', 'comment'] },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '<', close: '>' },
{ open: '\'', close: '\'' },
{ open: '"', close: '"' },
],
folding: {
markers: {
start: new RegExp("^\\s*#region\\b"),
end: new RegExp("^\\s*#endregion\\b")
}
}
};
var language = {
defaultToken: '',
tokenPostfix: '.cs',
brackets: [
{ open: '{', close: '}', token: 'delimiter.curly' },
{ open: '[', close: ']', token: 'delimiter.square' },
{ open: '(', close: ')', token: 'delimiter.parenthesis' },
{ open: '<', close: '>', token: 'delimiter.angle' }
],
keywords: [
'extern', 'alias', 'using', 'bool', 'decimal', 'sbyte', 'byte', 'short',
'ushort', 'int', 'uint', 'long', 'ulong', 'char', 'float', 'double',
'object', 'dynamic', 'string', 'assembly', 'is', 'as', 'ref',
'out', 'this', 'base', 'new', 'typeof', 'void', 'checked', 'unchecked',
'default', 'delegate', 'var', 'const', 'if', 'else', 'switch', 'case',
'while', 'do', 'for', 'foreach', 'in', 'break', 'continue', 'goto',
'return', 'throw', 'try', 'catch', 'finally', 'lock', 'yield', 'from',
'let', 'where', 'join', 'on', 'equals', 'into', 'orderby', 'ascending',
'descending', 'select', 'group', 'by', 'namespace', 'partial', 'class',
'field', 'event', 'method', 'param', 'property', 'public', 'protected',
'internal', 'private', 'abstract', 'sealed', 'static', 'struct', 'readonly',
'volatile', 'virtual', 'override', 'params', 'get', 'set', 'add', 'remove',
'operator', 'true', 'false', 'implicit', 'explicit', 'interface', 'enum',
'null', 'async', 'await', 'fixed', 'sizeof', 'stackalloc', 'unsafe', 'nameof',
'when'
],
namespaceFollows: [
'namespace', 'using',
],
parenFollows: [
'if', 'for', 'while', 'switch', 'foreach', 'using', 'catch', 'when'
],
operators: [
'=', '??', '||', '&&', '|', '^', '&', '==', '!=', '<=', '>=', '<<',
'+', '-', '*', '/', '%', '!', '~', '++', '--', '+=',
'-=', '*=', '/=', '%=', '&=', '|=', '^=', '<<=', '>>=', '>>', '=>'
],
symbols: /[=><!~?:&|+\-*\/\^%]+/,
// escape sequences
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
// The main tokenizer for our languages
tokenizer: {
root: [
// identifiers and keywords
[/\@?[a-zA-Z_]\w*/, {
cases: {
'@namespaceFollows': { token: 'keyword.$0', next: '@namespace' },
'@keywords': { token: 'keyword.$0', next: '@qualified' },
'@default': { token: 'identifier', next: '@qualified' }
}
}],
// whitespace
{ include: '@whitespace' },
// delimiters and operators
[/}/, {
cases: {
'$S2==interpolatedstring': { token: 'string.quote', next: '@pop' },
'$S2==litinterpstring': { token: 'string.quote', next: '@pop' },
'@default': '@brackets'
}
}],
[/[{}()\[\]]/, '@brackets'],
[/[<>](?!@symbols)/, '@brackets'],
[/@symbols/, {
cases: {
'@operators': 'delimiter',
'@default': ''
}
}],
// numbers
[/[0-9_]*\.[0-9_]+([eE][\-+]?\d+)?[fFdD]?/, 'number.float'],
[/0[xX][0-9a-fA-F_]+/, 'number.hex'],
[/0[bB][01_]+/, 'number.hex'],
[/[0-9_]+/, 'number'],
// delimiter: after number because of .\d floats
[/[;,.]/, 'delimiter'],
// strings
[/"([^"\\]|\\.)*$/, 'string.invalid'],
[/"/, { token: 'string.quote', next: '@string' }],
[/\$\@"/, { token: 'string.quote', next: '@litinterpstring' }],
[/\@"/, { token: 'string.quote', next: '@litstring' }],
[/\$"/, { token: 'string.quote', next: '@interpolatedstring' }],
// characters
[/'[^\\']'/, 'string'],
[/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
[/'/, 'string.invalid']
],
qualified: [
[/[a-zA-Z_][\w]*/, {
cases: {
'@keywords': { token: 'keyword.$0' },
'@default': 'identifier'
}
}],
[/\./, 'delimiter'],
['', '', '@pop'],
],
namespace: [
{ include: '@whitespace' },
[/[A-Z]\w*/, 'namespace'],
[/[\.=]/, 'delimiter'],
['', '', '@pop'],
],
comment: [
[/[^\/*]+/, 'comment'],
// [/\/\*/, 'comment', '@push' ], // no nested comments :-(
['\\*/', 'comment', '@pop'],
[/[\/*]/, 'comment']
],
string: [
[/[^\\"]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/"/, { token: 'string.quote', next: '@pop' }]
],
litstring: [
[/[^"]+/, 'string'],
[/""/, 'string.escape'],
[/"/, { token: 'string.quote', next: '@pop' }]
],
litinterpstring: [
[/[^"{]+/, 'string'],
[/""/, 'string.escape'],
[/{{/, 'string.escape'],
[/}}/, 'string.escape'],
[/{/, { token: 'string.quote', next: 'root.litinterpstring' }],
[/"/, { token: 'string.quote', next: '@pop' }]
],
interpolatedstring: [
[/[^\\"{]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/{{/, 'string.escape'],
[/}}/, 'string.escape'],
[/{/, { token: 'string.quote', next: 'root.interpolatedstring' }],
[/"/, { token: 'string.quote', next: '@pop' }]
],
whitespace: [
[/^[ \t\v\f]*#((r)|(load))(?=\s)/, 'directive.csx'],
[/^[ \t\v\f]*#\w.*$/, 'namespace.cpp'],
[/[ \t\v\f\r\n]+/, ''],
[/\/\*/, 'comment', '@comment'],
[/\/\/.*$/, 'comment'],
],
},
};
/***/ })
}]);

75
36.ae4ab8cb.async.js Normal file
View File

@ -0,0 +1,75 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[36],{
/***/ "p+q7":
/*!**********************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/csp/csp.js ***!
\**********************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/csp/csp.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
brackets: [],
autoClosingPairs: [],
surroundingPairs: []
};
var language = {
// Set defaultToken to invalid to see what you do not tokenize yet
// defaultToken: 'invalid',
keywords: [],
typeKeywords: [],
tokenPostfix: '.csp',
operators: [],
symbols: /[=><!~?:&|+\-*\/\^%]+/,
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
tokenizer: {
root: [
[/child-src/, 'string.quote'],
[/connect-src/, 'string.quote'],
[/default-src/, 'string.quote'],
[/font-src/, 'string.quote'],
[/frame-src/, 'string.quote'],
[/img-src/, 'string.quote'],
[/manifest-src/, 'string.quote'],
[/media-src/, 'string.quote'],
[/object-src/, 'string.quote'],
[/script-src/, 'string.quote'],
[/style-src/, 'string.quote'],
[/worker-src/, 'string.quote'],
[/base-uri/, 'string.quote'],
[/plugin-types/, 'string.quote'],
[/sandbox/, 'string.quote'],
[/disown-opener/, 'string.quote'],
[/form-action/, 'string.quote'],
[/frame-ancestors/, 'string.quote'],
[/report-uri/, 'string.quote'],
[/report-to/, 'string.quote'],
[/upgrade-insecure-requests/, 'string.quote'],
[/block-all-mixed-content/, 'string.quote'],
[/require-sri-for/, 'string.quote'],
[/reflected-xss/, 'string.quote'],
[/referrer/, 'string.quote'],
[/policy-uri/, 'string.quote'],
[/'self'/, 'string.quote'],
[/'unsafe-inline'/, 'string.quote'],
[/'unsafe-eval'/, 'string.quote'],
[/'strict-dynamic'/, 'string.quote'],
[/'unsafe-hashed-attributes'/, 'string.quote']
]
}
};
/***/ })
}]);

191
37.677d55ee.async.js Normal file
View File

@ -0,0 +1,191 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[37],{
/***/ "v7Iz":
/*!**********************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/css/css.js ***!
\**********************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/css/css.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
wordPattern: /(#?-?\d*\.\d\w*%?)|((::|[@#.!:])?[\w-?]+%?)|::|[@#.!:]/g,
comments: {
blockComment: ['/*', '*/']
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}', notIn: ['string', 'comment'] },
{ open: '[', close: ']', notIn: ['string', 'comment'] },
{ open: '(', close: ')', notIn: ['string', 'comment'] },
{ open: '"', close: '"', notIn: ['string', 'comment'] },
{ open: '\'', close: '\'', notIn: ['string', 'comment'] }
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' }
],
folding: {
markers: {
start: new RegExp("^\\s*\\/\\*\\s*#region\\b\\s*(.*?)\\s*\\*\\/"),
end: new RegExp("^\\s*\\/\\*\\s*#endregion\\b.*\\*\\/")
}
}
};
var language = {
defaultToken: '',
tokenPostfix: '.css',
ws: '[ \t\n\r\f]*',
identifier: '-?-?([a-zA-Z]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*',
brackets: [
{ open: '{', close: '}', token: 'delimiter.bracket' },
{ open: '[', close: ']', token: 'delimiter.bracket' },
{ open: '(', close: ')', token: 'delimiter.parenthesis' },
{ open: '<', close: '>', token: 'delimiter.angle' }
],
tokenizer: {
root: [
{ include: '@selector' },
],
selector: [
{ include: '@comments' },
{ include: '@import' },
{ include: '@strings' },
['[@](keyframes|-webkit-keyframes|-moz-keyframes|-o-keyframes)', { token: 'keyword', next: '@keyframedeclaration' }],
['[@](page|content|font-face|-moz-document)', { token: 'keyword' }],
['[@](charset|namespace)', { token: 'keyword', next: '@declarationbody' }],
['(url-prefix)(\\()', ['attribute.value', { token: 'delimiter.parenthesis', next: '@urldeclaration' }]],
['(url)(\\()', ['attribute.value', { token: 'delimiter.parenthesis', next: '@urldeclaration' }]],
{ include: '@selectorname' },
['[\\*]', 'tag'],
['[>\\+,]', 'delimiter'],
['\\[', { token: 'delimiter.bracket', next: '@selectorattribute' }],
['{', { token: 'delimiter.bracket', next: '@selectorbody' }]
],
selectorbody: [
{ include: '@comments' },
['[*_]?@identifier@ws:(?=(\\s|\\d|[^{;}]*[;}]))', 'attribute.name', '@rulevalue'],
['}', { token: 'delimiter.bracket', next: '@pop' }]
],
selectorname: [
['(\\.|#(?=[^{])|%|(@identifier)|:)+', 'tag'],
],
selectorattribute: [
{ include: '@term' },
[']', { token: 'delimiter.bracket', next: '@pop' }],
],
term: [
{ include: '@comments' },
['(url-prefix)(\\()', ['attribute.value', { token: 'delimiter.parenthesis', next: '@urldeclaration' }]],
['(url)(\\()', ['attribute.value', { token: 'delimiter.parenthesis', next: '@urldeclaration' }]],
{ include: '@functioninvocation' },
{ include: '@numbers' },
{ include: '@name' },
['([<>=\\+\\-\\*\\/\\^\\|\\~,])', 'delimiter'],
[',', 'delimiter']
],
rulevalue: [
{ include: '@comments' },
{ include: '@strings' },
{ include: '@term' },
['!important', 'keyword'],
[';', 'delimiter', '@pop'],
['(?=})', { token: '', next: '@pop' }] // missing semicolon
],
warndebug: [
['[@](warn|debug)', { token: 'keyword', next: '@declarationbody' }]
],
import: [
['[@](import)', { token: 'keyword', next: '@declarationbody' }]
],
urldeclaration: [
{ include: '@strings' },
['[^)\r\n]+', 'string'],
['\\)', { token: 'delimiter.parenthesis', next: '@pop' }]
],
parenthizedterm: [
{ include: '@term' },
['\\)', { token: 'delimiter.parenthesis', next: '@pop' }]
],
declarationbody: [
{ include: '@term' },
[';', 'delimiter', '@pop'],
['(?=})', { token: '', next: '@pop' }] // missing semicolon
],
comments: [
['\\/\\*', 'comment', '@comment'],
['\\/\\/+.*', 'comment']
],
comment: [
['\\*\\/', 'comment', '@pop'],
[/[^*/]+/, 'comment'],
[/./, 'comment'],
],
name: [
['@identifier', 'attribute.value']
],
numbers: [
['-?(\\d*\\.)?\\d+([eE][\\-+]?\\d+)?', { token: 'attribute.value.number', next: '@units' }],
['#[0-9a-fA-F_]+(?!\\w)', 'attribute.value.hex']
],
units: [
['(em|ex|ch|rem|vmin|vmax|vw|vh|vm|cm|mm|in|px|pt|pc|deg|grad|rad|turn|s|ms|Hz|kHz|%)?', 'attribute.value.unit', '@pop']
],
keyframedeclaration: [
['@identifier', 'attribute.value'],
['{', { token: 'delimiter.bracket', switchTo: '@keyframebody' }],
],
keyframebody: [
{ include: '@term' },
['{', { token: 'delimiter.bracket', next: '@selectorbody' }],
['}', { token: 'delimiter.bracket', next: '@pop' }],
],
functioninvocation: [
['@identifier\\(', { token: 'attribute.value', next: '@functionarguments' }],
],
functionarguments: [
['\\$@identifier@ws:', 'attribute.name'],
['[,]', 'delimiter'],
{ include: '@term' },
['\\)', { token: 'attribute.value', next: '@pop' }],
],
strings: [
['~?"', { token: 'string', next: '@stringenddoublequote' }],
['~?\'', { token: 'string', next: '@stringendquote' }]
],
stringenddoublequote: [
['\\\\.', 'string'],
['"', { token: 'string', next: '@pop' }],
[/[^\\"]+/, 'string'],
['.', 'string']
],
stringendquote: [
['\\\\.', 'string'],
['\'', { token: 'string', next: '@pop' }],
[/[^\\']+/, 'string'],
['.', 'string']
]
}
};
/***/ })
}]);

129
38.af45cc50.async.js Normal file
View File

@ -0,0 +1,129 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[38],{
/***/ "Dsrv":
/*!************************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/dockerfile/dockerfile.js ***!
\************************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/dockerfile/dockerfile.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
]
};
var language = {
defaultToken: '',
tokenPostfix: '.dockerfile',
variable: /\${?[\w]+}?/,
tokenizer: {
root: [
{ include: '@whitespace' },
{ include: '@comment' },
[/(ONBUILD)(\s+)/, ['keyword', '']],
[/(ENV)(\s+)([\w]+)/, ['keyword', '', { token: 'variable', next: '@arguments' }]],
[/(FROM|MAINTAINER|RUN|EXPOSE|ENV|ADD|ARG|VOLUME|LABEL|USER|WORKDIR|COPY|CMD|STOPSIGNAL|SHELL|HEALTHCHECK|ENTRYPOINT)/, { token: 'keyword', next: '@arguments' }]
],
arguments: [
{ include: '@whitespace' },
{ include: '@strings' },
[/(@variable)/, {
cases: {
'@eos': { token: 'variable', next: '@popall' },
'@default': 'variable'
}
}],
[/\\/, {
cases: {
'@eos': '',
'@default': ''
}
}],
[/./, {
cases: {
'@eos': { token: '', next: '@popall' },
'@default': ''
}
}],
],
// Deal with white space, including comments
whitespace: [
[/\s+/, {
cases: {
'@eos': { token: '', next: '@popall' },
'@default': ''
}
}],
],
comment: [
[/(^#.*$)/, 'comment', '@popall']
],
// Recognize strings, including those broken across lines with \ (but not without)
strings: [
[/'$/, 'string', '@popall'],
[/'/, 'string', '@stringBody'],
[/"$/, 'string', '@popall'],
[/"/, 'string', '@dblStringBody']
],
stringBody: [
[/[^\\\$']/, {
cases: {
'@eos': { token: 'string', next: '@popall' },
'@default': 'string'
}
}],
[/\\./, 'string.escape'],
[/'$/, 'string', '@popall'],
[/'/, 'string', '@pop'],
[/(@variable)/, 'variable'],
[/\\$/, 'string'],
[/$/, 'string', '@popall']
],
dblStringBody: [
[/[^\\\$"]/, {
cases: {
'@eos': { token: 'string', next: '@popall' },
'@default': 'string'
}
}],
[/\\./, 'string.escape'],
[/"$/, 'string', '@popall'],
[/"/, 'string', '@pop'],
[/(@variable)/, 'variable'],
[/\\$/, 'string'],
[/$/, 'string', '@popall']
]
}
};
/***/ })
}]);

158
39.b85a605a.async.js Normal file
View File

@ -0,0 +1,158 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[39],{
/***/ "yswY":
/*!****************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/fsharp/fsharp.js ***!
\****************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/fsharp/fsharp.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '//',
blockComment: ['(*', '*)'],
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' }
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' }
],
folding: {
markers: {
start: new RegExp("^\\s*//\\s*#region\\b|^\\s*\\(\\*\\s*#region(.*)\\*\\)"),
end: new RegExp("^\\s*//\\s*#endregion\\b|^\\s*\\(\\*\\s*#endregion\\s*\\*\\)")
}
}
};
var language = {
defaultToken: '',
tokenPostfix: '.fs',
keywords: [
'abstract', 'and', 'atomic', 'as',
'assert', 'asr', 'base', 'begin',
'break', 'checked', 'component',
'const', 'constraint', 'constructor',
'continue', 'class', 'default',
'delegate', 'do', 'done', 'downcast',
'downto', 'elif', 'else', 'end',
'exception', 'eager', 'event', 'external',
'extern', 'false', 'finally', 'for',
'fun', 'function', 'fixed', 'functor',
'global', 'if', 'in', 'include', 'inherit',
'inline', 'interface', 'internal', 'land',
'lor', 'lsl', 'lsr', 'lxor', 'lazy', 'let',
'match', 'member', 'mod', 'module', 'mutable',
'namespace', 'method', 'mixin', 'new', 'not',
'null', 'of', 'open', 'or', 'object',
'override', 'private', 'parallel', 'process',
'protected', 'pure', 'public', 'rec', 'return',
'static', 'sealed', 'struct', 'sig', 'then',
'to', 'true', 'tailcall', 'trait',
'try', 'type', 'upcast', 'use',
'val', 'void', 'virtual', 'volatile',
'when', 'while', 'with', 'yield'
],
// we include these common regular expressions
symbols: /[=><!~?:&|+\-*\^%;\.,\/]+/,
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
integersuffix: /[uU]?[yslnLI]?/,
floatsuffix: /[fFmM]?/,
// The main tokenizer for our languages
tokenizer: {
root: [
// identifiers and keywords
[/[a-zA-Z_]\w*/, {
cases: {
'@keywords': { token: 'keyword.$0' },
'@default': 'identifier'
}
}],
// whitespace
{ include: '@whitespace' },
// [< attributes >].
[/\[<.*>\]/, 'annotation'],
// Preprocessor directive
[/^#(if|else|endif)/, 'keyword'],
// delimiters and operators
[/[{}()\[\]]/, '@brackets'],
[/[<>](?!@symbols)/, '@brackets'],
[/@symbols/, 'delimiter'],
// numbers
[/\d*\d+[eE]([\-+]?\d+)?(@floatsuffix)/, 'number.float'],
[/\d*\.\d+([eE][\-+]?\d+)?(@floatsuffix)/, 'number.float'],
[/0x[0-9a-fA-F]+LF/, 'number.float'],
[/0x[0-9a-fA-F]+(@integersuffix)/, 'number.hex'],
[/0b[0-1]+(@integersuffix)/, 'number.bin'],
[/\d+(@integersuffix)/, 'number'],
// delimiter: after number because of .\d floats
[/[;,.]/, 'delimiter'],
// strings
[/"([^"\\]|\\.)*$/, 'string.invalid'],
[/"""/, 'string', '@string."""'],
[/"/, 'string', '@string."'],
// literal string
[/\@"/, { token: 'string.quote', next: '@litstring' }],
// characters
[/'[^\\']'B?/, 'string'],
[/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
[/'/, 'string.invalid']
],
whitespace: [
[/[ \t\r\n]+/, ''],
[/\(\*(?!\))/, 'comment', '@comment'],
[/\/\/.*$/, 'comment'],
],
comment: [
[/[^*(]+/, 'comment'],
[/\*\)/, 'comment', '@pop'],
[/\*/, 'comment'],
[/\(\*\)/, 'comment'],
[/\(/, 'comment']
],
string: [
[/[^\\"]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/("""|"B?)/, {
cases: {
'$#==$S2': { token: 'string', next: '@pop' },
'@default': 'string'
}
}]
],
litstring: [
[/[^"]+/, 'string'],
[/""/, 'string.escape'],
[/"/, { token: 'string.quote', next: '@pop' }]
],
},
};
/***/ })
}]);

190
40.aebd8ce5.async.js Normal file
View File

@ -0,0 +1,190 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[40],{
/***/ "lHAa":
/*!********************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/go/go.js ***!
\********************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/go/go.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '//',
blockComment: ['/*', '*/'],
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '`', close: '`', notIn: ['string'] },
{ open: '"', close: '"', notIn: ['string'] },
{ open: '\'', close: '\'', notIn: ['string', 'comment'] },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '`', close: '`' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
]
};
var language = {
defaultToken: '',
tokenPostfix: '.go',
keywords: [
'break',
'case',
'chan',
'const',
'continue',
'default',
'defer',
'else',
'fallthrough',
'for',
'func',
'go',
'goto',
'if',
'import',
'interface',
'map',
'package',
'range',
'return',
'select',
'struct',
'switch',
'type',
'var',
'bool',
'true',
'false',
'uint8',
'uint16',
'uint32',
'uint64',
'int8',
'int16',
'int32',
'int64',
'float32',
'float64',
'complex64',
'complex128',
'byte',
'rune',
'uint',
'int',
'uintptr',
'string',
'nil',
],
operators: [
'+', '-', '*', '/', '%', '&', '|', '^', '<<', '>>', '&^',
'+=', '-=', '*=', '/=', '%=', '&=', '|=', '^=', '<<=', '>>=', '&^=',
'&&', '||', '<-', '++', '--', '==', '<', '>', '=', '!', '!=', '<=', '>=', ':=', '...',
'(', ')', '', ']', '{', '}', ',', ';', '.', ':'
],
// we include these common regular expressions
symbols: /[=><!~?:&|+\-*\/\^%]+/,
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
// The main tokenizer for our languages
tokenizer: {
root: [
// identifiers and keywords
[/[a-zA-Z_]\w*/, {
cases: {
'@keywords': { token: 'keyword.$0' },
'@default': 'identifier'
}
}],
// whitespace
{ include: '@whitespace' },
// [[ attributes ]].
[/\[\[.*\]\]/, 'annotation'],
// Preprocessor directive
[/^\s*#\w+/, 'keyword'],
// delimiters and operators
[/[{}()\[\]]/, '@brackets'],
[/[<>](?!@symbols)/, '@brackets'],
[/@symbols/, {
cases: {
'@operators': 'delimiter',
'@default': ''
}
}],
// numbers
[/\d*\d+[eE]([\-+]?\d+)?/, 'number.float'],
[/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
[/0[xX][0-9a-fA-F']*[0-9a-fA-F]/, 'number.hex'],
[/0[0-7']*[0-7]/, 'number.octal'],
[/0[bB][0-1']*[0-1]/, 'number.binary'],
[/\d[\d']*/, 'number'],
[/\d/, 'number'],
// delimiter: after number because of .\d floats
[/[;,.]/, 'delimiter'],
// strings
[/"([^"\\]|\\.)*$/, 'string.invalid'],
[/"/, 'string', '@string'],
[/`/, "string", "@rawstring"],
// characters
[/'[^\\']'/, 'string'],
[/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
[/'/, 'string.invalid']
],
whitespace: [
[/[ \t\r\n]+/, ''],
[/\/\*\*(?!\/)/, 'comment.doc', '@doccomment'],
[/\/\*/, 'comment', '@comment'],
[/\/\/.*$/, 'comment'],
],
comment: [
[/[^\/*]+/, 'comment'],
// [/\/\*/, 'comment', '@push' ], // nested comment not allowed :-(
// [/\/\*/, 'comment.invalid' ], // this breaks block comments in the shape of /* //*/
[/\*\//, 'comment', '@pop'],
[/[\/*]/, 'comment']
],
//Identical copy of comment above, except for the addition of .doc
doccomment: [
[/[^\/*]+/, 'comment.doc'],
// [/\/\*/, 'comment.doc', '@push' ], // nested comment not allowed :-(
[/\/\*/, 'comment.doc.invalid'],
[/\*\//, 'comment.doc', '@pop'],
[/[\/*]/, 'comment.doc']
],
string: [
[/[^\\"]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/"/, 'string', '@pop']
],
rawstring: [
[/[^\`]/, "string"],
[/`/, "string", "@pop"]
],
},
};
/***/ })
}]);

149
41.f6f6840d.async.js Normal file
View File

@ -0,0 +1,149 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[41],{
/***/ "Eg73":
/*!******************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/graphql/graphql.js ***!
\******************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/graphql/graphql.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '#'
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"""', close: '"""', notIn: ['string', 'comment'] },
{ open: '"', close: '"', notIn: ['string', 'comment'] },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"""', close: '"""' },
{ open: '"', close: '"' },
],
folding: {
offSide: true
}
};
var language = {
// Set defaultToken to invalid to see what you do not tokenize yet
defaultToken: 'invalid',
tokenPostfix: '.gql',
keywords: [
'null', 'true', 'false',
'query', 'mutation', 'subscription',
'extend', 'schema', 'directive',
'scalar', 'type', 'interface', 'union', 'enum', 'input', 'implements',
'fragment', 'on',
],
typeKeywords: ['Int', 'Float', 'String', 'Boolean', 'ID'],
directiveLocations: [
'SCHEMA', 'SCALAR', 'OBJECT', 'FIELD_DEFINITION', 'ARGUMENT_DEFINITION',
'INTERFACE', 'UNION', 'ENUM', 'ENUM_VALUE', 'INPUT_OBJECT', 'INPUT_FIELD_DEFINITION',
'QUERY', 'MUTATION', 'SUBSCRIPTION', 'FIELD', 'FRAGMENT_DEFINITION',
'FRAGMENT_SPREAD', 'INLINE_FRAGMENT', 'VARIABLE_DEFINITION',
],
operators: ['=', '!', '?', ':', '&', '|'],
// we include these common regular expressions
symbols: /[=!?:&|]+/,
// https://facebook.github.io/graphql/draft/#sec-String-Value
escapes: /\\(?:["\\\/bfnrt]|u[0-9A-Fa-f]{4})/,
// The main tokenizer for our languages
tokenizer: {
root: [
// fields and argument names
[
/[a-z_][\w$]*/,
{
cases: {
'@keywords': 'keyword',
'@default': 'key.identifier',
},
},
],
// identify typed input variables
[
/[$][\w$]*/,
{
cases: {
'@keywords': 'keyword',
'@default': 'argument.identifier',
},
},
],
// to show class names nicely
[
/[A-Z][\w\$]*/,
{
cases: {
'@typeKeywords': 'keyword',
'@default': 'type.identifier',
},
},
],
// whitespace
{ include: '@whitespace' },
// delimiters and operators
[/[{}()\[\]]/, '@brackets'],
[
/@symbols/,
{ cases: { '@operators': 'operator', '@default': '' } },
],
// @ annotations.
// As an example, we emit a debugging log message on these tokens.
// Note: message are supressed during the first load -- change some lines to see them.
[
/@\s*[a-zA-Z_\$][\w\$]*/,
{ token: 'annotation', log: 'annotation token: $0' },
],
// numbers
[/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
[/0[xX][0-9a-fA-F]+/, 'number.hex'],
[/\d+/, 'number'],
// delimiter: after number because of .\d floats
[/[;,.]/, 'delimiter'],
[/"""/,
{ token: 'string', next: '@mlstring', nextEmbedded: 'markdown' }
],
// strings
[/"([^"\\]|\\.)*$/, 'string.invalid'],
[/"/, { token: 'string.quote', bracket: '@open', next: '@string' }],
],
mlstring: [
[/[^"]+/, 'string'],
['"""', { token: 'string', next: '@pop', nextEmbedded: '@pop' }]
],
string: [
[/[^\\"]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/"/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
],
whitespace: [[/[ \t\r\n]+/, ''], [/#.*$/, 'comment']],
},
};
/***/ })
}]);

214
42.175a4c11.async.js Normal file
View File

@ -0,0 +1,214 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[42],{
/***/ "O3xE":
/*!************************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/handlebars/handlebars.js ***!
\************************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/handlebars/handlebars.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
// Allow for running under nodejs/requirejs in tests
var _monaco = (typeof monaco === 'undefined' ? self.monaco : monaco);
var EMPTY_ELEMENTS = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr'];
var conf = {
wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\$\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\s]+)/g,
comments: {
blockComment: ['{{!--', '--}}']
},
brackets: [
['<!--', '-->'],
['<', '>'],
['{{', '}}'],
['{', '}'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' }
],
surroundingPairs: [
{ open: '<', close: '>' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' }
],
onEnterRules: [
{
beforeText: new RegExp("<(?!(?:" + EMPTY_ELEMENTS.join('|') + "))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$", 'i'),
afterText: /^<\/(\w[\w\d]*)\s*>$/i,
action: { indentAction: _monaco.languages.IndentAction.IndentOutdent }
},
{
beforeText: new RegExp("<(?!(?:" + EMPTY_ELEMENTS.join('|') + "))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$", 'i'),
action: { indentAction: _monaco.languages.IndentAction.Indent }
}
],
};
var language = {
defaultToken: '',
tokenPostfix: '',
// ignoreCase: true,
// The main tokenizer for our languages
tokenizer: {
root: [
[/\{\{/, { token: '@rematch', switchTo: '@handlebarsInSimpleState.root' }],
[/<!DOCTYPE/, 'metatag.html', '@doctype'],
[/<!--/, 'comment.html', '@comment'],
[/(<)(\w+)(\/>)/, ['delimiter.html', 'tag.html', 'delimiter.html']],
[/(<)(script)/, ['delimiter.html', { token: 'tag.html', next: '@script' }]],
[/(<)(style)/, ['delimiter.html', { token: 'tag.html', next: '@style' }]],
[/(<)([:\w]+)/, ['delimiter.html', { token: 'tag.html', next: '@otherTag' }]],
[/(<\/)(\w+)/, ['delimiter.html', { token: 'tag.html', next: '@otherTag' }]],
[/</, 'delimiter.html'],
[/\{/, 'delimiter.html'],
[/[^<{]+/] // text
],
doctype: [
[/\{\{/, { token: '@rematch', switchTo: '@handlebarsInSimpleState.comment' }],
[/[^>]+/, 'metatag.content.html'],
[/>/, 'metatag.html', '@pop'],
],
comment: [
[/\{\{/, { token: '@rematch', switchTo: '@handlebarsInSimpleState.comment' }],
[/-->/, 'comment.html', '@pop'],
[/[^-]+/, 'comment.content.html'],
[/./, 'comment.content.html']
],
otherTag: [
[/\{\{/, { token: '@rematch', switchTo: '@handlebarsInSimpleState.otherTag' }],
[/\/?>/, 'delimiter.html', '@pop'],
[/"([^"]*)"/, 'attribute.value'],
[/'([^']*)'/, 'attribute.value'],
[/[\w\-]+/, 'attribute.name'],
[/=/, 'delimiter'],
[/[ \t\r\n]+/],
],
// -- BEGIN <script> tags handling
// After <script
script: [
[/\{\{/, { token: '@rematch', switchTo: '@handlebarsInSimpleState.script' }],
[/type/, 'attribute.name', '@scriptAfterType'],
[/"([^"]*)"/, 'attribute.value'],
[/'([^']*)'/, 'attribute.value'],
[/[\w\-]+/, 'attribute.name'],
[/=/, 'delimiter'],
[/>/, { token: 'delimiter.html', next: '@scriptEmbedded.text/javascript', nextEmbedded: 'text/javascript' }],
[/[ \t\r\n]+/],
[/(<\/)(script\s*)(>)/, ['delimiter.html', 'tag.html', { token: 'delimiter.html', next: '@pop' }]]
],
// After <script ... type
scriptAfterType: [
[/\{\{/, { token: '@rematch', switchTo: '@handlebarsInSimpleState.scriptAfterType' }],
[/=/, 'delimiter', '@scriptAfterTypeEquals'],
[/>/, { token: 'delimiter.html', next: '@scriptEmbedded.text/javascript', nextEmbedded: 'text/javascript' }],
[/[ \t\r\n]+/],
[/<\/script\s*>/, { token: '@rematch', next: '@pop' }]
],
// After <script ... type =
scriptAfterTypeEquals: [
[/\{\{/, { token: '@rematch', switchTo: '@handlebarsInSimpleState.scriptAfterTypeEquals' }],
[/"([^"]*)"/, { token: 'attribute.value', switchTo: '@scriptWithCustomType.$1' }],
[/'([^']*)'/, { token: 'attribute.value', switchTo: '@scriptWithCustomType.$1' }],
[/>/, { token: 'delimiter.html', next: '@scriptEmbedded.text/javascript', nextEmbedded: 'text/javascript' }],
[/[ \t\r\n]+/],
[/<\/script\s*>/, { token: '@rematch', next: '@pop' }]
],
// After <script ... type = $S2
scriptWithCustomType: [
[/\{\{/, { token: '@rematch', switchTo: '@handlebarsInSimpleState.scriptWithCustomType.$S2' }],
[/>/, { token: 'delimiter.html', next: '@scriptEmbedded.$S2', nextEmbedded: '$S2' }],
[/"([^"]*)"/, 'attribute.value'],
[/'([^']*)'/, 'attribute.value'],
[/[\w\-]+/, 'attribute.name'],
[/=/, 'delimiter'],
[/[ \t\r\n]+/],
[/<\/script\s*>/, { token: '@rematch', next: '@pop' }]
],
scriptEmbedded: [
[/\{\{/, { token: '@rematch', switchTo: '@handlebarsInEmbeddedState.scriptEmbedded.$S2', nextEmbedded: '@pop' }],
[/<\/script/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }]
],
// -- END <script> tags handling
// -- BEGIN <style> tags handling
// After <style
style: [
[/\{\{/, { token: '@rematch', switchTo: '@handlebarsInSimpleState.style' }],
[/type/, 'attribute.name', '@styleAfterType'],
[/"([^"]*)"/, 'attribute.value'],
[/'([^']*)'/, 'attribute.value'],
[/[\w\-]+/, 'attribute.name'],
[/=/, 'delimiter'],
[/>/, { token: 'delimiter.html', next: '@styleEmbedded.text/css', nextEmbedded: 'text/css' }],
[/[ \t\r\n]+/],
[/(<\/)(style\s*)(>)/, ['delimiter.html', 'tag.html', { token: 'delimiter.html', next: '@pop' }]]
],
// After <style ... type
styleAfterType: [
[/\{\{/, { token: '@rematch', switchTo: '@handlebarsInSimpleState.styleAfterType' }],
[/=/, 'delimiter', '@styleAfterTypeEquals'],
[/>/, { token: 'delimiter.html', next: '@styleEmbedded.text/css', nextEmbedded: 'text/css' }],
[/[ \t\r\n]+/],
[/<\/style\s*>/, { token: '@rematch', next: '@pop' }]
],
// After <style ... type =
styleAfterTypeEquals: [
[/\{\{/, { token: '@rematch', switchTo: '@handlebarsInSimpleState.styleAfterTypeEquals' }],
[/"([^"]*)"/, { token: 'attribute.value', switchTo: '@styleWithCustomType.$1' }],
[/'([^']*)'/, { token: 'attribute.value', switchTo: '@styleWithCustomType.$1' }],
[/>/, { token: 'delimiter.html', next: '@styleEmbedded.text/css', nextEmbedded: 'text/css' }],
[/[ \t\r\n]+/],
[/<\/style\s*>/, { token: '@rematch', next: '@pop' }]
],
// After <style ... type = $S2
styleWithCustomType: [
[/\{\{/, { token: '@rematch', switchTo: '@handlebarsInSimpleState.styleWithCustomType.$S2' }],
[/>/, { token: 'delimiter.html', next: '@styleEmbedded.$S2', nextEmbedded: '$S2' }],
[/"([^"]*)"/, 'attribute.value'],
[/'([^']*)'/, 'attribute.value'],
[/[\w\-]+/, 'attribute.name'],
[/=/, 'delimiter'],
[/[ \t\r\n]+/],
[/<\/style\s*>/, { token: '@rematch', next: '@pop' }]
],
styleEmbedded: [
[/\{\{/, { token: '@rematch', switchTo: '@handlebarsInEmbeddedState.styleEmbedded.$S2', nextEmbedded: '@pop' }],
[/<\/style/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }]
],
// -- END <style> tags handling
handlebarsInSimpleState: [
[/\{\{\{?/, 'delimiter.handlebars'],
[/\}\}\}?/, { token: 'delimiter.handlebars', switchTo: '@$S2.$S3' }],
{ include: 'handlebarsRoot' }
],
handlebarsInEmbeddedState: [
[/\{\{\{?/, 'delimiter.handlebars'],
[/\}\}\}?/, { token: 'delimiter.handlebars', switchTo: '@$S2.$S3', nextEmbedded: '$S3' }],
{ include: 'handlebarsRoot' }
],
handlebarsRoot: [
[/"[^"]*"/, 'string.handlebars'],
[/[#/][^\s}]+/, 'keyword.helper.handlebars'],
[/else\b/, 'keyword.helper.handlebars'],
[/[\s]+/],
[/[^}]/, 'variable.parameter.handlebars'],
],
},
};
/***/ })
}]);

191
43.7cdda08a.async.js Normal file
View File

@ -0,0 +1,191 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[43],{
/***/ "tpLM":
/*!************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/html/html.js ***!
\************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/html/html.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
// Allow for running under nodejs/requirejs in tests
var _monaco = (typeof monaco === 'undefined' ? self.monaco : monaco);
var EMPTY_ELEMENTS = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr'];
var conf = {
wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\$\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\s]+)/g,
comments: {
blockComment: ['<!--', '-->']
},
brackets: [
['<!--', '-->'],
['<', '>'],
['{', '}'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' }
],
surroundingPairs: [
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '<', close: '>' },
],
onEnterRules: [
{
beforeText: new RegExp("<(?!(?:" + EMPTY_ELEMENTS.join('|') + "))([_:\\w][_:\\w-.\\d]*)([^/>]*(?!/)>)[^<]*$", 'i'),
afterText: /^<\/([_:\w][_:\w-.\d]*)\s*>$/i,
action: { indentAction: _monaco.languages.IndentAction.IndentOutdent }
},
{
beforeText: new RegExp("<(?!(?:" + EMPTY_ELEMENTS.join('|') + "))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$", 'i'),
action: { indentAction: _monaco.languages.IndentAction.Indent }
}
],
folding: {
markers: {
start: new RegExp("^\\s*<!--\\s*#region\\b.*-->"),
end: new RegExp("^\\s*<!--\\s*#endregion\\b.*-->")
}
}
};
var language = {
defaultToken: '',
tokenPostfix: '.html',
ignoreCase: true,
// The main tokenizer for our languages
tokenizer: {
root: [
[/<!DOCTYPE/, 'metatag', '@doctype'],
[/<!--/, 'comment', '@comment'],
[/(<)((?:[\w\-]+:)?[\w\-]+)(\s*)(\/>)/, ['delimiter', 'tag', '', 'delimiter']],
[/(<)(script)/, ['delimiter', { token: 'tag', next: '@script' }]],
[/(<)(style)/, ['delimiter', { token: 'tag', next: '@style' }]],
[/(<)((?:[\w\-]+:)?[\w\-]+)/, ['delimiter', { token: 'tag', next: '@otherTag' }]],
[/(<\/)((?:[\w\-]+:)?[\w\-]+)/, ['delimiter', { token: 'tag', next: '@otherTag' }]],
[/</, 'delimiter'],
[/[^<]+/],
],
doctype: [
[/[^>]+/, 'metatag.content'],
[/>/, 'metatag', '@pop'],
],
comment: [
[/-->/, 'comment', '@pop'],
[/[^-]+/, 'comment.content'],
[/./, 'comment.content']
],
otherTag: [
[/\/?>/, 'delimiter', '@pop'],
[/"([^"]*)"/, 'attribute.value'],
[/'([^']*)'/, 'attribute.value'],
[/[\w\-]+/, 'attribute.name'],
[/=/, 'delimiter'],
[/[ \t\r\n]+/],
],
// -- BEGIN <script> tags handling
// After <script
script: [
[/type/, 'attribute.name', '@scriptAfterType'],
[/"([^"]*)"/, 'attribute.value'],
[/'([^']*)'/, 'attribute.value'],
[/[\w\-]+/, 'attribute.name'],
[/=/, 'delimiter'],
[/>/, { token: 'delimiter', next: '@scriptEmbedded', nextEmbedded: 'text/javascript' }],
[/[ \t\r\n]+/],
[/(<\/)(script\s*)(>)/, ['delimiter', 'tag', { token: 'delimiter', next: '@pop' }]]
],
// After <script ... type
scriptAfterType: [
[/=/, 'delimiter', '@scriptAfterTypeEquals'],
[/>/, { token: 'delimiter', next: '@scriptEmbedded', nextEmbedded: 'text/javascript' }],
[/[ \t\r\n]+/],
[/<\/script\s*>/, { token: '@rematch', next: '@pop' }]
],
// After <script ... type =
scriptAfterTypeEquals: [
[/"([^"]*)"/, { token: 'attribute.value', switchTo: '@scriptWithCustomType.$1' }],
[/'([^']*)'/, { token: 'attribute.value', switchTo: '@scriptWithCustomType.$1' }],
[/>/, { token: 'delimiter', next: '@scriptEmbedded', nextEmbedded: 'text/javascript' }],
[/[ \t\r\n]+/],
[/<\/script\s*>/, { token: '@rematch', next: '@pop' }]
],
// After <script ... type = $S2
scriptWithCustomType: [
[/>/, { token: 'delimiter', next: '@scriptEmbedded.$S2', nextEmbedded: '$S2' }],
[/"([^"]*)"/, 'attribute.value'],
[/'([^']*)'/, 'attribute.value'],
[/[\w\-]+/, 'attribute.name'],
[/=/, 'delimiter'],
[/[ \t\r\n]+/],
[/<\/script\s*>/, { token: '@rematch', next: '@pop' }]
],
scriptEmbedded: [
[/<\/script/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
[/[^<]+/, '']
],
// -- END <script> tags handling
// -- BEGIN <style> tags handling
// After <style
style: [
[/type/, 'attribute.name', '@styleAfterType'],
[/"([^"]*)"/, 'attribute.value'],
[/'([^']*)'/, 'attribute.value'],
[/[\w\-]+/, 'attribute.name'],
[/=/, 'delimiter'],
[/>/, { token: 'delimiter', next: '@styleEmbedded', nextEmbedded: 'text/css' }],
[/[ \t\r\n]+/],
[/(<\/)(style\s*)(>)/, ['delimiter', 'tag', { token: 'delimiter', next: '@pop' }]]
],
// After <style ... type
styleAfterType: [
[/=/, 'delimiter', '@styleAfterTypeEquals'],
[/>/, { token: 'delimiter', next: '@styleEmbedded', nextEmbedded: 'text/css' }],
[/[ \t\r\n]+/],
[/<\/style\s*>/, { token: '@rematch', next: '@pop' }]
],
// After <style ... type =
styleAfterTypeEquals: [
[/"([^"]*)"/, { token: 'attribute.value', switchTo: '@styleWithCustomType.$1' }],
[/'([^']*)'/, { token: 'attribute.value', switchTo: '@styleWithCustomType.$1' }],
[/>/, { token: 'delimiter', next: '@styleEmbedded', nextEmbedded: 'text/css' }],
[/[ \t\r\n]+/],
[/<\/style\s*>/, { token: '@rematch', next: '@pop' }]
],
// After <style ... type = $S2
styleWithCustomType: [
[/>/, { token: 'delimiter', next: '@styleEmbedded.$S2', nextEmbedded: '$S2' }],
[/"([^"]*)"/, 'attribute.value'],
[/'([^']*)'/, 'attribute.value'],
[/[\w\-]+/, 'attribute.name'],
[/=/, 'delimiter'],
[/[ \t\r\n]+/],
[/<\/style\s*>/, { token: '@rematch', next: '@pop' }]
],
styleEmbedded: [
[/<\/style/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
[/[^<]+/, '']
],
},
};
/***/ })
}]);

88
44.08b4031f.async.js Normal file
View File

@ -0,0 +1,88 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[44],{
/***/ "On+f":
/*!**********************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/ini/ini.js ***!
\**********************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/ini/ini.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '#'
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')'],
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
]
};
var language = {
defaultToken: '',
tokenPostfix: '.ini',
// we include these common regular expressions
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
// The main tokenizer for our languages
tokenizer: {
root: [
// sections
[/^\[[^\]]*\]/, 'metatag'],
// keys
[/(^\w+)(\s*)(\=)/, ['key', '', 'delimiter']],
// whitespace
{ include: '@whitespace' },
// numbers
[/\d+/, 'number'],
// strings: recover on non-terminated strings
[/"([^"\\]|\\.)*$/, 'string.invalid'],
[/'([^'\\]|\\.)*$/, 'string.invalid'],
[/"/, 'string', '@string."'],
[/'/, 'string', '@string.\''],
],
whitespace: [
[/[ \t\r\n]+/, ''],
[/^\s*[#;].*$/, 'comment'],
],
string: [
[/[^\\"']+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/["']/, {
cases: {
'$#==$S2': { token: 'string', next: '@pop' },
'@default': 'string'
}
}]
],
},
};
/***/ })
}]);

155
45.397115c8.async.js Normal file
View File

@ -0,0 +1,155 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[45],{
/***/ "BjZ/":
/*!************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/java/java.js ***!
\************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/java/java.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
// the default separators except `@$`
wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
comments: {
lineComment: '//',
blockComment: ['/*', '*/'],
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')'],
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
{ open: '<', close: '>' },
],
folding: {
markers: {
start: new RegExp("^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))"),
end: new RegExp("^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))")
}
}
};
var language = {
defaultToken: '',
tokenPostfix: '.java',
keywords: [
'abstract', 'continue', 'for', 'new', 'switch', 'assert', 'default',
'goto', 'package', 'synchronized', 'boolean', 'do', 'if', 'private',
'this', 'break', 'double', 'implements', 'protected', 'throw', 'byte',
'else', 'import', 'public', 'throws', 'case', 'enum', 'instanceof', 'return',
'transient', 'catch', 'extends', 'int', 'short', 'try', 'char', 'final',
'interface', 'static', 'void', 'class', 'finally', 'long', 'strictfp',
'volatile', 'const', 'float', 'native', 'super', 'while', 'true', 'false'
],
operators: [
'=', '>', '<', '!', '~', '?', ':',
'==', '<=', '>=', '!=', '&&', '||', '++', '--',
'+', '-', '*', '/', '&', '|', '^', '%', '<<',
'>>', '>>>', '+=', '-=', '*=', '/=', '&=', '|=',
'^=', '%=', '<<=', '>>=', '>>>='
],
// we include these common regular expressions
symbols: /[=><!~?:&|+\-*\/\^%]+/,
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
digits: /\d+(_+\d+)*/,
octaldigits: /[0-7]+(_+[0-7]+)*/,
binarydigits: /[0-1]+(_+[0-1]+)*/,
hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
// The main tokenizer for our languages
tokenizer: {
root: [
// identifiers and keywords
[/[a-zA-Z_$][\w$]*/, {
cases: {
'@keywords': { token: 'keyword.$0' },
'@default': 'identifier'
}
}],
// whitespace
{ include: '@whitespace' },
// delimiters and operators
[/[{}()\[\]]/, '@brackets'],
[/[<>](?!@symbols)/, '@brackets'],
[/@symbols/, {
cases: {
'@operators': 'delimiter',
'@default': ''
}
}],
// @ annotations.
[/@\s*[a-zA-Z_\$][\w\$]*/, 'annotation'],
// numbers
[/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/, 'number.float'],
[/(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/, 'number.float'],
[/0[xX](@hexdigits)[Ll]?/, 'number.hex'],
[/0(@octaldigits)[Ll]?/, 'number.octal'],
[/0[bB](@binarydigits)[Ll]?/, 'number.binary'],
[/(@digits)[fFdD]/, 'number.float'],
[/(@digits)[lL]?/, 'number'],
// delimiter: after number because of .\d floats
[/[;,.]/, 'delimiter'],
// strings
[/"([^"\\]|\\.)*$/, 'string.invalid'],
[/"/, 'string', '@string'],
// characters
[/'[^\\']'/, 'string'],
[/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
[/'/, 'string.invalid']
],
whitespace: [
[/[ \t\r\n]+/, ''],
[/\/\*\*(?!\/)/, 'comment.doc', '@javadoc'],
[/\/\*/, 'comment', '@comment'],
[/\/\/.*$/, 'comment'],
],
comment: [
[/[^\/*]+/, 'comment'],
// [/\/\*/, 'comment', '@push' ], // nested comment not allowed :-(
// [/\/\*/, 'comment.invalid' ], // this breaks block comments in the shape of /* //*/
[/\*\//, 'comment', '@pop'],
[/[\/*]/, 'comment']
],
//Identical copy of comment above, except for the addition of .doc
javadoc: [
[/[^\/*]+/, 'comment.doc'],
// [/\/\*/, 'comment.doc', '@push' ], // nested comment not allowed :-(
[/\/\*/, 'comment.doc.invalid'],
[/\*\//, 'comment.doc', '@pop'],
[/[\/*]/, 'comment.doc']
],
string: [
[/[^\\"]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/"/, 'string', '@pop']
],
},
};
/***/ })
}]);

165
46.b673e63f.async.js Normal file
View File

@ -0,0 +1,165 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[46],{
/***/ "y0OK":
/*!****************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/kotlin/kotlin.js ***!
\****************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/kotlin/kotlin.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
// the default separators except `@$`
wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
comments: {
lineComment: '//',
blockComment: ['/*', '*/'],
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')'],
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
{ open: '<', close: '>' },
],
folding: {
markers: {
start: new RegExp("^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))"),
end: new RegExp("^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))")
}
}
};
var language = {
defaultToken: '',
tokenPostfix: '.kt',
keywords: [
'as', 'as?', 'break', 'class', 'continue', 'do', 'else', 'false', 'for', 'fun', 'if',
'in', '!in', 'interface', 'is', '!is', 'null', 'object', 'package', 'return', 'super',
'this', 'throw', 'true', 'try', 'typealias', 'val', 'var', 'when', 'while', 'by',
'catch', 'constructor', 'delegate', 'dynamic', 'field', 'file', 'finally', 'get',
'import', 'init', 'param', 'property', 'receiver', 'set', 'setparam', 'where', 'actual',
'abstract', 'annotation', 'companion', 'const', 'crossinline', 'data', 'enum', 'expect',
'external', 'final', 'infix', 'inline', 'inner', 'internal', 'lateinit', 'noinline',
'open', 'operator', 'out', 'override', 'private', 'protected', 'public', 'reified',
'sealed', 'suspend', 'tailrec', 'vararg', 'field', 'it'
],
operators: [
'+', '-', '*', '/', '%', '=', '+=', '-=', '*=', '/=',
'%=', '++', '--', '&&', '||', '!', '==', '!=', '===',
'!==', '>', '<', '<=', '>=', '[', ']', '!!', '?.', '?:',
'::', '..', ':', '?', '->', '@', ';', '$', '_'
],
// we include these common regular expressions
symbols: /[=><!~?:&|+\-*\/\^%]+/,
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
digits: /\d+(_+\d+)*/,
octaldigits: /[0-7]+(_+[0-7]+)*/,
binarydigits: /[0-1]+(_+[0-1]+)*/,
hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
// The main tokenizer for our languages
tokenizer: {
root: [
// class name highlighting
[/[A-Z][\w\$]*/, 'type.identifier'],
// identifiers and keywords
[/[a-zA-Z_$][\w$]*/, {
cases: {
'@keywords': { token: 'keyword.$0' },
'@default': 'identifier'
}
}],
// whitespace
{ include: '@whitespace' },
// delimiters and operators
[/[{}()\[\]]/, '@brackets'],
[/[<>](?!@symbols)/, '@brackets'],
[/@symbols/, {
cases: {
'@operators': 'delimiter',
'@default': ''
}
}],
// @ annotations.
[/@\s*[a-zA-Z_\$][\w\$]*/, 'annotation'],
// numbers
[/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/, 'number.float'],
[/(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/, 'number.float'],
[/0[xX](@hexdigits)[Ll]?/, 'number.hex'],
[/0(@octaldigits)[Ll]?/, 'number.octal'],
[/0[bB](@binarydigits)[Ll]?/, 'number.binary'],
[/(@digits)[fFdD]/, 'number.float'],
[/(@digits)[lL]?/, 'number'],
// delimiter: after number because of .\d floats
[/[;,.]/, 'delimiter'],
// strings
[/"([^"\\]|\\.)*$/, 'string.invalid'],
[/"""/, 'string', '@multistring'],
[/"/, 'string', '@string'],
// characters
[/'[^\\']'/, 'string'],
[/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
[/'/, 'string.invalid']
],
whitespace: [
[/[ \t\r\n]+/, ''],
[/\/\*\*(?!\/)/, 'comment.doc', '@javadoc'],
[/\/\*/, 'comment', '@comment'],
[/\/\/.*$/, 'comment'],
],
comment: [
[/[^\/*]+/, 'comment'],
[/\/\*/, 'comment', '@comment'],
[/\*\//, 'comment', '@pop'],
[/[\/*]/, 'comment']
],
//Identical copy of comment above, except for the addition of .doc
javadoc: [
[/[^\/*]+/, 'comment.doc'],
[/\/\*/, 'comment.doc', '@push'],
[/\/\*/, 'comment.doc.invalid'],
[/\*\//, 'comment.doc', '@pop'],
[/[\/*]/, 'comment.doc']
],
string: [
[/[^\\"]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/"/, 'string', '@pop']
],
multistring: [
[/[^\\"]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/"""/, 'string', '@pop'],
[/./, 'string']
],
},
};
/***/ })
}]);

164
47.3600c6a5.async.js Normal file
View File

@ -0,0 +1,164 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[47],{
/***/ "OfHX":
/*!************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/less/less.js ***!
\************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/less/less.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
wordPattern: /(#?-?\d*\.\d\w*%?)|([@#!.:]?[\w-?]+%?)|[@#!.]/g,
comments: {
blockComment: ['/*', '*/'],
lineComment: '//'
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')'],
],
autoClosingPairs: [
{ open: '{', close: '}', notIn: ['string', 'comment'] },
{ open: '[', close: ']', notIn: ['string', 'comment'] },
{ open: '(', close: ')', notIn: ['string', 'comment'] },
{ open: '"', close: '"', notIn: ['string', 'comment'] },
{ open: '\'', close: '\'', notIn: ['string', 'comment'] },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
folding: {
markers: {
start: new RegExp("^\\s*\\/\\*\\s*#region\\b\\s*(.*?)\\s*\\*\\/"),
end: new RegExp("^\\s*\\/\\*\\s*#endregion\\b.*\\*\\/")
}
}
};
var language = {
defaultToken: '',
tokenPostfix: '.less',
identifier: '-?-?([a-zA-Z]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*',
identifierPlus: '-?-?([a-zA-Z:.]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-:.]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*',
brackets: [
{ open: '{', close: '}', token: 'delimiter.curly' },
{ open: '[', close: ']', token: 'delimiter.bracket' },
{ open: '(', close: ')', token: 'delimiter.parenthesis' },
{ open: '<', close: '>', token: 'delimiter.angle' }
],
tokenizer: {
root: [
{ include: '@nestedJSBegin' },
['[ \\t\\r\\n]+', ''],
{ include: '@comments' },
{ include: '@keyword' },
{ include: '@strings' },
{ include: '@numbers' },
['[*_]?[a-zA-Z\\-\\s]+(?=:.*(;|(\\\\$)))', 'attribute.name', '@attribute'],
['url(\\-prefix)?\\(', { token: 'tag', next: '@urldeclaration' }],
['[{}()\\[\\]]', '@brackets'],
['[,:;]', 'delimiter'],
['#@identifierPlus', 'tag.id'],
['&', 'tag'],
['\\.@identifierPlus(?=\\()', 'tag.class', '@attribute'],
['\\.@identifierPlus', 'tag.class'],
['@identifierPlus', 'tag'],
{ include: '@operators' },
['@(@identifier(?=[:,\\)]))', 'variable', '@attribute'],
['@(@identifier)', 'variable'],
['@', 'key', '@atRules']
],
nestedJSBegin: [
['``', 'delimiter.backtick'],
['`', { token: 'delimiter.backtick', next: '@nestedJSEnd', nextEmbedded: 'text/javascript' }],
],
nestedJSEnd: [
['`', { token: 'delimiter.backtick', next: '@pop', nextEmbedded: '@pop' }],
],
operators: [
['[<>=\\+\\-\\*\\/\\^\\|\\~]', 'operator']
],
keyword: [
['(@[\\s]*import|![\\s]*important|true|false|when|iscolor|isnumber|isstring|iskeyword|isurl|ispixel|ispercentage|isem|hue|saturation|lightness|alpha|lighten|darken|saturate|desaturate|fadein|fadeout|fade|spin|mix|round|ceil|floor|percentage)\\b', 'keyword']
],
urldeclaration: [
{ include: '@strings' },
['[^)\r\n]+', 'string'],
['\\)', { token: 'tag', next: '@pop' }],
],
attribute: [
{ include: '@nestedJSBegin' },
{ include: '@comments' },
{ include: '@strings' },
{ include: '@numbers' },
{ include: '@keyword' },
['[a-zA-Z\\-]+(?=\\()', 'attribute.value', '@attribute'],
['>', 'operator', '@pop'],
['@identifier', 'attribute.value'],
{ include: '@operators' },
['@(@identifier)', 'variable'],
['[)\\}]', '@brackets', '@pop'],
['[{}()\\[\\]>]', '@brackets'],
['[;]', 'delimiter', '@pop'],
['[,=:]', 'delimiter'],
['\\s', ''],
['.', 'attribute.value']
],
comments: [
['\\/\\*', 'comment', '@comment'],
['\\/\\/+.*', 'comment'],
],
comment: [
['\\*\\/', 'comment', '@pop'],
['.', 'comment'],
],
numbers: [
['(\\d*\\.)?\\d+([eE][\\-+]?\\d+)?', { token: 'attribute.value.number', next: '@units' }],
['#[0-9a-fA-F_]+(?!\\w)', 'attribute.value.hex']
],
units: [
['(em|ex|ch|rem|vmin|vmax|vw|vh|vm|cm|mm|in|px|pt|pc|deg|grad|rad|turn|s|ms|Hz|kHz|%)?', 'attribute.value.unit', '@pop']
],
strings: [
['~?"', { token: 'string.delimiter', next: '@stringsEndDoubleQuote' }],
['~?\'', { token: 'string.delimiter', next: '@stringsEndQuote' }]
],
stringsEndDoubleQuote: [
['\\\\"', 'string'],
['"', { token: 'string.delimiter', next: '@popall' }],
['.', 'string']
],
stringsEndQuote: [
['\\\\\'', 'string'],
['\'', { token: 'string.delimiter', next: '@popall' }],
['.', 'string']
],
atRules: [
{ include: '@comments' },
{ include: '@strings' },
['[()]', 'delimiter'],
['[\\{;]', 'delimiter', '@pop'],
['.', 'key']
]
}
};
/***/ })
}]);

135
48.d1f24edf.async.js Normal file
View File

@ -0,0 +1,135 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[48],{
/***/ "yUwd":
/*!**********************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/lua/lua.js ***!
\**********************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/lua/lua.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '--',
blockComment: ['--[[', ']]'],
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
]
};
var language = {
defaultToken: '',
tokenPostfix: '.lua',
keywords: [
'and', 'break', 'do', 'else', 'elseif',
'end', 'false', 'for', 'function', 'goto', 'if',
'in', 'local', 'nil', 'not', 'or',
'repeat', 'return', 'then', 'true', 'until',
'while'
],
brackets: [
{ token: 'delimiter.bracket', open: '{', close: '}' },
{ token: 'delimiter.array', open: '[', close: ']' },
{ token: 'delimiter.parenthesis', open: '(', close: ')' }
],
operators: [
'+', '-', '*', '/', '%', '^', '#', '==', '~=', '<=', '>=', '<', '>', '=',
';', ':', ',', '.', '..', '...'
],
// we include these common regular expressions
symbols: /[=><!~?:&|+\-*\/\^%]+/,
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
// The main tokenizer for our languages
tokenizer: {
root: [
// identifiers and keywords
[/[a-zA-Z_]\w*/, {
cases: {
'@keywords': { token: 'keyword.$0' },
'@default': 'identifier'
}
}],
// whitespace
{ include: '@whitespace' },
// keys
[/(,)(\s*)([a-zA-Z_]\w*)(\s*)(:)(?!:)/, ['delimiter', '', 'key', '', 'delimiter']],
[/({)(\s*)([a-zA-Z_]\w*)(\s*)(:)(?!:)/, ['@brackets', '', 'key', '', 'delimiter']],
// delimiters and operators
[/[{}()\[\]]/, '@brackets'],
[/@symbols/, {
cases: {
'@operators': 'delimiter',
'@default': ''
}
}],
// numbers
[/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
[/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, 'number.hex'],
[/\d+?/, 'number'],
// delimiter: after number because of .\d floats
[/[;,.]/, 'delimiter'],
// strings: recover on non-terminated strings
[/"([^"\\]|\\.)*$/, 'string.invalid'],
[/'([^'\\]|\\.)*$/, 'string.invalid'],
[/"/, 'string', '@string."'],
[/'/, 'string', '@string.\''],
],
whitespace: [
[/[ \t\r\n]+/, ''],
[/--\[([=]*)\[/, 'comment', '@comment.$1'],
[/--.*$/, 'comment'],
],
comment: [
[/[^\]]+/, 'comment'],
[/\]([=]*)\]/, {
cases: {
'$1==$S2': { token: 'comment', next: '@pop' },
'@default': 'comment'
}
}],
[/./, 'comment']
],
string: [
[/[^\\"']+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/["']/, {
cases: {
'$#==$S2': { token: 'string', next: '@pop' },
'@default': 'string'
}
}]
],
},
};
/***/ })
}]);

198
49.d560ebf5.async.js Normal file
View File

@ -0,0 +1,198 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[49],{
/***/ "PhST":
/*!********************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/markdown/markdown.js ***!
\********************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/markdown/markdown.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
blockComment: ['<!--', '-->',]
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '<', close: '>', notIn: ['string'] }
],
surroundingPairs: [
{ open: '(', close: ')' },
{ open: '[', close: ']' },
{ open: '`', close: '`' },
],
folding: {
markers: {
start: new RegExp("^\\s*<!--\\s*#?region\\b.*-->"),
end: new RegExp("^\\s*<!--\\s*#?endregion\\b.*-->")
}
}
};
var language = {
defaultToken: '',
tokenPostfix: '.md',
// escape codes
control: /[\\`*_\[\]{}()#+\-\.!]/,
noncontrol: /[^\\`*_\[\]{}()#+\-\.!]/,
escapes: /\\(?:@control)/,
// escape codes for javascript/CSS strings
jsescapes: /\\(?:[btnfr\\"']|[0-7][0-7]?|[0-3][0-7]{2})/,
// non matched elements
empty: [
'area', 'base', 'basefont', 'br', 'col', 'frame',
'hr', 'img', 'input', 'isindex', 'link', 'meta', 'param'
],
tokenizer: {
root: [
// markdown tables
[/^\s*\|/, '@rematch', '@table_header'],
// headers (with #)
[/^(\s{0,3})(#+)((?:[^\\#]|@escapes)+)((?:#+)?)/, ['white', 'keyword', 'keyword', 'keyword']],
// headers (with =)
[/^\s*(=+|\-+)\s*$/, 'keyword'],
// headers (with ***)
[/^\s*((\*[ ]?)+)\s*$/, 'meta.separator'],
// quote
[/^\s*>+/, 'comment'],
// list (starting with * or number)
[/^\s*([\*\-+:]|\d+\.)\s/, 'keyword'],
// code block (4 spaces indent)
[/^(\t|[ ]{4})[^ ].*$/, 'string'],
// code block (3 tilde)
[/^\s*~~~\s*((?:\w|[\/\-#])+)?\s*$/, { token: 'string', next: '@codeblock' }],
// github style code blocks (with backticks and language)
[/^\s*```\s*((?:\w|[\/\-#])+).*$/, { token: 'string', next: '@codeblockgh', nextEmbedded: '$1' }],
// github style code blocks (with backticks but no language)
[/^\s*```\s*$/, { token: 'string', next: '@codeblock' }],
// markup within lines
{ include: '@linecontent' },
],
table_header: [
{ include: '@table_common' },
[/[^\|]+/, 'keyword.table.header'],
],
table_body: [
{ include: '@table_common' },
{ include: '@linecontent' },
],
table_common: [
[/\s*[\-:]+\s*/, { token: 'keyword', switchTo: 'table_body' }],
[/^\s*\|/, 'keyword.table.left'],
[/^\s*[^\|]/, '@rematch', '@pop'],
[/^\s*$/, '@rematch', '@pop'],
[/\|/, {
cases: {
'@eos': 'keyword.table.right',
'@default': 'keyword.table.middle',
}
}],
],
codeblock: [
[/^\s*~~~\s*$/, { token: 'string', next: '@pop' }],
[/^\s*```\s*$/, { token: 'string', next: '@pop' }],
[/.*$/, 'variable.source'],
],
// github style code blocks
codeblockgh: [
[/```\s*$/, { token: 'variable.source', next: '@pop', nextEmbedded: '@pop' }],
[/[^`]+/, 'variable.source'],
],
linecontent: [
// escapes
[/&\w+;/, 'string.escape'],
[/@escapes/, 'escape'],
// various markup
[/\b__([^\\_]|@escapes|_(?!_))+__\b/, 'strong'],
[/\*\*([^\\*]|@escapes|\*(?!\*))+\*\*/, 'strong'],
[/\b_[^_]+_\b/, 'emphasis'],
[/\*([^\\*]|@escapes)+\*/, 'emphasis'],
[/`([^\\`]|@escapes)+`/, 'variable'],
// links
[/\{+[^}]+\}+/, 'string.target'],
[/(!?\[)((?:[^\]\\]|@escapes)*)(\]\([^\)]+\))/, ['string.link', '', 'string.link']],
[/(!?\[)((?:[^\]\\]|@escapes)*)(\])/, 'string.link'],
// or html
{ include: 'html' },
],
// Note: it is tempting to rather switch to the real HTML mode instead of building our own here
// but currently there is a limitation in Monarch that prevents us from doing it: The opening
// '<' would start the HTML mode, however there is no way to jump 1 character back to let the
// HTML mode also tokenize the opening angle bracket. Thus, even though we could jump to HTML,
// we cannot correctly tokenize it in that mode yet.
html: [
// html tags
[/<(\w+)\/>/, 'tag'],
[/<(\w+)/, {
cases: {
'@empty': { token: 'tag', next: '@tag.$1' },
'@default': { token: 'tag', next: '@tag.$1' }
}
}],
[/<\/(\w+)\s*>/, { token: 'tag' }],
[/<!--/, 'comment', '@comment']
],
comment: [
[/[^<\-]+/, 'comment.content'],
[/-->/, 'comment', '@pop'],
[/<!--/, 'comment.content.invalid'],
[/[<\-]/, 'comment.content']
],
// Almost full HTML tag matching, complete with embedded scripts & styles
tag: [
[/[ \t\r\n]+/, 'white'],
[/(type)(\s*=\s*)(")([^"]+)(")/, ['attribute.name.html', 'delimiter.html', 'string.html',
{ token: 'string.html', switchTo: '@tag.$S2.$4' },
'string.html']],
[/(type)(\s*=\s*)(')([^']+)(')/, ['attribute.name.html', 'delimiter.html', 'string.html',
{ token: 'string.html', switchTo: '@tag.$S2.$4' },
'string.html']],
[/(\w+)(\s*=\s*)("[^"]*"|'[^']*')/, ['attribute.name.html', 'delimiter.html', 'string.html']],
[/\w+/, 'attribute.name.html'],
[/\/>/, 'tag', '@pop'],
[/>/, {
cases: {
'$S2==style': { token: 'tag', switchTo: 'embeddedStyle', nextEmbedded: 'text/css' },
'$S2==script': {
cases: {
'$S3': { token: 'tag', switchTo: 'embeddedScript', nextEmbedded: '$S3' },
'@default': { token: 'tag', switchTo: 'embeddedScript', nextEmbedded: 'text/javascript' }
}
},
'@default': { token: 'tag', next: '@pop' }
}
}],
],
embeddedStyle: [
[/[^<]+/, ''],
[/<\/style\s*>/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
[/</, '']
],
embeddedScript: [
[/[^<]+/, ''],
[/<\/script\s*>/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
[/</, '']
],
}
};
/***/ })
}]);

150
50.e31b4cd9.async.js Normal file
View File

@ -0,0 +1,150 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[50],{
/***/ "DTUS":
/*!************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/mips/mips.js ***!
\************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/mips/mips.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\$\-\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
comments: {
blockComment: ['###', '###'],
lineComment: '#'
},
folding: {
markers: {
start: new RegExp("^\\s*#region\\b"),
end: new RegExp("^\\s*#endregion\\b")
}
}
};
var language = {
defaultToken: '',
ignoreCase: false,
tokenPostfix: '.mips',
regEx: /\/(?!\/\/)(?:[^\/\\]|\\.)*\/[igm]*/,
keywords: [
'.data', '.text', 'syscall', 'trap',
'add', 'addu', 'addi', 'addiu', 'and', 'andi',
'div', 'divu', 'mult', 'multu', 'nor', 'or', 'ori',
'sll', 'slv', 'sra', 'srav', 'srl', 'srlv',
'sub', 'subu', 'xor', 'xori', 'lhi', 'lho',
'lhi', 'llo', 'slt', 'slti', 'sltu', 'sltiu',
'beq', 'bgtz', 'blez', 'bne', 'j', 'jal', 'jalr', 'jr',
'lb', 'lbu', 'lh', 'lhu', 'lw', 'li', 'la',
'sb', 'sh', 'sw', 'mfhi', 'mflo', 'mthi', 'mtlo', 'move',
],
// we include these common regular expressions
symbols: /[\.,\:]+/,
escapes: /\\(?:[abfnrtv\\"'$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
// The main tokenizer for our languages
tokenizer: {
root: [
// identifiers and keywords
[/\$[a-zA-Z_]\w*/, 'variable.predefined'],
[/[.a-zA-Z_]\w*/, {
cases: {
'this': 'variable.predefined',
'@keywords': { token: 'keyword.$0' },
'@default': ''
}
}],
// whitespace
[/[ \t\r\n]+/, ''],
// Comments
[/#.*$/, 'comment'],
// regular expressions
['///', { token: 'regexp', next: '@hereregexp' }],
[/^(\s*)(@regEx)/, ['', 'regexp']],
[/(\,)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
[/(\:)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
// delimiters
[/@symbols/, 'delimiter'],
// numbers
[/\d+[eE]([\-+]?\d+)?/, 'number.float'],
[/\d+\.\d+([eE][\-+]?\d+)?/, 'number.float'],
[/0[xX][0-9a-fA-F]+/, 'number.hex'],
[/0[0-7]+(?!\d)/, 'number.octal'],
[/\d+/, 'number'],
// delimiter: after number because of .\d floats
[/[,.]/, 'delimiter'],
// strings:
[/"""/, 'string', '@herestring."""'],
[/'''/, 'string', '@herestring.\'\'\''],
[/"/, {
cases: {
'@eos': 'string',
'@default': { token: 'string', next: '@string."' }
}
}],
[/'/, {
cases: {
'@eos': 'string',
'@default': { token: 'string', next: '@string.\'' }
}
}],
],
string: [
[/[^"'\#\\]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\./, 'string.escape.invalid'],
[/\./, 'string.escape.invalid'],
[/#{/, {
cases: {
'$S2=="': { token: 'string', next: 'root.interpolatedstring' },
'@default': 'string'
}
}],
[/["']/, {
cases: {
'$#==$S2': { token: 'string', next: '@pop' },
'@default': 'string'
}
}],
[/#/, 'string']
],
herestring: [
[/("""|''')/, {
cases: {
'$1==$S2': { token: 'string', next: '@pop' },
'@default': 'string'
}
}],
[/[^#\\'"]+/, 'string'],
[/['"]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\./, 'string.escape.invalid'],
[/#{/, { token: 'string.quote', next: 'root.interpolatedstring' }],
[/#/, 'string']
],
comment: [
[/[^#]+/, 'comment',],
[/#/, 'comment'],
],
hereregexp: [
[/[^\\\/#]+/, 'regexp'],
[/\\./, 'regexp'],
[/#.*$/, 'comment'],
['///[igm]*', { token: 'regexp', next: '@pop' }],
[/\//, 'regexp'],
],
},
};
/***/ })
}]);

188
51.c178c1b5.async.js Normal file
View File

@ -0,0 +1,188 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[51],{
/***/ "8m5U":
/*!**************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/msdax/msdax.js ***!
\**************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/msdax/msdax.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '//',
blockComment: ['/*', '*/'],
},
brackets: [['[', ']'], ['(', ')'], ['{', '}']],
autoClosingPairs: [
{ open: '"', close: '"', notIn: ['string', 'comment'] },
{ open: '\'', close: '\'', notIn: ['string', 'comment'] },
{ open: '[', close: ']', notIn: ['string', 'comment'] },
{ open: '(', close: ')', notIn: ['string', 'comment'] },
{ open: '{', close: '}', notIn: ['string', 'comment'] },
]
};
var language = {
defaultToken: '',
tokenPostfix: '.msdax',
ignoreCase: true,
brackets: [
{ open: '[', close: ']', token: 'delimiter.square' },
{ open: '{', close: '}', token: 'delimiter.brackets' },
{ open: '(', close: ')', token: 'delimiter.parenthesis' }
],
keywords: [
// Query keywords
'VAR',
'RETURN',
'NOT',
'EVALUATE',
'DATATABLE',
'ORDER',
'BY',
'START',
'AT',
'DEFINE',
'MEASURE',
'ASC',
'DESC',
'IN',
// Datatable types
'BOOLEAN',
'DOUBLE',
'INTEGER',
'DATETIME',
'CURRENCY',
'STRING'
],
functions: [
// Relational
'CLOSINGBALANCEMONTH', 'CLOSINGBALANCEQUARTER', 'CLOSINGBALANCEYEAR', 'DATEADD', 'DATESBETWEEN',
'DATESINPERIOD', 'DATESMTD', 'DATESQTD', 'DATESYTD', 'ENDOFMONTH',
'ENDOFQUARTER', 'ENDOFYEAR', 'FIRSTDATE', 'FIRSTNONBLANK', 'LASTDATE',
'LASTNONBLANK', 'NEXTDAY', 'NEXTMONTH', 'NEXTQUARTER', 'NEXTYEAR',
'OPENINGBALANCEMONTH', 'OPENINGBALANCEQUARTER', 'OPENINGBALANCEYEAR', 'PARALLELPERIOD', 'PREVIOUSDAY',
'PREVIOUSMONTH', 'PREVIOUSQUARTER', 'PREVIOUSYEAR', 'SAMEPERIODLASTYEAR', 'STARTOFMONTH',
'STARTOFQUARTER', 'STARTOFYEAR', 'TOTALMTD', 'TOTALQTD', 'TOTALYTD',
'ADDCOLUMNS', 'ADDMISSINGITEMS', 'ALL', 'ALLEXCEPT', 'ALLNOBLANKROW',
'ALLSELECTED', 'CALCULATE', 'CALCULATETABLE', 'CALENDAR', 'CALENDARAUTO',
'CROSSFILTER', 'CROSSJOIN', 'CURRENTGROUP', 'DATATABLE', 'DETAILROWS',
'DISTINCT', 'EARLIER', 'EARLIEST', 'EXCEPT', 'FILTER',
'FILTERS', 'GENERATE', 'GENERATEALL', 'GROUPBY', 'IGNORE',
'INTERSECT', 'ISONORAFTER', 'KEEPFILTERS', 'LOOKUPVALUE', 'NATURALINNERJOIN',
'NATURALLEFTOUTERJOIN', 'RELATED', 'RELATEDTABLE', 'ROLLUP', 'ROLLUPADDISSUBTOTAL',
'ROLLUPGROUP', 'ROLLUPISSUBTOTAL', 'ROW', 'SAMPLE', 'SELECTCOLUMNS',
'SUBSTITUTEWITHINDEX', 'SUMMARIZE', 'SUMMARIZECOLUMNS', 'TOPN', 'TREATAS',
'UNION', 'USERELATIONSHIP', 'VALUES', 'SUM', 'SUMX',
'PATH', 'PATHCONTAINS', 'PATHITEM', 'PATHITEMREVERSE', 'PATHLENGTH',
'AVERAGE', 'AVERAGEA', 'AVERAGEX', 'COUNT', 'COUNTA',
'COUNTAX', 'COUNTBLANK', 'COUNTROWS', 'COUNTX', 'DISTINCTCOUNT',
'DIVIDE', 'GEOMEAN', 'GEOMEANX', 'MAX', 'MAXA',
'MAXX', 'MEDIAN', 'MEDIANX', 'MIN', 'MINA',
'MINX', 'PERCENTILE.EXC', 'PERCENTILE.INC', 'PERCENTILEX.EXC', 'PERCENTILEX.INC',
'PRODUCT', 'PRODUCTX', 'RANK.EQ', 'RANKX', 'STDEV.P',
'STDEV.S', 'STDEVX.P', 'STDEVX.S', 'VAR.P', 'VAR.S',
'VARX.P', 'VARX.S', 'XIRR', 'XNPV',
// Scalar
'DATE', 'DATEDIFF', 'DATEVALUE', 'DAY', 'EDATE',
'EOMONTH', 'HOUR', 'MINUTE', 'MONTH', 'NOW',
'SECOND', 'TIME', 'TIMEVALUE', 'TODAY', 'WEEKDAY',
'WEEKNUM', 'YEAR', 'YEARFRAC', 'CONTAINS', 'CONTAINSROW',
'CUSTOMDATA', 'ERROR', 'HASONEFILTER', 'HASONEVALUE', 'ISBLANK',
'ISCROSSFILTERED', 'ISEMPTY', 'ISERROR', 'ISEVEN', 'ISFILTERED',
'ISLOGICAL', 'ISNONTEXT', 'ISNUMBER', 'ISODD', 'ISSUBTOTAL',
'ISTEXT', 'USERNAME', 'USERPRINCIPALNAME', 'AND', 'FALSE',
'IF', 'IFERROR', 'NOT', 'OR', 'SWITCH',
'TRUE', 'ABS', 'ACOS', 'ACOSH', 'ACOT',
'ACOTH', 'ASIN', 'ASINH', 'ATAN', 'ATANH',
'BETA.DIST', 'BETA.INV', 'CEILING', 'CHISQ.DIST', 'CHISQ.DIST.RT',
'CHISQ.INV', 'CHISQ.INV.RT', 'COMBIN', 'COMBINA', 'CONFIDENCE.NORM',
'CONFIDENCE.T', 'COS', 'COSH', 'COT', 'COTH',
'CURRENCY', 'DEGREES', 'EVEN', 'EXP', 'EXPON.DIST',
'FACT', 'FLOOR', 'GCD', 'INT', 'ISO.CEILING',
'LCM', 'LN', 'LOG', 'LOG10', 'MOD',
'MROUND', 'ODD', 'PERMUT', 'PI', 'POISSON.DIST',
'POWER', 'QUOTIENT', 'RADIANS', 'RAND', 'RANDBETWEEN',
'ROUND', 'ROUNDDOWN', 'ROUNDUP', 'SIGN', 'SIN',
'SINH', 'SQRT', 'SQRTPI', 'TAN', 'TANH',
'TRUNC', 'BLANK', 'CONCATENATE', 'CONCATENATEX', 'EXACT',
'FIND', 'FIXED', 'FORMAT', 'LEFT', 'LEN',
'LOWER', 'MID', 'REPLACE', 'REPT', 'RIGHT',
'SEARCH', 'SUBSTITUTE', 'TRIM', 'UNICHAR', 'UNICODE',
'UPPER', 'VALUE'
],
tokenizer: {
root: [
{ include: '@comments' },
{ include: '@whitespace' },
{ include: '@numbers' },
{ include: '@strings' },
{ include: '@complexIdentifiers' },
[/[;,.]/, 'delimiter'],
[/[({})]/, '@brackets'],
[/[a-z_][a-zA-Z0-9_]*/, {
cases: {
'@keywords': 'keyword',
'@functions': 'keyword',
'@default': 'identifier'
}
}],
[/[<>=!%&+\-*/|~^]/, 'operator'],
],
whitespace: [
[/\s+/, 'white']
],
comments: [
[/\/\/+.*/, 'comment'],
[/\/\*/, { token: 'comment.quote', next: '@comment' }]
],
comment: [
[/[^*/]+/, 'comment'],
[/\*\//, { token: 'comment.quote', next: '@pop' }],
[/./, 'comment']
],
numbers: [
[/0[xX][0-9a-fA-F]*/, 'number'],
[/[$][+-]*\d*(\.\d*)?/, 'number'],
[/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, 'number']
],
strings: [
[/N"/, { token: 'string', next: '@string' }],
[/"/, { token: 'string', next: '@string' }]
],
string: [
[/[^"]+/, 'string'],
[/""/, 'string'],
[/"/, { token: 'string', next: '@pop' }]
],
complexIdentifiers: [
[/\[/, { token: 'identifier.quote', next: '@bracketedIdentifier' }],
[/'/, { token: 'identifier.quote', next: '@quotedIdentifier' }]
],
bracketedIdentifier: [
[/[^\]]+/, 'identifier'],
[/]]/, 'identifier'],
[/]/, { token: 'identifier.quote', next: '@pop' }]
],
quotedIdentifier: [
[/[^']+/, 'identifier'],
[/''/, 'identifier'],
[/'/, { token: 'identifier.quote', next: '@pop' }]
]
}
};
/***/ })
}]);

233
52.d04fcbd7.async.js Normal file
View File

@ -0,0 +1,233 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[52],{
/***/ "tGOS":
/*!**************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/mysql/mysql.js ***!
\**************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/mysql/mysql.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '--',
blockComment: ['/*', '*/'],
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
]
};
var language = {
defaultToken: '',
tokenPostfix: '.sql',
ignoreCase: true,
brackets: [
{ open: '[', close: ']', token: 'delimiter.square' },
{ open: '(', close: ')', token: 'delimiter.parenthesis' }
],
keywords: [
"ACCESSIBLE", "ACCOUNT", "ACTION", "ADD", "AFTER", "AGAINST", "AGGREGATE", "ALGORITHM", "ALL", "ALTER", "ALWAYS", "ANALYSE", "ANALYZE",
"AND", "ANY", "AS", "ASC", "ASCII", "ASENSITIVE", "AT", "AUTOEXTEND_SIZE", "AUTO_INCREMENT", "AVG", "AVG_ROW_LENGTH", "BACKUP", "BEFORE",
"BEGIN", "BETWEEN", "BIGINT", "BINARY", "BINLOG", "BIT", "BLOB", "BLOCK", "BOOL", "BOOLEAN", "BOTH", "BTREE", "BY", "BYTE", "CACHE", "CALL",
"CASCADE", "CASCADED", "CASE", "CATALOG_NAME", "CHAIN", "CHANGE", "CHANGED", "CHANNEL", "CHAR", "CHARACTER", "CHARSET", "CHECK", "CHECKSUM",
"CIPHER", "CLASS_ORIGIN", "CLIENT", "CLOSE", "COALESCE", "CODE", "COLLATE", "COLLATION", "COLUMN", "COLUMNS", "COLUMN_FORMAT", "COLUMN_NAME",
"COMMENT", "COMMIT", "COMMITTED", "COMPACT", "COMPLETION", "COMPRESSED", "COMPRESSION", "CONCURRENT", "CONDITION", "CONNECTION", "CONSISTENT",
"CONSTRAINT", "CONSTRAINT_CATALOG", "CONSTRAINT_NAME", "CONSTRAINT_SCHEMA", "CONTAINS", "CONTEXT", "CONTINUE", "CONVERT", "CPU", "CREATE",
"CROSS", "CUBE", "CURRENT", "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", "CURSOR", "CURSOR_NAME", "DATA", "DATABASE",
"DATABASES", "DATAFILE", "DATE", "DATETIME", "DAY", "DAY_HOUR", "DAY_MICROSECOND", "DAY_MINUTE", "DAY_SECOND", "DEALLOCATE", "DEC", "DECIMAL",
"DECLARE", "DEFAULT", "DEFAULT_AUTH", "DEFINER", "DELAYED", "DELAY_KEY_WRITE", "DELETE", "DESC", "DESCRIBE", "DES_KEY_FILE", "DETERMINISTIC",
"DIAGNOSTICS", "DIRECTORY", "DISABLE", "DISCARD", "DISK", "DISTINCT", "DISTINCTROW", "DIV", "DO", "DOUBLE", "DROP", "DUAL", "DUMPFILE",
"DUPLICATE", "DYNAMIC", "EACH", "ELSE", "ELSEIF", "ENABLE", "ENCLOSED", "ENCRYPTION", "END", "ENDS", "ENGINE", "ENGINES", "ENUM", "ERROR",
"ERRORS", "ESCAPE", "ESCAPED", "EVENT", "EVENTS", "EVERY", "EXCHANGE", "EXECUTE", "EXISTS", "EXIT", "EXPANSION", "EXPIRE", "EXPLAIN", "EXPORT",
"EXTENDED", "EXTENT_SIZE", "FALSE", "FAST", "FAULTS", "FETCH", "FIELDS", "FILE", "FILE_BLOCK_SIZE", "FILTER", "FIRST", "FIXED", "FLOAT", "FLOAT4",
"FLOAT8", "FLUSH", "FOLLOWS", "FOR", "FORCE", "FOREIGN", "FORMAT", "FOUND", "FROM", "FULL", "FULLTEXT", "FUNCTION", "GENERAL", "GENERATED",
"GEOMETRY", "GEOMETRYCOLLECTION", "GET", "GET_FORMAT", "GLOBAL", "GRANT", "GRANTS", "GROUP", "GROUP_REPLICATION", "HANDLER", "HASH", "HAVING",
"HELP", "HIGH_PRIORITY", "HOST", "HOSTS", "HOUR", "HOUR_MICROSECOND", "HOUR_MINUTE", "HOUR_SECOND", "IDENTIFIED", "IF", "IGNORE", "IGNORE_SERVER_IDS",
"IMPORT", "INDEX", "INDEXES", "INFILE", "INITIAL_SIZE", "INNER", "INOUT", "INSENSITIVE", "INSERT", "INSERT_METHOD", "INSTALL", "INSTANCE",
"INT", "INT1", "INT2", "INT3", "INT4", "INT8", "INTEGER", "INTERVAL", "INTO", "INVOKER", "IO", "IO_AFTER_GTIDS", "IO_BEFORE_GTIDS", "IO_THREAD",
"IPC", "ISOLATION", "ISSUER", "ITERATE", "JOIN", "JSON", "KEY", "KEYS", "KEY_BLOCK_SIZE", "KILL", "LANGUAGE", "LAST", "LEADING", "LEAVE",
"LEAVES", "LEFT", "LESS", "LEVEL", "LIKE", "LIMIT", "LINEAR", "LINES", "LINESTRING", "LIST", "LOAD", "LOCAL", "LOCALTIME", "LOCALTIMESTAMP", "LOCK",
"LOCKS", "LOGFILE", "LOGS", "LONG", "LONGBLOB", "LONGTEXT", "LOOP", "LOW_PRIORITY", "MASTER", "MASTER_AUTO_POSITION", "MASTER_BIND", "MASTER_CONNECT_RETRY",
"MASTER_DELAY", "MASTER_HEARTBEAT_PERIOD", "MASTER_HOST", "MASTER_LOG_FILE", "MASTER_LOG_POS", "MASTER_PASSWORD", "MASTER_PORT", "MASTER_RETRY_COUNT",
"MASTER_SERVER_ID", "MASTER_SSL", "MASTER_SSL_CA", "MASTER_SSL_CAPATH", "MASTER_SSL_CERT", "MASTER_SSL_CIPHER", "MASTER_SSL_CRL", "MASTER_SSL_CRLPATH",
"MASTER_SSL_KEY", "MASTER_SSL_VERIFY_SERVER_CERT", "MASTER_TLS_VERSION", "MASTER_USER", "MATCH", "MAXVALUE", "MAX_CONNECTIONS_PER_HOUR", "MAX_QUERIES_PER_HOUR",
"MAX_ROWS", "MAX_SIZE", "MAX_STATEMENT_TIME", "MAX_UPDATES_PER_HOUR", "MAX_USER_CONNECTIONS", "MEDIUM", "MEDIUMBLOB", "MEDIUMINT", "MEDIUMTEXT", "MEMORY",
"MERGE", "MESSAGE_TEXT", "MICROSECOND", "MIDDLEINT", "MIGRATE", "MINUTE", "MINUTE_MICROSECOND", "MINUTE_SECOND", "MIN_ROWS", "MOD", "MODE", "MODIFIES",
"MODIFY", "MONTH", "MULTILINESTRING", "MULTIPOINT", "MULTIPOLYGON", "MUTEX", "MYSQL_ERRNO", "NAME", "NAMES", "NATIONAL", "NATURAL", "NCHAR", "NDB",
"NDBCLUSTER", "NEVER", "NEW", "NEXT", "NO", "NODEGROUP", "NONBLOCKING", "NONE", "NO_WAIT", "NO_WRITE_TO_BINLOG", "NUMBER", "NUMERIC",
"NVARCHAR", "OFFSET", "OLD_PASSWORD", "ON", "ONE", "ONLY", "OPEN", "OPTIMIZE", "OPTIMIZER_COSTS", "OPTION", "OPTIONALLY", "OPTIONS", "OR", "ORDER",
"OUT", "OUTER", "OUTFILE", "OWNER", "PACK_KEYS", "PAGE", "PARSER", "PARSE_GCOL_EXPR", "PARTIAL", "PARTITION", "PARTITIONING", "PARTITIONS", "PASSWORD",
"PHASE", "PLUGIN", "PLUGINS", "PLUGIN_DIR", "POINT", "POLYGON", "PORT", "PRECEDES", "PRECISION", "PREPARE", "PRESERVE", "PREV", "PRIMARY", "PRIVILEGES",
"PROCEDURE", "PROCESSLIST", "PROFILE", "PROFILES", "PROXY", "PURGE", "QUARTER", "QUERY", "QUICK", "RANGE", "READ", "READS", "READ_ONLY", "READ_WRITE",
"REAL", "REBUILD", "RECOVER", "REDOFILE", "REDO_BUFFER_SIZE", "REDUNDANT", "REFERENCES", "REGEXP", "RELAY", "RELAYLOG", "RELAY_LOG_FILE", "RELAY_LOG_POS",
"RELAY_THREAD", "RELEASE", "RELOAD", "REMOVE", "RENAME", "REORGANIZE", "REPAIR", "REPEAT", "REPEATABLE", "REPLACE", "REPLICATE_DO_DB", "REPLICATE_DO_TABLE",
"REPLICATE_IGNORE_DB", "REPLICATE_IGNORE_TABLE", "REPLICATE_REWRITE_DB", "REPLICATE_WILD_DO_TABLE", "REPLICATE_WILD_IGNORE_TABLE", "REPLICATION", "REQUIRE",
"RESET", "RESIGNAL", "RESTORE", "RESTRICT", "RESUME", "RETURN", "RETURNED_SQLSTATE", "RETURNS", "REVERSE", "REVOKE", "RIGHT", "RLIKE", "ROLLBACK", "ROLLUP",
"ROTATE", "ROUTINE", "ROW", "ROWS", "ROW_COUNT", "ROW_FORMAT", "RTREE", "SAVEPOINT", "SCHEDULE", "SCHEMA", "SCHEMAS", "SCHEMA_NAME", "SECOND", "SECOND_MICROSECOND",
"SECURITY", "SELECT", "SENSITIVE", "SEPARATOR", "SERIAL", "SERIALIZABLE", "SERVER", "SESSION", "SET", "SHARE", "SHOW", "SHUTDOWN", "SIGNAL", "SIGNED", "SIMPLE",
"SLAVE", "SLOW", "SMALLINT", "SNAPSHOT", "SOCKET", "SOME", "SONAME", "SOUNDS", "SOURCE", "SPATIAL", "SPECIFIC", "SQL", "SQLEXCEPTION", "SQLSTATE", "SQLWARNING",
"SQL_AFTER_GTIDS", "SQL_AFTER_MTS_GAPS", "SQL_BEFORE_GTIDS", "SQL_BIG_RESULT", "SQL_BUFFER_RESULT", "SQL_CACHE", "SQL_CALC_FOUND_ROWS", "SQL_NO_CACHE",
"SQL_SMALL_RESULT", "SQL_THREAD", "SQL_TSI_DAY", "SQL_TSI_HOUR", "SQL_TSI_MINUTE", "SQL_TSI_MONTH", "SQL_TSI_QUARTER", "SQL_TSI_SECOND", "SQL_TSI_WEEK",
"SQL_TSI_YEAR", "SSL", "STACKED", "START", "STARTING", "STARTS", "STATS_AUTO_RECALC", "STATS_PERSISTENT", "STATS_SAMPLE_PAGES", "STATUS", "STOP", "STORAGE",
"STORED", "STRAIGHT_JOIN", "STRING", "SUBCLASS_ORIGIN", "SUBJECT", "SUBPARTITION", "SUBPARTITIONS", "SUPER", "SUSPEND", "SWAPS", "SWITCHES", "TABLE", "TABLES",
"TABLESPACE", "TABLE_CHECKSUM", "TABLE_NAME", "TEMPORARY", "TEMPTABLE", "TERMINATED", "TEXT", "THAN", "THEN", "TIME", "TIMESTAMP", "TIMESTAMPADD", "TIMESTAMPDIFF",
"TINYBLOB", "TINYINT", "TINYTEXT", "TO", "TRAILING", "TRANSACTION", "TRIGGER", "TRIGGERS", "TRUE", "TRUNCATE", "TYPE", "TYPES", "UNCOMMITTED", "UNDEFINED", "UNDO",
"UNDOFILE", "UNDO_BUFFER_SIZE", "UNICODE", "UNINSTALL", "UNION", "UNIQUE", "UNKNOWN", "UNLOCK", "UNSIGNED", "UNTIL", "UPDATE", "UPGRADE", "USAGE", "USE", "USER",
"USER_RESOURCES", "USE_FRM", "USING", "UTC_DATE", "UTC_TIME", "UTC_TIMESTAMP", "VALIDATION", "VALUE", "VALUES", "VARBINARY", "VARCHAR", "VARCHARACTER", "VARIABLES",
"VARYING", "VIEW", "VIRTUAL", "WAIT", "WARNINGS", "WEEK", "WEIGHT_STRING", "WHEN", "WHERE", "WHILE", "WITH", "WITHOUT", "WORK", "WRAPPER", "WRITE", "X509", "XA",
"XID", "XML", "XOR", "YEAR", "YEAR_MONTH", "ZEROFILL"
],
operators: [
"AND", "BETWEEN", "IN", "LIKE", "NOT", "OR", "IS", "NULL", "INTERSECT", "UNION", "INNER", "JOIN", "LEFT", "OUTER", "RIGHT"
],
builtinFunctions: [
"ABS", "ACOS", "ADDDATE", "ADDTIME", "AES_DECRYPT", "AES_ENCRYPT", "ANY_VALUE", "Area", "AsBinary", "AsWKB", "ASCII", "ASIN",
"AsText", "AsWKT", "ASYMMETRIC_DECRYPT", "ASYMMETRIC_DERIVE", "ASYMMETRIC_ENCRYPT", "ASYMMETRIC_SIGN", "ASYMMETRIC_VERIFY",
"ATAN", "ATAN2", "ATAN", "AVG", "BENCHMARK", "BIN", "BIT_AND", "BIT_COUNT", "BIT_LENGTH", "BIT_OR", "BIT_XOR", "Buffer", "CAST",
"CEIL", "CEILING", "Centroid", "CHAR", "CHAR_LENGTH", "CHARACTER_LENGTH", "CHARSET", "COALESCE", "COERCIBILITY", "COLLATION",
"COMPRESS", "CONCAT", "CONCAT_WS", "CONNECTION_ID", "Contains", "CONV", "CONVERT", "CONVERT_TZ", "ConvexHull", "COS", "COT",
"COUNT", "CRC32", "CREATE_ASYMMETRIC_PRIV_KEY", "CREATE_ASYMMETRIC_PUB_KEY", "CREATE_DH_PARAMETERS", "CREATE_DIGEST", "Crosses",
"CURDATE", "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", "CURTIME", "DATABASE", "DATE", "DATE_ADD",
"DATE_FORMAT", "DATE_SUB", "DATEDIFF", "DAY", "DAYNAME", "DAYOFMONTH", "DAYOFWEEK", "DAYOFYEAR", "DECODE", "DEFAULT", "DEGREES",
"DES_DECRYPT", "DES_ENCRYPT", "Dimension", "Disjoint", "Distance", "ELT", "ENCODE", "ENCRYPT", "EndPoint", "Envelope", "Equals",
"EXP", "EXPORT_SET", "ExteriorRing", "EXTRACT", "ExtractValue", "FIELD", "FIND_IN_SET", "FLOOR", "FORMAT", "FOUND_ROWS", "FROM_BASE64",
"FROM_DAYS", "FROM_UNIXTIME", "GeomCollFromText", "GeometryCollectionFromText", "GeomCollFromWKB", "GeometryCollectionFromWKB",
"GeometryCollection", "GeometryN", "GeometryType", "GeomFromText", "GeometryFromText", "GeomFromWKB", "GeometryFromWKB", "GET_FORMAT",
"GET_LOCK", "GLength", "GREATEST", "GROUP_CONCAT", "GTID_SUBSET", "GTID_SUBTRACT", "HEX", "HOUR", "IF", "IFNULL", "INET_ATON",
"INET_NTOA", "INET6_ATON", "INET6_NTOA", "INSERT", "INSTR", "InteriorRingN", "Intersects", "INTERVAL", "IS_FREE_LOCK", "IS_IPV4",
"IS_IPV4_COMPAT", "IS_IPV4_MAPPED", "IS_IPV6", "IS_USED_LOCK", "IsClosed", "IsEmpty", "ISNULL", "IsSimple", "JSON_APPEND", "JSON_ARRAY",
"JSON_ARRAY_APPEND", "JSON_ARRAY_INSERT", "JSON_CONTAINS", "JSON_CONTAINS_PATH", "JSON_DEPTH", "JSON_EXTRACT", "JSON_INSERT", "JSON_KEYS",
"JSON_LENGTH", "JSON_MERGE", "JSON_MERGE_PRESERVE", "JSON_OBJECT", "JSON_QUOTE", "JSON_REMOVE", "JSON_REPLACE", "JSON_SEARCH", "JSON_SET",
"JSON_TYPE", "JSON_UNQUOTE", "JSON_VALID", "LAST_INSERT_ID", "LCASE", "LEAST", "LEFT", "LENGTH", "LineFromText", "LineStringFromText",
"LineFromWKB", "LineStringFromWKB", "LineString", "LN", "LOAD_FILE", "LOCALTIME", "LOCALTIMESTAMP", "LOCATE", "LOG", "LOG10", "LOG2",
"LOWER", "LPAD", "LTRIM", "MAKE_SET", "MAKEDATE", "MAKETIME", "MASTER_POS_WAIT", "MAX", "MBRContains", "MBRCoveredBy", "MBRCovers",
"MBRDisjoint", "MBREqual", "MBREquals", "MBRIntersects", "MBROverlaps", "MBRTouches", "MBRWithin", "MD5", "MICROSECOND", "MID",
"MIN", "MINUTE", "MLineFromText", "MultiLineStringFromText", "MLineFromWKB", "MultiLineStringFromWKB", "MOD", "MONTH", "MONTHNAME",
"MPointFromText", "MultiPointFromText", "MPointFromWKB", "MultiPointFromWKB", "MPolyFromText", "MultiPolygonFromText", "MPolyFromWKB",
"MultiPolygonFromWKB", "MultiLineString", "MultiPoint", "MultiPolygon", "NAME_CONST", "NOT IN", "NOW", "NULLIF", "NumGeometries",
"NumInteriorRings", "NumPoints", "OCT", "OCTET_LENGTH", "OLD_PASSWORD", "ORD", "Overlaps", "PASSWORD", "PERIOD_ADD", "PERIOD_DIFF",
"PI", "Point", "PointFromText", "PointFromWKB", "PointN", "PolyFromText", "PolygonFromText", "PolyFromWKB", "PolygonFromWKB", "Polygon",
"POSITION", "POW", "POWER", "PROCEDURE ANALYSE", "QUARTER", "QUOTE", "RADIANS", "RAND", "RANDOM_BYTES", "RELEASE_ALL_LOCKS", "RELEASE_LOCK",
"REPEAT", "REPLACE", "REVERSE", "RIGHT", "ROUND", "ROW_COUNT", "RPAD", "RTRIM", "SCHEMA", "SEC_TO_TIME", "SECOND", "SESSION_USER", "SHA1",
"SHA", "SHA2", "SIGN", "SIN", "SLEEP", "SOUNDEX", "SPACE", "SQRT", "SRID", "ST_Area", "ST_AsBinary", "ST_AsWKB", "ST_AsGeoJSON", "ST_AsText",
"ST_AsWKT", "ST_Buffer", "ST_Buffer_Strategy", "ST_Centroid", "ST_Contains", "ST_ConvexHull", "ST_Crosses", "ST_Difference", "ST_Dimension",
"ST_Disjoint", "ST_Distance", "ST_Distance_Sphere", "ST_EndPoint", "ST_Envelope", "ST_Equals", "ST_ExteriorRing", "ST_GeoHash",
"ST_GeomCollFromText", "ST_GeometryCollectionFromText", "ST_GeomCollFromTxt", "ST_GeomCollFromWKB", "ST_GeometryCollectionFromWKB",
"ST_GeometryN", "ST_GeometryType", "ST_GeomFromGeoJSON", "ST_GeomFromText", "ST_GeometryFromText", "ST_GeomFromWKB", "ST_GeometryFromWKB",
"ST_InteriorRingN", "ST_Intersection", "ST_Intersects", "ST_IsClosed", "ST_IsEmpty", "ST_IsSimple", "ST_IsValid", "ST_LatFromGeoHash",
"ST_Length", "ST_LineFromText", "ST_LineStringFromText", "ST_LineFromWKB", "ST_LineStringFromWKB", "ST_LongFromGeoHash", "ST_MakeEnvelope",
"ST_MLineFromText", "ST_MultiLineStringFromText", "ST_MLineFromWKB", "ST_MultiLineStringFromWKB", "ST_MPointFromText", "ST_MultiPointFromText",
"ST_MPointFromWKB", "ST_MultiPointFromWKB", "ST_MPolyFromText", "ST_MultiPolygonFromText", "ST_MPolyFromWKB", "ST_MultiPolygonFromWKB",
"ST_NumGeometries", "ST_NumInteriorRing", "ST_NumInteriorRings", "ST_NumPoints", "ST_Overlaps", "ST_PointFromGeoHash", "ST_PointFromText",
"ST_PointFromWKB", "ST_PointN", "ST_PolyFromText", "ST_PolygonFromText", "ST_PolyFromWKB", "ST_PolygonFromWKB", "ST_Simplify", "ST_SRID",
"ST_StartPoint", "ST_SymDifference", "ST_Touches", "ST_Union", "ST_Validate", "ST_Within", "ST_X", "ST_Y", "StartPoint", "STD", "STDDEV",
"STDDEV_POP", "STDDEV_SAMP", "STR_TO_DATE", "STRCMP", "SUBDATE", "SUBSTR", "SUBSTRING", "SUBSTRING_INDEX", "SUBTIME", "SUM", "SYSDATE",
"SYSTEM_USER", "TAN", "TIME", "TIME_FORMAT", "TIME_TO_SEC", "TIMEDIFF", "TIMESTAMP", "TIMESTAMPADD", "TIMESTAMPDIFF", "TO_BASE64", "TO_DAYS",
"TO_SECONDS", "Touches", "TRIM", "TRUNCATE", "UCASE", "UNCOMPRESS", "UNCOMPRESSED_LENGTH", "UNHEX", "UNIX_TIMESTAMP", "UpdateXML", "UPPER",
"USER", "UTC_DATE", "UTC_TIME", "UTC_TIMESTAMP", "UUID", "UUID_SHORT", "VALIDATE_PASSWORD_STRENGTH", "VALUES", "VAR_POP", "VAR_SAMP", "VARIANCE",
"VERSION", "WAIT_FOR_EXECUTED_GTID_SET", "WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS", "WEEK", "WEEKDAY", "WEEKOFYEAR", "WEIGHT_STRING", "Within",
"X", "Y", "YEAR", "YEARWEEK"
],
builtinVariables: [
// NOT SUPPORTED
],
tokenizer: {
root: [
{ include: '@comments' },
{ include: '@whitespace' },
{ include: '@numbers' },
{ include: '@strings' },
{ include: '@complexIdentifiers' },
{ include: '@scopes' },
[/[;,.]/, 'delimiter'],
[/[()]/, '@brackets'],
[/[\w@]+/, {
cases: {
'@keywords': 'keyword',
'@operators': 'operator',
'@builtinVariables': 'predefined',
'@builtinFunctions': 'predefined',
'@default': 'identifier'
}
}],
[/[<>=!%&+\-*/|~^]/, 'operator'],
],
whitespace: [
[/\s+/, 'white']
],
comments: [
[/--+.*/, 'comment'],
[/#+.*/, 'comment'],
[/\/\*/, { token: 'comment.quote', next: '@comment' }]
],
comment: [
[/[^*/]+/, 'comment'],
// Not supporting nested comments, as nested comments seem to not be standard?
// i.e. http://stackoverflow.com/questions/728172/are-there-multiline-comment-delimiters-in-sql-that-are-vendor-agnostic
// [/\/\*/, { token: 'comment.quote', next: '@push' }], // nested comment not allowed :-(
[/\*\//, { token: 'comment.quote', next: '@pop' }],
[/./, 'comment']
],
numbers: [
[/0[xX][0-9a-fA-F]*/, 'number'],
[/[$][+-]*\d*(\.\d*)?/, 'number'],
[/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, 'number']
],
strings: [
[/'/, { token: 'string', next: '@string' }],
[/"/, { token: 'string.double', next: '@stringDouble' }]
],
string: [
[/[^']+/, 'string'],
[/''/, 'string'],
[/'/, { token: 'string', next: '@pop' }],
],
stringDouble: [
[/[^"]+/, 'string.double'],
[/""/, 'string.double'],
[/"/, { token: 'string.double', next: '@pop' }]
],
complexIdentifiers: [
[/`/, { token: 'identifier.quote', next: '@quotedIdentifier' }]
],
quotedIdentifier: [
[/[^`]+/, 'identifier'],
[/``/, 'identifier'],
[/`/, { token: 'identifier.quote', next: '@pop' }]
],
scopes: [
// NOT SUPPORTED
]
}
};
/***/ })
}]);

201
53.1d23b9df.async.js Normal file
View File

@ -0,0 +1,201 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[53],{
/***/ "fYNN":
/*!**************************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/objective-c/objective-c.js ***!
\**************************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/objective-c/objective-c.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '//',
blockComment: ['/*', '*/'],
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
]
};
var language = {
defaultToken: '',
tokenPostfix: '.objective-c',
keywords: [
'#import',
'#include',
'#define',
'#else',
'#endif',
'#if',
'#ifdef',
'#ifndef',
'#ident',
'#undef',
'@class',
'@defs',
'@dynamic',
'@encode',
'@end',
'@implementation',
'@interface',
'@package',
'@private',
'@protected',
'@property',
'@protocol',
'@public',
'@selector',
'@synthesize',
'__declspec',
'assign',
'auto',
'BOOL',
'break',
'bycopy',
'byref',
'case',
'char',
'Class',
'const',
'copy',
'continue',
'default',
'do',
'double',
'else',
'enum',
'extern',
'FALSE',
'false',
'float',
'for',
'goto',
'if',
'in',
'int',
'id',
'inout',
'IMP',
'long',
'nil',
'nonatomic',
'NULL',
'oneway',
'out',
'private',
'public',
'protected',
'readwrite',
'readonly',
'register',
'return',
'SEL',
'self',
'short',
'signed',
'sizeof',
'static',
'struct',
'super',
'switch',
'typedef',
'TRUE',
'true',
'union',
'unsigned',
'volatile',
'void',
'while',
],
decpart: /\d(_?\d)*/,
decimal: /0|@decpart/,
tokenizer: {
root: [
{ include: '@comments' },
{ include: '@whitespace' },
{ include: '@numbers' },
{ include: '@strings' },
[/[,:;]/, 'delimiter'],
[/[{}\[\]()<>]/, '@brackets'],
[/[a-zA-Z@#]\w*/, {
cases: {
'@keywords': 'keyword',
'@default': 'identifier'
}
}],
[/[<>=\\+\\-\\*\\/\\^\\|\\~,]|and\\b|or\\b|not\\b]/, 'operator'],
],
whitespace: [
[/\s+/, 'white'],
],
comments: [
['\\/\\*', 'comment', '@comment'],
['\\/\\/+.*', 'comment'],
],
comment: [
['\\*\\/', 'comment', '@pop'],
['.', 'comment',],
],
numbers: [
[/0[xX][0-9a-fA-F]*(_?[0-9a-fA-F])*/, 'number.hex'],
[/@decimal((\.@decpart)?([eE][\-+]?@decpart)?)[fF]*/, {
cases: {
'(\\d)*': 'number',
'$0': 'number.float'
}
}]
],
// Recognize strings, including those broken across lines with \ (but not without)
strings: [
[/'$/, 'string.escape', '@popall'],
[/'/, 'string.escape', '@stringBody'],
[/"$/, 'string.escape', '@popall'],
[/"/, 'string.escape', '@dblStringBody']
],
stringBody: [
[/[^\\']+$/, 'string', '@popall'],
[/[^\\']+/, 'string'],
[/\\./, 'string'],
[/'/, 'string.escape', '@popall'],
[/\\$/, 'string']
],
dblStringBody: [
[/[^\\"]+$/, 'string', '@popall'],
[/[^\\"]+/, 'string'],
[/\\./, 'string'],
[/"/, 'string.escape', '@popall'],
[/\\$/, 'string']
]
}
};
/***/ })
}]);

151
54.be8dbc89.async.js Normal file
View File

@ -0,0 +1,151 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[54],{
/***/ "meXB":
/*!****************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/pascal/pascal.js ***!
\****************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/pascal/pascal.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
// the default separators except `@$`
wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
comments: {
lineComment: '//',
blockComment: ['{', '}'],
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')'],
['<', '>'],
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '<', close: '>' },
{ open: '\'', close: '\'' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '<', close: '>' },
{ open: '\'', close: '\'' },
],
folding: {
markers: {
start: new RegExp("^\\s*\\{\\$REGION(\\s\\'.*\\')?\\}"),
end: new RegExp("^\\s*\\{\\$ENDREGION\\}")
}
}
};
var language = {
defaultToken: '',
tokenPostfix: '.pascal',
ignoreCase: true,
brackets: [
{ open: '{', close: '}', token: 'delimiter.curly' },
{ open: '[', close: ']', token: 'delimiter.square' },
{ open: '(', close: ')', token: 'delimiter.parenthesis' },
{ open: '<', close: '>', token: 'delimiter.angle' }
],
keywords: [
'absolute', 'abstract', 'all', 'and_then', 'array', 'as', 'asm',
'attribute', 'begin', 'bindable', 'case', 'class', 'const',
'contains', 'default', 'div', 'else', 'end', 'except',
'exports', 'external', 'far', 'file', 'finalization', 'finally',
'forward', 'generic', 'goto', 'if', 'implements', 'import', 'in',
'index', 'inherited', 'initialization', 'interrupt', 'is', 'label',
'library', 'mod', 'module', 'name', 'near', 'not', 'object', 'of',
'on', 'only', 'operator', 'or_else', 'otherwise', 'override',
'package', 'packed', 'pow', 'private', 'program', 'protected',
'public', 'published', 'interface', 'implementation', 'qualified',
'read', 'record', 'resident', 'requires', 'resourcestring',
'restricted', 'segment', 'set', 'shl', 'shr', 'specialize', 'stored',
'then', 'threadvar', 'to', 'try', 'type', 'unit', 'uses', 'var',
'view', 'virtual', 'dynamic', 'overload', 'reintroduce', 'with',
'write', 'xor', 'true', 'false', 'procedure', 'function',
'constructor', 'destructor', 'property', 'break', 'continue', 'exit',
'abort', 'while', 'do', 'for', 'raise', 'repeat', 'until'
],
typeKeywords: [
'boolean', 'double', 'byte', 'integer', 'shortint', 'char',
'longint', 'float', 'string'
],
operators: [
'=', '>', '<', '<=', '>=', '<>', ':', ':=', 'and', 'or',
'+', '-', '*', '/', '@', '&', '^', '%'
],
// we include these common regular expressions
symbols: /[=><:@\^&|+\-*\/\^%]+/,
// The main tokenizer for our languages
tokenizer: {
root: [
// identifiers and keywords
[/[a-zA-Z_][\w]*/, {
cases: {
'@keywords': { token: 'keyword.$0' },
'@default': 'identifier'
}
}],
// whitespace
{ include: '@whitespace' },
// delimiters and operators
[/[{}()\[\]]/, '@brackets'],
[/[<>](?!@symbols)/, '@brackets'],
[/@symbols/, {
cases: {
'@operators': 'delimiter',
'@default': ''
}
}],
// numbers
[/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
[/\$[0-9a-fA-F]{1,16}/, 'number.hex'],
[/\d+/, 'number'],
// delimiter: after number because of .\d floats
[/[;,.]/, 'delimiter'],
// strings
[/'([^'\\]|\\.)*$/, 'string.invalid'],
[/'/, 'string', '@string'],
// characters
[/'[^\\']'/, 'string'],
[/'/, 'string.invalid'],
[/\#\d+/, 'string']
],
comment: [
[/[^\*\}]+/, 'comment'],
//[/\(\*/, 'comment', '@push' ], // nested comment not allowed :-(
[/\}/, 'comment', '@pop'],
[/[\{]/, 'comment']
],
string: [
[/[^\\']+/, 'string'],
[/\\./, 'string.escape.invalid'],
[/'/, { token: 'string.quote', bracket: '@close', next: '@pop' }]
],
whitespace: [
[/[ \t\r\n]+/, 'white'],
[/\{/, 'comment', '@comment'],
[/\/\/.*$/, 'comment'],
],
},
};
/***/ })
}]);

131
55.60853033.async.js Normal file
View File

@ -0,0 +1,131 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[55],{
/***/ "ywQP":
/*!**********************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/pascaligo/pascaligo.js ***!
\**********************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/pascaligo/pascaligo.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '//',
blockComment: ['(*', '*)'],
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')'],
['<', '>'],
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '<', close: '>' },
{ open: '\'', close: '\'' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '<', close: '>' },
{ open: '\'', close: '\'' },
]
};
var language = {
defaultToken: '',
tokenPostfix: '.pascaligo',
ignoreCase: true,
brackets: [
{ open: '{', close: '}', token: 'delimiter.curly' },
{ open: '[', close: ']', token: 'delimiter.square' },
{ open: '(', close: ')', token: 'delimiter.parenthesis' },
{ open: '<', close: '>', token: 'delimiter.angle' }
],
keywords: [
'begin', 'block', 'case', 'const', 'else', 'end',
'fail', 'for', 'from', 'function', 'if', 'is', 'nil',
'of', 'remove', 'return', 'skip', 'then', 'type', 'var',
'while', 'with', 'option', 'None', 'transaction'
],
typeKeywords: [
'bool', 'int', 'list', 'map', 'nat', 'record',
'string', 'unit', 'address', 'map', 'mtz', 'xtz'
],
operators: [
'=', '>', '<', '<=', '>=', '<>', ':', ':=', 'and', 'mod', 'or',
'+', '-', '*', '/', '@', '&', '^', '%'
],
// we include these common regular expressions
symbols: /[=><:@\^&|+\-*\/\^%]+/,
// The main tokenizer for our languages
tokenizer: {
root: [
// identifiers and keywords
[/[a-zA-Z_][\w]*/, {
cases: {
'@keywords': { token: 'keyword.$0' },
'@default': 'identifier'
}
}],
// whitespace
{ include: '@whitespace' },
// delimiters and operators
[/[{}()\[\]]/, '@brackets'],
[/[<>](?!@symbols)/, '@brackets'],
[/@symbols/, {
cases: {
'@operators': 'delimiter',
'@default': ''
}
}],
// numbers
[/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
[/\$[0-9a-fA-F]{1,16}/, 'number.hex'],
[/\d+/, 'number'],
// delimiter: after number because of .\d floats
[/[;,.]/, 'delimiter'],
// strings
[/'([^'\\]|\\.)*$/, 'string.invalid'],
[/'/, 'string', '@string'],
// characters
[/'[^\\']'/, 'string'],
[/'/, 'string.invalid'],
[/\#\d+/, 'string']
],
/* */
comment: [
[/[^\(\*]+/, 'comment'],
//[/\(\*/, 'comment', '@push' ], // nested comment not allowed :-(
[/\*\)/, 'comment', '@pop'],
[/\(\*/, 'comment']
],
string: [
[/[^\\']+/, 'string'],
[/\\./, 'string.escape.invalid'],
[/'/, { token: 'string.quote', bracket: '@close', next: '@pop' }]
],
whitespace: [
[/[ \t\r\n]+/, 'white'],
[/\(\*/, 'comment', '@comment'],
[/\/\/.*$/, 'comment'],
],
},
};
/***/ })
}]);

633
56.10955429.async.js Normal file
View File

@ -0,0 +1,633 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[56],{
/***/ "QKwv":
/*!************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/perl/perl.js ***!
\************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/perl/perl.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '#',
},
brackets: [['{', '}'], ['[', ']'], ['(', ')']],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: "'", close: "'" },
{ open: '`', close: '`' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: "'", close: "'" },
{ open: '`', close: '`' },
],
};
var language = {
defaultToken: '',
tokenPostfix: '.perl',
brackets: [
{ token: 'delimiter.bracket', open: '{', close: '}' },
{ token: 'delimiter.parenthesis', open: '(', close: ')' },
{ token: 'delimiter.square', open: '[', close: ']' },
],
// https://learn.perl.org/docs/keywords.html
// Perl syntax
keywords: [
'__DATA__',
'else',
'lock',
'__END__',
'elsif',
'lt',
'__FILE__',
'eq',
'__LINE__',
'exp',
'ne',
'sub',
'__PACKAGE__',
'for',
'no',
'and',
'foreach',
'or',
'unless',
'cmp',
'ge',
'package',
'until',
'continue',
'gt',
'while',
'CORE',
'if',
'xor',
'do',
'le',
'__DIE__',
'__WARN__',
],
// Perl functions
builtinFunctions: [
'-A',
'END',
'length',
'setpgrp',
'-B',
'endgrent',
'link',
'setpriority',
'-b',
'endhostent',
'listen',
'setprotoent',
'-C',
'endnetent',
'local',
'setpwent',
'-c',
'endprotoent',
'localtime',
'setservent',
'-d',
'endpwent',
'log',
'setsockopt',
'-e',
'endservent',
'lstat',
'shift',
'-f',
'eof',
'map',
'shmctl',
'-g',
'eval',
'mkdir',
'shmget',
'-k',
'exec',
'msgctl',
'shmread',
'-l',
'exists',
'msgget',
'shmwrite',
'-M',
'exit',
'msgrcv',
'shutdown',
'-O',
'fcntl',
'msgsnd',
'sin',
'-o',
'fileno',
'my',
'sleep',
'-p',
'flock',
'next',
'socket',
'-r',
'fork',
'not',
'socketpair',
'-R',
'format',
'oct',
'sort',
'-S',
'formline',
'open',
'splice',
'-s',
'getc',
'opendir',
'split',
'-T',
'getgrent',
'ord',
'sprintf',
'-t',
'getgrgid',
'our',
'sqrt',
'-u',
'getgrnam',
'pack',
'srand',
'-w',
'gethostbyaddr',
'pipe',
'stat',
'-W',
'gethostbyname',
'pop',
'state',
'-X',
'gethostent',
'pos',
'study',
'-x',
'getlogin',
'print',
'substr',
'-z',
'getnetbyaddr',
'printf',
'symlink',
'abs',
'getnetbyname',
'prototype',
'syscall',
'accept',
'getnetent',
'push',
'sysopen',
'alarm',
'getpeername',
'quotemeta',
'sysread',
'atan2',
'getpgrp',
'rand',
'sysseek',
'AUTOLOAD',
'getppid',
'read',
'system',
'BEGIN',
'getpriority',
'readdir',
'syswrite',
'bind',
'getprotobyname',
'readline',
'tell',
'binmode',
'getprotobynumber',
'readlink',
'telldir',
'bless',
'getprotoent',
'readpipe',
'tie',
'break',
'getpwent',
'recv',
'tied',
'caller',
'getpwnam',
'redo',
'time',
'chdir',
'getpwuid',
'ref',
'times',
'CHECK',
'getservbyname',
'rename',
'truncate',
'chmod',
'getservbyport',
'require',
'uc',
'chomp',
'getservent',
'reset',
'ucfirst',
'chop',
'getsockname',
'return',
'umask',
'chown',
'getsockopt',
'reverse',
'undef',
'chr',
'glob',
'rewinddir',
'UNITCHECK',
'chroot',
'gmtime',
'rindex',
'unlink',
'close',
'goto',
'rmdir',
'unpack',
'closedir',
'grep',
'say',
'unshift',
'connect',
'hex',
'scalar',
'untie',
'cos',
'index',
'seek',
'use',
'crypt',
'INIT',
'seekdir',
'utime',
'dbmclose',
'int',
'select',
'values',
'dbmopen',
'ioctl',
'semctl',
'vec',
'defined',
'join',
'semget',
'wait',
'delete',
'keys',
'semop',
'waitpid',
'DESTROY',
'kill',
'send',
'wantarray',
'die',
'last',
'setgrent',
'warn',
'dump',
'lc',
'sethostent',
'write',
'each',
'lcfirst',
'setnetent',
],
// File handlers
builtinFileHandlers: ['ARGV', 'STDERR', 'STDOUT', 'ARGVOUT', 'STDIN', 'ENV'],
// Perl variables
builtinVariables: [
'$!',
'$^RE_TRIE_MAXBUF',
'$LAST_REGEXP_CODE_RESULT',
'$"',
'$^S',
'$LIST_SEPARATOR',
'$#',
'$^T',
'$MATCH',
'$$',
'$^TAINT',
'$MULTILINE_MATCHING',
'$%',
'$^UNICODE',
'$NR',
'$&',
'$^UTF8LOCALE',
'$OFMT',
"$'",
'$^V',
'$OFS',
'$(',
'$^W',
'$ORS',
'$)',
'$^WARNING_BITS',
'$OS_ERROR',
'$*',
'$^WIDE_SYSTEM_CALLS',
'$OSNAME',
'$+',
'$^X',
'$OUTPUT_AUTO_FLUSH',
'$,',
'$_',
'$OUTPUT_FIELD_SEPARATOR',
'$-',
'$`',
'$OUTPUT_RECORD_SEPARATOR',
'$.',
'$a',
'$PERL_VERSION',
'$/',
'$ACCUMULATOR',
'$PERLDB',
'$0',
'$ARG',
'$PID',
'$:',
'$ARGV',
'$POSTMATCH',
'$;',
'$b',
'$PREMATCH',
'$<',
'$BASETIME',
'$PROCESS_ID',
'$=',
'$CHILD_ERROR',
'$PROGRAM_NAME',
'$>',
'$COMPILING',
'$REAL_GROUP_ID',
'$?',
'$DEBUGGING',
'$REAL_USER_ID',
'$@',
'$EFFECTIVE_GROUP_ID',
'$RS',
'$[',
'$EFFECTIVE_USER_ID',
'$SUBSCRIPT_SEPARATOR',
'$\\',
'$EGID',
'$SUBSEP',
'$]',
'$ERRNO',
'$SYSTEM_FD_MAX',
'$^',
'$EUID',
'$UID',
'$^A',
'$EVAL_ERROR',
'$WARNING',
'$^C',
'$EXCEPTIONS_BEING_CAUGHT',
'$|',
'$^CHILD_ERROR_NATIVE',
'$EXECUTABLE_NAME',
'$~',
'$^D',
'$EXTENDED_OS_ERROR',
'%!',
'$^E',
'$FORMAT_FORMFEED',
'%^H',
'$^ENCODING',
'$FORMAT_LINE_BREAK_CHARACTERS',
'%ENV',
'$^F',
'$FORMAT_LINES_LEFT',
'%INC',
'$^H',
'$FORMAT_LINES_PER_PAGE',
'%OVERLOAD',
'$^I',
'$FORMAT_NAME',
'%SIG',
'$^L',
'$FORMAT_PAGE_NUMBER',
'@+',
'$^M',
'$FORMAT_TOP_NAME',
'@-',
'$^N',
'$GID',
'@_',
'$^O',
'$INPLACE_EDIT',
'@ARGV',
'$^OPEN',
'$INPUT_LINE_NUMBER',
'@INC',
'$^P',
'$INPUT_RECORD_SEPARATOR',
'@LAST_MATCH_START',
'$^R',
'$LAST_MATCH_END',
'$^RE_DEBUG_FLAGS',
'$LAST_PAREN_MATCH',
],
// operators
symbols: /[:+\-\^*$&%@=<>!?|\/~\.]/,
quoteLikeOps: ['qr', 'm', 's', 'q', 'qq', 'qx', 'qw', 'tr', 'y'],
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
// The main tokenizer for our languages
tokenizer: {
root: [
{ include: '@whitespace' },
[
/[a-zA-Z\-_][\w\-_]*/,
{
cases: {
'@keywords': 'keyword',
'@builtinFunctions': 'type.identifier',
'@builtinFileHandlers': 'variable.predefined',
'@quoteLikeOps': { token: '@rematch', next: 'quotedConstructs' },
'@default': '',
},
},
],
// Perl variables
[
/[\$@%][*@#?\+\-\$!\w\\\^><~:;\.]+/,
{
cases: {
'@builtinVariables': 'variable.predefined',
'@default': 'variable',
},
},
],
{ include: '@strings' },
{ include: '@dblStrings' },
// Perl Doc
{ include: '@perldoc' },
// Here Doc
{ include: '@heredoc' },
[/[{}\[\]()]/, '@brackets'],
// RegExp
[
/[\/](?:(?:\[(?:\\]|[^\]])+\])|(?:\\\/|[^\]\/]))*[\/]\w*\s*(?=[).,;]|$)/,
'regexp',
],
[/@symbols/, 'operators'],
{ include: '@numbers' },
[/[,;]/, 'delimiter'],
],
whitespace: [
[/\s+/, 'white'],
[/(^#!.*$)/, 'metatag'],
[/(^#.*$)/, 'comment'],
],
numbers: [
[/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
[/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, 'number.hex'],
[/\d+/, 'number'],
],
// Single quote string
strings: [[/'/, 'string', '@stringBody']],
stringBody: [
[/'/, 'string', '@popall'],
[/\\'/, 'string.escape'],
[/./, 'string'],
],
// Double quote string
dblStrings: [[/"/, 'string', '@dblStringBody']],
dblStringBody: [
[/"/, 'string', '@popall'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
{ include: '@variables' },
[/./, 'string'],
],
// Quoted constructs
// Percent strings in Ruby are similar to quote-like operators in Perl.
// This is adapted from pstrings in ../ruby/ruby.ts.
quotedConstructs: [
[/(q|qw|tr|y)\s*\(/, { token: 'string.delim', switchTo: '@qstring.(.)' }],
[/(q|qw|tr|y)\s*\[/, { token: 'string.delim', switchTo: '@qstring.[.]' }],
[/(q|qw|tr|y)\s*\{/, { token: 'string.delim', switchTo: '@qstring.{.}' }],
[/(q|qw|tr|y)\s*</, { token: 'string.delim', switchTo: '@qstring.<.>' }],
[/(q|qw|tr|y)#/, { token: 'string.delim', switchTo: '@qstring.#.#' }],
[/(q|qw|tr|y)\s*([^A-Za-z0-9#\s])/, { token: 'string.delim', switchTo: '@qstring.$2.$2' }],
[/(q|qw|tr|y)\s+(\w)/, { token: 'string.delim', switchTo: '@qstring.$2.$2' }],
[/(qr|m|s)\s*\(/, { token: 'regexp.delim', switchTo: '@qregexp.(.)' }],
[/(qr|m|s)\s*\[/, { token: 'regexp.delim', switchTo: '@qregexp.[.]' }],
[/(qr|m|s)\s*\{/, { token: 'regexp.delim', switchTo: '@qregexp.{.}' }],
[/(qr|m|s)\s*</, { token: 'regexp.delim', switchTo: '@qregexp.<.>' }],
[/(qr|m|s)#/, { token: 'regexp.delim', switchTo: '@qregexp.#.#' }],
[/(qr|m|s)\s*([^A-Za-z0-9_#\s])/, { token: 'regexp.delim', switchTo: '@qregexp.$2.$2' }],
[/(qr|m|s)\s+(\w)/, { token: 'regexp.delim', switchTo: '@qregexp.$2.$2' }],
[/(qq|qx)\s*\(/, { token: 'string.delim', switchTo: '@qqstring.(.)' }],
[/(qq|qx)\s*\[/, { token: 'string.delim', switchTo: '@qqstring.[.]' }],
[/(qq|qx)\s*\{/, { token: 'string.delim', switchTo: '@qqstring.{.}' }],
[/(qq|qx)\s*</, { token: 'string.delim', switchTo: '@qqstring.<.>' }],
[/(qq|qx)#/, { token: 'string.delim', switchTo: '@qqstring.#.#' }],
[/(qq|qx)\s*([^A-Za-z0-9#\s])/, { token: 'string.delim', switchTo: '@qqstring.$2.$2' }],
[/(qq|qx)\s+(\w)/, { token: 'string.delim', switchTo: '@qqstring.$2.$2' }],
],
// Non-expanded quoted string
// qstring<open>.<close>
// open = open delimiter
// close = close delimiter
qstring: [
[/\\./, 'string.escape'],
[/./, {
cases: {
'$#==$S3': { token: 'string.delim', next: '@pop' },
'$#==$S2': { token: 'string.delim', next: '@push' },
'@default': 'string'
}
}],
],
// Quoted regexp
// qregexp.<open>.<close>
// open = open delimiter
// close = close delimiter
qregexp: [
{ include: '@variables' },
[/\\./, 'regexp.escape'],
[/./, {
cases: {
'$#==$S3': { token: 'regexp.delim', next: '@regexpModifiers' },
'$#==$S2': { token: 'regexp.delim', next: '@push' },
'@default': 'regexp'
}
}],
],
regexpModifiers: [
[/[msixpodualngcer]+/, { token: 'regexp.modifier', next: '@popall' }],
],
// Expanded quoted string
// qqstring.<open>.<close>
// open = open delimiter
// close = close delimiter
qqstring: [
{ include: '@variables' },
{ include: '@qstring' },
],
heredoc: [
[
/<<\s*['"`]?([\w\-]+)['"`]?/,
{ token: 'string.heredoc.delimiter', next: '@heredocBody.$1' },
],
],
heredocBody: [
[
/^([\w\-]+)$/,
{
cases: {
'$1==$S2': [{ token: 'string.heredoc.delimiter', next: '@popall' }],
'@default': 'string.heredoc',
},
},
],
[/./, 'string.heredoc'],
],
perldoc: [[/^=\w/, 'comment.doc', '@perldocBody']],
perldocBody: [
[/^=cut\b/, 'type.identifier', '@popall'],
[/./, 'comment.doc'],
],
variables: [
[/\$\w+/, 'variable'],
[/@\w+/, 'variable'],
[/%\w+/, 'variable'],
],
},
};
/***/ })
}]);

269
57.2bd0c3a7.async.js Normal file
View File

@ -0,0 +1,269 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[57],{
/***/ "HGU1":
/*!**************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/pgsql/pgsql.js ***!
\**************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/pgsql/pgsql.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '--',
blockComment: ['/*', '*/'],
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
]
};
var language = {
defaultToken: '',
tokenPostfix: '.sql',
ignoreCase: true,
brackets: [
{ open: '[', close: ']', token: 'delimiter.square' },
{ open: '(', close: ')', token: 'delimiter.parenthesis' }
],
keywords: [
"A", "ABORT", "ABS", "ABSENT", "ABSOLUTE", "ACCESS", "ACCORDING", "ACTION", "ADA", "ADD", "ADMIN", "AFTER", "AGGREGATE", "ALL",
"ALLOCATE", "ALSO", "ALTER", "ALWAYS", "ANALYSE", "ANALYZE", "AND", "ANY", "ARE", "ARRAY", "ARRAY_AGG", "ARRAY_MAX_CARDINALITY",
"AS", "ASC", "ASENSITIVE", "ASSERTION", "ASSIGNMENT", "ASYMMETRIC", "AT", "ATOMIC", "ATTRIBUTE", "ATTRIBUTES", "AUTHORIZATION",
"AVG", "BACKWARD", "BASE64", "BEFORE", "BEGIN", "BEGIN_FRAME", "BEGIN_PARTITION", "BERNOULLI", "BETWEEN", "BIGINT", "BINARY",
"BIT", "BIT_LENGTH", "BLOB", "BLOCKED", "BOM", "BOOLEAN", "BOTH", "BREADTH", "BY", "C", "CACHE", "CALL", "CALLED", "CARDINALITY",
"CASCADE", "CASCADED", "CASE", "CAST", "CATALOG", "CATALOG_NAME", "CEIL", "CEILING", "CHAIN", "CHAR", "CHARACTER",
"CHARACTERISTICS", "CHARACTERS", "CHARACTER_LENGTH", "CHARACTER_SET_CATALOG", "CHARACTER_SET_NAME", "CHARACTER_SET_SCHEMA",
"CHAR_LENGTH", "CHECK", "CHECKPOINT", "CLASS", "CLASS_ORIGIN", "CLOB", "CLOSE", "CLUSTER", "COALESCE", "COBOL", "COLLATE",
"COLLATION", "COLLATION_CATALOG", "COLLATION_NAME", "COLLATION_SCHEMA", "COLLECT", "COLUMN", "COLUMNS", "COLUMN_NAME",
"COMMAND_FUNCTION", "COMMAND_FUNCTION_CODE", "COMMENT", "COMMENTS", "COMMIT", "COMMITTED", "CONCURRENTLY", "CONDITION",
"CONDITION_NUMBER", "CONFIGURATION", "CONFLICT", "CONNECT", "CONNECTION", "CONNECTION_NAME", "CONSTRAINT", "CONSTRAINTS",
"CONSTRAINT_CATALOG", "CONSTRAINT_NAME", "CONSTRAINT_SCHEMA", "CONSTRUCTOR", "CONTAINS", "CONTENT", "CONTINUE", "CONTROL",
"CONVERSION", "CONVERT", "COPY", "CORR", "CORRESPONDING", "COST", "COUNT", "COVAR_POP", "COVAR_SAMP", "CREATE", "CROSS", "CSV",
"CUBE", "CUME_DIST", "CURRENT", "CURRENT_CATALOG", "CURRENT_DATE", "CURRENT_DEFAULT_TRANSFORM_GROUP", "CURRENT_PATH",
"CURRENT_ROLE", "CURRENT_ROW", "CURRENT_SCHEMA", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_TRANSFORM_GROUP_FOR_TYPE",
"CURRENT_USER", "CURSOR", "CURSOR_NAME", "CYCLE", "DATA", "DATABASE", "DATALINK", "DATE", "DATETIME_INTERVAL_CODE",
"DATETIME_INTERVAL_PRECISION", "DAY", "DB", "DEALLOCATE", "DEC", "DECIMAL", "DECLARE", "DEFAULT", "DEFAULTS", "DEFERRABLE",
"DEFERRED", "DEFINED", "DEFINER", "DEGREE", "DELETE", "DELIMITER", "DELIMITERS", "DENSE_RANK", "DEPENDS", "DEPTH", "DEREF",
"DERIVED", "DESC", "DESCRIBE", "DESCRIPTOR", "DETERMINISTIC", "DIAGNOSTICS", "DICTIONARY", "DISABLE", "DISCARD", "DISCONNECT",
"DISPATCH", "DISTINCT", "DLNEWCOPY", "DLPREVIOUSCOPY", "DLURLCOMPLETE", "DLURLCOMPLETEONLY", "DLURLCOMPLETEWRITE", "DLURLPATH",
"DLURLPATHONLY", "DLURLPATHWRITE", "DLURLSCHEME", "DLURLSERVER", "DLVALUE", "DO", "DOCUMENT", "DOMAIN", "DOUBLE", "DROP",
"DYNAMIC", "DYNAMIC_FUNCTION", "DYNAMIC_FUNCTION_CODE", "EACH", "ELEMENT", "ELSE", "EMPTY", "ENABLE", "ENCODING", "ENCRYPTED",
"END", "END-EXEC", "END_FRAME", "END_PARTITION", "ENFORCED", "ENUM", "EQUALS", "ESCAPE", "EVENT", "EVERY", "EXCEPT", "EXCEPTION",
"EXCLUDE", "EXCLUDING", "EXCLUSIVE", "EXEC", "EXECUTE", "EXISTS", "EXP", "EXPLAIN", "EXPRESSION", "EXTENSION", "EXTERNAL",
"EXTRACT", "FALSE", "FAMILY", "FETCH", "FILE", "FILTER", "FINAL", "FIRST", "FIRST_VALUE", "FLAG", "FLOAT", "FLOOR", "FOLLOWING",
"FOR", "FORCE", "FOREIGN", "FORTRAN", "FORWARD", "FOUND", "FRAME_ROW", "FREE", "FREEZE", "FROM", "FS", "FULL", "FUNCTION",
"FUNCTIONS", "FUSION", "G", "GENERAL", "GENERATED", "GET", "GLOBAL", "GO", "GOTO", "GRANT", "GRANTED", "GREATEST", "GROUP",
"GROUPING", "GROUPS", "HANDLER", "HAVING", "HEADER", "HEX", "HIERARCHY", "HOLD", "HOUR", "ID", "IDENTITY", "IF", "IGNORE",
"ILIKE", "IMMEDIATE", "IMMEDIATELY", "IMMUTABLE", "IMPLEMENTATION", "IMPLICIT", "IMPORT", "IN", "INCLUDING", "INCREMENT",
"INDENT", "INDEX", "INDEXES", "INDICATOR", "INHERIT", "INHERITS", "INITIALLY", "INLINE", "INNER", "INOUT", "INPUT",
"INSENSITIVE", "INSERT", "INSTANCE", "INSTANTIABLE", "INSTEAD", "INT", "INTEGER", "INTEGRITY", "INTERSECT", "INTERSECTION",
"INTERVAL", "INTO", "INVOKER", "IS", "ISNULL", "ISOLATION", "JOIN", "K", "KEY", "KEY_MEMBER", "KEY_TYPE", "LABEL", "LAG",
"LANGUAGE", "LARGE", "LAST", "LAST_VALUE", "LATERAL", "LEAD", "LEADING", "LEAKPROOF", "LEAST", "LEFT", "LENGTH", "LEVEL",
"LIBRARY", "LIKE", "LIKE_REGEX", "LIMIT", "LINK", "LISTEN", "LN", "LOAD", "LOCAL", "LOCALTIME", "LOCALTIMESTAMP", "LOCATION",
"LOCATOR", "LOCK", "LOCKED", "LOGGED", "LOWER", "M", "MAP", "MAPPING", "MATCH", "MATCHED", "MATERIALIZED", "MAX", "MAXVALUE",
"MAX_CARDINALITY", "MEMBER", "MERGE", "MESSAGE_LENGTH", "MESSAGE_OCTET_LENGTH", "MESSAGE_TEXT", "METHOD", "MIN", "MINUTE",
"MINVALUE", "MOD", "MODE", "MODIFIES", "MODULE", "MONTH", "MORE", "MOVE", "MULTISET", "MUMPS", "NAME", "NAMES", "NAMESPACE",
"NATIONAL", "NATURAL", "NCHAR", "NCLOB", "NESTING", "NEW", "NEXT", "NFC", "NFD", "NFKC", "NFKD", "NIL", "NO", "NONE",
"NORMALIZE", "NORMALIZED", "NOT", "NOTHING", "NOTIFY", "NOTNULL", "NOWAIT", "NTH_VALUE", "NTILE", "NULL", "NULLABLE", "NULLIF",
"NULLS", "NUMBER", "NUMERIC", "OBJECT", "OCCURRENCES_REGEX", "OCTETS", "OCTET_LENGTH", "OF", "OFF", "OFFSET", "OIDS", "OLD",
"ON", "ONLY", "OPEN", "OPERATOR", "OPTION", "OPTIONS", "OR", "ORDER", "ORDERING", "ORDINALITY", "OTHERS", "OUT", "OUTER",
"OUTPUT", "OVER", "OVERLAPS", "OVERLAY", "OVERRIDING", "OWNED", "OWNER", "P", "PAD", "PARALLEL", "PARAMETER", "PARAMETER_MODE",
"PARAMETER_NAME", "PARAMETER_ORDINAL_POSITION", "PARAMETER_SPECIFIC_CATALOG", "PARAMETER_SPECIFIC_NAME",
"PARAMETER_SPECIFIC_SCHEMA", "PARSER", "PARTIAL", "PARTITION", "PASCAL", "PASSING", "PASSTHROUGH", "PASSWORD", "PATH",
"PERCENT", "PERCENTILE_CONT", "PERCENTILE_DISC", "PERCENT_RANK", "PERIOD", "PERMISSION", "PLACING", "PLANS", "PLI", "POLICY",
"PORTION", "POSITION", "POSITION_REGEX", "POWER", "PRECEDES", "PRECEDING", "PRECISION", "PREPARE", "PREPARED", "PRESERVE",
"PRIMARY", "PRIOR", "PRIVILEGES", "PROCEDURAL", "PROCEDURE", "PROGRAM", "PUBLIC", "QUOTE", "RANGE", "RANK", "READ", "READS",
"REAL", "REASSIGN", "RECHECK", "RECOVERY", "RECURSIVE", "REF", "REFERENCES", "REFERENCING", "REFRESH", "REGR_AVGX", "REGR_AVGY",
"REGR_COUNT", "REGR_INTERCEPT", "REGR_R2", "REGR_SLOPE", "REGR_SXX", "REGR_SXY", "REGR_SYY", "REINDEX", "RELATIVE", "RELEASE",
"RENAME", "REPEATABLE", "REPLACE", "REPLICA", "REQUIRING", "RESET", "RESPECT", "RESTART", "RESTORE", "RESTRICT", "RESULT",
"RETURN", "RETURNED_CARDINALITY", "RETURNED_LENGTH", "RETURNED_OCTET_LENGTH", "RETURNED_SQLSTATE", "RETURNING", "RETURNS",
"REVOKE", "RIGHT", "ROLE", "ROLLBACK", "ROLLUP", "ROUTINE", "ROUTINE_CATALOG", "ROUTINE_NAME", "ROUTINE_SCHEMA", "ROW", "ROWS",
"ROW_COUNT", "ROW_NUMBER", "RULE", "SAVEPOINT", "SCALE", "SCHEMA", "SCHEMA_NAME", "SCOPE", "SCOPE_CATALOG", "SCOPE_NAME",
"SCOPE_SCHEMA", "SCROLL", "SEARCH", "SECOND", "SECTION", "SECURITY", "SELECT", "SELECTIVE", "SELF", "SENSITIVE", "SEQUENCE",
"SEQUENCES", "SERIALIZABLE", "SERVER", "SERVER_NAME", "SESSION", "SESSION_USER", "SET", "SETOF", "SETS", "SHARE", "SHOW",
"SIMILAR", "SIMPLE", "SIZE", "SKIP", "SMALLINT", "SNAPSHOT", "SOME", "SOURCE", "SPACE", "SPECIFIC", "SPECIFICTYPE",
"SPECIFIC_NAME", "SQL", "SQLCODE", "SQLERROR", "SQLEXCEPTION", "SQLSTATE", "SQLWARNING", "SQRT", "STABLE", "STANDALONE",
"START", "STATE", "STATEMENT", "STATIC", "STATISTICS", "STDDEV_POP", "STDDEV_SAMP", "STDIN", "STDOUT", "STORAGE", "STRICT",
"STRIP", "STRUCTURE", "STYLE", "SUBCLASS_ORIGIN", "SUBMULTISET", "SUBSTRING", "SUBSTRING_REGEX", "SUCCEEDS", "SUM", "SYMMETRIC",
"SYSID", "SYSTEM", "SYSTEM_TIME", "SYSTEM_USER", "T", "TABLE", "TABLES", "TABLESAMPLE", "TABLESPACE", "TABLE_NAME", "TEMP",
"TEMPLATE", "TEMPORARY", "TEXT", "THEN", "TIES", "TIME", "TIMESTAMP", "TIMEZONE_HOUR", "TIMEZONE_MINUTE", "TO", "TOKEN",
"TOP_LEVEL_COUNT", "TRAILING", "TRANSACTION", "TRANSACTIONS_COMMITTED", "TRANSACTIONS_ROLLED_BACK", "TRANSACTION_ACTIVE",
"TRANSFORM", "TRANSFORMS", "TRANSLATE", "TRANSLATE_REGEX", "TRANSLATION", "TREAT", "TRIGGER", "TRIGGER_CATALOG", "TRIGGER_NAME",
"TRIGGER_SCHEMA", "TRIM", "TRIM_ARRAY", "TRUE", "TRUNCATE", "TRUSTED", "TYPE", "TYPES", "UESCAPE", "UNBOUNDED", "UNCOMMITTED",
"UNDER", "UNENCRYPTED", "UNION", "UNIQUE", "UNKNOWN", "UNLINK", "UNLISTEN", "UNLOGGED", "UNNAMED", "UNNEST", "UNTIL", "UNTYPED",
"UPDATE", "UPPER", "URI", "USAGE", "USER", "USER_DEFINED_TYPE_CATALOG", "USER_DEFINED_TYPE_CODE", "USER_DEFINED_TYPE_NAME",
"USER_DEFINED_TYPE_SCHEMA", "USING", "VACUUM", "VALID", "VALIDATE", "VALIDATOR", "VALUE", "VALUES", "VALUE_OF", "VARBINARY",
"VARCHAR", "VARIADIC", "VARYING", "VAR_POP", "VAR_SAMP", "VERBOSE", "VERSION", "VERSIONING", "VIEW", "VIEWS", "VOLATILE",
"WHEN", "WHENEVER", "WHERE", "WHITESPACE", "WIDTH_BUCKET", "WINDOW", "WITH", "WITHIN", "WITHOUT", "WORK", "WRAPPER", "WRITE",
"XML", "XMLAGG", "XMLATTRIBUTES", "XMLBINARY", "XMLCAST", "XMLCOMMENT", "XMLCONCAT", "XMLDECLARATION", "XMLDOCUMENT",
"XMLELEMENT", "XMLEXISTS", "XMLFOREST", "XMLITERATE", "XMLNAMESPACES", "XMLPARSE", "XMLPI", "XMLQUERY", "XMLROOT", "XMLSCHEMA",
"XMLSERIALIZE", "XMLTABLE", "XMLTEXT", "XMLVALIDATE", "YEAR", "YES", "ZONE"
],
operators: [
"AND", "BETWEEN", "IN", "LIKE", "NOT", "OR", "IS", "NULL", "INTERSECT", "UNION", "INNER", "JOIN", "LEFT", "OUTER", "RIGHT"
],
builtinFunctions: [
"abbrev", "abs", "acos", "acosd", "age", "any", "area", "array_agg", "array_append", "array_cat", "array_dims", "array_fill",
"array_length", "array_lower", "array_ndims", "array_position", "array_positions", "array_prepend", "array_remove", "array_replace",
"array_to_json", "array_to_string", "array_to_tsvector", "array_upper", "ascii", "asin", "asind", "atan", "atan2", "atan2d", "atand",
"avg", "bit", "bit_and", "bit_length", "bit_or", "bool_and", "bool_or", "bound_box", "box", "brin_summarize_new_values", "broadcast",
"btrim", "cardinality", "cbrt", "ceil", "ceiling", "center", "char_length", "character_length", "chr", "circle", "clock_timestamp",
"coalesce", "col_description", "concat", "concat_ws", "convert", "convert_from", "convert_to", "corr", "cos", "cosd", "cot", "cotd",
"count", "covar_pop", "covar_samp", "cume_dist", "current_catalog", "current_database", "current_date", "current_query", "current_role",
"current_schema", "current_schemas", "current_setting", "current_time", "current_timestamp", "current_user", "currval", "cursor_to_xml",
"date_part", "date_trunc", "decode", "degrees", "dense_rank", "diameter", "div", "encode", "enum_first", "enum_last", "enum_range", "every",
"exp", "extract", "family", "first_value", "floor", "format", "format_type", "generate_series", "generate_subscripts", "get_bit", "get_byte",
"get_current_ts_config", "gin_clean_pending_list", "greatest", "grouping", "has_any_column_privilege", "has_column_privilege",
"has_database_privilege", "has_foreign_data_wrapper_privilege", "has_function_privilege", "has_language_privilege", "has_schema_privilege",
"has_sequence_privilege", "has_server_privilege", "has_table_privilege", "has_tablespace_privilege", "has_type_privilege", "height", "host",
"hostmask", "inet_client_addr", "inet_client_port", "inet_merge", "inet_same_family", "inet_server_addr", "inet_server_port", "initcap",
"isclosed", "isempty", "isfinite", "isopen", "json_agg", "json_object", "json_object_agg", "json_populate_record", "json_populate_recordset",
"json_to_record", "json_to_recordset", "jsonb_agg", "jsonb_object_agg", "justify_days", "justify_hours", "justify_interval", "lag",
"last_value", "lastval", "lead", "least", "left", "length", "line", "ln", "localtime", "localtimestamp", "log", "lower", "lower_inc",
"lower_inf", "lpad", "lseg", "ltrim", "make_date", "make_interval", "make_time", "make_timestamp", "make_timestamptz", "masklen", "max",
"md5", "min", "mod", "mode", "netmask", "network", "nextval", "now", "npoints", "nth_value", "ntile", "nullif", "num_nonnulls", "num_nulls",
"numnode", "obj_description", "octet_length", "overlay", "parse_ident", "path", "pclose", "percent_rank", "percentile_cont", "percentile_disc",
"pg_advisory_lock", "pg_advisory_lock_shared", "pg_advisory_unlock", "pg_advisory_unlock_all", "pg_advisory_unlock_shared", "pg_advisory_xact_lock",
"pg_advisory_xact_lock_shared", "pg_backend_pid", "pg_backup_start_time", "pg_blocking_pids", "pg_cancel_backend", "pg_client_encoding",
"pg_collation_is_visible", "pg_column_size", "pg_conf_load_time", "pg_control_checkpoint", "pg_control_init", "pg_control_recovery",
"pg_control_system", "pg_conversion_is_visible", "pg_create_logical_replication_slot", "pg_create_physical_replication_slot", "pg_create_restore_point",
"pg_current_xlog_flush_location", "pg_current_xlog_insert_location", "pg_current_xlog_location", "pg_database_size", "pg_describe_object",
"pg_drop_replication_slot", "pg_export_snapshot", "pg_filenode_relation", "pg_function_is_visible", "pg_get_constraintdef", "pg_get_expr",
"pg_get_function_arguments", "pg_get_function_identity_arguments", "pg_get_function_result", "pg_get_functiondef", "pg_get_indexdef", "pg_get_keywords",
"pg_get_object_address", "pg_get_owned_sequence", "pg_get_ruledef", "pg_get_serial_sequence", "pg_get_triggerdef", "pg_get_userbyid", "pg_get_viewdef",
"pg_has_role", "pg_identify_object", "pg_identify_object_as_address", "pg_index_column_has_property", "pg_index_has_property", "pg_indexam_has_property",
"pg_indexes_size", "pg_is_in_backup", "pg_is_in_recovery", "pg_is_other_temp_schema", "pg_is_xlog_replay_paused", "pg_last_committed_xact",
"pg_last_xact_replay_timestamp", "pg_last_xlog_receive_location", "pg_last_xlog_replay_location", "pg_listening_channels", "pg_logical_emit_message",
"pg_logical_slot_get_binary_changes", "pg_logical_slot_get_changes", "pg_logical_slot_peek_binary_changes", "pg_logical_slot_peek_changes", "pg_ls_dir",
"pg_my_temp_schema", "pg_notification_queue_usage", "pg_opclass_is_visible", "pg_operator_is_visible", "pg_opfamily_is_visible", "pg_options_to_table",
"pg_postmaster_start_time", "pg_read_binary_file", "pg_read_file", "pg_relation_filenode", "pg_relation_filepath", "pg_relation_size", "pg_reload_conf",
"pg_replication_origin_create", "pg_replication_origin_drop", "pg_replication_origin_oid", "pg_replication_origin_progress", "pg_replication_origin_session_is_setup",
"pg_replication_origin_session_progress", "pg_replication_origin_session_reset", "pg_replication_origin_session_setup", "pg_replication_origin_xact_reset",
"pg_replication_origin_xact_setup", "pg_rotate_logfile", "pg_size_bytes", "pg_size_pretty", "pg_sleep", "pg_sleep_for", "pg_sleep_until", "pg_start_backup",
"pg_stat_file", "pg_stop_backup", "pg_switch_xlog", "pg_table_is_visible", "pg_table_size", "pg_tablespace_databases", "pg_tablespace_location",
"pg_tablespace_size", "pg_terminate_backend", "pg_total_relation_size", "pg_trigger_depth", "pg_try_advisory_lock", "pg_try_advisory_lock_shared",
"pg_try_advisory_xact_lock", "pg_try_advisory_xact_lock_shared", "pg_ts_config_is_visible", "pg_ts_dict_is_visible", "pg_ts_parser_is_visible",
"pg_ts_template_is_visible", "pg_type_is_visible", "pg_typeof", "pg_xact_commit_timestamp", "pg_xlog_location_diff", "pg_xlog_replay_pause",
"pg_xlog_replay_resume", "pg_xlogfile_name", "pg_xlogfile_name_offset", "phraseto_tsquery", "pi", "plainto_tsquery", "point", "polygon", "popen", "position",
"power", "pqserverversion", "query_to_xml", "querytree", "quote_ident", "quote_literal", "quote_nullable", "radians", "radius", "random", "range_merge",
"rank", "regexp_matches", "regexp_replace", "regexp_split_to_array", "regexp_split_to_table", "regr_avgx", "regr_avgy", "regr_count", "regr_intercept",
"regr_r2", "regr_slope", "regr_sxx", "regr_sxy", "regr_syy", "repeat", "replace", "reverse", "right", "round", "row_number", "row_security_active",
"row_to_json", "rpad", "rtrim", "scale", "session_user", "set_bit", "set_byte", "set_config", "set_masklen", "setseed", "setval", "setweight",
"shobj_description", "sign", "sin", "sind", "split_part", "sprintf", "sqrt", "statement_timestamp", "stddev", "stddev_pop", "stddev_samp", "string_agg",
"string_to_array", "strip", "strpos", "substr", "substring", "sum", "table_to_xml", "table_to_xml_and_xmlschema", "tan", "tand", "text", "timeofday",
"timezone", "to_ascii", "to_char", "to_date", "to_hex", "to_json", "to_number", "to_regclass", "to_regnamespace", "to_regoper", "to_regoperator", "to_regproc",
"to_regprocedure", "to_regrole", "to_regtype", "to_timestamp", "to_tsquery", "to_tsvector", "transaction_timestamp", "translate", "trim", "trunc", "ts_debug",
"ts_delete", "ts_filter", "ts_headline", "ts_lexize", "ts_parse", "ts_rank", "ts_rank_cd", "ts_rewrite", "ts_stat", "ts_token_type", "tsquery_phrase",
"tsvector_to_array", "tsvector_update_trigger", "tsvector_update_trigger_column", "txid_current", "txid_current_snapshot", "txid_snapshot_xip", "txid_snapshot_xmax",
"txid_snapshot_xmin", "txid_visible_in_snapshot", "unnest", "upper", "upper_inc", "upper_inf", "user", "var_pop", "var_samp", "variance", "version", "width",
"width_bucket", "xml_is_well_formed", "xml_is_well_formed_content", "xml_is_well_formed_document", "xmlagg", "xmlcomment", "xmlconcat", "xmlelement", "xmlexists",
"xmlforest", "xmlparse", "xmlpi", "xmlroot", "xmlserialize", "xpath", "xpath_exists"
],
builtinVariables: [
// NOT SUPPORTED
],
pseudoColumns: [
// NOT SUPPORTED
],
tokenizer: {
root: [
{ include: '@comments' },
{ include: '@whitespace' },
{ include: '@pseudoColumns' },
{ include: '@numbers' },
{ include: '@strings' },
{ include: '@complexIdentifiers' },
{ include: '@scopes' },
[/[;,.]/, 'delimiter'],
[/[()]/, '@brackets'],
[/[\w@#$]+/, {
cases: {
'@keywords': 'keyword',
'@operators': 'operator',
'@builtinVariables': 'predefined',
'@builtinFunctions': 'predefined',
'@default': 'identifier'
}
}],
[/[<>=!%&+\-*/|~^]/, 'operator'],
],
whitespace: [
[/\s+/, 'white']
],
comments: [
[/--+.*/, 'comment'],
[/\/\*/, { token: 'comment.quote', next: '@comment' }]
],
comment: [
[/[^*/]+/, 'comment'],
// Not supporting nested comments, as nested comments seem to not be standard?
// i.e. http://stackoverflow.com/questions/728172/are-there-multiline-comment-delimiters-in-sql-that-are-vendor-agnostic
// [/\/\*/, { token: 'comment.quote', next: '@push' }], // nested comment not allowed :-(
[/\*\//, { token: 'comment.quote', next: '@pop' }],
[/./, 'comment']
],
pseudoColumns: [
[/[$][A-Za-z_][\w@#$]*/, {
cases: {
'@pseudoColumns': 'predefined',
'@default': 'identifier'
}
}],
],
numbers: [
[/0[xX][0-9a-fA-F]*/, 'number'],
[/[$][+-]*\d*(\.\d*)?/, 'number'],
[/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, 'number']
],
strings: [
[/'/, { token: 'string', next: '@string' }],
],
string: [
[/[^']+/, 'string'],
[/''/, 'string'],
[/'/, { token: 'string', next: '@pop' }]
],
complexIdentifiers: [
[/"/, { token: 'identifier.quote', next: '@quotedIdentifier' }]
],
quotedIdentifier: [
[/[^"]+/, 'identifier'],
[/""/, 'identifier'],
[/"/, { token: 'identifier.quote', next: '@pop' }]
],
scopes: [
// NOT SUPPORTED
]
}
};
/***/ })
}]);

298
58.3a115454.async.js Normal file
View File

@ -0,0 +1,298 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[58],{
/***/ "lXEz":
/*!**********************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/php/php.js ***!
\**********************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/php/php.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
comments: {
lineComment: '//',
blockComment: ['/*', '*/']
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}', notIn: ['string'] },
{ open: '[', close: ']', notIn: ['string'] },
{ open: '(', close: ')', notIn: ['string'] },
{ open: '"', close: '"', notIn: ['string'] },
{ open: '\'', close: '\'', notIn: ['string', 'comment'] }
],
folding: {
markers: {
start: new RegExp("^\\s*(#|\/\/)region\\b"),
end: new RegExp("^\\s*(#|\/\/)endregion\\b")
}
}
};
var language = {
defaultToken: '',
tokenPostfix: '',
// ignoreCase: true,
// The main tokenizer for our languages
tokenizer: {
root: [
[/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInSimpleState.root' }],
[/<!DOCTYPE/, 'metatag.html', '@doctype'],
[/<!--/, 'comment.html', '@comment'],
[/(<)(\w+)(\/>)/, ['delimiter.html', 'tag.html', 'delimiter.html']],
[/(<)(script)/, ['delimiter.html', { token: 'tag.html', next: '@script' }]],
[/(<)(style)/, ['delimiter.html', { token: 'tag.html', next: '@style' }]],
[/(<)([:\w]+)/, ['delimiter.html', { token: 'tag.html', next: '@otherTag' }]],
[/(<\/)(\w+)/, ['delimiter.html', { token: 'tag.html', next: '@otherTag' }]],
[/</, 'delimiter.html'],
[/[^<]+/] // text
],
doctype: [
[/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInSimpleState.comment' }],
[/[^>]+/, 'metatag.content.html'],
[/>/, 'metatag.html', '@pop'],
],
comment: [
[/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInSimpleState.comment' }],
[/-->/, 'comment.html', '@pop'],
[/[^-]+/, 'comment.content.html'],
[/./, 'comment.content.html']
],
otherTag: [
[/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInSimpleState.otherTag' }],
[/\/?>/, 'delimiter.html', '@pop'],
[/"([^"]*)"/, 'attribute.value'],
[/'([^']*)'/, 'attribute.value'],
[/[\w\-]+/, 'attribute.name'],
[/=/, 'delimiter'],
[/[ \t\r\n]+/],
],
// -- BEGIN <script> tags handling
// After <script
script: [
[/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInSimpleState.script' }],
[/type/, 'attribute.name', '@scriptAfterType'],
[/"([^"]*)"/, 'attribute.value'],
[/'([^']*)'/, 'attribute.value'],
[/[\w\-]+/, 'attribute.name'],
[/=/, 'delimiter'],
[/>/, { token: 'delimiter.html', next: '@scriptEmbedded.text/javascript', nextEmbedded: 'text/javascript' }],
[/[ \t\r\n]+/],
[/(<\/)(script\s*)(>)/, ['delimiter.html', 'tag.html', { token: 'delimiter.html', next: '@pop' }]]
],
// After <script ... type
scriptAfterType: [
[/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInSimpleState.scriptAfterType' }],
[/=/, 'delimiter', '@scriptAfterTypeEquals'],
[/>/, { token: 'delimiter.html', next: '@scriptEmbedded.text/javascript', nextEmbedded: 'text/javascript' }],
[/[ \t\r\n]+/],
[/<\/script\s*>/, { token: '@rematch', next: '@pop' }]
],
// After <script ... type =
scriptAfterTypeEquals: [
[/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInSimpleState.scriptAfterTypeEquals' }],
[/"([^"]*)"/, { token: 'attribute.value', switchTo: '@scriptWithCustomType.$1' }],
[/'([^']*)'/, { token: 'attribute.value', switchTo: '@scriptWithCustomType.$1' }],
[/>/, { token: 'delimiter.html', next: '@scriptEmbedded.text/javascript', nextEmbedded: 'text/javascript' }],
[/[ \t\r\n]+/],
[/<\/script\s*>/, { token: '@rematch', next: '@pop' }]
],
// After <script ... type = $S2
scriptWithCustomType: [
[/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInSimpleState.scriptWithCustomType.$S2' }],
[/>/, { token: 'delimiter.html', next: '@scriptEmbedded.$S2', nextEmbedded: '$S2' }],
[/"([^"]*)"/, 'attribute.value'],
[/'([^']*)'/, 'attribute.value'],
[/[\w\-]+/, 'attribute.name'],
[/=/, 'delimiter'],
[/[ \t\r\n]+/],
[/<\/script\s*>/, { token: '@rematch', next: '@pop' }]
],
scriptEmbedded: [
[/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInEmbeddedState.scriptEmbedded.$S2', nextEmbedded: '@pop' }],
[/<\/script/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }]
],
// -- END <script> tags handling
// -- BEGIN <style> tags handling
// After <style
style: [
[/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInSimpleState.style' }],
[/type/, 'attribute.name', '@styleAfterType'],
[/"([^"]*)"/, 'attribute.value'],
[/'([^']*)'/, 'attribute.value'],
[/[\w\-]+/, 'attribute.name'],
[/=/, 'delimiter'],
[/>/, { token: 'delimiter.html', next: '@styleEmbedded.text/css', nextEmbedded: 'text/css' }],
[/[ \t\r\n]+/],
[/(<\/)(style\s*)(>)/, ['delimiter.html', 'tag.html', { token: 'delimiter.html', next: '@pop' }]]
],
// After <style ... type
styleAfterType: [
[/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInSimpleState.styleAfterType' }],
[/=/, 'delimiter', '@styleAfterTypeEquals'],
[/>/, { token: 'delimiter.html', next: '@styleEmbedded.text/css', nextEmbedded: 'text/css' }],
[/[ \t\r\n]+/],
[/<\/style\s*>/, { token: '@rematch', next: '@pop' }]
],
// After <style ... type =
styleAfterTypeEquals: [
[/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInSimpleState.styleAfterTypeEquals' }],
[/"([^"]*)"/, { token: 'attribute.value', switchTo: '@styleWithCustomType.$1' }],
[/'([^']*)'/, { token: 'attribute.value', switchTo: '@styleWithCustomType.$1' }],
[/>/, { token: 'delimiter.html', next: '@styleEmbedded.text/css', nextEmbedded: 'text/css' }],
[/[ \t\r\n]+/],
[/<\/style\s*>/, { token: '@rematch', next: '@pop' }]
],
// After <style ... type = $S2
styleWithCustomType: [
[/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInSimpleState.styleWithCustomType.$S2' }],
[/>/, { token: 'delimiter.html', next: '@styleEmbedded.$S2', nextEmbedded: '$S2' }],
[/"([^"]*)"/, 'attribute.value'],
[/'([^']*)'/, 'attribute.value'],
[/[\w\-]+/, 'attribute.name'],
[/=/, 'delimiter'],
[/[ \t\r\n]+/],
[/<\/style\s*>/, { token: '@rematch', next: '@pop' }]
],
styleEmbedded: [
[/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInEmbeddedState.styleEmbedded.$S2', nextEmbedded: '@pop' }],
[/<\/style/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }]
],
// -- END <style> tags handling
phpInSimpleState: [
[/<\?((php)|=)?/, 'metatag.php'],
[/\?>/, { token: 'metatag.php', switchTo: '@$S2.$S3' }],
{ include: 'phpRoot' }
],
phpInEmbeddedState: [
[/<\?((php)|=)?/, 'metatag.php'],
[/\?>/, { token: 'metatag.php', switchTo: '@$S2.$S3', nextEmbedded: '$S3' }],
{ include: 'phpRoot' }
],
phpRoot: [
[/[a-zA-Z_]\w*/, {
cases: {
'@phpKeywords': { token: 'keyword.php' },
'@phpCompileTimeConstants': { token: 'constant.php' },
'@default': 'identifier.php'
}
}],
[/[$a-zA-Z_]\w*/, {
cases: {
'@phpPreDefinedVariables': { token: 'variable.predefined.php' },
'@default': 'variable.php'
}
}],
// brackets
[/[{}]/, 'delimiter.bracket.php'],
[/[\[\]]/, 'delimiter.array.php'],
[/[()]/, 'delimiter.parenthesis.php'],
// whitespace
[/[ \t\r\n]+/],
// comments
[/(#|\/\/)$/, 'comment.php'],
[/(#|\/\/)/, 'comment.php', '@phpLineComment'],
// block comments
[/\/\*/, 'comment.php', '@phpComment'],
// strings
[/"/, 'string.php', '@phpDoubleQuoteString'],
[/'/, 'string.php', '@phpSingleQuoteString'],
// delimiters
[/[\+\-\*\%\&\|\^\~\!\=\<\>\/\?\;\:\.\,\@]/, 'delimiter.php'],
// numbers
[/\d*\d+[eE]([\-+]?\d+)?/, 'number.float.php'],
[/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float.php'],
[/0[xX][0-9a-fA-F']*[0-9a-fA-F]/, 'number.hex.php'],
[/0[0-7']*[0-7]/, 'number.octal.php'],
[/0[bB][0-1']*[0-1]/, 'number.binary.php'],
[/\d[\d']*/, 'number.php'],
[/\d/, 'number.php'],
],
phpComment: [
[/\*\//, 'comment.php', '@pop'],
[/[^*]+/, 'comment.php'],
[/./, 'comment.php']
],
phpLineComment: [
[/\?>/, { token: '@rematch', next: '@pop' }],
[/.$/, 'comment.php', '@pop'],
[/[^?]+$/, 'comment.php', '@pop'],
[/[^?]+/, 'comment.php'],
[/./, 'comment.php']
],
phpDoubleQuoteString: [
[/[^\\"]+/, 'string.php'],
[/@escapes/, 'string.escape.php'],
[/\\./, 'string.escape.invalid.php'],
[/"/, 'string.php', '@pop']
],
phpSingleQuoteString: [
[/[^\\']+/, 'string.php'],
[/@escapes/, 'string.escape.php'],
[/\\./, 'string.escape.invalid.php'],
[/'/, 'string.php', '@pop']
],
},
phpKeywords: [
'abstract', 'and', 'array', 'as', 'break',
'callable', 'case', 'catch', 'cfunction', 'class', 'clone',
'const', 'continue', 'declare', 'default', 'do',
'else', 'elseif', 'enddeclare', 'endfor', 'endforeach',
'endif', 'endswitch', 'endwhile', 'extends', 'false', 'final',
'for', 'foreach', 'function', 'global', 'goto',
'if', 'implements', 'interface', 'instanceof', 'insteadof',
'namespace', 'new', 'null', 'object', 'old_function', 'or', 'private',
'protected', 'public', 'resource', 'static', 'switch', 'throw', 'trait',
'try', 'true', 'use', 'var', 'while', 'xor',
'die', 'echo', 'empty', 'exit', 'eval',
'include', 'include_once', 'isset', 'list', 'require',
'require_once', 'return', 'print', 'unset', 'yield',
'__construct'
],
phpCompileTimeConstants: [
'__CLASS__',
'__DIR__',
'__FILE__',
'__LINE__',
'__NAMESPACE__',
'__METHOD__',
'__FUNCTION__',
'__TRAIT__'
],
phpPreDefinedVariables: [
'$GLOBALS',
'$_SERVER',
'$_GET',
'$_POST',
'$_FILES',
'$_REQUEST',
'$_SESSION',
'$_ENV',
'$_COOKIE',
'$php_errormsg',
'$HTTP_RAW_POST_DATA',
'$http_response_header',
'$argc',
'$argv'
],
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
};
/***/ })
}]);

632
59.d672ee7a.async.js Normal file
View File

@ -0,0 +1,632 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[59],{
/***/ "YdqL":
/*!********************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/postiats/postiats.js ***!
\********************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/postiats/postiats.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Artyom Shalkhakov. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*
* Based on the ATS/Postiats lexer by Hongwei Xi.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '//',
blockComment: ['(*', '*)'],
},
brackets: [['{', '}'], ['[', ']'], ['(', ')'], ['<', '>']],
autoClosingPairs: [
{ open: '"', close: '"', notIn: ['string', 'comment'] },
{ open: '{', close: '}', notIn: ['string', 'comment'] },
{ open: '[', close: ']', notIn: ['string', 'comment'] },
{ open: '(', close: ')', notIn: ['string', 'comment'] },
]
};
var language = {
tokenPostfix: '.pats',
// TODO: staload and dynload are followed by a special kind of string literals
// with {$IDENTIFER} variables, and it also may make sense to highlight
// the punctuation (. and / and \) differently.
// Set defaultToken to invalid to see what you do not tokenize yet
defaultToken: 'invalid',
// keyword reference: https://github.com/githwxi/ATS-Postiats/blob/master/src/pats_lexing_token.dats
keywords: [
//
"abstype",
"abst0ype",
"absprop",
"absview",
"absvtype",
"absviewtype",
"absvt0ype",
"absviewt0ype",
//
"as",
//
"and",
//
"assume",
//
"begin",
//
/*
"case", // CASE
*/
//
"classdec",
//
"datasort",
//
"datatype",
"dataprop",
"dataview",
"datavtype",
"dataviewtype",
//
"do",
//
"end",
//
"extern",
"extype",
"extvar",
//
"exception",
//
"fn",
"fnx",
"fun",
//
"prfn",
"prfun",
//
"praxi",
"castfn",
//
"if",
"then",
"else",
//
"ifcase",
//
"in",
//
"infix",
"infixl",
"infixr",
"prefix",
"postfix",
//
"implmnt",
"implement",
//
"primplmnt",
"primplement",
//
"import",
//
/*
"lam", // LAM
"llam", // LLAM
"fix", // FIX
*/
//
"let",
//
"local",
//
"macdef",
"macrodef",
//
"nonfix",
//
"symelim",
"symintr",
"overload",
//
"of",
"op",
//
"rec",
//
"sif",
"scase",
//
"sortdef",
/*
// HX: [sta] is now deprecated
*/
"sta",
"stacst",
"stadef",
"static",
/*
"stavar", // T_STAVAR
*/
//
"staload",
"dynload",
//
"try",
//
"tkindef",
//
/*
"type", // TYPE
*/
"typedef",
"propdef",
"viewdef",
"vtypedef",
"viewtypedef",
//
/*
"val", // VAL
*/
"prval",
//
"var",
"prvar",
//
"when",
"where",
//
/*
"for", // T_FOR
"while", // T_WHILE
*/
//
"with",
//
"withtype",
"withprop",
"withview",
"withvtype",
"withviewtype",
],
keywords_dlr: [
"$delay",
"$ldelay",
//
"$arrpsz",
"$arrptrsize",
//
"$d2ctype",
//
"$effmask",
"$effmask_ntm",
"$effmask_exn",
"$effmask_ref",
"$effmask_wrt",
"$effmask_all",
//
"$extern",
"$extkind",
"$extype",
"$extype_struct",
//
"$extval",
"$extfcall",
"$extmcall",
//
"$literal",
//
"$myfilename",
"$mylocation",
"$myfunction",
//
"$lst",
"$lst_t",
"$lst_vt",
"$list",
"$list_t",
"$list_vt",
//
"$rec",
"$rec_t",
"$rec_vt",
"$record",
"$record_t",
"$record_vt",
//
"$tup",
"$tup_t",
"$tup_vt",
"$tuple",
"$tuple_t",
"$tuple_vt",
//
"$break",
"$continue",
//
"$raise",
//
"$showtype",
//
"$vcopyenv_v",
"$vcopyenv_vt",
//
"$tempenver",
//
"$solver_assert",
"$solver_verify",
],
keywords_srp: [
//
"#if",
"#ifdef",
"#ifndef",
//
"#then",
//
"#elif",
"#elifdef",
"#elifndef",
//
"#else",
"#endif",
//
"#error",
//
"#prerr",
"#print",
//
"#assert",
//
"#undef",
"#define",
//
"#include",
"#require",
//
"#pragma",
"#codegen2",
"#codegen3",
],
irregular_keyword_list: [
"val+",
"val-",
"val",
"case+",
"case-",
"case",
"addr@",
"addr",
"fold@",
"free@",
"fix@",
"fix",
"lam@",
"lam",
"llam@",
"llam",
"viewt@ype+",
"viewt@ype-",
"viewt@ype",
"viewtype+",
"viewtype-",
"viewtype",
"view+",
"view-",
"view@",
"view",
"type+",
"type-",
"type",
"vtype+",
"vtype-",
"vtype",
"vt@ype+",
"vt@ype-",
"vt@ype",
"viewt@ype+",
"viewt@ype-",
"viewt@ype",
"viewtype+",
"viewtype-",
"viewtype",
"prop+",
"prop-",
"prop",
"type+",
"type-",
"type",
"t@ype",
"t@ype+",
"t@ype-",
"abst@ype",
"abstype",
"absviewt@ype",
"absvt@ype",
"for*",
"for",
"while*",
"while"
],
keywords_types: [
'bool',
'double',
'byte',
'int',
'short',
'char',
'void',
'unit',
'long',
'float',
'string',
'strptr'
],
// TODO: reference for this?
keywords_effects: [
"0",
"fun",
"clo",
"prf",
"funclo",
"cloptr",
"cloref",
"ref",
"ntm",
"1" // all effects
],
operators: [
"@",
"!",
"|",
"`",
":",
"$",
".",
"=",
"#",
"~",
//
"..",
"...",
//
"=>",
// "=<", // T_EQLT
"=<>",
"=/=>",
"=>>",
"=/=>>",
//
"<",
">",
//
"><",
//
".<",
">.",
//
".<>.",
//
"->",
//"-<", // T_MINUSLT
"-<>",
],
brackets: [
{ open: ',(', close: ')', token: 'delimiter.parenthesis' },
{ open: '`(', close: ')', token: 'delimiter.parenthesis' },
{ open: '%(', close: ')', token: 'delimiter.parenthesis' },
{ open: '\'(', close: ')', token: 'delimiter.parenthesis' },
{ open: '\'{', close: '}', token: 'delimiter.parenthesis' },
{ open: '@(', close: ')', token: 'delimiter.parenthesis' },
{ open: '@{', close: '}', token: 'delimiter.brace' },
{ open: '@[', close: ']', token: 'delimiter.square' },
{ open: '#[', close: ']', token: 'delimiter.square' },
{ open: '{', close: '}', token: 'delimiter.curly' },
{ open: '[', close: ']', token: 'delimiter.square' },
{ open: '(', close: ')', token: 'delimiter.parenthesis' },
{ open: '<', close: '>', token: 'delimiter.angle' }
],
// we include these common regular expressions
symbols: /[=><!~?:&|+\-*\/\^%]+/,
IDENTFST: /[a-zA-Z_]/,
IDENTRST: /[a-zA-Z0-9_'$]/,
symbolic: /[%&+-./:=@~`^|*!$#?<>]/,
digit: /[0-9]/,
digitseq0: /@digit*/,
xdigit: /[0-9A-Za-z]/,
xdigitseq0: /@xdigit*/,
INTSP: /[lLuU]/,
FLOATSP: /[fFlL]/,
fexponent: /[eE][+-]?[0-9]+/,
fexponent_bin: /[pP][+-]?[0-9]+/,
deciexp: /\.[0-9]*@fexponent?/,
hexiexp: /\.[0-9a-zA-Z]*@fexponent_bin?/,
irregular_keywords: /val[+-]?|case[+-]?|addr\@?|fold\@|free\@|fix\@?|lam\@?|llam\@?|prop[+-]?|type[+-]?|view[+-@]?|viewt@?ype[+-]?|t@?ype[+-]?|v(iew)?t@?ype[+-]?|abst@?ype|absv(iew)?t@?ype|for\*?|while\*?/,
ESCHAR: /[ntvbrfa\\\?'"\(\[\{]/,
start: 'root',
// The main tokenizer for ATS/Postiats
// reference: https://github.com/githwxi/ATS-Postiats/blob/master/src/pats_lexing.dats
tokenizer: {
root: [
// lexing_blankseq0
{ regex: /[ \t\r\n]+/, action: { token: '' } },
// NOTE: (*) is an invalid ML-like comment!
{ regex: /\(\*\)/, action: { token: 'invalid' } },
{ regex: /\(\*/, action: { token: 'comment', next: 'lexing_COMMENT_block_ml' } },
{ regex: /\(/, action: '@brackets' /*{ token: 'delimiter.parenthesis' }*/ },
{ regex: /\)/, action: '@brackets' /*{ token: 'delimiter.parenthesis' }*/ },
{ regex: /\[/, action: '@brackets' /*{ token: 'delimiter.bracket' }*/ },
{ regex: /\]/, action: '@brackets' /*{ token: 'delimiter.bracket' }*/ },
{ regex: /\{/, action: '@brackets' /*{ token: 'delimiter.brace' }*/ },
{ regex: /\}/, action: '@brackets' /*{ token: 'delimiter.brace' }*/ },
// lexing_COMMA
{ regex: /,\(/, action: '@brackets' /*{ token: 'delimiter.parenthesis' }*/ },
{ regex: /,/, action: { token: 'delimiter.comma' } },
{ regex: /;/, action: { token: 'delimiter.semicolon' } },
// lexing_AT
{ regex: /@\(/, action: '@brackets' /* { token: 'delimiter.parenthesis' }*/ },
{ regex: /@\[/, action: '@brackets' /* { token: 'delimiter.bracket' }*/ },
{ regex: /@\{/, action: '@brackets' /*{ token: 'delimiter.brace' }*/ },
// lexing_COLON
{ regex: /:</, action: { token: 'keyword', next: '@lexing_EFFECT_commaseq0' } },
/*
lexing_DOT:
. // SYMBOLIC => lexing_IDENT_sym
. FLOATDOT => lexing_FLOAT_deciexp
. DIGIT => T_DOTINT
*/
{ regex: /\.@symbolic+/, action: { token: 'identifier.sym' } },
// FLOATDOT case
{ regex: /\.@digit*@fexponent@FLOATSP*/, action: { token: 'number.float' } },
{ regex: /\.@digit+/, action: { token: 'number.float' } },
// lexing_DOLLAR:
// '$' IDENTFST IDENTRST* => lexing_IDENT_dlr, _ => lexing_IDENT_sym
{
regex: /\$@IDENTFST@IDENTRST*/,
action: {
cases: {
'@keywords_dlr': { token: 'keyword.dlr' },
'@default': { token: 'namespace' },
}
}
},
// lexing_SHARP:
// '#' IDENTFST IDENTRST* => lexing_ident_srp, _ => lexing_IDENT_sym
{
regex: /\#@IDENTFST@IDENTRST*/,
action: {
cases: {
'@keywords_srp': { token: 'keyword.srp' },
'@default': { token: 'identifier' },
}
}
},
// lexing_PERCENT:
{ regex: /%\(/, action: { token: 'delimiter.parenthesis' } },
{ regex: /^%{(#|\^|\$)?/, action: { token: 'keyword', next: '@lexing_EXTCODE', nextEmbedded: 'text/javascript' } },
{ regex: /^%}/, action: { token: 'keyword' } },
// lexing_QUOTE
{ regex: /'\(/, action: { token: 'delimiter.parenthesis' } },
{ regex: /'\[/, action: { token: 'delimiter.bracket' } },
{ regex: /'\{/, action: { token: 'delimiter.brace' } },
[/(')(\\@ESCHAR|\\[xX]@xdigit+|\\@digit+)(')/, ['string', 'string.escape', 'string']],
[/'[^\\']'/, 'string'],
// lexing_DQUOTE
[/"/, 'string.quote', '@lexing_DQUOTE'],
// lexing_BQUOTE
{ regex: /`\(/, action: '@brackets' /* { token: 'delimiter.parenthesis' }*/ },
// TODO: otherwise, try lexing_IDENT_sym
{ regex: /\\/, action: { token: 'punctuation' } },
// lexing_IDENT_alp:
// NOTE: (?!regex) is syntax for "not-followed-by" regex
// to resolve ambiguity such as foreach$fwork being incorrectly lexed as [for] [each$fwork]!
{ regex: /@irregular_keywords(?!@IDENTRST)/, action: { token: 'keyword' } },
{
regex: /@IDENTFST@IDENTRST*[<!\[]?/,
action: {
cases: {
// TODO: dynload and staload should be specially parsed
// dynload whitespace+ "special_string"
// this special string is really:
// '/' '\\' '.' => punctuation
// ({\$)([a-zA-Z_][a-zA-Z_0-9]*)(}) => punctuation,keyword,punctuation
// [^"] => identifier/literal
'@keywords': { token: 'keyword' },
'@keywords_types': { token: 'type' },
'@default': { token: 'identifier' }
}
}
},
// lexing_IDENT_sym:
{ regex: /\/\/\/\//, action: { token: 'comment', next: '@lexing_COMMENT_rest' } },
{ regex: /\/\/.*$/, action: { token: 'comment' } },
{ regex: /\/\*/, action: { token: 'comment', next: '@lexing_COMMENT_block_c' } },
// AS-20160627: specifically for effect annotations
{ regex: /-<|=</, action: { token: 'keyword', next: '@lexing_EFFECT_commaseq0' } },
{
regex: /@symbolic+/,
action: {
cases: {
'@operators': 'keyword',
'@default': 'operator'
}
}
},
// lexing_ZERO:
// FIXME: this one is quite messy/unfinished yet
// TODO: lexing_INT_hex
// - testing_hexiexp => lexing_FLOAT_hexiexp
// - testing_fexponent_bin => lexing_FLOAT_hexiexp
// - testing_intspseq0 => T_INT_hex
// lexing_INT_hex:
{ regex: /0[xX]@xdigit+(@hexiexp|@fexponent_bin)@FLOATSP*/, action: { token: 'number.float' } },
{ regex: /0[xX]@xdigit+@INTSP*/, action: { token: 'number.hex' } },
{ regex: /0[0-7]+(?![0-9])@INTSP*/, action: { token: 'number.octal' } },
//{regex: /0/, action: { token: 'number' } }, // INTZERO
// lexing_INT_dec:
// - testing_deciexp => lexing_FLOAT_deciexp
// - testing_fexponent => lexing_FLOAT_deciexp
// - otherwise => intspseq0 ([0-9]*[lLuU]?)
{ regex: /@digit+(@fexponent|@deciexp)@FLOATSP*/, action: { token: 'number.float' } },
{ regex: /@digit@digitseq0@INTSP*/, action: { token: 'number.decimal' } },
// DIGIT, if followed by digitseq0, is lexing_INT_dec
{ regex: /@digit+@INTSP*/, action: { token: 'number' } },
],
lexing_COMMENT_block_ml: [
[/[^\(\*]+/, 'comment'],
[/\(\*/, 'comment', '@push'],
[/\(\*/, 'comment.invalid'],
[/\*\)/, 'comment', '@pop'],
[/\*/, 'comment']
],
lexing_COMMENT_block_c: [
[/[^\/*]+/, 'comment'],
// [/\/\*/, 'comment', '@push' ], // nested C-style block comments not allowed
// [/\/\*/, 'comment.invalid' ], // NOTE: this breaks block comments in the shape of /* //*/
[/\*\//, 'comment', '@pop'],
[/[\/*]/, 'comment']
],
lexing_COMMENT_rest: [
[/$/, 'comment', '@pop'],
[/.*/, 'comment']
],
// NOTE: added by AS, specifically for highlighting
lexing_EFFECT_commaseq0: [
{
regex: /@IDENTFST@IDENTRST+|@digit+/,
action: {
cases: {
'@keywords_effects': { token: 'type.effect' },
'@default': { token: 'identifier' }
}
}
},
{ regex: /,/, action: { token: 'punctuation' } },
{ regex: />/, action: { token: '@rematch', next: '@pop' } },
],
lexing_EXTCODE: [
{ regex: /^%}/, action: { token: '@rematch', next: '@pop', nextEmbedded: '@pop' } },
{ regex: /[^%]+/, action: '' },
],
lexing_DQUOTE: [
{ regex: /"/, action: { token: 'string.quote', next: '@pop' } },
// AS-20160628: additional hi-lighting for variables in staload/dynload strings
{ regex: /(\{\$)(@IDENTFST@IDENTRST*)(\})/, action: [{ token: 'string.escape' }, { token: 'identifier' }, { token: 'string.escape' }] },
{ regex: /\\$/, action: { token: 'string.escape' } },
{ regex: /\\(@ESCHAR|[xX]@xdigit+|@digit+)/, action: { token: 'string.escape' } },
{ regex: /[^\\"]+/, action: { token: 'string' } }
],
},
};
/***/ })
}]);

926
60.bc984e39.async.js Normal file
View File

@ -0,0 +1,926 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[60],{
/***/ "W1QP":
/*!************************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/powerquery/powerquery.js ***!
\************************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/powerquery/powerquery.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '//',
blockComment: ['/*', '*/'],
},
brackets: [['[', ']'], ['(', ')'], ['{', '}']],
autoClosingPairs: [
{ open: '"', close: '"', notIn: ['string', 'comment', 'identifier'] },
{ open: '[', close: ']', notIn: ['string', 'comment', 'identifier'] },
{ open: '(', close: ')', notIn: ['string', 'comment', 'identifier'] },
{ open: '{', close: '}', notIn: ['string', 'comment', 'identifier'] },
]
};
var language = {
defaultToken: '',
tokenPostfix: '.pq',
ignoreCase: false,
brackets: [
{ open: '[', close: ']', token: 'delimiter.square' },
{ open: '{', close: '}', token: 'delimiter.brackets' },
{ open: '(', close: ')', token: 'delimiter.parenthesis' }
],
operatorKeywords: [
"and",
"not",
"or"
],
keywords: [
"as",
"each",
"else",
"error",
"false",
"if",
"in",
"is",
"let",
"meta",
"otherwise",
"section",
"shared",
"then",
"true",
"try",
"type"
],
constructors: [
"#binary",
"#date",
"#datetime",
"#datetimezone",
"#duration",
"#table",
"#time"
],
constants: [
"#infinity",
"#nan",
"#sections",
"#shared"
],
typeKeywords: [
"action",
"any",
"anynonnull",
"none",
"null",
"logical",
"number",
"time",
"date",
"datetime",
"datetimezone",
"duration",
"text",
"binary",
"list",
"record",
"table",
"function"
],
builtinFunctions: [
"Access.Database",
"Action.Return",
"Action.Sequence",
"Action.Try",
"ActiveDirectory.Domains",
"AdoDotNet.DataSource",
"AdoDotNet.Query",
"AdobeAnalytics.Cubes",
"AnalysisServices.Database",
"AnalysisServices.Databases",
"AzureStorage.BlobContents",
"AzureStorage.Blobs",
"AzureStorage.Tables",
"Binary.Buffer",
"Binary.Combine",
"Binary.Compress",
"Binary.Decompress",
"Binary.End",
"Binary.From",
"Binary.FromList",
"Binary.FromText",
"Binary.InferContentType",
"Binary.Length",
"Binary.ToList",
"Binary.ToText",
"BinaryFormat.7BitEncodedSignedInteger",
"BinaryFormat.7BitEncodedUnsignedInteger",
"BinaryFormat.Binary",
"BinaryFormat.Byte",
"BinaryFormat.ByteOrder",
"BinaryFormat.Choice",
"BinaryFormat.Decimal",
"BinaryFormat.Double",
"BinaryFormat.Group",
"BinaryFormat.Length",
"BinaryFormat.List",
"BinaryFormat.Null",
"BinaryFormat.Record",
"BinaryFormat.SignedInteger16",
"BinaryFormat.SignedInteger32",
"BinaryFormat.SignedInteger64",
"BinaryFormat.Single",
"BinaryFormat.Text",
"BinaryFormat.Transform",
"BinaryFormat.UnsignedInteger16",
"BinaryFormat.UnsignedInteger32",
"BinaryFormat.UnsignedInteger64",
"Byte.From",
"Character.FromNumber",
"Character.ToNumber",
"Combiner.CombineTextByDelimiter",
"Combiner.CombineTextByEachDelimiter",
"Combiner.CombineTextByLengths",
"Combiner.CombineTextByPositions",
"Combiner.CombineTextByRanges",
"Comparer.Equals",
"Comparer.FromCulture",
"Comparer.Ordinal",
"Comparer.OrdinalIgnoreCase",
"Csv.Document",
"Cube.AddAndExpandDimensionColumn",
"Cube.AddMeasureColumn",
"Cube.ApplyParameter",
"Cube.AttributeMemberId",
"Cube.AttributeMemberProperty",
"Cube.CollapseAndRemoveColumns",
"Cube.Dimensions",
"Cube.DisplayFolders",
"Cube.Measures",
"Cube.Parameters",
"Cube.Properties",
"Cube.PropertyKey",
"Cube.ReplaceDimensions",
"Cube.Transform",
"Currency.From",
"DB2.Database",
"Date.AddDays",
"Date.AddMonths",
"Date.AddQuarters",
"Date.AddWeeks",
"Date.AddYears",
"Date.Day",
"Date.DayOfWeek",
"Date.DayOfWeekName",
"Date.DayOfYear",
"Date.DaysInMonth",
"Date.EndOfDay",
"Date.EndOfMonth",
"Date.EndOfQuarter",
"Date.EndOfWeek",
"Date.EndOfYear",
"Date.From",
"Date.FromText",
"Date.IsInCurrentDay",
"Date.IsInCurrentMonth",
"Date.IsInCurrentQuarter",
"Date.IsInCurrentWeek",
"Date.IsInCurrentYear",
"Date.IsInNextDay",
"Date.IsInNextMonth",
"Date.IsInNextNDays",
"Date.IsInNextNMonths",
"Date.IsInNextNQuarters",
"Date.IsInNextNWeeks",
"Date.IsInNextNYears",
"Date.IsInNextQuarter",
"Date.IsInNextWeek",
"Date.IsInNextYear",
"Date.IsInPreviousDay",
"Date.IsInPreviousMonth",
"Date.IsInPreviousNDays",
"Date.IsInPreviousNMonths",
"Date.IsInPreviousNQuarters",
"Date.IsInPreviousNWeeks",
"Date.IsInPreviousNYears",
"Date.IsInPreviousQuarter",
"Date.IsInPreviousWeek",
"Date.IsInPreviousYear",
"Date.IsInYearToDate",
"Date.IsLeapYear",
"Date.Month",
"Date.MonthName",
"Date.QuarterOfYear",
"Date.StartOfDay",
"Date.StartOfMonth",
"Date.StartOfQuarter",
"Date.StartOfWeek",
"Date.StartOfYear",
"Date.ToRecord",
"Date.ToText",
"Date.WeekOfMonth",
"Date.WeekOfYear",
"Date.Year",
"DateTime.AddZone",
"DateTime.Date",
"DateTime.FixedLocalNow",
"DateTime.From",
"DateTime.FromFileTime",
"DateTime.FromText",
"DateTime.IsInCurrentHour",
"DateTime.IsInCurrentMinute",
"DateTime.IsInCurrentSecond",
"DateTime.IsInNextHour",
"DateTime.IsInNextMinute",
"DateTime.IsInNextNHours",
"DateTime.IsInNextNMinutes",
"DateTime.IsInNextNSeconds",
"DateTime.IsInNextSecond",
"DateTime.IsInPreviousHour",
"DateTime.IsInPreviousMinute",
"DateTime.IsInPreviousNHours",
"DateTime.IsInPreviousNMinutes",
"DateTime.IsInPreviousNSeconds",
"DateTime.IsInPreviousSecond",
"DateTime.LocalNow",
"DateTime.Time",
"DateTime.ToRecord",
"DateTime.ToText",
"DateTimeZone.FixedLocalNow",
"DateTimeZone.FixedUtcNow",
"DateTimeZone.From",
"DateTimeZone.FromFileTime",
"DateTimeZone.FromText",
"DateTimeZone.LocalNow",
"DateTimeZone.RemoveZone",
"DateTimeZone.SwitchZone",
"DateTimeZone.ToLocal",
"DateTimeZone.ToRecord",
"DateTimeZone.ToText",
"DateTimeZone.ToUtc",
"DateTimeZone.UtcNow",
"DateTimeZone.ZoneHours",
"DateTimeZone.ZoneMinutes",
"Decimal.From",
"Diagnostics.ActivityId",
"Diagnostics.Trace",
"DirectQueryCapabilities.From",
"Double.From",
"Duration.Days",
"Duration.From",
"Duration.FromText",
"Duration.Hours",
"Duration.Minutes",
"Duration.Seconds",
"Duration.ToRecord",
"Duration.ToText",
"Duration.TotalDays",
"Duration.TotalHours",
"Duration.TotalMinutes",
"Duration.TotalSeconds",
"Embedded.Value",
"Error.Record",
"Excel.CurrentWorkbook",
"Excel.Workbook",
"Exchange.Contents",
"Expression.Constant",
"Expression.Evaluate",
"Expression.Identifier",
"Facebook.Graph",
"File.Contents",
"Folder.Contents",
"Folder.Files",
"Function.From",
"Function.Invoke",
"Function.InvokeAfter",
"Function.IsDataSource",
"GoogleAnalytics.Accounts",
"Guid.From",
"HdInsight.Containers",
"HdInsight.Contents",
"HdInsight.Files",
"Hdfs.Contents",
"Hdfs.Files",
"Informix.Database",
"Int16.From",
"Int32.From",
"Int64.From",
"Int8.From",
"ItemExpression.From",
"Json.Document",
"Json.FromValue",
"Lines.FromBinary",
"Lines.FromText",
"Lines.ToBinary",
"Lines.ToText",
"List.Accumulate",
"List.AllTrue",
"List.Alternate",
"List.AnyTrue",
"List.Average",
"List.Buffer",
"List.Combine",
"List.Contains",
"List.ContainsAll",
"List.ContainsAny",
"List.Count",
"List.Covariance",
"List.DateTimeZones",
"List.DateTimes",
"List.Dates",
"List.Difference",
"List.Distinct",
"List.Durations",
"List.FindText",
"List.First",
"List.FirstN",
"List.Generate",
"List.InsertRange",
"List.Intersect",
"List.IsDistinct",
"List.IsEmpty",
"List.Last",
"List.LastN",
"List.MatchesAll",
"List.MatchesAny",
"List.Max",
"List.MaxN",
"List.Median",
"List.Min",
"List.MinN",
"List.Mode",
"List.Modes",
"List.NonNullCount",
"List.Numbers",
"List.PositionOf",
"List.PositionOfAny",
"List.Positions",
"List.Product",
"List.Random",
"List.Range",
"List.RemoveFirstN",
"List.RemoveItems",
"List.RemoveLastN",
"List.RemoveMatchingItems",
"List.RemoveNulls",
"List.RemoveRange",
"List.Repeat",
"List.ReplaceMatchingItems",
"List.ReplaceRange",
"List.ReplaceValue",
"List.Reverse",
"List.Select",
"List.Single",
"List.SingleOrDefault",
"List.Skip",
"List.Sort",
"List.StandardDeviation",
"List.Sum",
"List.Times",
"List.Transform",
"List.TransformMany",
"List.Union",
"List.Zip",
"Logical.From",
"Logical.FromText",
"Logical.ToText",
"MQ.Queue",
"MySQL.Database",
"Number.Abs",
"Number.Acos",
"Number.Asin",
"Number.Atan",
"Number.Atan2",
"Number.BitwiseAnd",
"Number.BitwiseNot",
"Number.BitwiseOr",
"Number.BitwiseShiftLeft",
"Number.BitwiseShiftRight",
"Number.BitwiseXor",
"Number.Combinations",
"Number.Cos",
"Number.Cosh",
"Number.Exp",
"Number.Factorial",
"Number.From",
"Number.FromText",
"Number.IntegerDivide",
"Number.IsEven",
"Number.IsNaN",
"Number.IsOdd",
"Number.Ln",
"Number.Log",
"Number.Log10",
"Number.Mod",
"Number.Permutations",
"Number.Power",
"Number.Random",
"Number.RandomBetween",
"Number.Round",
"Number.RoundAwayFromZero",
"Number.RoundDown",
"Number.RoundTowardZero",
"Number.RoundUp",
"Number.Sign",
"Number.Sin",
"Number.Sinh",
"Number.Sqrt",
"Number.Tan",
"Number.Tanh",
"Number.ToText",
"OData.Feed",
"Odbc.DataSource",
"Odbc.Query",
"OleDb.DataSource",
"OleDb.Query",
"Oracle.Database",
"Percentage.From",
"PostgreSQL.Database",
"RData.FromBinary",
"Record.AddField",
"Record.Combine",
"Record.Field",
"Record.FieldCount",
"Record.FieldNames",
"Record.FieldOrDefault",
"Record.FieldValues",
"Record.FromList",
"Record.FromTable",
"Record.HasFields",
"Record.RemoveFields",
"Record.RenameFields",
"Record.ReorderFields",
"Record.SelectFields",
"Record.ToList",
"Record.ToTable",
"Record.TransformFields",
"Replacer.ReplaceText",
"Replacer.ReplaceValue",
"RowExpression.Column",
"RowExpression.From",
"Salesforce.Data",
"Salesforce.Reports",
"SapBusinessWarehouse.Cubes",
"SapHana.Database",
"SharePoint.Contents",
"SharePoint.Files",
"SharePoint.Tables",
"Single.From",
"Soda.Feed",
"Splitter.SplitByNothing",
"Splitter.SplitTextByAnyDelimiter",
"Splitter.SplitTextByDelimiter",
"Splitter.SplitTextByEachDelimiter",
"Splitter.SplitTextByLengths",
"Splitter.SplitTextByPositions",
"Splitter.SplitTextByRanges",
"Splitter.SplitTextByRepeatedLengths",
"Splitter.SplitTextByWhitespace",
"Sql.Database",
"Sql.Databases",
"SqlExpression.SchemaFrom",
"SqlExpression.ToExpression",
"Sybase.Database",
"Table.AddColumn",
"Table.AddIndexColumn",
"Table.AddJoinColumn",
"Table.AddKey",
"Table.AggregateTableColumn",
"Table.AlternateRows",
"Table.Buffer",
"Table.Column",
"Table.ColumnCount",
"Table.ColumnNames",
"Table.ColumnsOfType",
"Table.Combine",
"Table.CombineColumns",
"Table.Contains",
"Table.ContainsAll",
"Table.ContainsAny",
"Table.DemoteHeaders",
"Table.Distinct",
"Table.DuplicateColumn",
"Table.ExpandListColumn",
"Table.ExpandRecordColumn",
"Table.ExpandTableColumn",
"Table.FillDown",
"Table.FillUp",
"Table.FilterWithDataTable",
"Table.FindText",
"Table.First",
"Table.FirstN",
"Table.FirstValue",
"Table.FromColumns",
"Table.FromList",
"Table.FromPartitions",
"Table.FromRecords",
"Table.FromRows",
"Table.FromValue",
"Table.Group",
"Table.HasColumns",
"Table.InsertRows",
"Table.IsDistinct",
"Table.IsEmpty",
"Table.Join",
"Table.Keys",
"Table.Last",
"Table.LastN",
"Table.MatchesAllRows",
"Table.MatchesAnyRows",
"Table.Max",
"Table.MaxN",
"Table.Min",
"Table.MinN",
"Table.NestedJoin",
"Table.Partition",
"Table.PartitionValues",
"Table.Pivot",
"Table.PositionOf",
"Table.PositionOfAny",
"Table.PrefixColumns",
"Table.Profile",
"Table.PromoteHeaders",
"Table.Range",
"Table.RemoveColumns",
"Table.RemoveFirstN",
"Table.RemoveLastN",
"Table.RemoveMatchingRows",
"Table.RemoveRows",
"Table.RemoveRowsWithErrors",
"Table.RenameColumns",
"Table.ReorderColumns",
"Table.Repeat",
"Table.ReplaceErrorValues",
"Table.ReplaceKeys",
"Table.ReplaceMatchingRows",
"Table.ReplaceRelationshipIdentity",
"Table.ReplaceRows",
"Table.ReplaceValue",
"Table.ReverseRows",
"Table.RowCount",
"Table.Schema",
"Table.SelectColumns",
"Table.SelectRows",
"Table.SelectRowsWithErrors",
"Table.SingleRow",
"Table.Skip",
"Table.Sort",
"Table.SplitColumn",
"Table.ToColumns",
"Table.ToList",
"Table.ToRecords",
"Table.ToRows",
"Table.TransformColumnNames",
"Table.TransformColumnTypes",
"Table.TransformColumns",
"Table.TransformRows",
"Table.Transpose",
"Table.Unpivot",
"Table.UnpivotOtherColumns",
"Table.View",
"Table.ViewFunction",
"TableAction.DeleteRows",
"TableAction.InsertRows",
"TableAction.UpdateRows",
"Tables.GetRelationships",
"Teradata.Database",
"Text.AfterDelimiter",
"Text.At",
"Text.BeforeDelimiter",
"Text.BetweenDelimiters",
"Text.Clean",
"Text.Combine",
"Text.Contains",
"Text.End",
"Text.EndsWith",
"Text.Format",
"Text.From",
"Text.FromBinary",
"Text.Insert",
"Text.Length",
"Text.Lower",
"Text.Middle",
"Text.NewGuid",
"Text.PadEnd",
"Text.PadStart",
"Text.PositionOf",
"Text.PositionOfAny",
"Text.Proper",
"Text.Range",
"Text.Remove",
"Text.RemoveRange",
"Text.Repeat",
"Text.Replace",
"Text.ReplaceRange",
"Text.Select",
"Text.Split",
"Text.SplitAny",
"Text.Start",
"Text.StartsWith",
"Text.ToBinary",
"Text.ToList",
"Text.Trim",
"Text.TrimEnd",
"Text.TrimStart",
"Text.Upper",
"Time.EndOfHour",
"Time.From",
"Time.FromText",
"Time.Hour",
"Time.Minute",
"Time.Second",
"Time.StartOfHour",
"Time.ToRecord",
"Time.ToText",
"Type.AddTableKey",
"Type.ClosedRecord",
"Type.Facets",
"Type.ForFunction",
"Type.ForRecord",
"Type.FunctionParameters",
"Type.FunctionRequiredParameters",
"Type.FunctionReturn",
"Type.Is",
"Type.IsNullable",
"Type.IsOpenRecord",
"Type.ListItem",
"Type.NonNullable",
"Type.OpenRecord",
"Type.RecordFields",
"Type.ReplaceFacets",
"Type.ReplaceTableKeys",
"Type.TableColumn",
"Type.TableKeys",
"Type.TableRow",
"Type.TableSchema",
"Type.Union",
"Uri.BuildQueryString",
"Uri.Combine",
"Uri.EscapeDataString",
"Uri.Parts",
"Value.Add",
"Value.As",
"Value.Compare",
"Value.Divide",
"Value.Equals",
"Value.Firewall",
"Value.FromText",
"Value.Is",
"Value.Metadata",
"Value.Multiply",
"Value.NativeQuery",
"Value.NullableEquals",
"Value.RemoveMetadata",
"Value.ReplaceMetadata",
"Value.ReplaceType",
"Value.Subtract",
"Value.Type",
"ValueAction.NativeStatement",
"ValueAction.Replace",
"Variable.Value",
"Web.Contents",
"Web.Page",
"WebAction.Request",
"Xml.Document",
"Xml.Tables"
],
builtinConstants: [
"BinaryEncoding.Base64",
"BinaryEncoding.Hex",
"BinaryOccurrence.Optional",
"BinaryOccurrence.Repeating",
"BinaryOccurrence.Required",
"ByteOrder.BigEndian",
"ByteOrder.LittleEndian",
"Compression.Deflate",
"Compression.GZip",
"CsvStyle.QuoteAfterDelimiter",
"CsvStyle.QuoteAlways",
"Culture.Current",
"Day.Friday",
"Day.Monday",
"Day.Saturday",
"Day.Sunday",
"Day.Thursday",
"Day.Tuesday",
"Day.Wednesday",
"ExtraValues.Error",
"ExtraValues.Ignore",
"ExtraValues.List",
"GroupKind.Global",
"GroupKind.Local",
"JoinAlgorithm.Dynamic",
"JoinAlgorithm.LeftHash",
"JoinAlgorithm.LeftIndex",
"JoinAlgorithm.PairwiseHash",
"JoinAlgorithm.RightHash",
"JoinAlgorithm.RightIndex",
"JoinAlgorithm.SortMerge",
"JoinKind.FullOuter",
"JoinKind.Inner",
"JoinKind.LeftAnti",
"JoinKind.LeftOuter",
"JoinKind.RightAnti",
"JoinKind.RightOuter",
"JoinSide.Left",
"JoinSide.Right",
"MissingField.Error",
"MissingField.Ignore",
"MissingField.UseNull",
"Number.E",
"Number.Epsilon",
"Number.NaN",
"Number.NegativeInfinity",
"Number.PI",
"Number.PositiveInfinity",
"Occurrence.All",
"Occurrence.First",
"Occurrence.Last",
"Occurrence.Optional",
"Occurrence.Repeating",
"Occurrence.Required",
"Order.Ascending",
"Order.Descending",
"Precision.Decimal",
"Precision.Double",
"QuoteStyle.Csv",
"QuoteStyle.None",
"RelativePosition.FromEnd",
"RelativePosition.FromStart",
"RoundingMode.AwayFromZero",
"RoundingMode.Down",
"RoundingMode.ToEven",
"RoundingMode.TowardZero",
"RoundingMode.Up",
"SapHanaDistribution.All",
"SapHanaDistribution.Connection",
"SapHanaDistribution.Off",
"SapHanaDistribution.Statement",
"SapHanaRangeOperator.Equals",
"SapHanaRangeOperator.GreaterThan",
"SapHanaRangeOperator.GreaterThanOrEquals",
"SapHanaRangeOperator.LessThan",
"SapHanaRangeOperator.LessThanOrEquals",
"SapHanaRangeOperator.NotEquals",
"TextEncoding.Ascii",
"TextEncoding.BigEndianUnicode",
"TextEncoding.Unicode",
"TextEncoding.Utf16",
"TextEncoding.Utf8",
"TextEncoding.Windows",
"TraceLevel.Critical",
"TraceLevel.Error",
"TraceLevel.Information",
"TraceLevel.Verbose",
"TraceLevel.Warning",
"WebMethod.Delete",
"WebMethod.Get",
"WebMethod.Head",
"WebMethod.Patch",
"WebMethod.Post",
"WebMethod.Put"
],
builtinTypes: [
"Action.Type",
"Any.Type",
"Binary.Type",
"BinaryEncoding.Type",
"BinaryOccurrence.Type",
"Byte.Type",
"ByteOrder.Type",
"Character.Type",
"Compression.Type",
"CsvStyle.Type",
"Currency.Type",
"Date.Type",
"DateTime.Type",
"DateTimeZone.Type",
"Day.Type",
"Decimal.Type",
"Double.Type",
"Duration.Type",
"ExtraValues.Type",
"Function.Type",
"GroupKind.Type",
"Guid.Type",
"Int16.Type",
"Int32.Type",
"Int64.Type",
"Int8.Type",
"JoinAlgorithm.Type",
"JoinKind.Type",
"JoinSide.Type",
"List.Type",
"Logical.Type",
"MissingField.Type",
"None.Type",
"Null.Type",
"Number.Type",
"Occurrence.Type",
"Order.Type",
"Password.Type",
"Percentage.Type",
"Precision.Type",
"QuoteStyle.Type",
"Record.Type",
"RelativePosition.Type",
"RoundingMode.Type",
"SapHanaDistribution.Type",
"SapHanaRangeOperator.Type",
"Single.Type",
"Table.Type",
"Text.Type",
"TextEncoding.Type",
"Time.Type",
"TraceLevel.Type",
"Type.Type",
"Uri.Type",
"WebMethod.Type"
],
tokenizer: {
root: [
// quoted identifier
[/#"[\w \.]+"/, "identifier.quote"],
// numbers
[/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
[/0[xX][0-9a-fA-F]+/, "number.hex"],
[/\d+([eE][\-+]?\d+)?/, "number"],
// keywords
[/(#?[a-z]+)\b/,
{
cases: {
"@typeKeywords": "type",
"@keywords": "keyword",
"@constants": "constant",
"@constructors": "constructor",
"@operatorKeywords": "operators",
"@default": "identifier"
}
}
],
// built-in types
[/\b([A-Z][a-zA-Z0-9]+\.Type)\b/,
{
cases: {
"@builtinTypes": "type",
"@default": "identifier"
}
}
],
// other built-ins
[/\b([A-Z][a-zA-Z0-9]+\.[A-Z][a-zA-Z0-9]+)\b/,
{
cases: {
"@builtinFunctions": "keyword.function",
"@builtinConstants": "constant",
"@default": "identifier"
}
}
],
// other identifiers
[/\b([a-zA-Z_][\w\.]*)\b/, "identifier"],
{ include: "@whitespace" },
{ include: "@comments" },
{ include: "@strings" },
[/[{}()\[\]]/, "@brackets"],
[/([=\+<>\-\*&@\?\/!])|([<>]=)|(<>)|(=>)|(\.\.\.)|(\.\.)/, "operators"],
[/[,;]/, "delimiter"],
],
whitespace: [
[/\s+/, "white"]
],
comments: [
["\\/\\*", "comment", "@comment"],
["\\/\\/+.*", "comment"]
],
comment: [
["\\*\\/", "comment", "@pop"],
[".", "comment"]
],
strings: [
["\"", "string", "@string"]
],
string: [
["\"\"", "string.escape"],
["\"", "string", "@pop"],
[".", "string"]
]
}
};
/***/ })
}]);

191
61.4bce22df.async.js Normal file
View File

@ -0,0 +1,191 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[61],{
/***/ "ppMK":
/*!************************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/powershell/powershell.js ***!
\************************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/powershell/powershell.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
// the default separators except `$-`
wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
comments: {
lineComment: '#',
blockComment: ['<#', '#>'],
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"', notIn: ['string'] },
{ open: '\'', close: '\'', notIn: ['string', 'comment'] },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
folding: {
markers: {
start: new RegExp("^\\s*#region\\b"),
end: new RegExp("^\\s*#endregion\\b")
}
}
};
var language = {
defaultToken: '',
ignoreCase: true,
tokenPostfix: '.ps1',
brackets: [
{ token: 'delimiter.curly', open: '{', close: '}' },
{ token: 'delimiter.square', open: '[', close: ']' },
{ token: 'delimiter.parenthesis', open: '(', close: ')' }
],
keywords: [
'begin', 'break', 'catch', 'class', 'continue', 'data',
'define', 'do', 'dynamicparam', 'else', 'elseif', 'end',
'exit', 'filter', 'finally', 'for', 'foreach', 'from',
'function', 'if', 'in', 'param', 'process', 'return',
'switch', 'throw', 'trap', 'try', 'until', 'using',
'var', 'while', 'workflow', 'parallel', 'sequence', 'inlinescript', 'configuration'
],
helpKeywords: /SYNOPSIS|DESCRIPTION|PARAMETER|EXAMPLE|INPUTS|OUTPUTS|NOTES|LINK|COMPONENT|ROLE|FUNCTIONALITY|FORWARDHELPTARGETNAME|FORWARDHELPCATEGORY|REMOTEHELPRUNSPACE|EXTERNALHELP/,
// we include these common regular expressions
symbols: /[=><!~?&%|+\-*\/\^;\.,]+/,
escapes: /`(?:[abfnrtv\\"'$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
// The main tokenizer for our languages
tokenizer: {
root: [
// commands and keywords
[/[a-zA-Z_][\w-]*/, {
cases: {
'@keywords': { token: 'keyword.$0' },
'@default': ''
}
}],
// whitespace
[/[ \t\r\n]+/, ''],
// labels
[/^:\w*/, 'metatag'],
// variables
[/\$(\{((global|local|private|script|using):)?[\w]+\}|((global|local|private|script|using):)?[\w]+)/, 'variable'],
// Comments
[/<#/, 'comment', '@comment'],
[/#.*$/, 'comment'],
// delimiters
[/[{}()\[\]]/, '@brackets'],
[/@symbols/, 'delimiter'],
// numbers
[/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
[/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, 'number.hex'],
[/\d+?/, 'number'],
// delimiter: after number because of .\d floats
[/[;,.]/, 'delimiter'],
// strings:
[/\@"/, 'string', '@herestring."'],
[/\@'/, 'string', '@herestring.\''],
[/"/, {
cases: {
'@eos': 'string',
'@default': { token: 'string', next: '@string."' }
}
}],
[/'/, {
cases: {
'@eos': 'string',
'@default': { token: 'string', next: '@string.\'' }
}
}],
],
string: [
[/[^"'\$`]+/, {
cases: {
'@eos': { token: 'string', next: '@popall' },
'@default': 'string'
}
}],
[/@escapes/, {
cases: {
'@eos': { token: 'string.escape', next: '@popall' },
'@default': 'string.escape'
}
}],
[/`./, {
cases: {
'@eos': { token: 'string.escape.invalid', next: '@popall' },
'@default': 'string.escape.invalid'
}
}],
[/\$[\w]+$/, {
cases: {
'$S2=="': { token: 'variable', next: '@popall' },
'@default': { token: 'string', next: '@popall' }
}
}],
[/\$[\w]+/, {
cases: {
'$S2=="': 'variable',
'@default': 'string'
}
}],
[/["']/, {
cases: {
'$#==$S2': { token: 'string', next: '@pop' },
'@default': {
cases: {
'@eos': { token: 'string', next: '@popall' },
'@default': 'string'
}
}
}
}],
],
herestring: [
[/^\s*(["'])@/, {
cases: {
'$1==$S2': { token: 'string', next: '@pop' },
'@default': 'string'
}
}],
[/[^\$`]+/, 'string'],
[/@escapes/, 'string.escape'],
[/`./, 'string.escape.invalid'],
[/\$[\w]+/, {
cases: {
'$S2=="': 'variable',
'@default': 'string'
}
}],
],
comment: [
[/[^#\.]+/, 'comment'],
[/#>/, 'comment', '@pop'],
[/(\.)(@helpKeywords)(?!\w)/, { token: 'comment.keyword.$2' }],
[/[\.#]/, 'comment']
],
},
};
/***/ })
}]);

247
62.85f60d91.async.js Normal file
View File

@ -0,0 +1,247 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[62],{
/***/ "I+Au":
/*!**********************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/pug/pug.js ***!
\**********************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/pug/pug.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '//'
},
brackets: [['{', '}'], ['[', ']'], ['(', ')']],
autoClosingPairs: [
{ open: '"', close: '"', notIn: ['string', 'comment'] },
{ open: '\'', close: '\'', notIn: ['string', 'comment'] },
{ open: '{', close: '}', notIn: ['string', 'comment'] },
{ open: '[', close: ']', notIn: ['string', 'comment'] },
{ open: '(', close: ')', notIn: ['string', 'comment'] },
],
folding: {
offSide: true
}
};
var language = {
defaultToken: '',
tokenPostfix: '.pug',
ignoreCase: true,
brackets: [
{ token: 'delimiter.curly', open: '{', close: '}' },
{ token: 'delimiter.array', open: '[', close: ']' },
{ token: 'delimiter.parenthesis', open: '(', close: ')' }
],
keywords: ['append', 'block', 'case', 'default', 'doctype', 'each', 'else', 'extends',
'for', 'if', 'in', 'include', 'mixin', 'typeof', 'unless', 'var', 'when'],
tags: [
'a', 'abbr', 'acronym', 'address', 'area', 'article', 'aside', 'audio',
'b', 'base', 'basefont', 'bdi', 'bdo', 'blockquote', 'body', 'br', 'button',
'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'command',
'datalist', 'dd', 'del', 'details', 'dfn', 'div', 'dl', 'dt',
'em', 'embed',
'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'frame', 'frameset',
'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html',
'i', 'iframe', 'img', 'input', 'ins',
'keygen', 'kbd',
'label', 'li', 'link',
'map', 'mark', 'menu', 'meta', 'meter',
'nav', 'noframes', 'noscript',
'object', 'ol', 'optgroup', 'option', 'output',
'p', 'param', 'pre', 'progress',
'q',
'rp', 'rt', 'ruby',
's', 'samp', 'script', 'section', 'select', 'small', 'source', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup',
'table', 'tbody', 'td', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'tracks', 'tt',
'u', 'ul',
'video',
'wbr'
],
// we include these common regular expressions
symbols: /[\+\-\*\%\&\|\!\=\/\.\,\:]+/,
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
tokenizer: {
root: [
// Tag or a keyword at start
[/^(\s*)([a-zA-Z_-][\w-]*)/,
{
cases: {
'$2@tags': {
cases: {
'@eos': ['', 'tag'],
'@default': ['', { token: 'tag', next: '@tag.$1' },]
}
},
'$2@keywords': ['', { token: 'keyword.$2' },],
'@default': ['', '',]
}
}
],
// id
[/^(\s*)(#[a-zA-Z_-][\w-]*)/, {
cases: {
'@eos': ['', 'tag.id'],
'@default': ['', { token: 'tag.id', next: '@tag.$1' }]
}
}],
// class
[/^(\s*)(\.[a-zA-Z_-][\w-]*)/, {
cases: {
'@eos': ['', 'tag.class'],
'@default': ['', { token: 'tag.class', next: '@tag.$1' }]
}
}],
// plain text with pipe
[/^(\s*)(\|.*)$/, ''],
{ include: '@whitespace' },
// keywords
[/[a-zA-Z_$][\w$]*/, {
cases: {
'@keywords': { token: 'keyword.$0' },
'@default': ''
}
}],
// delimiters and operators
[/[{}()\[\]]/, '@brackets'],
[/@symbols/, 'delimiter'],
// numbers
[/\d+\.\d+([eE][\-+]?\d+)?/, 'number.float'],
[/\d+/, 'number'],
// strings:
[/"/, 'string', '@string."'],
[/'/, 'string', '@string.\''],
],
tag: [
[/(\.)(\s*$)/, [{ token: 'delimiter', next: '@blockText.$S2.' }, '']],
[/\s+/, { token: '', next: '@simpleText' }],
// id
[/#[a-zA-Z_-][\w-]*/, {
cases: {
'@eos': { token: 'tag.id', next: '@pop' },
'@default': 'tag.id'
}
}],
// class
[/\.[a-zA-Z_-][\w-]*/, {
cases: {
'@eos': { token: 'tag.class', next: '@pop' },
'@default': 'tag.class'
}
}],
// attributes
[/\(/, { token: 'delimiter.parenthesis', next: '@attributeList' }],
],
simpleText: [
[/[^#]+$/, { token: '', next: '@popall' }],
[/[^#]+/, { token: '' }],
// interpolation
[/(#{)([^}]*)(})/, {
cases: {
'@eos': ['interpolation.delimiter', 'interpolation', { token: 'interpolation.delimiter', next: '@popall' }],
'@default': ['interpolation.delimiter', 'interpolation', 'interpolation.delimiter']
}
}],
[/#$/, { token: '', next: '@popall' }],
[/#/, '']
],
attributeList: [
[/\s+/, ''],
[/(\w+)(\s*=\s*)("|')/, ['attribute.name', 'delimiter', { token: 'attribute.value', next: '@value.$3' }]],
[/\w+/, 'attribute.name'],
[/,/, {
cases: {
'@eos': { token: 'attribute.delimiter', next: '@popall' },
'@default': 'attribute.delimiter'
}
}],
[/\)$/, { token: 'delimiter.parenthesis', next: '@popall' }],
[/\)/, { token: 'delimiter.parenthesis', next: '@pop' }],
],
whitespace: [
[/^(\s*)(\/\/.*)$/, { token: 'comment', next: '@blockText.$1.comment' }],
[/[ \t\r\n]+/, ''],
[/<!--/, { token: 'comment', next: '@comment' }],
],
blockText: [
[/^\s+.*$/, {
cases: {
'($S2\\s+.*$)': { token: '$S3' },
'@default': { token: '@rematch', next: '@popall' }
}
}],
[/./, { token: '@rematch', next: '@popall' }]
],
comment: [
[/[^<\-]+/, 'comment.content'],
[/-->/, { token: 'comment', next: '@pop' }],
[/<!--/, 'comment.content.invalid'],
[/[<\-]/, 'comment.content']
],
string: [
[/[^\\"'#]+/, {
cases: {
'@eos': { token: 'string', next: '@popall' },
'@default': 'string'
}
}],
[/@escapes/, {
cases: {
'@eos': { token: 'string.escape', next: '@popall' },
'@default': 'string.escape'
}
}],
[/\\./, {
cases: {
'@eos': { token: 'string.escape.invalid', next: '@popall' },
'@default': 'string.escape.invalid'
}
}],
// interpolation
[/(#{)([^}]*)(})/, ['interpolation.delimiter', 'interpolation', 'interpolation.delimiter']],
[/#/, 'string'],
[/["']/, {
cases: {
'$#==$S2': { token: 'string', next: '@pop' },
'@default': { token: 'string' }
}
}],
],
// Almost identical to above, except for escapes and the output token
value: [
[/[^\\"']+/, {
cases: {
'@eos': { token: 'attribute.value', next: '@popall' },
'@default': 'attribute.value'
}
}],
[/\\./, {
cases: {
'@eos': { token: 'attribute.value', next: '@popall' },
'@default': 'attribute.value'
}
}],
[/["']/, {
cases: {
'$#==$S2': { token: 'attribute.value', next: '@pop' },
'@default': { token: 'attribute.value' }
}
}],
],
},
};
/***/ })
}]);

263
63.fdc8f2e1.async.js Normal file
View File

@ -0,0 +1,263 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[63],{
/***/ "8ahN":
/*!****************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/python/python.js ***!
\****************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/python/python.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
// Allow for running under nodejs/requirejs in tests
var _monaco = (typeof monaco === 'undefined' ? self.monaco : monaco);
var conf = {
comments: {
lineComment: '#',
blockComment: ['\'\'\'', '\'\'\''],
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"', notIn: ['string'] },
{ open: '\'', close: '\'', notIn: ['string', 'comment'] },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
onEnterRules: [
{
beforeText: new RegExp("^\\s*(?:def|class|for|if|elif|else|while|try|with|finally|except|async).*?:\\s*$"),
action: { indentAction: _monaco.languages.IndentAction.Indent }
}
],
folding: {
offSide: true,
markers: {
start: new RegExp("^\\s*#region\\b"),
end: new RegExp("^\\s*#endregion\\b")
}
}
};
var language = {
defaultToken: '',
tokenPostfix: '.python',
keywords: [
'and',
'as',
'assert',
'break',
'class',
'continue',
'def',
'del',
'elif',
'else',
'except',
'exec',
'finally',
'for',
'from',
'global',
'if',
'import',
'in',
'is',
'lambda',
'None',
'not',
'or',
'pass',
'print',
'raise',
'return',
'self',
'try',
'while',
'with',
'yield',
'int',
'float',
'long',
'complex',
'hex',
'abs',
'all',
'any',
'apply',
'basestring',
'bin',
'bool',
'buffer',
'bytearray',
'callable',
'chr',
'classmethod',
'cmp',
'coerce',
'compile',
'complex',
'delattr',
'dict',
'dir',
'divmod',
'enumerate',
'eval',
'execfile',
'file',
'filter',
'format',
'frozenset',
'getattr',
'globals',
'hasattr',
'hash',
'help',
'id',
'input',
'intern',
'isinstance',
'issubclass',
'iter',
'len',
'locals',
'list',
'map',
'max',
'memoryview',
'min',
'next',
'object',
'oct',
'open',
'ord',
'pow',
'print',
'property',
'reversed',
'range',
'raw_input',
'reduce',
'reload',
'repr',
'reversed',
'round',
'set',
'setattr',
'slice',
'sorted',
'staticmethod',
'str',
'sum',
'super',
'tuple',
'type',
'unichr',
'unicode',
'vars',
'xrange',
'zip',
'True',
'False',
'__dict__',
'__methods__',
'__members__',
'__class__',
'__bases__',
'__name__',
'__mro__',
'__subclasses__',
'__init__',
'__import__'
],
brackets: [
{ open: '{', close: '}', token: 'delimiter.curly' },
{ open: '[', close: ']', token: 'delimiter.bracket' },
{ open: '(', close: ')', token: 'delimiter.parenthesis' }
],
tokenizer: {
root: [
{ include: '@whitespace' },
{ include: '@numbers' },
{ include: '@strings' },
[/[,:;]/, 'delimiter'],
[/[{}\[\]()]/, '@brackets'],
[/@[a-zA-Z]\w*/, 'tag'],
[/[a-zA-Z]\w*/, {
cases: {
'@keywords': 'keyword',
'@default': 'identifier'
}
}]
],
// Deal with white space, including single and multi-line comments
whitespace: [
[/\s+/, 'white'],
[/(^#.*$)/, 'comment'],
[/'''/, 'string', '@endDocString'],
[/"""/, 'string', '@endDblDocString']
],
endDocString: [
[/[^']+/, 'string'],
[/\\'/, 'string'],
[/'''/, 'string', '@popall'],
[/'/, 'string']
],
endDblDocString: [
[/[^"]+/, 'string'],
[/\\"/, 'string'],
[/"""/, 'string', '@popall'],
[/"/, 'string']
],
// Recognize hex, negatives, decimals, imaginaries, longs, and scientific notation
numbers: [
[/-?0x([abcdef]|[ABCDEF]|\d)+[lL]?/, 'number.hex'],
[/-?(\d*\.)?\d+([eE][+\-]?\d+)?[jJ]?[lL]?/, 'number']
],
// Recognize strings, including those broken across lines with \ (but not without)
strings: [
[/'$/, 'string.escape', '@popall'],
[/'/, 'string.escape', '@stringBody'],
[/"$/, 'string.escape', '@popall'],
[/"/, 'string.escape', '@dblStringBody']
],
stringBody: [
[/[^\\']+$/, 'string', '@popall'],
[/[^\\']+/, 'string'],
[/\\./, 'string'],
[/'/, 'string.escape', '@popall'],
[/\\$/, 'string']
],
dblStringBody: [
[/[^\\"]+$/, 'string', '@popall'],
[/[^\\"]+/, 'string'],
[/\\./, 'string'],
[/"/, 'string.escape', '@popall'],
[/\\$/, 'string']
]
}
};
/***/ })
}]);

238
64.6256f2ac.async.js Normal file
View File

@ -0,0 +1,238 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[64],{
/***/ "Qx4d":
/*!******************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/r/r.js ***!
\******************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/r/r.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '#'
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
]
};
var language = {
defaultToken: '',
tokenPostfix: '.r',
roxygen: [
'@param',
'@return',
'@name',
'@rdname',
'@examples',
'@include',
'@docType',
'@S3method',
'@TODO',
'@aliases',
'@alias',
'@assignee',
'@author',
'@callGraphDepth',
'@callGraph',
'@callGraphPrimitives',
'@concept',
'@exportClass',
'@exportMethod',
'@exportPattern',
'@export',
'@formals',
'@format',
'@importClassesFrom',
'@importFrom',
'@importMethodsFrom',
'@import',
'@keywords',
'@method',
'@nord',
'@note',
'@references',
'@seealso',
'@setClass',
'@slot',
'@source',
'@title',
'@usage'
],
constants: [
'NULL',
'FALSE',
'TRUE',
'NA',
'Inf',
'NaN ',
'NA_integer_',
'NA_real_',
'NA_complex_',
'NA_character_ ',
'T',
'F',
'LETTERS',
'letters',
'month.abb',
'month.name',
'pi',
'R.version.string'
],
keywords: [
'break',
'next',
'return',
'if',
'else',
'for',
'in',
'repeat',
'while',
'array',
'category',
'character',
'complex',
'double',
'function',
'integer',
'list',
'logical',
'matrix',
'numeric',
'vector',
'data.frame',
'factor',
'library',
'require',
'attach',
'detach',
'source'
],
special: [
'\\n',
'\\r',
'\\t',
'\\b',
'\\a',
'\\f',
'\\v',
'\\\'',
'\\"',
'\\\\'
],
brackets: [
{ open: '{', close: '}', token: 'delimiter.curly' },
{ open: '[', close: ']', token: 'delimiter.bracket' },
{ open: '(', close: ')', token: 'delimiter.parenthesis' }
],
tokenizer: {
root: [
{ include: '@numbers' },
{ include: '@strings' },
[/[{}\[\]()]/, '@brackets'],
{ include: '@operators' },
[/#'/, 'comment.doc', '@roxygen'],
[/(^#.*$)/, 'comment'],
[/\s+/, 'white'],
[/[,:;]/, 'delimiter'],
[/@[a-zA-Z]\w*/, 'tag'],
[/[a-zA-Z]\w*/, {
cases: {
'@keywords': 'keyword',
'@constants': 'constant',
'@default': 'identifier'
}
}]
],
// Recognize Roxygen comments
roxygen: [
[/@\w+/, {
cases: {
'@roxygen': 'tag',
'@eos': { token: 'comment.doc', next: '@pop' },
'@default': 'comment.doc'
}
}],
[/\s+/, {
cases: {
'@eos': { token: 'comment.doc', next: '@pop' },
'@default': 'comment.doc'
}
}],
[/.*/, { token: 'comment.doc', next: '@pop' }]
],
// Recognize positives, negatives, decimals, imaginaries, and scientific notation
numbers: [
[/0[xX][0-9a-fA-F]+/, 'number.hex'],
[/-?(\d*\.)?\d+([eE][+\-]?\d+)?/, 'number']
],
// Recognize operators
operators: [
[/<{1,2}-/, 'operator'],
[/->{1,2}/, 'operator'],
[/%[^%\s]+%/, 'operator'],
[/\*\*/, 'operator'],
[/%%/, 'operator'],
[/&&/, 'operator'],
[/\|\|/, 'operator'],
[/<</, 'operator'],
[/>>/, 'operator'],
[/[-+=&|!<>^~*/:$]/, 'operator']
],
// Recognize strings, including those broken across lines
strings: [
[/'/, 'string.escape', '@stringBody'],
[/"/, 'string.escape', '@dblStringBody']
],
stringBody: [
[/\\./, {
cases: {
'@special': 'string',
'@default': 'error-token'
}
}],
[/'/, 'string.escape', '@popall'],
[/./, 'string'],
],
dblStringBody: [
[/\\./, {
cases: {
'@special': 'string',
'@default': 'error-token'
}
}],
[/"/, 'string.escape', '@popall'],
[/./, 'string'],
]
}
};
/***/ })
}]);

292
65.6f8b888b.async.js Normal file
View File

@ -0,0 +1,292 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[65],{
/***/ "Fzfo":
/*!**************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/razor/razor.js ***!
\**************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/razor/razor.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
// Allow for running under nodejs/requirejs in tests
var _monaco = (typeof monaco === 'undefined' ? self.monaco : monaco);
var EMPTY_ELEMENTS = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr'];
var conf = {
wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\$\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\s]+)/g,
comments: {
blockComment: ['<!--', '-->']
},
brackets: [
['<!--', '-->'],
['<', '>'],
['{', '}'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' }
],
surroundingPairs: [
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
{ open: '<', close: '>' }
],
onEnterRules: [
{
beforeText: new RegExp("<(?!(?:" + EMPTY_ELEMENTS.join('|') + "))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$", 'i'),
afterText: /^<\/(\w[\w\d]*)\s*>$/i,
action: { indentAction: _monaco.languages.IndentAction.IndentOutdent }
},
{
beforeText: new RegExp("<(?!(?:" + EMPTY_ELEMENTS.join('|') + "))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$", 'i'),
action: { indentAction: _monaco.languages.IndentAction.Indent }
}
],
};
var language = {
defaultToken: '',
tokenPostfix: '',
// ignoreCase: true,
// The main tokenizer for our languages
tokenizer: {
root: [
[/@@/],
[/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.root' }],
[/<!DOCTYPE/, 'metatag.html', '@doctype'],
[/<!--/, 'comment.html', '@comment'],
[/(<)(\w+)(\/>)/, ['delimiter.html', 'tag.html', 'delimiter.html']],
[/(<)(script)/, ['delimiter.html', { token: 'tag.html', next: '@script' }]],
[/(<)(style)/, ['delimiter.html', { token: 'tag.html', next: '@style' }]],
[/(<)([:\w]+)/, ['delimiter.html', { token: 'tag.html', next: '@otherTag' }]],
[/(<\/)(\w+)/, ['delimiter.html', { token: 'tag.html', next: '@otherTag' }]],
[/</, 'delimiter.html'],
[/[ \t\r\n]+/],
[/[^<@]+/],
],
doctype: [
[/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.comment' }],
[/[^>]+/, 'metatag.content.html'],
[/>/, 'metatag.html', '@pop'],
],
comment: [
[/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.comment' }],
[/-->/, 'comment.html', '@pop'],
[/[^-]+/, 'comment.content.html'],
[/./, 'comment.content.html']
],
otherTag: [
[/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.otherTag' }],
[/\/?>/, 'delimiter.html', '@pop'],
[/"([^"]*)"/, 'attribute.value'],
[/'([^']*)'/, 'attribute.value'],
[/[\w\-]+/, 'attribute.name'],
[/=/, 'delimiter'],
[/[ \t\r\n]+/],
],
// -- BEGIN <script> tags handling
// After <script
script: [
[/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.script' }],
[/type/, 'attribute.name', '@scriptAfterType'],
[/"([^"]*)"/, 'attribute.value'],
[/'([^']*)'/, 'attribute.value'],
[/[\w\-]+/, 'attribute.name'],
[/=/, 'delimiter'],
[/>/, { token: 'delimiter.html', next: '@scriptEmbedded.text/javascript', nextEmbedded: 'text/javascript' }],
[/[ \t\r\n]+/],
[/(<\/)(script\s*)(>)/, ['delimiter.html', 'tag.html', { token: 'delimiter.html', next: '@pop' }]]
],
// After <script ... type
scriptAfterType: [
[/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.scriptAfterType' }],
[/=/, 'delimiter', '@scriptAfterTypeEquals'],
[/>/, { token: 'delimiter.html', next: '@scriptEmbedded.text/javascript', nextEmbedded: 'text/javascript' }],
[/[ \t\r\n]+/],
[/<\/script\s*>/, { token: '@rematch', next: '@pop' }]
],
// After <script ... type =
scriptAfterTypeEquals: [
[/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.scriptAfterTypeEquals' }],
[/"([^"]*)"/, { token: 'attribute.value', switchTo: '@scriptWithCustomType.$1' }],
[/'([^']*)'/, { token: 'attribute.value', switchTo: '@scriptWithCustomType.$1' }],
[/>/, { token: 'delimiter.html', next: '@scriptEmbedded.text/javascript', nextEmbedded: 'text/javascript' }],
[/[ \t\r\n]+/],
[/<\/script\s*>/, { token: '@rematch', next: '@pop' }]
],
// After <script ... type = $S2
scriptWithCustomType: [
[/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.scriptWithCustomType.$S2' }],
[/>/, { token: 'delimiter.html', next: '@scriptEmbedded.$S2', nextEmbedded: '$S2' }],
[/"([^"]*)"/, 'attribute.value'],
[/'([^']*)'/, 'attribute.value'],
[/[\w\-]+/, 'attribute.name'],
[/=/, 'delimiter'],
[/[ \t\r\n]+/],
[/<\/script\s*>/, { token: '@rematch', next: '@pop' }]
],
scriptEmbedded: [
[/@[^@]/, { token: '@rematch', switchTo: '@razorInEmbeddedState.scriptEmbedded.$S2', nextEmbedded: '@pop' }],
[/<\/script/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }]
],
// -- END <script> tags handling
// -- BEGIN <style> tags handling
// After <style
style: [
[/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.style' }],
[/type/, 'attribute.name', '@styleAfterType'],
[/"([^"]*)"/, 'attribute.value'],
[/'([^']*)'/, 'attribute.value'],
[/[\w\-]+/, 'attribute.name'],
[/=/, 'delimiter'],
[/>/, { token: 'delimiter.html', next: '@styleEmbedded.text/css', nextEmbedded: 'text/css' }],
[/[ \t\r\n]+/],
[/(<\/)(style\s*)(>)/, ['delimiter.html', 'tag.html', { token: 'delimiter.html', next: '@pop' }]]
],
// After <style ... type
styleAfterType: [
[/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.styleAfterType' }],
[/=/, 'delimiter', '@styleAfterTypeEquals'],
[/>/, { token: 'delimiter.html', next: '@styleEmbedded.text/css', nextEmbedded: 'text/css' }],
[/[ \t\r\n]+/],
[/<\/style\s*>/, { token: '@rematch', next: '@pop' }]
],
// After <style ... type =
styleAfterTypeEquals: [
[/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.styleAfterTypeEquals' }],
[/"([^"]*)"/, { token: 'attribute.value', switchTo: '@styleWithCustomType.$1' }],
[/'([^']*)'/, { token: 'attribute.value', switchTo: '@styleWithCustomType.$1' }],
[/>/, { token: 'delimiter.html', next: '@styleEmbedded.text/css', nextEmbedded: 'text/css' }],
[/[ \t\r\n]+/],
[/<\/style\s*>/, { token: '@rematch', next: '@pop' }]
],
// After <style ... type = $S2
styleWithCustomType: [
[/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.styleWithCustomType.$S2' }],
[/>/, { token: 'delimiter.html', next: '@styleEmbedded.$S2', nextEmbedded: '$S2' }],
[/"([^"]*)"/, 'attribute.value'],
[/'([^']*)'/, 'attribute.value'],
[/[\w\-]+/, 'attribute.name'],
[/=/, 'delimiter'],
[/[ \t\r\n]+/],
[/<\/style\s*>/, { token: '@rematch', next: '@pop' }]
],
styleEmbedded: [
[/@[^@]/, { token: '@rematch', switchTo: '@razorInEmbeddedState.styleEmbedded.$S2', nextEmbedded: '@pop' }],
[/<\/style/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }]
],
// -- END <style> tags handling
razorInSimpleState: [
[/@\*/, 'comment.cs', '@razorBlockCommentTopLevel'],
[/@[{(]/, 'metatag.cs', '@razorRootTopLevel'],
[/(@)(\s*[\w]+)/, ['metatag.cs', { token: 'identifier.cs', switchTo: '@$S2.$S3' }]],
[/[})]/, { token: 'metatag.cs', switchTo: '@$S2.$S3' }],
[/\*@/, { token: 'comment.cs', switchTo: '@$S2.$S3' }],
],
razorInEmbeddedState: [
[/@\*/, 'comment.cs', '@razorBlockCommentTopLevel'],
[/@[{(]/, 'metatag.cs', '@razorRootTopLevel'],
[/(@)(\s*[\w]+)/, ['metatag.cs', { token: 'identifier.cs', switchTo: '@$S2.$S3', nextEmbedded: '$S3' }]],
[/[})]/, { token: 'metatag.cs', switchTo: '@$S2.$S3', nextEmbedded: '$S3' }],
[/\*@/, { token: 'comment.cs', switchTo: '@$S2.$S3', nextEmbedded: '$S3' }],
],
razorBlockCommentTopLevel: [
[/\*@/, '@rematch', '@pop'],
[/[^*]+/, 'comment.cs'],
[/./, 'comment.cs']
],
razorBlockComment: [
[/\*@/, 'comment.cs', '@pop'],
[/[^*]+/, 'comment.cs'],
[/./, 'comment.cs']
],
razorRootTopLevel: [
[/\{/, 'delimiter.bracket.cs', '@razorRoot'],
[/\(/, 'delimiter.parenthesis.cs', '@razorRoot'],
[/[})]/, '@rematch', '@pop'],
{ include: 'razorCommon' }
],
razorRoot: [
[/\{/, 'delimiter.bracket.cs', '@razorRoot'],
[/\(/, 'delimiter.parenthesis.cs', '@razorRoot'],
[/\}/, 'delimiter.bracket.cs', '@pop'],
[/\)/, 'delimiter.parenthesis.cs', '@pop'],
{ include: 'razorCommon' }
],
razorCommon: [
[/[a-zA-Z_]\w*/, {
cases: {
'@razorKeywords': { token: 'keyword.cs' },
'@default': 'identifier.cs'
}
}],
// brackets
[/[\[\]]/, 'delimiter.array.cs'],
// whitespace
[/[ \t\r\n]+/],
// comments
[/\/\/.*$/, 'comment.cs'],
[/@\*/, 'comment.cs', '@razorBlockComment'],
// strings
[/"([^"]*)"/, 'string.cs'],
[/'([^']*)'/, 'string.cs'],
// simple html
[/(<)(\w+)(\/>)/, ['delimiter.html', 'tag.html', 'delimiter.html']],
[/(<)(\w+)(>)/, ['delimiter.html', 'tag.html', 'delimiter.html']],
[/(<\/)(\w+)(>)/, ['delimiter.html', 'tag.html', 'delimiter.html']],
// delimiters
[/[\+\-\*\%\&\|\^\~\!\=\<\>\/\?\;\:\.\,]/, 'delimiter.cs'],
// numbers
[/\d*\d+[eE]([\-+]?\d+)?/, 'number.float.cs'],
[/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float.cs'],
[/0[xX][0-9a-fA-F']*[0-9a-fA-F]/, 'number.hex.cs'],
[/0[0-7']*[0-7]/, 'number.octal.cs'],
[/0[bB][0-1']*[0-1]/, 'number.binary.cs'],
[/\d[\d']*/, 'number.cs'],
[/\d/, 'number.cs'],
]
},
razorKeywords: [
'abstract', 'as', 'async', 'await', 'base', 'bool',
'break', 'by', 'byte', 'case',
'catch', 'char', 'checked', 'class',
'const', 'continue', 'decimal', 'default',
'delegate', 'do', 'double', 'descending',
'explicit', 'event', 'extern', 'else',
'enum', 'false', 'finally', 'fixed',
'float', 'for', 'foreach', 'from',
'goto', 'group', 'if', 'implicit',
'in', 'int', 'interface', 'internal',
'into', 'is', 'lock', 'long', 'nameof',
'new', 'null', 'namespace', 'object',
'operator', 'out', 'override', 'orderby',
'params', 'private', 'protected', 'public',
'readonly', 'ref', 'return', 'switch',
'struct', 'sbyte', 'sealed', 'short',
'sizeof', 'stackalloc', 'static', 'string',
'select', 'this', 'throw', 'true',
'try', 'typeof', 'uint', 'ulong',
'unchecked', 'unsafe', 'ushort', 'using',
'var', 'virtual', 'volatile', 'void', 'when',
'while', 'where', 'yield',
'model', 'inject' // Razor specific
],
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
};
/***/ })
}]);

141
66.4dfce51c.async.js Normal file
View File

@ -0,0 +1,141 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[66],{
/***/ "j6Xs":
/*!**************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/redis/redis.js ***!
\**************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/redis/redis.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
]
};
var language = {
defaultToken: '',
tokenPostfix: '.redis',
ignoreCase: true,
brackets: [
{ open: '[', close: ']', token: 'delimiter.square' },
{ open: '(', close: ')', token: 'delimiter.parenthesis' }
],
keywords: [
"APPEND", "AUTH", "BGREWRITEAOF", "BGSAVE", "BITCOUNT", "BITFIELD", "BITOP", "BITPOS", "BLPOP", "BRPOP", "BRPOPLPUSH",
"CLIENT", "KILL", "LIST", "GETNAME", "PAUSE", "REPLY", "SETNAME", "CLUSTER", "ADDSLOTS", "COUNT-FAILURE-REPORTS",
"COUNTKEYSINSLOT", "DELSLOTS", "FAILOVER", "FORGET", "GETKEYSINSLOT", "INFO", "KEYSLOT", "MEET", "NODES", "REPLICATE",
"RESET", "SAVECONFIG", "SET-CONFIG-EPOCH", "SETSLOT", "SLAVES", "SLOTS", "COMMAND", "COUNT", "GETKEYS", "CONFIG", "GET",
"REWRITE", "SET", "RESETSTAT", "DBSIZE", "DEBUG", "OBJECT", "SEGFAULT", "DECR", "DECRBY", "DEL", "DISCARD", "DUMP", "ECHO",
"EVAL", "EVALSHA", "EXEC", "EXISTS", "EXPIRE", "EXPIREAT", "FLUSHALL", "FLUSHDB", "GEOADD", "GEOHASH", "GEOPOS", "GEODIST",
"GEORADIUS", "GEORADIUSBYMEMBER", "GETBIT", "GETRANGE", "GETSET", "HDEL", "HEXISTS", "HGET", "HGETALL", "HINCRBY", "HINCRBYFLOAT",
"HKEYS", "HLEN", "HMGET", "HMSET", "HSET", "HSETNX", "HSTRLEN", "HVALS", "INCR", "INCRBY", "INCRBYFLOAT", "KEYS", "LASTSAVE",
"LINDEX", "LINSERT", "LLEN", "LPOP", "LPUSH", "LPUSHX", "LRANGE", "LREM", "LSET", "LTRIM", "MGET", "MIGRATE", "MONITOR",
"MOVE", "MSET", "MSETNX", "MULTI", "PERSIST", "PEXPIRE", "PEXPIREAT", "PFADD", "PFCOUNT", "PFMERGE", "PING", "PSETEX",
"PSUBSCRIBE", "PUBSUB", "PTTL", "PUBLISH", "PUNSUBSCRIBE", "QUIT", "RANDOMKEY", "READONLY", "READWRITE", "RENAME", "RENAMENX",
"RESTORE", "ROLE", "RPOP", "RPOPLPUSH", "RPUSH", "RPUSHX", "SADD", "SAVE", "SCARD", "SCRIPT", "FLUSH", "LOAD", "SDIFF",
"SDIFFSTORE", "SELECT", "SETBIT", "SETEX", "SETNX", "SETRANGE", "SHUTDOWN", "SINTER", "SINTERSTORE", "SISMEMBER", "SLAVEOF",
"SLOWLOG", "SMEMBERS", "SMOVE", "SORT", "SPOP", "SRANDMEMBER", "SREM", "STRLEN", "SUBSCRIBE", "SUNION", "SUNIONSTORE", "SWAPDB",
"SYNC", "TIME", "TOUCH", "TTL", "TYPE", "UNSUBSCRIBE", "UNLINK", "UNWATCH", "WAIT", "WATCH", "ZADD", "ZCARD", "ZCOUNT", "ZINCRBY",
"ZINTERSTORE", "ZLEXCOUNT", "ZRANGE", "ZRANGEBYLEX", "ZREVRANGEBYLEX", "ZRANGEBYSCORE", "ZRANK", "ZREM", "ZREMRANGEBYLEX",
"ZREMRANGEBYRANK", "ZREMRANGEBYSCORE", "ZREVRANGE", "ZREVRANGEBYSCORE", "ZREVRANK", "ZSCORE", "ZUNIONSTORE", "SCAN", "SSCAN",
"HSCAN", "ZSCAN"
],
operators: [
// NOT SUPPORTED
],
builtinFunctions: [
// NOT SUPPORTED
],
builtinVariables: [
// NOT SUPPORTED
],
pseudoColumns: [
// NOT SUPPORTED
],
tokenizer: {
root: [
{ include: '@whitespace' },
{ include: '@pseudoColumns' },
{ include: '@numbers' },
{ include: '@strings' },
{ include: '@scopes' },
[/[;,.]/, 'delimiter'],
[/[()]/, '@brackets'],
[/[\w@#$]+/, {
cases: {
'@keywords': 'keyword',
'@operators': 'operator',
'@builtinVariables': 'predefined',
'@builtinFunctions': 'predefined',
'@default': 'identifier'
}
}],
[/[<>=!%&+\-*/|~^]/, 'operator'],
],
whitespace: [
[/\s+/, 'white']
],
pseudoColumns: [
[/[$][A-Za-z_][\w@#$]*/, {
cases: {
'@pseudoColumns': 'predefined',
'@default': 'identifier'
}
}],
],
numbers: [
[/0[xX][0-9a-fA-F]*/, 'number'],
[/[$][+-]*\d*(\.\d*)?/, 'number'],
[/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, 'number']
],
strings: [
[/'/, { token: 'string', next: '@string' }],
[/"/, { token: 'string.double', next: '@stringDouble' }]
],
string: [
[/[^']+/, 'string'],
[/''/, 'string'],
[/'/, { token: 'string', next: '@pop' }],
],
stringDouble: [
[/[^"]+/, 'string.double'],
[/""/, 'string.double'],
[/"/, { token: 'string.double', next: '@pop' }]
],
scopes: [
// NOT SUPPORTED
]
}
};
/***/ })
}]);

227
67.cb8e8499.async.js Normal file
View File

@ -0,0 +1,227 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[67],{
/***/ "KpXS":
/*!********************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/redshift/redshift.js ***!
\********************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/redshift/redshift.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '--',
blockComment: ['/*', '*/'],
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
]
};
var language = {
defaultToken: '',
tokenPostfix: '.sql',
ignoreCase: true,
brackets: [
{ open: '[', close: ']', token: 'delimiter.square' },
{ open: '(', close: ')', token: 'delimiter.parenthesis' }
],
keywords: [
"AES128", "AES256", "ALL", "ALLOWOVERWRITE", "ANALYSE", "ANALYZE", "AND", "ANY", "ARRAY", "AS", "ASC", "AUTHORIZATION",
"BACKUP", "BETWEEN", "BINARY", "BLANKSASNULL", "BOTH", "BYTEDICT", "BZIP2", "CASE", "CAST", "CHECK", "COLLATE", "COLUMN",
"CONSTRAINT", "CREATE", "CREDENTIALS", "CROSS", "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER",
"CURRENT_USER_ID", "DEFAULT", "DEFERRABLE", "DEFLATE", "DEFRAG", "DELTA", "DELTA32K", "DESC", "DISABLE", "DISTINCT", "DO",
"ELSE", "EMPTYASNULL", "ENABLE", "ENCODE", "ENCRYPT", "ENCRYPTION", "END", "EXCEPT", "EXPLICIT", "FALSE", "FOR", "FOREIGN",
"FREEZE", "FROM", "FULL", "GLOBALDICT256", "GLOBALDICT64K", "GRANT", "GROUP", "GZIP", "HAVING", "IDENTITY", "IGNORE", "ILIKE",
"IN", "INITIALLY", "INNER", "INTERSECT", "INTO", "IS", "ISNULL", "JOIN", "LEADING", "LEFT", "LIKE", "LIMIT", "LOCALTIME",
"LOCALTIMESTAMP", "LUN", "LUNS", "LZO", "LZOP", "MINUS", "MOSTLY13", "MOSTLY32", "MOSTLY8", "NATURAL", "NEW", "NOT", "NOTNULL",
"NULL", "NULLS", "OFF", "OFFLINE", "OFFSET", "OID", "OLD", "ON", "ONLY", "OPEN", "OR", "ORDER", "OUTER", "OVERLAPS", "PARALLEL",
"PARTITION", "PERCENT", "PERMISSIONS", "PLACING", "PRIMARY", "RAW", "READRATIO", "RECOVER", "REFERENCES", "RESPECT", "REJECTLOG",
"RESORT", "RESTORE", "RIGHT", "SELECT", "SESSION_USER", "SIMILAR", "SNAPSHOT", "SOME", "SYSDATE", "SYSTEM", "TABLE", "TAG",
"TDES", "TEXT255", "TEXT32K", "THEN", "TIMESTAMP", "TO", "TOP", "TRAILING", "TRUE", "TRUNCATECOLUMNS", "UNION", "UNIQUE", "USER",
"USING", "VERBOSE", "WALLET", "WHEN", "WHERE", "WITH", "WITHOUT"
],
operators: [
"AND", "BETWEEN", "IN", "LIKE", "NOT", "OR", "IS", "NULL", "INTERSECT", "UNION", "INNER", "JOIN", "LEFT", "OUTER", "RIGHT"
],
builtinFunctions: [
"current_schema", "current_schemas", "has_database_privilege", "has_schema_privilege", "has_table_privilege", "age",
"current_time", "current_timestamp", "localtime", "isfinite", "now", "ascii", "get_bit", "get_byte", "set_bit", "set_byte",
"to_ascii", "approximate percentile_disc", "avg", "count", "listagg", "max", "median", "min", "percentile_cont", "stddev_samp",
"stddev_pop", "sum", "var_samp", "var_pop", "bit_and", "bit_or", "bool_and", "bool_or", "cume_dist", "first_value", "lag",
"last_value", "lead", "nth_value", "ratio_to_report", "dense_rank", "ntile", "percent_rank", "rank", "row_number", "case",
"coalesce", "decode", "greatest", "least", "nvl", "nvl2", "nullif", "add_months", "at time zone", "convert_timezone",
"current_date", "date_cmp", "date_cmp_timestamp", "date_cmp_timestamptz", "date_part_year", "dateadd", "datediff",
"date_part", "date_trunc", "extract", "getdate", "interval_cmp", "last_day", "months_between", "next_day", "sysdate",
"timeofday", "timestamp_cmp", "timestamp_cmp_date", "timestamp_cmp_timestamptz", "timestamptz_cmp", "timestamptz_cmp_date",
"timestamptz_cmp_timestamp", "timezone", "to_timestamp", "trunc", "abs", "acos", "asin", "atan", "atan2", "cbrt", "ceil",
"ceiling", "checksum", "cos", "cot", "degrees", "dexp", "dlog1", "dlog10", "exp", "floor", "ln", "log", "mod", "pi", "power",
"radians", "random", "round", "sin", "sign", "sqrt", "tan", "to_hex", "bpcharcmp", "btrim", "bttext_pattern_cmp", "char_length",
"character_length", "charindex", "chr", "concat", "crc32", "func_sha1", "initcap", "left and rights", "len", "length", "lower",
"lpad and rpads", "ltrim", "md5", "octet_length", "position", "quote_ident", "quote_literal", "regexp_count", "regexp_instr",
"regexp_replace", "regexp_substr", "repeat", "replace", "replicate", "reverse", "rtrim", "split_part", "strpos", "strtol",
"substring", "textlen", "translate", "trim", "upper", "cast", "convert", "to_char", "to_date", "to_number", "json_array_length",
"json_extract_array_element_text", "json_extract_path_text", "current_setting", "pg_cancel_backend", "pg_terminate_backend",
"set_config", "current_database", "current_user", "current_user_id", "pg_backend_pid", "pg_last_copy_count", "pg_last_copy_id",
"pg_last_query_id", "pg_last_unload_count", "session_user", "slice_num", "user", "version", "abbrev", "acosd", "any", "area",
"array_agg", "array_append", "array_cat", "array_dims", "array_fill", "array_length", "array_lower", "array_ndims",
"array_position", "array_positions", "array_prepend", "array_remove", "array_replace", "array_to_json", "array_to_string",
"array_to_tsvector", "array_upper", "asind", "atan2d", "atand", "bit", "bit_length", "bound_box", "box",
"brin_summarize_new_values", "broadcast", "cardinality", "center", "circle", "clock_timestamp", "col_description", "concat_ws",
"convert_from", "convert_to", "corr", "cosd", "cotd", "covar_pop", "covar_samp", "current_catalog", "current_query",
"current_role", "currval", "cursor_to_xml", "diameter", "div", "encode", "enum_first", "enum_last", "enum_range", "every",
"family", "format", "format_type", "generate_series", "generate_subscripts", "get_current_ts_config", "gin_clean_pending_list",
"grouping", "has_any_column_privilege", "has_column_privilege", "has_foreign_data_wrapper_privilege", "has_function_privilege",
"has_language_privilege", "has_sequence_privilege", "has_server_privilege", "has_tablespace_privilege", "has_type_privilege",
"height", "host", "hostmask", "inet_client_addr", "inet_client_port", "inet_merge", "inet_same_family", "inet_server_addr",
"inet_server_port", "isclosed", "isempty", "isopen", "json_agg", "json_object", "json_object_agg", "json_populate_record",
"json_populate_recordset", "json_to_record", "json_to_recordset", "jsonb_agg", "jsonb_object_agg", "justify_days", "justify_hours",
"justify_interval", "lastval", "left", "line", "localtimestamp", "lower_inc", "lower_inf", "lpad", "lseg", "make_date",
"make_interval", "make_time", "make_timestamp", "make_timestamptz", "masklen", "mode", "netmask", "network", "nextval", "npoints",
"num_nonnulls", "num_nulls", "numnode", "obj_description", "overlay", "parse_ident", "path", "pclose", "percentile_disc",
"pg_advisory_lock", "pg_advisory_lock_shared", "pg_advisory_unlock", "pg_advisory_unlock_all", "pg_advisory_unlock_shared",
"pg_advisory_xact_lock", "pg_advisory_xact_lock_shared", "pg_backup_start_time", "pg_blocking_pids", "pg_client_encoding",
"pg_collation_is_visible", "pg_column_size", "pg_conf_load_time", "pg_control_checkpoint", "pg_control_init", "pg_control_recovery",
"pg_control_system", "pg_conversion_is_visible", "pg_create_logical_replication_slot", "pg_create_physical_replication_slot",
"pg_create_restore_point", "pg_current_xlog_flush_location", "pg_current_xlog_insert_location", "pg_current_xlog_location",
"pg_database_size", "pg_describe_object", "pg_drop_replication_slot", "pg_export_snapshot", "pg_filenode_relation",
"pg_function_is_visible", "pg_get_constraintdef", "pg_get_expr", "pg_get_function_arguments", "pg_get_function_identity_arguments",
"pg_get_function_result", "pg_get_functiondef", "pg_get_indexdef", "pg_get_keywords", "pg_get_object_address",
"pg_get_owned_sequence", "pg_get_ruledef", "pg_get_serial_sequence", "pg_get_triggerdef", "pg_get_userbyid", "pg_get_viewdef",
"pg_has_role", "pg_identify_object", "pg_identify_object_as_address", "pg_index_column_has_property", "pg_index_has_property",
"pg_indexam_has_property", "pg_indexes_size", "pg_is_in_backup", "pg_is_in_recovery", "pg_is_other_temp_schema",
"pg_is_xlog_replay_paused", "pg_last_committed_xact", "pg_last_xact_replay_timestamp", "pg_last_xlog_receive_location",
"pg_last_xlog_replay_location", "pg_listening_channels", "pg_logical_emit_message", "pg_logical_slot_get_binary_changes",
"pg_logical_slot_get_changes", "pg_logical_slot_peek_binary_changes", "pg_logical_slot_peek_changes", "pg_ls_dir",
"pg_my_temp_schema", "pg_notification_queue_usage", "pg_opclass_is_visible", "pg_operator_is_visible", "pg_opfamily_is_visible",
"pg_options_to_table", "pg_postmaster_start_time", "pg_read_binary_file", "pg_read_file", "pg_relation_filenode",
"pg_relation_filepath", "pg_relation_size", "pg_reload_conf", "pg_replication_origin_create", "pg_replication_origin_drop",
"pg_replication_origin_oid", "pg_replication_origin_progress", "pg_replication_origin_session_is_setup",
"pg_replication_origin_session_progress", "pg_replication_origin_session_reset", "pg_replication_origin_session_setup",
"pg_replication_origin_xact_reset", "pg_replication_origin_xact_setup", "pg_rotate_logfile", "pg_size_bytes", "pg_size_pretty",
"pg_sleep", "pg_sleep_for", "pg_sleep_until", "pg_start_backup", "pg_stat_file", "pg_stop_backup", "pg_switch_xlog",
"pg_table_is_visible", "pg_table_size", "pg_tablespace_databases", "pg_tablespace_location", "pg_tablespace_size",
"pg_total_relation_size", "pg_trigger_depth", "pg_try_advisory_lock", "pg_try_advisory_lock_shared", "pg_try_advisory_xact_lock",
"pg_try_advisory_xact_lock_shared", "pg_ts_config_is_visible", "pg_ts_dict_is_visible", "pg_ts_parser_is_visible",
"pg_ts_template_is_visible", "pg_type_is_visible", "pg_typeof", "pg_xact_commit_timestamp", "pg_xlog_location_diff",
"pg_xlog_replay_pause", "pg_xlog_replay_resume", "pg_xlogfile_name", "pg_xlogfile_name_offset", "phraseto_tsquery",
"plainto_tsquery", "point", "polygon", "popen", "pqserverversion", "query_to_xml", "querytree", "quote_nullable", "radius",
"range_merge", "regexp_matches", "regexp_split_to_array", "regexp_split_to_table", "regr_avgx", "regr_avgy", "regr_count",
"regr_intercept", "regr_r2", "regr_slope", "regr_sxx", "regr_sxy", "regr_syy", "right", "row_security_active", "row_to_json",
"rpad", "scale", "set_masklen", "setseed", "setval", "setweight", "shobj_description", "sind", "sprintf", "statement_timestamp",
"stddev", "string_agg", "string_to_array", "strip", "substr", "table_to_xml", "table_to_xml_and_xmlschema", "tand", "text",
"to_json", "to_regclass", "to_regnamespace", "to_regoper", "to_regoperator", "to_regproc", "to_regprocedure", "to_regrole",
"to_regtype", "to_tsquery", "to_tsvector", "transaction_timestamp", "ts_debug", "ts_delete", "ts_filter", "ts_headline",
"ts_lexize", "ts_parse", "ts_rank", "ts_rank_cd", "ts_rewrite", "ts_stat", "ts_token_type", "tsquery_phrase", "tsvector_to_array",
"tsvector_update_trigger", "tsvector_update_trigger_column", "txid_current", "txid_current_snapshot", "txid_snapshot_xip",
"txid_snapshot_xmax", "txid_snapshot_xmin", "txid_visible_in_snapshot", "unnest", "upper_inc", "upper_inf", "variance", "width",
"width_bucket", "xml_is_well_formed", "xml_is_well_formed_content", "xml_is_well_formed_document", "xmlagg", "xmlcomment",
"xmlconcat", "xmlelement", "xmlexists", "xmlforest", "xmlparse", "xmlpi", "xmlroot", "xmlserialize", "xpath", "xpath_exists"
],
builtinVariables: [
// NOT SUPPORTED
],
pseudoColumns: [
// NOT SUPPORTED
],
tokenizer: {
root: [
{ include: '@comments' },
{ include: '@whitespace' },
{ include: '@pseudoColumns' },
{ include: '@numbers' },
{ include: '@strings' },
{ include: '@complexIdentifiers' },
{ include: '@scopes' },
[/[;,.]/, 'delimiter'],
[/[()]/, '@brackets'],
[/[\w@#$]+/, {
cases: {
'@keywords': 'keyword',
'@operators': 'operator',
'@builtinVariables': 'predefined',
'@builtinFunctions': 'predefined',
'@default': 'identifier'
}
}],
[/[<>=!%&+\-*/|~^]/, 'operator'],
],
whitespace: [
[/\s+/, 'white']
],
comments: [
[/--+.*/, 'comment'],
[/\/\*/, { token: 'comment.quote', next: '@comment' }]
],
comment: [
[/[^*/]+/, 'comment'],
// Not supporting nested comments, as nested comments seem to not be standard?
// i.e. http://stackoverflow.com/questions/728172/are-there-multiline-comment-delimiters-in-sql-that-are-vendor-agnostic
// [/\/\*/, { token: 'comment.quote', next: '@push' }], // nested comment not allowed :-(
[/\*\//, { token: 'comment.quote', next: '@pop' }],
[/./, 'comment']
],
pseudoColumns: [
[/[$][A-Za-z_][\w@#$]*/, {
cases: {
'@pseudoColumns': 'predefined',
'@default': 'identifier'
}
}],
],
numbers: [
[/0[xX][0-9a-fA-F]*/, 'number'],
[/[$][+-]*\d*(\.\d*)?/, 'number'],
[/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, 'number']
],
strings: [
[/'/, { token: 'string', next: '@string' }],
],
string: [
[/[^']+/, 'string'],
[/''/, 'string'],
[/'/, { token: 'string', next: '@pop' }]
],
complexIdentifiers: [
[/"/, { token: 'identifier.quote', next: '@quotedIdentifier' }]
],
quotedIdentifier: [
[/[^"]+/, 'identifier'],
[/""/, 'identifier'],
[/"/, { token: 'identifier.quote', next: '@pop' }]
],
scopes: [
// NOT SUPPORTED
]
}
};
/***/ })
}]);

163
68.b0fe1b4d.async.js Normal file
View File

@ -0,0 +1,163 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[68],{
/***/ "LdT9":
/*!************************************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/restructuredtext/restructuredtext.js ***!
\************************************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/restructuredtext/restructuredtext.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '<', close: '>', notIn: ['string'] }
],
surroundingPairs: [
{ open: '(', close: ')' },
{ open: '[', close: ']' },
{ open: '`', close: '`' },
],
folding: {
markers: {
start: new RegExp("^\\s*<!--\\s*#?region\\b.*-->"),
end: new RegExp("^\\s*<!--\\s*#?endregion\\b.*-->")
}
}
};
var language = {
defaultToken: '',
tokenPostfix: '.rst',
control: /[\\`*_\[\]{}()#+\-\.!]/,
escapes: /\\(?:@control)/,
empty: [
'area', 'base', 'basefont', 'br', 'col', 'frame',
'hr', 'img', 'input', 'isindex', 'link', 'meta', 'param'
],
alphanumerics: /[A-Za-z0-9]/,
alphanumericsplus: /[A-Za-z0-9-_+:.]/,
simpleRefNameWithoutBq: /(?:@alphanumerics@alphanumericsplus*@alphanumerics)+|(?:@alphanumerics+)/,
simpleRefName: /(?:`@simpleRefNameWithoutBq`|@simpleRefNameWithoutBq)/,
phrase: /@simpleRefName(?:\s@simpleRefName)*/,
citationName: /[A-Za-z][A-Za-z0-9-_.]*/,
blockLiteralStart: /(?:[!"#$%&'()*+,-./:;<=>?@\[\]^_`{|}~]|[\s])/,
precedingChars: /(?:[ -:/'"<([{])/,
followingChars: /(?:[ -.,:;!?/'")\]}>]|$)/,
punctuation: /(=|-|~|`|#|"|\^|\+|\*|:|\.|'|_|\+)/,
tokenizer: {
root: [
//sections
[/^(@punctuation{3,}$){1,1}?/, 'keyword'],
//line-blocks
//No rules on it
//bullet-lists
[/^\s*([\*\-+‣•]|[a-zA-Z0-9]+\.|\([a-zA-Z0-9]+\)|[a-zA-Z0-9]+\))\s/, 'keyword'],
//literal-blocks
[/([ ]::)\s*$/, 'keyword', '@blankLineOfLiteralBlocks'],
[/(::)\s*$/, 'keyword', '@blankLineOfLiteralBlocks'],
{ include: '@tables' },
{ include: '@explicitMarkupBlocks' },
{ include: '@inlineMarkup' },
],
explicitMarkupBlocks: [
//citations
{ include: '@citations' },
//footnotes
{ include: '@footnotes' },
//directives
[/^(\.\.\s)(@simpleRefName)(::\s)(.*)$/, [{ token: '', next: 'subsequentLines' }, 'keyword', '', '']],
//hyperlink-targets
[/^(\.\.)(\s+)(_)(@simpleRefName)(:)(\s+)(.*)/, [{ token: '', next: 'hyperlinks' }, '', '', 'string.link', '', '', 'string.link']],
//anonymous-hyperlinks
[/^((?:(?:\.\.)(?:\s+))?)(__)(:)(\s+)(.*)/, [{ token: '', next: 'subsequentLines' }, '', '', '', 'string.link']],
[/^(__\s+)(.+)/, ['', 'string.link']],
//substitution-definitions
[/^(\.\.)( \|)([^| ]+[^|]*[^| ]*)(\| )(@simpleRefName)(:: .*)/, [{ token: '', next: 'subsequentLines' }, '', 'string.link', '', 'keyword', ''], '@rawBlocks'],
[/(\|)([^| ]+[^|]*[^| ]*)(\|_{0,2})/, ['', 'string.link', '']],
//comments
[/^(\.\.)([ ].*)$/, [{ token: '', next: '@comments' }, 'comment']],
],
inlineMarkup: [
{ include: '@citationsReference' },
{ include: '@footnotesReference' },
//hyperlink-references
[/(@simpleRefName)(_{1,2})/, ['string.link', '']],
//embedded-uris-and-aliases
[/(`)([^<`]+\s+)(<)(.*)(>)(`)(_)/, ['', 'string.link', '', 'string.link', '', '', '']],
//emphasis
[/\*\*([^\\*]|\*(?!\*))+\*\*/, 'strong'],
[/\*[^*]+\*/, 'emphasis'],
//inline-literals
[/(``)((?:[^`]|\`(?!`))+)(``)/, ['', 'keyword', '']],
[/(__\s+)(.+)/, ['', 'keyword']],
//interpreted-text
[/(:)((?:@simpleRefNameWithoutBq)?)(:`)([^`]+)(`)/, ['', 'keyword', '', '', '']],
[/(`)([^`]+)(`:)((?:@simpleRefNameWithoutBq)?)(:)/, ['', '', '', 'keyword', '']],
[/(`)([^`]+)(`)/, ''],
//inline-internal-targets
[/(_`)(@phrase)(`)/, ['', 'string.link', '']],
],
citations: [
[/^(\.\.\s+\[)((?:@citationName))(\]\s+)(.*)/, [{ token: '', next: '@subsequentLines' }, 'string.link', '', '']],
],
citationsReference: [
[/(\[)(@citationName)(\]_)/, ['', 'string.link', '']],
],
footnotes: [
[/^(\.\.\s+\[)((?:[0-9]+))(\]\s+.*)/, [{ token: '', next: '@subsequentLines' }, 'string.link', '']],
[/^(\.\.\s+\[)((?:#@simpleRefName?))(\]\s+)(.*)/, [{ token: '', next: '@subsequentLines' }, 'string.link', '', '']],
[/^(\.\.\s+\[)((?:\*))(\]\s+)(.*)/, [{ token: '', next: '@subsequentLines' }, 'string.link', '', '']],
],
footnotesReference: [
[/(\[)([0-9]+)(\])(_)/, ['', 'string.link', '', '']],
[/(\[)(#@simpleRefName?)(\])(_)/, ['', 'string.link', '', '']],
[/(\[)(\*)(\])(_)/, ['', 'string.link', '', '']]
],
blankLineOfLiteralBlocks: [
[/^$/, '', '@subsequentLinesOfLiteralBlocks'],
[/^.*$/, '', '@pop'],
],
subsequentLinesOfLiteralBlocks: [
[/(@blockLiteralStart+)(.*)/, ['keyword', '']],
[/^(?!blockLiteralStart)/, '', '@popall']
],
subsequentLines: [
[/^[\s]+.*/, ''],
[/^(?!\s)/, '', '@pop'],
],
hyperlinks: [
[/^[\s]+.*/, 'string.link'],
[/^(?!\s)/, '', '@pop'],
],
comments: [
[/^[\s]+.*/, 'comment'],
[/^(?!\s)/, '', '@pop'],
],
tables: [
[/\+-[+-]+/, 'keyword'],
[/\+=[+=]+/, 'keyword'],
],
}
};
/***/ })
}]);

411
69.ff71a626.async.js Normal file
View File

@ -0,0 +1,411 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[69],{
/***/ "3MdH":
/*!************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/ruby/ruby.js ***!
\************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/ruby/ruby.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '#',
blockComment: ['=begin', '=end'],
},
brackets: [
['(', ')'],
['{', '}'],
['[', ']']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
indentationRules: {
increaseIndentPattern: new RegExp('^\\s*((begin|class|(private|protected)\\s+def|def|else|elsif|ensure|for|if|module|rescue|unless|until|when|while|case)|([^#]*\\sdo\\b)|([^#]*=\\s*(case|if|unless)))\\b([^#\\{;]|("|\'|\/).*\\4)*(#.*)?$'),
decreaseIndentPattern: new RegExp('^\\s*([}\\]]([,)]?\\s*(#|$)|\\.[a-zA-Z_]\\w*\\b)|(end|rescue|ensure|else|elsif|when)\\b)'),
}
};
/*
* Ruby language definition
*
* Quite a complex language due to elaborate escape sequences
* and quoting of literate strings/regular expressions, and
* an 'end' keyword that does not always apply to modifiers like until and while,
* and a 'do' keyword that sometimes starts a block, but sometimes is part of
* another statement (like 'while').
*
* (1) end blocks:
* 'end' may end declarations like if or until, but sometimes 'if' or 'until'
* are modifiers where there is no 'end'. Also, 'do' sometimes starts a block
* that is ended by 'end', but sometimes it is part of a 'while', 'for', or 'until'
* To do proper brace matching we do some elaborate state manipulation.
* some examples:
*
* until bla do
* work until tired
* list.each do
* something if test
* end
* end
*
* or
*
* if test
* something (if test then x end)
* bar if bla
* end
*
* or, how about using class as a property..
*
* class Test
* def endpoint
* self.class.endpoint || routes
* end
* end
*
* (2) quoting:
* there are many kinds of strings and escape sequences. But also, one can
* start many string-like things as '%qx' where q specifies the kind of string
* (like a command, escape expanded, regular expression, symbol etc.), and x is
* some character and only another 'x' ends the sequence. Except for brackets
* where the closing bracket ends the sequence.. and except for a nested bracket
* inside the string like entity. Also, such strings can contain interpolated
* ruby expressions again (and span multiple lines). Moreover, expanded
* regular expression can also contain comments.
*/
var language = {
tokenPostfix: '.ruby',
keywords: [
'__LINE__', '__ENCODING__', '__FILE__', 'BEGIN', 'END', 'alias', 'and', 'begin',
'break', 'case', 'class', 'def', 'defined?', 'do', 'else', 'elsif', 'end',
'ensure', 'for', 'false', 'if', 'in', 'module', 'next', 'nil', 'not', 'or', 'redo',
'rescue', 'retry', 'return', 'self', 'super', 'then', 'true', 'undef', 'unless',
'until', 'when', 'while', 'yield',
],
keywordops: [
'::', '..', '...', '?', ':', '=>'
],
builtins: [
'require', 'public', 'private', 'include', 'extend', 'attr_reader',
'protected', 'private_class_method', 'protected_class_method', 'new'
],
// these are closed by 'end' (if, while and until are handled separately)
declarations: [
'module', 'class', 'def', 'case', 'do', 'begin', 'for', 'if', 'while', 'until', 'unless'
],
linedecls: [
'def', 'case', 'do', 'begin', 'for', 'if', 'while', 'until', 'unless'
],
operators: [
'^', '&', '|', '<=>', '==', '===', '!~', '=~', '>', '>=', '<', '<=', '<<', '>>', '+',
'-', '*', '/', '%', '**', '~', '+@', '-@', '[]', '[]=', '`',
'+=', '-=', '*=', '**=', '/=', '^=', '%=', '<<=', '>>=', '&=', '&&=', '||=', '|='
],
brackets: [
{ open: '(', close: ')', token: 'delimiter.parenthesis' },
{ open: '{', close: '}', token: 'delimiter.curly' },
{ open: '[', close: ']', token: 'delimiter.square' }
],
// we include these common regular expressions
symbols: /[=><!~?:&|+\-*\/\^%\.]+/,
// 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)/,
decpart: /\d(_?\d)*/,
decimal: /0|@decpart/,
delim: /[^a-zA-Z0-9\s\n\r]/,
heredelim: /(?:\w+|'[^']*'|"[^"]*"|`[^`]*`)/,
regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
regexpesc: /\\(?:[AzZbBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})?/,
// The main tokenizer for our languages
tokenizer: {
// Main entry.
// root.<decl> where decl is the current opening declaration (like 'class')
root: [
// identifiers and keywords
// most complexity here is due to matching 'end' correctly with declarations.
// We distinguish a declaration that comes first on a line, versus declarations further on a line (which are most likey modifiers)
[/^(\s*)([a-z_]\w*[!?=]?)/, ['white',
{
cases: {
'for|until|while': { token: 'keyword.$2', next: '@dodecl.$2' },
'@declarations': { token: 'keyword.$2', next: '@root.$2' },
'end': { token: 'keyword.$S2', next: '@pop' },
'@keywords': 'keyword',
'@builtins': 'predefined',
'@default': 'identifier'
}
}]],
[/[a-z_]\w*[!?=]?/,
{
cases: {
'if|unless|while|until': { token: 'keyword.$0x', next: '@modifier.$0x' },
'for': { token: 'keyword.$2', next: '@dodecl.$2' },
'@linedecls': { token: 'keyword.$0', next: '@root.$0' },
'end': { token: 'keyword.$S2', next: '@pop' },
'@keywords': 'keyword',
'@builtins': 'predefined',
'@default': 'identifier'
}
}],
[/[A-Z][\w]*[!?=]?/, 'constructor.identifier'],
[/\$[\w]*/, 'global.constant'],
[/@[\w]*/, 'namespace.instance.identifier'],
[/@@[\w]*/, 'namespace.class.identifier'],
// here document
[/<<[-~](@heredelim).*/, { token: 'string.heredoc.delimiter', next: '@heredoc.$1' }],
[/[ \t\r\n]+<<(@heredelim).*/, { token: 'string.heredoc.delimiter', next: '@heredoc.$1' }],
[/^<<(@heredelim).*/, { token: 'string.heredoc.delimiter', next: '@heredoc.$1' }],
// whitespace
{ include: '@whitespace' },
// strings
[/"/, { token: 'string.d.delim', next: '@dstring.d."' }],
[/'/, { token: 'string.sq.delim', next: '@sstring.sq' }],
// % literals. For efficiency, rematch in the 'pstring' state
[/%([rsqxwW]|Q?)/, { token: '@rematch', next: 'pstring' }],
// commands and symbols
[/`/, { token: 'string.x.delim', next: '@dstring.x.`' }],
[/:(\w|[$@])\w*[!?=]?/, 'string.s'],
[/:"/, { token: 'string.s.delim', next: '@dstring.s."' }],
[/:'/, { token: 'string.s.delim', next: '@sstring.s' }],
// regular expressions. Lookahead for a (not escaped) closing forwardslash on the same line
[/\/(?=(\\\/|[^\/\n])+\/)/, { token: 'regexp.delim', next: '@regexp' }],
// delimiters and operators
[/[{}()\[\]]/, '@brackets'],
[/@symbols/, {
cases: {
'@keywordops': 'keyword',
'@operators': 'operator',
'@default': ''
}
}],
[/[;,]/, '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'],
[/0[dD]@decpart/, 'number'],
[/@decimal((\.@decpart)?([eE][\-+]?@decpart)?)/, {
cases: {
'$1': 'number.float',
'@default': 'number'
}
}],
],
// used to not treat a 'do' as a block opener if it occurs on the same
// line as a 'do' statement: 'while|until|for'
// dodecl.<decl> where decl is the declarations started, like 'while'
dodecl: [
[/^/, { token: '', switchTo: '@root.$S2' }],
[/[a-z_]\w*[!?=]?/, {
cases: {
'end': { token: 'keyword.$S2', next: '@pop' },
'do': { token: 'keyword', switchTo: '@root.$S2' },
'@linedecls': { token: '@rematch', switchTo: '@root.$S2' },
'@keywords': 'keyword',
'@builtins': 'predefined',
'@default': 'identifier'
}
}],
{ include: '@root' }
],
// used to prevent potential modifiers ('if|until|while|unless') to match
// with 'end' keywords.
// modifier.<decl>x where decl is the declaration starter, like 'if'
modifier: [
[/^/, '', '@pop'],
[/[a-z_]\w*[!?=]?/, {
cases: {
'end': { token: 'keyword.$S2', next: '@pop' },
'then|else|elsif|do': { token: 'keyword', switchTo: '@root.$S2' },
'@linedecls': { token: '@rematch', switchTo: '@root.$S2' },
'@keywords': 'keyword',
'@builtins': 'predefined',
'@default': 'identifier'
}
}],
{ include: '@root' }
],
// single quote strings (also used for symbols)
// sstring.<kind> where kind is 'sq' (single quote) or 's' (symbol)
sstring: [
[/[^\\']+/, 'string.$S2'],
[/\\\\|\\'|\\$/, 'string.$S2.escape'],
[/\\./, 'string.$S2.invalid'],
[/'/, { token: 'string.$S2.delim', next: '@pop' }]
],
// double quoted "string".
// dstring.<kind>.<delim> where kind is 'd' (double quoted), 'x' (command), or 's' (symbol)
// and delim is the ending delimiter (" or `)
dstring: [
[/[^\\`"#]+/, 'string.$S2'],
[/#/, 'string.$S2.escape', '@interpolated'],
[/\\$/, 'string.$S2.escape'],
[/@escapes/, 'string.$S2.escape'],
[/\\./, 'string.$S2.escape.invalid'],
[/[`"]/, {
cases: {
'$#==$S3': { token: 'string.$S2.delim', next: '@pop' },
'@default': 'string.$S2'
}
}]
],
// literal documents
// heredoc.<close> where close is the closing delimiter
heredoc: [
[/^(\s*)(@heredelim)$/, {
cases: {
'$2==$S2': ['string.heredoc', { token: 'string.heredoc.delimiter', next: '@pop' }],
'@default': ['string.heredoc', 'string.heredoc']
}
}],
[/.*/, 'string.heredoc'],
],
// interpolated sequence
interpolated: [
[/\$\w*/, 'global.constant', '@pop'],
[/@\w*/, 'namespace.class.identifier', '@pop'],
[/@@\w*/, 'namespace.instance.identifier', '@pop'],
[/[{]/, { token: 'string.escape.curly', switchTo: '@interpolated_compound' }],
['', '', '@pop'],
],
// any code
interpolated_compound: [
[/[}]/, { token: 'string.escape.curly', next: '@pop' }],
{ include: '@root' },
],
// %r quoted regexp
// pregexp.<open>.<close> where open/close are the open/close delimiter
pregexp: [
{ include: '@whitespace' },
// turns out that you can quote using regex control characters, aargh!
// for example; %r|kgjgaj| is ok (even though | is used for alternation)
// so, we need to match those first
[/[^\(\{\[\\]/, {
cases: {
'$#==$S3': { token: 'regexp.delim', next: '@pop' },
'$#==$S2': { token: 'regexp.delim', next: '@push' },
'~[)}\\]]': '@brackets.regexp.escape.control',
'~@regexpctl': 'regexp.escape.control',
'@default': 'regexp'
}
}],
{ include: '@regexcontrol' },
],
// We match regular expression quite precisely
regexp: [
{ include: '@regexcontrol' },
[/[^\\\/]/, 'regexp'],
['/[ixmp]*', { token: 'regexp.delim' }, '@pop'],
],
regexcontrol: [
[/(\{)(\d+(?:,\d*)?)(\})/, ['@brackets.regexp.escape.control', 'regexp.escape.control', '@brackets.regexp.escape.control']],
[/(\[)(\^?)/, ['@brackets.regexp.escape.control', { token: 'regexp.escape.control', next: '@regexrange' }]],
[/(\()(\?[:=!])/, ['@brackets.regexp.escape.control', 'regexp.escape.control']],
[/\(\?#/, { token: 'regexp.escape.control', next: '@regexpcomment' }],
[/[()]/, '@brackets.regexp.escape.control'],
[/@regexpctl/, 'regexp.escape.control'],
[/\\$/, 'regexp.escape'],
[/@regexpesc/, 'regexp.escape'],
[/\\\./, 'regexp.invalid'],
[/#/, 'regexp.escape', '@interpolated'],
],
regexrange: [
[/-/, 'regexp.escape.control'],
[/\^/, 'regexp.invalid'],
[/\\$/, 'regexp.escape'],
[/@regexpesc/, 'regexp.escape'],
[/[^\]]/, 'regexp'],
[/\]/, '@brackets.regexp.escape.control', '@pop'],
],
regexpcomment: [
[/[^)]+/, 'comment'],
[/\)/, { token: 'regexp.escape.control', next: '@pop' }]
],
// % quoted strings
// A bit repetitive since we need to often special case the kind of ending delimiter
pstring: [
[/%([qws])\(/, { token: 'string.$1.delim', switchTo: '@qstring.$1.(.)' }],
[/%([qws])\[/, { token: 'string.$1.delim', switchTo: '@qstring.$1.[.]' }],
[/%([qws])\{/, { token: 'string.$1.delim', switchTo: '@qstring.$1.{.}' }],
[/%([qws])</, { token: 'string.$1.delim', switchTo: '@qstring.$1.<.>' }],
[/%([qws])(@delim)/, { token: 'string.$1.delim', switchTo: '@qstring.$1.$2.$2' }],
[/%r\(/, { token: 'regexp.delim', switchTo: '@pregexp.(.)' }],
[/%r\[/, { token: 'regexp.delim', switchTo: '@pregexp.[.]' }],
[/%r\{/, { token: 'regexp.delim', switchTo: '@pregexp.{.}' }],
[/%r</, { token: 'regexp.delim', switchTo: '@pregexp.<.>' }],
[/%r(@delim)/, { token: 'regexp.delim', switchTo: '@pregexp.$1.$1' }],
[/%(x|W|Q?)\(/, { token: 'string.$1.delim', switchTo: '@qqstring.$1.(.)' }],
[/%(x|W|Q?)\[/, { token: 'string.$1.delim', switchTo: '@qqstring.$1.[.]' }],
[/%(x|W|Q?)\{/, { token: 'string.$1.delim', switchTo: '@qqstring.$1.{.}' }],
[/%(x|W|Q?)</, { token: 'string.$1.delim', switchTo: '@qqstring.$1.<.>' }],
[/%(x|W|Q?)(@delim)/, { token: 'string.$1.delim', switchTo: '@qqstring.$1.$2.$2' }],
[/%([rqwsxW]|Q?)./, { token: 'invalid', next: '@pop' }],
[/./, { token: 'invalid', next: '@pop' }],
],
// non-expanded quoted string.
// qstring.<kind>.<open>.<close>
// kind = q|w|s (single quote, array, symbol)
// open = open delimiter
// close = close delimiter
qstring: [
[/\\$/, 'string.$S2.escape'],
[/\\./, 'string.$S2.escape'],
[/./, {
cases: {
'$#==$S4': { token: 'string.$S2.delim', next: '@pop' },
'$#==$S3': { token: 'string.$S2.delim', next: '@push' },
'@default': 'string.$S2'
}
}],
],
// expanded quoted string.
// qqstring.<kind>.<open>.<close>
// kind = Q|W|x (double quote, array, command)
// open = open delimiter
// close = close delimiter
qqstring: [
[/#/, 'string.$S2.escape', '@interpolated'],
{ include: '@qstring' }
],
// whitespace & comments
whitespace: [
[/[ \t\r\n]+/, ''],
[/^\s*=begin\b/, 'comment', '@comment'],
[/#.*$/, 'comment'],
],
comment: [
[/[^=]+/, 'comment'],
[/^\s*=begin\b/, 'comment.invalid'],
[/^\s*=end\b.*/, 'comment', '@pop'],
[/[=]/, 'comment']
],
}
};
/***/ })
}]);

174
70.ffd82168.async.js Normal file
View File

@ -0,0 +1,174 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[70],{
/***/ "/0xJ":
/*!************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/rust/rust.js ***!
\************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/rust/rust.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '//',
blockComment: ['/*', '*/'],
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '[', close: ']' },
{ open: '{', close: '}' },
{ open: '(', close: ')' },
{ open: '\'', close: '\'', notIn: ['string', 'comment'] },
{ open: '"', close: '"', notIn: ['string'] },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
folding: {
markers: {
start: new RegExp("^\\s*#pragma\\s+region\\b"),
end: new RegExp("^\\s*#pragma\\s+endregion\\b")
}
}
};
var language = {
tokenPostfix: '.rust',
defaultToken: 'invalid',
keywords: [
'as', 'box', 'break', 'const', 'continue', 'crate', 'else', 'enum',
'extern', 'false', 'fn', 'for', 'if', 'impl', 'in', 'let', 'loop',
'match', 'mod', 'move', 'mut', 'pub', 'ref', 'return', 'self',
'static', 'struct', 'super', 'trait', 'true', 'type', 'unsafe', 'use',
'where', 'while', 'catch', 'default', 'union', 'static', 'abstract',
'alignof', 'become', 'do', 'final', 'macro', 'offsetof', 'override',
'priv', 'proc', 'pure', 'sizeof', 'typeof', 'unsized', 'virtual',
'yield',
],
typeKeywords: [
'Self', 'm32', 'm64', 'm128', 'f80', 'f16', 'f128', 'int', 'uint',
'float', 'char', 'bool', 'u8', 'u16', 'u32', 'u64', 'f32', 'f64', 'i8',
'i16', 'i32', 'i64', 'str', 'Option', 'Either', 'c_float', 'c_double',
'c_void', 'FILE', 'fpos_t', 'DIR', 'dirent', 'c_char', 'c_schar',
'c_uchar', 'c_short', 'c_ushort', 'c_int', 'c_uint', 'c_long',
'c_ulong', 'size_t', 'ptrdiff_t', 'clock_t', 'time_t', 'c_longlong',
'c_ulonglong', 'intptr_t', 'uintptr_t', 'off_t', 'dev_t', 'ino_t',
'pid_t', 'mode_t', 'ssize_t',
],
constants: [
'true', 'false', 'Some', 'None', 'Left', 'Right', 'Ok', 'Err',
],
supportConstants: [
'EXIT_FAILURE', 'EXIT_SUCCESS', 'RAND_MAX', 'EOF', 'SEEK_SET',
'SEEK_CUR', 'SEEK_END', '_IOFBF', '_IONBF', '_IOLBF', 'BUFSIZ',
'FOPEN_MAX', 'FILENAME_MAX', 'L_tmpnam', 'TMP_MAX', 'O_RDONLY',
'O_WRONLY', 'O_RDWR', 'O_APPEND', 'O_CREAT', 'O_EXCL', 'O_TRUNC',
'S_IFIFO', 'S_IFCHR', 'S_IFBLK', 'S_IFDIR', 'S_IFREG', 'S_IFMT',
'S_IEXEC', 'S_IWRITE', 'S_IREAD', 'S_IRWXU', 'S_IXUSR', 'S_IWUSR',
'S_IRUSR', 'F_OK', 'R_OK', 'W_OK', 'X_OK', 'STDIN_FILENO',
'STDOUT_FILENO', 'STDERR_FILENO',
],
supportMacros: [
'format!', 'print!', 'println!', 'panic!', 'format_args!', 'unreachable!',
'write!', 'writeln!'
],
operators: [
'!', '!=', '%', '%=', '&', '&=', '&&', '*', '*=', '+', '+=', '-', '-=',
'->', '.', '..', '...', '/', '/=', ':', ';', '<<', '<<=', '<', '<=', '=',
'==', '=>', '>', '>=', '>>', '>>=', '@', '^', '^=', '|', '|=', '||', '_',
'?', '#'
],
escapes: /\\([nrt0\"''\\]|x\h{2}|u\{\h{1,6}\})/,
delimiters: /[,]/,
symbols: /[\#\!\%\&\*\+\-\.\/\:\;\<\=\>\@\^\|_\?]+/,
intSuffixes: /[iu](8|16|32|64|128|size)/,
floatSuffixes: /f(32|64)/,
tokenizer: {
root: [
[/[a-zA-Z][a-zA-Z0-9_]*!?|_[a-zA-Z0-9_]+/,
{
cases: {
'@typeKeywords': 'keyword.type',
'@keywords': 'keyword',
'@supportConstants': 'keyword',
'@supportMacros': 'keyword',
'@constants': 'keyword',
'@default': 'identifier',
}
}
],
// Designator
[/\$/, 'identifier'],
// Lifetime annotations
[/'[a-zA-Z_][a-zA-Z0-9_]*(?=[^\'])/, 'identifier'],
// Byte literal
[/'\S'/, 'string.byteliteral'],
// Strings
[/"/, { token: 'string.quote', bracket: '@open', next: '@string' }],
{ include: '@numbers' },
// Whitespace + comments
{ include: '@whitespace' },
[/@delimiters/, {
cases: {
'@keywords': 'keyword',
'@default': 'delimiter'
}
}],
[/[{}()\[\]<>]/, '@brackets'],
[/@symbols/, { cases: { '@operators': 'operator', '@default': '' } }],
],
whitespace: [
[/[ \t\r\n]+/, 'white'],
[/\/\*/, 'comment', '@comment'],
[/\/\/.*$/, 'comment'],
],
comment: [
[/[^\/*]+/, 'comment'],
[/\/\*/, 'comment', '@push'],
["\\*/", 'comment', '@pop'],
[/[\/*]/, 'comment']
],
string: [
[/[^\\"]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/"/, { token: 'string.quote', bracket: '@close', next: '@pop' }]
],
numbers: [
//Octal
[/(0o[0-7_]+)(@intSuffixes)?/, { token: 'number' }],
//Binary
[/(0b[0-1_]+)(@intSuffixes)?/, { token: 'number' }],
//Exponent
[/[\d][\d_]*(\.[\d][\d_]*)?[eE][+-][\d_]+(@floatSuffixes)?/, { token: 'number' }],
//Float
[/\b(\d\.?[\d_]*)(@floatSuffixes)?\b/, { token: 'number' }],
//Hexadecimal
[/(0x[\da-fA-F]+)_?(@intSuffixes)?/, { token: 'number' }],
//Integer
[/[\d][\d_]*(@intSuffixes?)?/, { token: 'number' }],
]
}
};
/***/ })
}]);

116
71.bb4f487c.async.js Normal file
View File

@ -0,0 +1,116 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[71],{
/***/ "ynbn":
/*!********************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/sb/sb.js ***!
\********************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/sb/sb.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '\'',
},
brackets: [
['(', ')'], ['[', ']'],
['If', 'EndIf'],
['While', 'EndWhile'],
['For', 'EndFor'],
['Sub', 'EndSub']
],
autoClosingPairs: [
{ open: '"', close: '"', notIn: ['string', 'comment'] },
{ open: '(', close: ')', notIn: ['string', 'comment'] },
{ open: '[', close: ']', notIn: ['string', 'comment'] },
]
};
var language = {
defaultToken: '',
tokenPostfix: '.sb',
ignoreCase: true,
brackets: [
{ token: 'delimiter.array', open: '[', close: ']' },
{ token: 'delimiter.parenthesis', open: '(', close: ')' },
// Special bracket statement pairs
{ token: 'keyword.tag-if', open: 'If', close: 'EndIf' },
{ token: 'keyword.tag-while', open: 'While', close: 'EndWhile' },
{ token: 'keyword.tag-for', open: 'For', close: 'EndFor' },
{ token: 'keyword.tag-sub', open: 'Sub', close: 'EndSub' },
],
keywords: [
'Else', 'ElseIf', 'EndFor', 'EndIf', 'EndSub', 'EndWhile',
'For', 'Goto', 'If', 'Step', 'Sub', 'Then', 'To', 'While'
],
tagwords: [
'If', 'Sub', 'While', 'For'
],
operators: ['>', '<', '<>', '<=', '>=', 'And', 'Or', '+', '-', '*', '/', '='],
// we include these common regular expressions
identifier: /[a-zA-Z_][\w]*/,
symbols: /[=><:+\-*\/%\.,]+/,
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
// The main tokenizer for our languages
tokenizer: {
root: [
// whitespace
{ include: '@whitespace' },
// classes
[/(@identifier)(?=[.])/, 'type'],
// identifiers, tagwords, and keywords
[/@identifier/, {
cases: {
'@keywords': { token: 'keyword.$0' },
'@operators': 'operator',
'@default': 'variable.name'
}
}],
// methods, properties, and events
[/([.])(@identifier)/, {
cases: {
'$2': ['delimiter', 'type.member'],
'@default': ''
}
}],
// numbers
[/\d*\.\d+/, 'number.float'],
[/\d+/, 'number'],
// delimiters and operators
[/[()\[\]]/, '@brackets'],
[/@symbols/, {
cases: {
'@operators': 'operator',
'@default': 'delimiter'
}
}],
// strings
[/"([^"\\]|\\.)*$/, 'string.invalid'],
[/"/, 'string', '@string'],
],
whitespace: [
[/[ \t\r\n]+/, ''],
[/(\').*$/, 'comment']
],
string: [
[/[^\\"]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/"C?/, 'string', '@pop']
],
},
};
/***/ })
}]);

126
72.811fa516.async.js Normal file
View File

@ -0,0 +1,126 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[72],{
/***/ "fB/Z":
/*!****************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/scheme/scheme.js ***!
\****************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/scheme/scheme.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: ';',
blockComment: ['#|', '|#'],
},
brackets: [['(', ')'], ['{', '}'], ['[', ']']],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
],
};
var language = {
defaultToken: '',
ignoreCase: true,
tokenPostfix: '.scheme',
brackets: [
{ open: '(', close: ')', token: 'delimiter.parenthesis' },
{ open: '{', close: '}', token: 'delimiter.curly' },
{ open: '[', close: ']', token: 'delimiter.square' },
],
keywords: [
'case',
'do',
'let',
'loop',
'if',
'else',
'when',
'cons',
'car',
'cdr',
'cond',
'lambda',
'lambda*',
'syntax-rules',
'format',
'set!',
'quote',
'eval',
'append',
'list',
'list?',
'member?',
'load',
],
constants: ['#t', '#f'],
operators: ['eq?', 'eqv?', 'equal?', 'and', 'or', 'not', 'null?'],
tokenizer: {
root: [
[/#[xXoObB][0-9a-fA-F]+/, 'number.hex'],
[/[+-]?\d+(?:(?:\.\d*)?(?:[eE][+-]?\d+)?)?/, 'number.float'],
[
/(?:\b(?:(define|define-syntax|define-macro))\b)(\s+)((?:\w|\-|\!|\?)*)/,
['keyword', 'white', 'variable'],
],
{ include: '@whitespace' },
{ include: '@strings' },
[
/[a-zA-Z_#][a-zA-Z0-9_\-\?\!\*]*/,
{
cases: {
'@keywords': 'keyword',
'@constants': 'constant',
'@operators': 'operators',
'@default': 'identifier',
},
},
],
],
comment: [
[/[^\|#]+/, 'comment'],
[/#\|/, 'comment', '@push'],
[/\|#/, 'comment', '@pop'],
[/[\|#]/, 'comment'],
],
whitespace: [
[/[ \t\r\n]+/, 'white'],
[/#\|/, 'comment', '@comment'],
[/;.*$/, 'comment'],
],
strings: [
[/"$/, 'string', '@popall'],
[/"(?=.)/, 'string', '@multiLineString'],
],
multiLineString: [
[/[^\\"]+$/, 'string', '@popall'],
[/[^\\"]+/, 'string'],
[/\\./, 'string.escape'],
[/"/, 'string', '@popall'],
[/\\$/, 'string']
],
},
};
/***/ })
}]);

263
73.51a0cc5a.async.js Normal file
View File

@ -0,0 +1,263 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[73],{
/***/ "QJnQ":
/*!************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/scss/scss.js ***!
\************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/scss/scss.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
wordPattern: /(#?-?\d*\.\d\w*%?)|([@$#!.:]?[\w-?]+%?)|[@#!.]/g,
comments: {
blockComment: ['/*', '*/'],
lineComment: '//'
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}', notIn: ['string', 'comment'] },
{ open: '[', close: ']', notIn: ['string', 'comment'] },
{ open: '(', close: ')', notIn: ['string', 'comment'] },
{ open: '"', close: '"', notIn: ['string', 'comment'] },
{ open: '\'', close: '\'', notIn: ['string', 'comment'] },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
folding: {
markers: {
start: new RegExp("^\\s*\\/\\*\\s*#region\\b\\s*(.*?)\\s*\\*\\/"),
end: new RegExp("^\\s*\\/\\*\\s*#endregion\\b.*\\*\\/")
}
}
};
var language = {
defaultToken: '',
tokenPostfix: '.scss',
ws: '[ \t\n\r\f]*',
identifier: '-?-?([a-zA-Z]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*',
brackets: [
{ open: '{', close: '}', token: 'delimiter.curly' },
{ open: '[', close: ']', token: 'delimiter.bracket' },
{ open: '(', close: ')', token: 'delimiter.parenthesis' },
{ open: '<', close: '>', token: 'delimiter.angle' }
],
tokenizer: {
root: [
{ include: '@selector' },
],
selector: [
{ include: '@comments' },
{ include: '@import' },
{ include: '@variabledeclaration' },
{ include: '@warndebug' },
['[@](include)', { token: 'keyword', next: '@includedeclaration' }],
['[@](keyframes|-webkit-keyframes|-moz-keyframes|-o-keyframes)', { token: 'keyword', next: '@keyframedeclaration' }],
['[@](page|content|font-face|-moz-document)', { token: 'keyword' }],
['[@](charset|namespace)', { token: 'keyword', next: '@declarationbody' }],
['[@](function)', { token: 'keyword', next: '@functiondeclaration' }],
['[@](mixin)', { token: 'keyword', next: '@mixindeclaration' }],
['url(\\-prefix)?\\(', { token: 'meta', next: '@urldeclaration' }],
{ include: '@controlstatement' },
{ include: '@selectorname' },
['[&\\*]', 'tag'],
['[>\\+,]', 'delimiter'],
['\\[', { token: 'delimiter.bracket', next: '@selectorattribute' }],
['{', { token: 'delimiter.curly', next: '@selectorbody' }],
],
selectorbody: [
['[*_]?@identifier@ws:(?=(\\s|\\d|[^{;}]*[;}]))', 'attribute.name', '@rulevalue'],
{ include: '@selector' },
['[@](extend)', { token: 'keyword', next: '@extendbody' }],
['[@](return)', { token: 'keyword', next: '@declarationbody' }],
['}', { token: 'delimiter.curly', next: '@pop' }],
],
selectorname: [
['#{', { token: 'meta', next: '@variableinterpolation' }],
['(\\.|#(?=[^{])|%|(@identifier)|:)+', 'tag'],
],
selectorattribute: [
{ include: '@term' },
[']', { token: 'delimiter.bracket', next: '@pop' }],
],
term: [
{ include: '@comments' },
['url(\\-prefix)?\\(', { token: 'meta', next: '@urldeclaration' }],
{ include: '@functioninvocation' },
{ include: '@numbers' },
{ include: '@strings' },
{ include: '@variablereference' },
['(and\\b|or\\b|not\\b)', 'operator'],
{ include: '@name' },
['([<>=\\+\\-\\*\\/\\^\\|\\~,])', 'operator'],
[',', 'delimiter'],
['!default', 'literal'],
['\\(', { token: 'delimiter.parenthesis', next: '@parenthizedterm' }],
],
rulevalue: [
{ include: '@term' },
['!important', 'literal'],
[';', 'delimiter', '@pop'],
['{', { token: 'delimiter.curly', switchTo: '@nestedproperty' }],
['(?=})', { token: '', next: '@pop' }],
],
nestedproperty: [
['[*_]?@identifier@ws:', 'attribute.name', '@rulevalue'],
{ include: '@comments' },
['}', { token: 'delimiter.curly', next: '@pop' }],
],
warndebug: [
['[@](warn|debug)', { token: 'keyword', next: '@declarationbody' }],
],
import: [
['[@](import)', { token: 'keyword', next: '@declarationbody' }],
],
variabledeclaration: [
['\\$@identifier@ws:', 'variable.decl', '@declarationbody'],
],
urldeclaration: [
{ include: '@strings' },
['[^)\r\n]+', 'string'],
['\\)', { token: 'meta', next: '@pop' }],
],
parenthizedterm: [
{ include: '@term' },
['\\)', { token: 'delimiter.parenthesis', next: '@pop' }],
],
declarationbody: [
{ include: '@term' },
[';', 'delimiter', '@pop'],
['(?=})', { token: '', next: '@pop' }],
],
extendbody: [
{ include: '@selectorname' },
['!optional', 'literal'],
[';', 'delimiter', '@pop'],
['(?=})', { token: '', next: '@pop' }],
],
variablereference: [
['\\$@identifier', 'variable.ref'],
['\\.\\.\\.', 'operator'],
['#{', { token: 'meta', next: '@variableinterpolation' }],
],
variableinterpolation: [
{ include: '@variablereference' },
['}', { token: 'meta', next: '@pop' }],
],
comments: [
['\\/\\*', 'comment', '@comment'],
['\\/\\/+.*', 'comment'],
],
comment: [
['\\*\\/', 'comment', '@pop'],
['.', 'comment'],
],
name: [
['@identifier', 'attribute.value'],
],
numbers: [
['(\\d*\\.)?\\d+([eE][\\-+]?\\d+)?', { token: 'number', next: '@units' }],
['#[0-9a-fA-F_]+(?!\\w)', 'number.hex'],
],
units: [
['(em|ex|ch|rem|vmin|vmax|vw|vh|vm|cm|mm|in|px|pt|pc|deg|grad|rad|turn|s|ms|Hz|kHz|%)?', 'number', '@pop']
],
functiondeclaration: [
['@identifier@ws\\(', { token: 'meta', next: '@parameterdeclaration' }],
['{', { token: 'delimiter.curly', switchTo: '@functionbody' }],
],
mixindeclaration: [
// mixin with parameters
['@identifier@ws\\(', { token: 'meta', next: '@parameterdeclaration' }],
// mixin without parameters
['@identifier', 'meta'],
['{', { token: 'delimiter.curly', switchTo: '@selectorbody' }],
],
parameterdeclaration: [
['\\$@identifier@ws:', 'variable.decl'],
['\\.\\.\\.', 'operator'],
[',', 'delimiter'],
{ include: '@term' },
['\\)', { token: 'meta', next: '@pop' }],
],
includedeclaration: [
{ include: '@functioninvocation' },
['@identifier', 'meta'],
[';', 'delimiter', '@pop'],
['(?=})', { token: '', next: '@pop' }],
['{', { token: 'delimiter.curly', switchTo: '@selectorbody' }],
],
keyframedeclaration: [
['@identifier', 'meta'],
['{', { token: 'delimiter.curly', switchTo: '@keyframebody' }],
],
keyframebody: [
{ include: '@term' },
['{', { token: 'delimiter.curly', next: '@selectorbody' }],
['}', { token: 'delimiter.curly', next: '@pop' }],
],
controlstatement: [
['[@](if|else|for|while|each|media)', { token: 'keyword.flow', next: '@controlstatementdeclaration' }],
],
controlstatementdeclaration: [
['(in|from|through|if|to)\\b', { token: 'keyword.flow' }],
{ include: '@term' },
['{', { token: 'delimiter.curly', switchTo: '@selectorbody' }],
],
functionbody: [
['[@](return)', { token: 'keyword' }],
{ include: '@variabledeclaration' },
{ include: '@term' },
{ include: '@controlstatement' },
[';', 'delimiter'],
['}', { token: 'delimiter.curly', next: '@pop' }],
],
functioninvocation: [
['@identifier\\(', { token: 'meta', next: '@functionarguments' }],
],
functionarguments: [
['\\$@identifier@ws:', 'attribute.name'],
['[,]', 'delimiter'],
{ include: '@term' },
['\\)', { token: 'meta', next: '@pop' }],
],
strings: [
['~?"', { token: 'string.delimiter', next: '@stringenddoublequote' }],
['~?\'', { token: 'string.delimiter', next: '@stringendquote' }]
],
stringenddoublequote: [
['\\\\.', 'string'],
['"', { token: 'string.delimiter', next: '@pop' }],
['.', 'string']
],
stringendquote: [
['\\\\.', 'string'],
['\'', { token: 'string.delimiter', next: '@pop' }],
['.', 'string']
]
}
};
/***/ })
}]);

227
74.30bf2410.async.js Normal file
View File

@ -0,0 +1,227 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[74],{
/***/ "l/4i":
/*!**************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/shell/shell.js ***!
\**************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/shell/shell.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '#',
},
brackets: [['{', '}'], ['[', ']'], ['(', ')']],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: "'", close: "'" },
{ open: '`', close: '`' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: "'", close: "'" },
{ open: '`', close: '`' },
],
};
var language = {
defaultToken: '',
ignoreCase: true,
tokenPostfix: '.shell',
brackets: [
{ token: 'delimiter.bracket', open: '{', close: '}' },
{ token: 'delimiter.parenthesis', open: '(', close: ')' },
{ token: 'delimiter.square', open: '[', close: ']' },
],
keywords: [
'if',
'then',
'do',
'else',
'elif',
'while',
'until',
'for',
'in',
'esac',
'fi',
'fin',
'fil',
'done',
'exit',
'set',
'unset',
'export',
'function',
],
builtins: [
'ab',
'awk',
'bash',
'beep',
'cat',
'cc',
'cd',
'chown',
'chmod',
'chroot',
'clear',
'cp',
'curl',
'cut',
'diff',
'echo',
'find',
'gawk',
'gcc',
'get',
'git',
'grep',
'hg',
'kill',
'killall',
'ln',
'ls',
'make',
'mkdir',
'openssl',
'mv',
'nc',
'node',
'npm',
'ping',
'ps',
'restart',
'rm',
'rmdir',
'sed',
'service',
'sh',
'shopt',
'shred',
'source',
'sort',
'sleep',
'ssh',
'start',
'stop',
'su',
'sudo',
'svn',
'tee',
'telnet',
'top',
'touch',
'vi',
'vim',
'wall',
'wc',
'wget',
'who',
'write',
'yes',
'zsh',
],
// we include these common regular expressions
symbols: /[=><!~?&|+\-*\/\^;\.,]+/,
// The main tokenizer for our languages
tokenizer: {
root: [
{ include: '@whitespace' },
[
/[a-zA-Z]\w*/,
{
cases: {
'@keywords': 'keyword',
'@builtins': 'type.identifier',
'@default': ''
},
},
],
{ include: '@strings' },
{ include: '@parameters' },
{ include: '@heredoc' },
[/[{}\[\]()]/, '@brackets'],
[/-+\w+/, 'attribute.name'],
[/@symbols/, 'delimiter'],
{ include: '@numbers' },
[/[,;]/, 'delimiter'],
],
whitespace: [
[/\s+/, 'white'],
[/(^#!.*$)/, 'metatag'],
[/(^#.*$)/, 'comment'],
],
numbers: [
[/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
[/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, 'number.hex'],
[/\d+/, 'number'],
],
// Recognize strings, including those broken across lines
strings: [
[/'/, 'string', '@stringBody'],
[/"/, 'string', '@dblStringBody']
],
stringBody: [
[/'/, 'string', '@popall'],
[/./, 'string'],
],
dblStringBody: [
[/"/, 'string', '@popall'],
[/./, 'string'],
],
heredoc: [
[/(<<[-<]?)(\s*)(['"`]?)([\w\-]+)(['"`]?)/, ['constants', 'white', 'string.heredoc.delimiter', 'string.heredoc', 'string.heredoc.delimiter']]
],
parameters: [
[/\$\d+/, 'variable.predefined'],
[/\$\w+/, 'variable'],
[/\$[*@#?\-$!0_]/, 'variable'],
[/\$'/, 'variable', '@parameterBodyQuote'],
[/\$"/, 'variable', '@parameterBodyDoubleQuote'],
[/\$\(/, 'variable', '@parameterBodyParen'],
[/\$\{/, 'variable', '@parameterBodyCurlyBrace'],
],
parameterBodyQuote: [
[/[^#:%*@\-!_']+/, 'variable'],
[/[#:%*@\-!_]/, 'delimiter'],
[/[']/, 'variable', '@pop'],
],
parameterBodyDoubleQuote: [
[/[^#:%*@\-!_"]+/, 'variable'],
[/[#:%*@\-!_]/, 'delimiter'],
[/["]/, 'variable', '@pop'],
],
parameterBodyParen: [
[/[^#:%*@\-!_)]+/, 'variable'],
[/[#:%*@\-!_]/, 'delimiter'],
[/[)]/, 'variable', '@pop'],
],
parameterBodyCurlyBrace: [
[/[^#:%*@\-!_}]+/, 'variable'],
[/[#:%*@\-!_]/, 'delimiter'],
[/[}]/, 'variable', '@pop'],
],
}
};
/***/ })
}]);

188
75.e6343d6c.async.js Normal file

File diff suppressed because one or more lines are too long

176
76.fb8c2f41.async.js Normal file
View File

@ -0,0 +1,176 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[76],{
/***/ "cOMg":
/*!****************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/sophia/sophia.js ***!
\****************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/sophia/sophia.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '//',
blockComment: ['/*', '*/'],
},
brackets: [['{', '}'], ['[', ']'], ['(', ')'], ['<', '>']],
autoClosingPairs: [
{ open: '"', close: '"', notIn: ['string', 'comment'] },
{ open: '{', close: '}', notIn: ['string', 'comment'] },
{ open: '[', close: ']', notIn: ['string', 'comment'] },
{ open: '(', close: ')', notIn: ['string', 'comment'] },
]
};
var language = {
defaultToken: '',
tokenPostfix: '.aes',
brackets: [
{ token: 'delimiter.curly', open: '{', close: '}' },
{ token: 'delimiter.parenthesis', open: '(', close: ')' },
{ token: 'delimiter.square', open: '[', close: ']' },
{ token: 'delimiter.angle', open: '<', close: '>' }
],
keywords: [
// Main keywords
'contract',
'library',
'entrypoint',
'function',
'stateful',
'state',
'hash',
'signature',
'tuple',
'list',
'address',
'string',
'bool',
'int',
'record',
'datatype',
'type',
'option',
'oracle',
'oracle_query',
'Call',
'Bits',
'Bytes',
'Oracle',
'String',
'Crypto',
'Address',
'Auth',
'Chain',
'None',
'Some',
'bits',
'bytes',
'event',
'let',
'map',
'private',
'public',
'true',
'false',
'var',
'if',
'else',
'throw'
],
operators: [
'=', '>', '<', '!', '~', '?', '::', ':',
'==', '<=', '>=', '!=', '&&', '||', '++', '--',
'+', '-', '*', '/', '&', '|', '^', '%', '<<',
'>>', '>>>', '+=', '-=', '*=', '/=', '&=', '|=',
'^=', '%=', '<<=', '>>=', '>>>='
],
// we include these common regular expressions
symbols: /[=><!~?:&|+\-*\/\^%]+/,
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
integersuffix: /(ll|LL|u|U|l|L)?(ll|LL|u|U|l|L)?/,
floatsuffix: /[fFlL]?/,
// The main tokenizer for our languages
tokenizer: {
root: [
// identifiers and keywords
[/[a-zA-Z_]\w*/, {
cases: {
'@keywords': { token: 'keyword.$0' },
'@default': 'identifier'
}
}],
// whitespace
{ include: '@whitespace' },
// [[ attributes ]].
[/\[\[.*\]\]/, 'annotation'],
// Preprocessor directive
[/^\s*#\w+/, 'keyword'],
//DataTypes
[/int\d*/, 'keyword'],
// delimiters and operators
[/[{}()\[\]]/, '@brackets'],
[/[<>](?!@symbols)/, '@brackets'],
[/@symbols/, {
cases: {
'@operators': 'delimiter',
'@default': ''
}
}],
// numbers
[/\d*\d+[eE]([\-+]?\d+)?(@floatsuffix)/, 'number.float'],
[/\d*\.\d+([eE][\-+]?\d+)?(@floatsuffix)/, 'number.float'],
[/0[xX][0-9a-fA-F']*[0-9a-fA-F](@integersuffix)/, 'number.hex'],
[/0[0-7']*[0-7](@integersuffix)/, 'number.octal'],
[/0[bB][0-1']*[0-1](@integersuffix)/, 'number.binary'],
[/\d[\d']*\d(@integersuffix)/, 'number'],
[/\d(@integersuffix)/, 'number'],
// delimiter: after number because of .\d floats
[/[;,.]/, 'delimiter'],
// strings
[/"([^"\\]|\\.)*$/, 'string.invalid'],
[/"/, 'string', '@string'],
// characters
[/'[^\\']'/, 'string'],
[/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
[/'/, 'string.invalid']
],
whitespace: [
[/[ \t\r\n]+/, ''],
[/\/\*\*(?!\/)/, 'comment.doc', '@doccomment'],
[/\/\*/, 'comment', '@comment'],
[/\/\/.*$/, 'comment'],
],
comment: [
[/[^\/*]+/, 'comment'],
[/\*\//, 'comment', '@pop'],
[/[\/*]/, 'comment']
],
//Identical copy of comment above, except for the addition of .doc
doccomment: [
[/[^\/*]+/, 'comment.doc'],
[/\*\//, 'comment.doc', '@pop'],
[/[\/*]/, 'comment.doc']
],
string: [
[/[^\\"]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/"/, 'string', '@pop']
],
},
};
/***/ })
}]);

1156
77.3c15cc88.async.js Normal file

File diff suppressed because it is too large Load Diff

257
78.da1449d6.async.js Normal file
View File

@ -0,0 +1,257 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[78],{
/***/ "rMIR":
/*!********************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/st/st.js ***!
\********************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/st/st.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '//',
blockComment: ['(*', '*)'],
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')'],
['var', 'end_var'],
['var_input', 'end_var'],
['var_output', 'end_var'],
['var_in_out', 'end_var'],
['var_temp', 'end_var'],
['var_global', 'end_var'],
['var_access', 'end_var'],
['var_external', 'end_var'],
['type', 'end_type'],
['struct', 'end_struct'],
['program', 'end_program'],
['function', 'end_function'],
['function_block', 'end_function_block'],
['action', 'end_action'],
['step', 'end_step'],
['initial_step', 'end_step'],
['transaction', 'end_transaction'],
['configuration', 'end_configuration'],
['tcp', 'end_tcp'],
['recource', 'end_recource'],
['channel', 'end_channel'],
['library', 'end_library'],
['folder', 'end_folder'],
['binaries', 'end_binaries'],
['includes', 'end_includes'],
['sources', 'end_sources']
],
autoClosingPairs: [
{ open: '[', close: ']' },
{ open: '{', close: '}' },
{ open: '(', close: ')' },
{ open: '/*', close: '*/' },
{ open: '\'', close: '\'', notIn: ['string_sq'] },
{ open: '"', close: '"', notIn: ['string_dq'] },
{ open: 'var_input', close: 'end_var' },
{ open: 'var_output', close: 'end_var' },
{ open: 'var_in_out', close: 'end_var' },
{ open: 'var_temp', close: 'end_var' },
{ open: 'var_global', close: 'end_var' },
{ open: 'var_access', close: 'end_var' },
{ open: 'var_external', close: 'end_var' },
{ open: 'type', close: 'end_type' },
{ open: 'struct', close: 'end_struct' },
{ open: 'program', close: 'end_program' },
{ open: 'function', close: 'end_function' },
{ open: 'function_block', close: 'end_function_block' },
{ open: 'action', close: 'end_action' },
{ open: 'step', close: 'end_step' },
{ open: 'initial_step', close: 'end_step' },
{ open: 'transaction', close: 'end_transaction' },
{ open: 'configuration', close: 'end_configuration' },
{ open: 'tcp', close: 'end_tcp' },
{ open: 'recource', close: 'end_recource' },
{ open: 'channel', close: 'end_channel' },
{ open: 'library', close: 'end_library' },
{ open: 'folder', close: 'end_folder' },
{ open: 'binaries', close: 'end_binaries' },
{ open: 'includes', close: 'end_includes' },
{ open: 'sources', close: 'end_sources' }
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
{ open: 'var', close: 'end_var' },
{ open: 'var_input', close: 'end_var' },
{ open: 'var_output', close: 'end_var' },
{ open: 'var_in_out', close: 'end_var' },
{ open: 'var_temp', close: 'end_var' },
{ open: 'var_global', close: 'end_var' },
{ open: 'var_access', close: 'end_var' },
{ open: 'var_external', close: 'end_var' },
{ open: 'type', close: 'end_type' },
{ open: 'struct', close: 'end_struct' },
{ open: 'program', close: 'end_program' },
{ open: 'function', close: 'end_function' },
{ open: 'function_block', close: 'end_function_block' },
{ open: 'action', close: 'end_action' },
{ open: 'step', close: 'end_step' },
{ open: 'initial_step', close: 'end_step' },
{ open: 'transaction', close: 'end_transaction' },
{ open: 'configuration', close: 'end_configuration' },
{ open: 'tcp', close: 'end_tcp' },
{ open: 'recource', close: 'end_recource' },
{ open: 'channel', close: 'end_channel' },
{ open: 'library', close: 'end_library' },
{ open: 'folder', close: 'end_folder' },
{ open: 'binaries', close: 'end_binaries' },
{ open: 'includes', close: 'end_includes' },
{ open: 'sources', close: 'end_sources' }
],
folding: {
markers: {
start: new RegExp("^\\s*#pragma\\s+region\\b"),
end: new RegExp("^\\s*#pragma\\s+endregion\\b")
}
}
};
var language = {
defaultToken: '',
tokenPostfix: '.st',
ignoreCase: true,
brackets: [
{ token: 'delimiter.curly', open: '{', close: '}' },
{ token: 'delimiter.parenthesis', open: '(', close: ')' },
{ token: 'delimiter.square', open: '[', close: ']' }
],
keywords: ['if', 'end_if', 'elsif', 'else', 'case', 'of', 'to', '__try', '__catch', '__finally',
'do', 'with', 'by', 'while', 'repeat', 'end_while', 'end_repeat', 'end_case',
'for', 'end_for', 'task', 'retain', 'non_retain', 'constant', 'with', 'at',
'exit', 'return', 'interval', 'priority', 'address', 'port', 'on_channel',
'then', 'iec', 'file', 'uses', 'version', 'packagetype', 'displayname',
'copyright', 'summary', 'vendor', 'common_source', 'from', 'extends'],
constant: ['false', 'true', 'null'],
defineKeywords: [
'var', 'var_input', 'var_output', 'var_in_out', 'var_temp', 'var_global',
'var_access', 'var_external', 'end_var',
'type', 'end_type', 'struct', 'end_struct', 'program', 'end_program',
'function', 'end_function', 'function_block', 'end_function_block',
'interface', 'end_interface', 'method', 'end_method',
'property', 'end_property', 'namespace', 'end_namespace',
'configuration', 'end_configuration', 'tcp', 'end_tcp', 'resource',
'end_resource', 'channel', 'end_channel', 'library', 'end_library',
'folder', 'end_folder', 'binaries', 'end_binaries', 'includes',
'end_includes', 'sources', 'end_sources',
'action', 'end_action', 'step', 'initial_step', 'end_step', 'transaction', 'end_transaction'
],
typeKeywords: ['int', 'sint', 'dint', 'lint', 'usint', 'uint', 'udint', 'ulint',
'real', 'lreal', 'time', 'date', 'time_of_day', 'date_and_time', 'string',
'bool', 'byte', 'word', 'dword', 'array', 'pointer', 'lword'],
operators: ['=', '>', '<', ':', ':=', '<=', '>=', '<>', '&', '+', '-', '*', '**',
'MOD', '^', 'or', 'and', 'not', 'xor', 'abs', 'acos', 'asin', 'atan', 'cos',
'exp', 'expt', 'ln', 'log', 'sin', 'sqrt', 'tan', 'sel', 'max', 'min', 'limit',
'mux', 'shl', 'shr', 'rol', 'ror', 'indexof', 'sizeof', 'adr', 'adrinst',
'bitadr', 'is_valid', 'ref', 'ref_to'],
builtinVariables: [],
builtinFunctions: ['sr', 'rs', 'tp', 'ton', 'tof', 'eq', 'ge', 'le', 'lt',
'ne', 'round', 'trunc', 'ctd', 'сtu', 'ctud', 'r_trig', 'f_trig',
'move', 'concat', 'delete', 'find', 'insert', 'left', 'len', 'replace',
'right', 'rtc'],
// we include these common regular expressions
symbols: /[=><!~?:&|+\-*\/\^%]+/,
// C# style strings
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
// The main tokenizer for our languages
tokenizer: {
root: [
[/(\.\.)/, 'delimiter'],
[/\b(16#[0-9A-Fa-f\_]*)+\b/, 'number.hex'],
[/\b(2#[01\_]+)+\b/, 'number.binary'],
[/\b(8#[0-9\_]*)+\b/, 'number.octal'],
[/\b\d*\.\d+([eE][\-+]?\d+)?\b/, 'number.float'],
[/\b(L?REAL)#[0-9\_\.e]+\b/, 'number.float'],
[/\b(BYTE|(?:D|L)?WORD|U?(?:S|D|L)?INT)#[0-9\_]+\b/, 'number'],
[/\d+/, 'number'],
[/\b(T|DT|TOD)#[0-9:-_shmyd]+\b/, 'tag'],
[/\%(I|Q|M)(X|B|W|D|L)[0-9\.]+/, 'tag'],
[/\%(I|Q|M)[0-9\.]*/, 'tag'],
[/\b[A-Za-z]{1,6}#[0-9]+\b/, 'tag'],
[/\b(TO_|CTU_|CTD_|CTUD_|MUX_|SEL_)[A_Za-z]+\b/, 'predefined'],
[/\b[A_Za-z]+(_TO_)[A_Za-z]+\b/, 'predefined'],
[/[;]/, 'delimiter'],
[/[.]/, { token: 'delimiter', next: '@params' }],
// identifiers and keywords
[/[a-zA-Z_]\w*/, {
cases: {
'@operators': 'operators',
'@keywords': 'keyword',
'@typeKeywords': 'type',
'@defineKeywords': 'variable',
'@constant': 'constant',
'@builtinVariables': 'predefined',
'@builtinFunctions': 'predefined',
'@default': 'identifier'
}
}],
{ include: '@whitespace' },
[/[{}()\[\]]/, '@brackets'],
[/"([^"\\]|\\.)*$/, 'string.invalid'],
[/"/, { token: 'string.quote', bracket: '@open', next: '@string_dq' }],
[/'/, { token: 'string.quote', bracket: '@open', next: '@string_sq' }],
[/'[^\\']'/, 'string'],
[/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
[/'/, 'string.invalid']
],
params: [
[/\b[A-Za-z0-9_]+\b(?=\()/, { token: 'identifier', next: '@pop' }],
[/\b[A-Za-z0-9_]+\b/, 'variable.name', '@pop']
],
comment: [
[/[^\/*]+/, 'comment'],
[/\/\*/, 'comment', '@push'],
["\\*/", 'comment', '@pop'],
[/[\/*]/, 'comment']
],
comment2: [
[/[^\(*]+/, 'comment'],
[/\(\*/, 'comment', '@push'],
["\\*\\)", 'comment', '@pop'],
[/[\(*]/, 'comment']
],
whitespace: [
[/[ \t\r\n]+/, 'white'],
[/\/\/.*$/, 'comment'],
[/\/\*/, 'comment', '@comment'],
[/\(\*/, 'comment', '@comment2'],
],
string_dq: [
[/[^\\"]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/"/, { token: 'string.quote', bracket: '@close', next: '@pop' }]
],
string_sq: [
[/[^\\']+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/'/, { token: 'string.quote', bracket: '@close', next: '@pop' }]
]
}
};
/***/ })
}]);

179
79.889f6e69.async.js Normal file
View File

@ -0,0 +1,179 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[79],{
/***/ "05+/":
/*!**************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/swift/swift.js ***!
\**************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/swift/swift.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*!---------------------------------------------------------------------------------------------
* Copyright (C) David Owens II, owensd.io. All rights reserved.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '//',
blockComment: ['/*', '*/'],
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
{ open: '`', close: '`' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
{ open: '`', close: '`' },
]
};
var language = {
defaultToken: '',
tokenPostfix: '.swift',
// TODO(owensd): Support the full range of unicode valid identifiers.
identifier: /[a-zA-Z_][\w$]*/,
// TODO(owensd): Support the @availability macro properly.
attributes: [
'@autoclosure', '@noescape', '@noreturn', '@NSApplicationMain', '@NSCopying', '@NSManaged',
'@objc', '@UIApplicationMain', '@noreturn', '@availability', '@IBAction', '@IBDesignable', '@IBInspectable', '@IBOutlet'
],
accessmodifiers: ['public', 'private', 'internal'],
keywords: [
'__COLUMN__', '__FILE__', '__FUNCTION__', '__LINE__', 'as', 'as!', 'as?', 'associativity', 'break', 'case', 'catch',
'class', 'continue', 'convenience', 'default', 'deinit', 'didSet', 'do', 'dynamic', 'dynamicType',
'else', 'enum', 'extension', 'fallthrough', 'final', 'for', 'func', 'get', 'guard', 'if', 'import', 'in', 'infix',
'init', 'inout', 'internal', 'is', 'lazy', 'left', 'let', 'mutating', 'nil', 'none', 'nonmutating', 'operator',
'optional', 'override', 'postfix', 'precedence', 'prefix', 'private', 'protocol', 'Protocol', 'public',
'repeat', 'required', 'return', 'right', 'self', 'Self', 'set', 'static', 'struct', 'subscript', 'super', 'switch',
'throw', 'throws', 'try', 'try!', 'Type', 'typealias', 'unowned', 'var', 'weak', 'where', 'while', 'willSet', 'FALSE', 'TRUE'
],
symbols: /[=(){}\[\].,:;@#\_&\-<>`?!+*\\\/]/,
// Moved . to operatorstart so it can be a delimiter
operatorstart: /[\/=\-+!*%<>&|^~?\u00A1-\u00A7\u00A9\u00AB\u00AC\u00AE\u00B0-\u00B1\u00B6\u00BB\u00BF\u00D7\u00F7\u2016-\u2017\u2020-\u2027\u2030-\u203E\u2041-\u2053\u2055-\u205E\u2190-\u23FF\u2500-\u2775\u2794-\u2BFF\u2E00-\u2E7F\u3001-\u3003\u3008-\u3030]/,
operatorend: /[\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE00-\uFE0F\uFE20-\uFE2F\uE0100-\uE01EF]/,
operators: /(@operatorstart)((@operatorstart)|(@operatorend))*/,
// TODO(owensd): These are borrowed from C#; need to validate correctness for Swift.
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
tokenizer: {
root: [
{ include: '@whitespace' },
{ include: '@comment' },
{ include: '@attribute' },
{ include: '@literal' },
{ include: '@keyword' },
{ include: '@invokedmethod' },
{ include: '@symbol' },
],
whitespace: [
[/\s+/, 'white'],
[/"""/, 'string.quote', '@endDblDocString']
],
endDblDocString: [
[/[^"]+/, 'string'],
[/\\"/, 'string'],
[/"""/, 'string.quote', '@popall'],
[/"/, 'string']
],
symbol: [
[/[{}()\[\]]/, '@brackets'],
[/[<>](?!@symbols)/, '@brackets'],
[/[.]/, 'delimiter'],
[/@operators/, 'operator'],
[/@symbols/, 'operator']
],
comment: [
[/\/\/\/.*$/, 'comment.doc'],
[/\/\*\*/, 'comment.doc', '@commentdocbody'],
[/\/\/.*$/, 'comment'],
[/\/\*/, 'comment', '@commentbody']
],
commentdocbody: [
[/\/\*/, 'comment', '@commentbody'],
[/\*\//, 'comment.doc', '@pop'],
[/\:[a-zA-Z]+\:/, 'comment.doc.param'],
[/./, 'comment.doc']
],
commentbody: [
[/\/\*/, 'comment', '@commentbody'],
[/\*\//, 'comment', '@pop'],
[/./, 'comment']
],
attribute: [
[/\@@identifier/, {
cases: {
'@attributes': 'keyword.control',
'@default': ''
}
}]
],
literal: [
[/"/, { token: 'string.quote', next: '@stringlit' }],
[/0[b]([01]_?)+/, 'number.binary'],
[/0[o]([0-7]_?)+/, 'number.octal'],
[/0[x]([0-9a-fA-F]_?)+([pP][\-+](\d_?)+)?/, 'number.hex'],
[/(\d_?)*\.(\d_?)+([eE][\-+]?(\d_?)+)?/, 'number.float'],
[/(\d_?)+/, 'number']
],
stringlit: [
[/\\\(/, { token: 'operator', next: '@interpolatedexpression' }],
[/@escapes/, 'string'],
[/\\./, 'string.escape.invalid'],
[/"/, { token: 'string.quote', next: '@pop' }],
[/./, 'string']
],
interpolatedexpression: [
[/\(/, { token: 'operator', next: '@interpolatedexpression' }],
[/\)/, { token: 'operator', next: '@pop' }],
{ include: '@literal' },
{ include: '@keyword' },
{ include: '@symbol' }
],
keyword: [
[/`/, { token: 'operator', next: '@escapedkeyword' }],
[/@identifier/, {
cases: {
'@keywords': 'keyword', '[A-Z][\a-zA-Z0-9$]*': 'type.identifier',
'@default': 'identifier'
}
}]
],
escapedkeyword: [
[/`/, { token: 'operator', next: '@pop' }],
[/./, 'identifier']
],
// symbol: [
// [ /@symbols/, 'operator' ],
// [ /@operators/, 'operator' ]
// ],
invokedmethod: [
[/([.])(@identifier)/, {
cases: {
'$2': ['delimeter', 'type.identifier'],
'@default': ''
}
}],
]
}
};
/***/ })
}]);

151
80.f8dfbb68.async.js Normal file
View File

@ -0,0 +1,151 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[80],{
/***/ "xT+r":
/*!**********************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/tcl/tcl.js ***!
\**********************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/tcl/tcl.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
]
};
var language = {
tokenPostfix: '.tcl',
specialFunctions: [
'set', 'unset', 'rename', 'variable', 'proc', 'coroutine',
'foreach',
'incr', 'append',
'lappend', 'linsert', 'lreplace'
],
mainFunctions: [
'if', 'then', 'elseif', 'else', 'case', 'switch', 'while', 'for',
'break', 'continue', 'return',
'package', 'namespace',
'catch', 'exit',
'eval', 'expr', 'uplevel', 'upvar'
],
builtinFunctions: [
'file', 'info', 'concat', 'join', 'lindex',
'list', 'llength', 'lrange', 'lsearch', 'lsort', 'split',
'array', 'parray', 'binary', 'format', 'regexp', 'regsub', 'scan', 'string',
'subst', 'dict', 'cd', 'clock', 'exec', 'glob', 'pid', 'pwd', 'close', 'eof', 'fblocked',
'fconfigure', 'fcopy', 'fileevent', 'flush', 'gets', 'open', 'puts', 'read', 'seek',
'socket', 'tell', 'interp', 'after', 'auto_execok',
'auto_load', 'auto_mkindex', 'auto_reset', 'bgerror', 'error',
'global', 'history', 'load', 'source', 'time', 'trace',
'unknown', 'unset', 'update', 'vwait', 'winfo', 'wm', 'bind', 'event',
'pack', 'place', 'grid', 'font', 'bell', 'clipboard', 'destroy', 'focus', 'grab', 'lower',
'option', 'raise', 'selection', 'send', 'tk', 'tkwait', 'tk_bisque', 'tk_focusNext',
'tk_focusPrev', 'tk_focusFollowsMouse', 'tk_popup', 'tk_setPalette'
],
symbols: /[=><!~?:&|+\-*\/\^%]+/,
brackets: [
{ open: '(', close: ')', token: 'delimiter.parenthesis' },
{ open: '{', close: '}', token: 'delimiter.curly' },
{ open: '[', close: ']', token: 'delimiter.square' }
],
escapes: /\\(?:[abfnrtv\\"'\[\]\{\};\$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
variables: /(?:\$+(?:(?:\:\:?)?[a-zA-Z_]\w*)+)/,
tokenizer: {
root: [
// identifiers and keywords
[/[a-zA-Z_]\w*/, { cases: {
'@specialFunctions': { token: 'keyword.flow', next: '@specialFunc' },
'@mainFunctions': 'keyword',
'@builtinFunctions': 'variable',
'@default': 'operator.scss'
} }],
[/\s+\-+(?!\d|\.)\w*|{\*}/, 'metatag'],
// whitespace
{ include: '@whitespace' },
// delimiters and operators
[/[{}()\[\]]/, '@brackets'],
[/@symbols/, 'operator'],
[/\$+(?:\:\:)?\{/, { token: 'identifier', next: '@nestedVariable' }],
[/@variables/, 'type.identifier'],
[/\.(?!\d|\.)[\w\-]*/, 'operator.sql'],
// numbers
[/\d+(\.\d+)?/, 'number'],
[/\d+/, 'number'],
// delimiter
[/;/, 'delimiter'],
// strings
[/"/, { token: 'string.quote', bracket: '@open', next: '@dstring' }],
[/'/, { token: 'string.quote', bracket: '@open', next: '@sstring' }]
],
dstring: [
[/\[/, { token: '@brackets', next: '@nestedCall' }],
[/\$+(?:\:\:)?\{/, { token: 'identifier', next: '@nestedVariable' }],
[/@variables/, 'type.identifier'],
[/[^\\$\[\]"]+/, 'string'],
[/@escapes/, 'string.escape'],
[/"/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
],
sstring: [
[/\[/, { token: '@brackets', next: '@nestedCall' }],
[/\$+(?:\:\:)?\{/, { token: 'identifier', next: '@nestedVariable' }],
[/@variables/, 'type.identifier'],
[/[^\\$\[\]']+/, 'string'],
[/@escapes/, 'string.escape'],
[/'/, { token: 'string.quote', bracket: '@close', next: '@pop' }]
],
whitespace: [
[/[ \t\r\n]+/, 'white'],
[/#.*\\$/, { token: 'comment', next: '@newlineComment' }],
[/#.*(?!\\)$/, 'comment']
],
newlineComment: [
[/.*\\$/, 'comment'],
[/.*(?!\\)$/, { token: 'comment', next: '@pop' }]
],
nestedVariable: [
[/[^\{\}\$]+/, 'type.identifier'],
[/\}/, { token: 'identifier', next: '@pop' }]
],
nestedCall: [
[/\[/, { token: '@brackets', next: '@nestedCall' }],
[/\]/, { token: '@brackets', next: '@pop' }],
{ include: 'root' }
],
specialFunc: [
[/"/, { token: 'string', next: '@dstring' }],
[/'/, { token: 'string', next: '@sstring' }],
[/\S+/, { token: 'type', next: '@pop' }],
]
}
};
/***/ })
}]);

293
81.20860e11.async.js Normal file
View File

@ -0,0 +1,293 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[81],{
/***/ "nNVF":
/*!************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/twig/twig.js ***!
\************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/twig/twig.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\$\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\s]+)/g,
comments: {
blockComment: ['{#', '#}'],
},
brackets: [
['{#', '#}'],
['{%', '%}'],
['{{', '}}'],
['(', ')'],
['[', ']'],
// HTML
['<!--', '-->'],
['<', '>'],
],
autoClosingPairs: [
{ open: '{# ', close: ' #}' },
{ open: '{% ', close: ' %}' },
{ open: '{{ ', close: ' }}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
surroundingPairs: [
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
// HTML
{ open: '<', close: '>' },
],
};
var language = {
defaultToken: '',
tokenPostfix: '',
ignoreCase: true,
keywords: [
// (opening) tags
'apply', 'autoescape', 'block', 'deprecated', 'do', 'embed', 'extends',
'flush', 'for', 'from', 'if', 'import', 'include', 'macro', 'sandbox',
'set', 'use', 'verbatim', 'with',
// closing tags
'endapply', 'endautoescape', 'endblock', 'endembed', 'endfor', 'endif',
'endmacro', 'endsandbox', 'endset', 'endwith',
// literals
'true', 'false',
],
tokenizer: {
root: [
// whitespace
[/\s+/],
// Twig Tag Delimiters
[/{#/, 'comment.twig', '@commentState'],
[/{%[-~]?/, 'delimiter.twig', '@blockState'],
[/{{[-~]?/, 'delimiter.twig', '@variableState'],
// HTML
[/<!DOCTYPE/, 'metatag.html', '@doctype'],
[/<!--/, 'comment.html', '@comment'],
[/(<)((?:[\w\-]+:)?[\w\-]+)(\s*)(\/>)/, ['delimiter.html', 'tag.html', '', 'delimiter.html']],
[/(<)(script)/, ['delimiter.html', { token: 'tag.html', next: '@script' }]],
[/(<)(style)/, ['delimiter.html', { token: 'tag.html', next: '@style' }]],
[/(<)((?:[\w\-]+:)?[\w\-]+)/, ['delimiter.html', { token: 'tag.html', next: '@otherTag' }]],
[/(<\/)((?:[\w\-]+:)?[\w\-]+)/, ['delimiter.html', { token: 'tag.html', next: '@otherTag' }]],
[/</, 'delimiter.html'],
[/[^<]+/],
],
/**
* Comment Tag Handling
*/
commentState: [
[/#}/, 'comment.twig', '@pop'],
[/./, 'comment.twig'],
],
/**
* Block Tag Handling
*/
blockState: [
[/[-~]?%}/, 'delimiter.twig', '@pop'],
// whitespace
[/\s+/],
// verbatim
// Unlike other blocks, verbatim ehas its own state
// transition to ensure we mark its contents as strings.
[/(verbatim)(\s*)([-~]?%})/, [
'keyword.twig',
'',
{ token: 'delimiter.twig', next: '@rawDataState' },
]],
{ include: 'expression' }
],
rawDataState: [
// endverbatim
[/({%[-~]?)(\s*)(endverbatim)(\s*)([-~]?%})/, [
'delimiter.twig',
'',
'keyword.twig',
'',
{ token: 'delimiter.twig', next: '@popall' },
]],
[/./, 'string.twig'],
],
/**
* Variable Tag Handling
*/
variableState: [
[/[-~]?}}/, 'delimiter.twig', '@pop'],
{ include: 'expression' },
],
stringState: [
// closing double quoted string
[/"/, 'string.twig', '@pop'],
// interpolation start
[/#{\s*/, 'string.twig', '@interpolationState'],
// string part
[/[^#"\\]*(?:(?:\\.|#(?!\{))[^#"\\]*)*/, 'string.twig'],
],
interpolationState: [
// interpolation end
[/}/, 'string.twig', '@pop'],
{ include: 'expression' },
],
/**
* Expression Handling
*/
expression: [
// whitespace
[/\s+/],
// operators - math
[/\+|-|\/{1,2}|%|\*{1,2}/, 'operators.twig'],
// operators - logic
[/(and|or|not|b-and|b-xor|b-or)(\s+)/, ['operators.twig', '']],
// operators - comparison (symbols)
[/==|!=|<|>|>=|<=/, 'operators.twig'],
// operators - comparison (words)
[/(starts with|ends with|matches)(\s+)/, ['operators.twig', '']],
// operators - containment
[/(in)(\s+)/, ['operators.twig', '']],
// operators - test
[/(is)(\s+)/, ['operators.twig', '']],
// operators - misc
[/\||~|:|\.{1,2}|\?{1,2}/, 'operators.twig'],
// names
[/[^\W\d][\w]*/, {
cases: {
'@keywords': 'keyword.twig',
'@default': 'variable.twig'
}
}],
// numbers
[/\d+(\.\d+)?/, 'number.twig'],
// punctuation
[/\(|\)|\[|\]|{|}|,/, 'delimiter.twig'],
// strings
[/"([^#"\\]*(?:\\.[^#"\\]*)*)"|\'([^\'\\]*(?:\\.[^\'\\]*)*)\'/, 'string.twig'],
// opening double quoted string
[/"/, 'string.twig', '@stringState'],
// misc syntactic constructs
// These are not operators per se, but for the purposes of lexical analysis we
// can treat them as such.
// arrow functions
[/=>/, 'operators.twig'],
// assignment
[/=/, 'operators.twig'],
],
/**
* HTML
*/
doctype: [
[/[^>]+/, 'metatag.content.html'],
[/>/, 'metatag.html', '@pop'],
],
comment: [
[/-->/, 'comment.html', '@pop'],
[/[^-]+/, 'comment.content.html'],
[/./, 'comment.content.html']
],
otherTag: [
[/\/?>/, 'delimiter.html', '@pop'],
[/"([^"]*)"/, 'attribute.value.html'],
[/'([^']*)'/, 'attribute.value.html'],
[/[\w\-]+/, 'attribute.name.html'],
[/=/, 'delimiter.html'],
[/[ \t\r\n]+/],
],
// -- BEGIN <script> tags handling
// After <script
script: [
[/type/, 'attribute.name.html', '@scriptAfterType'],
[/"([^"]*)"/, 'attribute.value.html'],
[/'([^']*)'/, 'attribute.value.html'],
[/[\w\-]+/, 'attribute.name.html'],
[/=/, 'delimiter.html'],
[/>/, { token: 'delimiter.html', next: '@scriptEmbedded', nextEmbedded: 'text/javascript' }],
[/[ \t\r\n]+/],
[/(<\/)(script\s*)(>)/, ['delimiter.html', 'tag.html', { token: 'delimiter.html', next: '@pop' }]]
],
// After <script ... type
scriptAfterType: [
[/=/, 'delimiter.html', '@scriptAfterTypeEquals'],
[/>/, { token: 'delimiter.html', next: '@scriptEmbedded', nextEmbedded: 'text/javascript' }],
[/[ \t\r\n]+/],
[/<\/script\s*>/, { token: '@rematch', next: '@pop' }]
],
// After <script ... type =
scriptAfterTypeEquals: [
[/"([^"]*)"/, { token: 'attribute.value.html', switchTo: '@scriptWithCustomType.$1' }],
[/'([^']*)'/, { token: 'attribute.value.html', switchTo: '@scriptWithCustomType.$1' }],
[/>/, { token: 'delimiter.html', next: '@scriptEmbedded', nextEmbedded: 'text/javascript' }],
[/[ \t\r\n]+/],
[/<\/script\s*>/, { token: '@rematch', next: '@pop' }]
],
// After <script ... type = $S2
scriptWithCustomType: [
[/>/, { token: 'delimiter.html', next: '@scriptEmbedded.$S2', nextEmbedded: '$S2' }],
[/"([^"]*)"/, 'attribute.value.html'],
[/'([^']*)'/, 'attribute.value.html'],
[/[\w\-]+/, 'attribute.name.html'],
[/=/, 'delimiter.html'],
[/[ \t\r\n]+/],
[/<\/script\s*>/, { token: '@rematch', next: '@pop' }]
],
scriptEmbedded: [
[/<\/script/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
[/[^<]+/, '']
],
// -- END <script> tags handling
// -- BEGIN <style> tags handling
// After <style
style: [
[/type/, 'attribute.name.html', '@styleAfterType'],
[/"([^"]*)"/, 'attribute.value.html'],
[/'([^']*)'/, 'attribute.value.html'],
[/[\w\-]+/, 'attribute.name.html'],
[/=/, 'delimiter.html'],
[/>/, { token: 'delimiter.html', next: '@styleEmbedded', nextEmbedded: 'text/css' }],
[/[ \t\r\n]+/],
[/(<\/)(style\s*)(>)/, ['delimiter.html', 'tag.html', { token: 'delimiter.html', next: '@pop' }]]
],
// After <style ... type
styleAfterType: [
[/=/, 'delimiter.html', '@styleAfterTypeEquals'],
[/>/, { token: 'delimiter.html', next: '@styleEmbedded', nextEmbedded: 'text/css' }],
[/[ \t\r\n]+/],
[/<\/style\s*>/, { token: '@rematch', next: '@pop' }]
],
// After <style ... type =
styleAfterTypeEquals: [
[/"([^"]*)"/, { token: 'attribute.value.html', switchTo: '@styleWithCustomType.$1' }],
[/'([^']*)'/, { token: 'attribute.value.html', switchTo: '@styleWithCustomType.$1' }],
[/>/, { token: 'delimiter.html', next: '@styleEmbedded', nextEmbedded: 'text/css' }],
[/[ \t\r\n]+/],
[/<\/style\s*>/, { token: '@rematch', next: '@pop' }]
],
// After <style ... type = $S2
styleWithCustomType: [
[/>/, { token: 'delimiter.html', next: '@styleEmbedded.$S2', nextEmbedded: '$S2' }],
[/"([^"]*)"/, 'attribute.value.html'],
[/'([^']*)'/, 'attribute.value.html'],
[/[\w\-]+/, 'attribute.name.html'],
[/=/, 'delimiter.html'],
[/[ \t\r\n]+/],
[/<\/style\s*>/, { token: '@rematch', next: '@pop' }]
],
styleEmbedded: [
[/<\/style/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
[/[^<]+/, '']
],
}
};
/***/ })
}]);

219
82.10a2cced.async.js Normal file
View File

@ -0,0 +1,219 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[82],{
/***/ "87dK":
/*!************************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/typescript/typescript.js ***!
\************************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/typescript/typescript.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
// Allow for running under nodejs/requirejs in tests
var _monaco = (typeof monaco === 'undefined' ? self.monaco : monaco);
var conf = {
wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
comments: {
lineComment: '//',
blockComment: ['/*', '*/']
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
onEnterRules: [
{
// e.g. /** | */
beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
afterText: /^\s*\*\/$/,
action: { indentAction: _monaco.languages.IndentAction.IndentOutdent, appendText: ' * ' }
},
{
// e.g. /** ...|
beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
action: { indentAction: _monaco.languages.IndentAction.None, appendText: ' * ' }
},
{
// e.g. * ...|
beforeText: /^(\t|(\ \ ))*\ \*(\ ([^\*]|\*(?!\/))*)?$/,
action: { indentAction: _monaco.languages.IndentAction.None, appendText: '* ' }
},
{
// e.g. */|
beforeText: /^(\t|(\ \ ))*\ \*\/\s*$/,
action: { indentAction: _monaco.languages.IndentAction.None, removeText: 1 }
}
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"', notIn: ['string'] },
{ open: '\'', close: '\'', notIn: ['string', 'comment'] },
{ open: '`', close: '`', notIn: ['string', 'comment'] },
{ open: "/**", close: " */", notIn: ["string"] }
],
folding: {
markers: {
start: new RegExp("^\\s*//\\s*#?region\\b"),
end: new RegExp("^\\s*//\\s*#?endregion\\b")
}
}
};
var language = {
// Set defaultToken to invalid to see what you do not tokenize yet
defaultToken: 'invalid',
tokenPostfix: '.ts',
keywords: [
'abstract', 'as', 'break', 'case', 'catch', 'class', 'continue', 'const',
'constructor', 'debugger', 'declare', 'default', 'delete', 'do', 'else',
'enum', 'export', 'extends', 'false', 'finally', 'for', 'from', 'function',
'get', 'if', 'implements', 'import', 'in', 'infer', 'instanceof', 'interface',
'is', 'keyof', 'let', 'module', 'namespace', 'never', 'new', 'null', 'package',
'private', 'protected', 'public', 'readonly', 'require', 'global', 'return',
'set', 'static', 'super', 'switch', 'symbol', 'this', 'throw', 'true', 'try',
'type', 'typeof', 'unique', 'var', 'void', 'while', 'with', 'yield', 'async',
'await', 'of'
],
typeKeywords: [
'any', 'boolean', 'number', 'object', 'string', 'undefined'
],
operators: [
'<=', '>=', '==', '!=', '===', '!==', '=>', '+', '-', '**',
'*', '/', '%', '++', '--', '<<', '</', '>>', '>>>', '&',
'|', '^', '!', '~', '&&', '||', '??', '?', ':', '=', '+=', '-=',
'*=', '**=', '/=', '%=', '<<=', '>>=', '>>>=', '&=', '|=',
'^=', '@',
],
// we include these common regular expressions
symbols: /[=><!~?:&|+\-*\/\^%]+/,
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
digits: /\d+(_+\d+)*/,
octaldigits: /[0-7]+(_+[0-7]+)*/,
binarydigits: /[0-1]+(_+[0-1]+)*/,
hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
regexpesc: /\\(?:[bBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})/,
// The main tokenizer for our languages
tokenizer: {
root: [
[/[{}]/, 'delimiter.bracket'],
{ include: 'common' }
],
common: [
// identifiers and keywords
[/[a-z_$][\w$]*/, {
cases: {
'@typeKeywords': 'keyword',
'@keywords': 'keyword',
'@default': 'identifier'
}
}],
[/[A-Z][\w\$]*/, 'type.identifier'],
// [/[A-Z][\w\$]*/, 'identifier'],
// whitespace
{ include: '@whitespace' },
// regular expression: ensure it is terminated before beginning (otherwise it is an opeator)
[/\/(?=([^\\\/]|\\.)+\/([gimsuy]*)(\s*)(\.|;|,|\)|\]|\}|$))/, { token: 'regexp', bracket: '@open', next: '@regexp' }],
// delimiters and operators
[/[()\[\]]/, '@brackets'],
[/[<>](?!@symbols)/, '@brackets'],
[/!(?=([^=]|$))/, 'delimiter'],
[/@symbols/, {
cases: {
'@operators': 'delimiter',
'@default': ''
}
}],
// numbers
[/(@digits)[eE]([\-+]?(@digits))?/, 'number.float'],
[/(@digits)\.(@digits)([eE][\-+]?(@digits))?/, 'number.float'],
[/0[xX](@hexdigits)n?/, 'number.hex'],
[/0[oO]?(@octaldigits)n?/, 'number.octal'],
[/0[bB](@binarydigits)n?/, 'number.binary'],
[/(@digits)n?/, 'number'],
// delimiter: after number because of .\d floats
[/[;,.]/, 'delimiter'],
// strings
[/"([^"\\]|\\.)*$/, 'string.invalid'],
[/'([^'\\]|\\.)*$/, 'string.invalid'],
[/"/, 'string', '@string_double'],
[/'/, 'string', '@string_single'],
[/`/, 'string', '@string_backtick'],
],
whitespace: [
[/[ \t\r\n]+/, ''],
[/\/\*\*(?!\/)/, 'comment.doc', '@jsdoc'],
[/\/\*/, 'comment', '@comment'],
[/\/\/.*$/, 'comment'],
],
comment: [
[/[^\/*]+/, 'comment'],
[/\*\//, 'comment', '@pop'],
[/[\/*]/, 'comment']
],
jsdoc: [
[/[^\/*]+/, 'comment.doc'],
[/\*\//, 'comment.doc', '@pop'],
[/[\/*]/, 'comment.doc']
],
// We match regular expression quite precisely
regexp: [
[/(\{)(\d+(?:,\d*)?)(\})/, ['regexp.escape.control', 'regexp.escape.control', 'regexp.escape.control']],
[/(\[)(\^?)(?=(?:[^\]\\\/]|\\.)+)/, ['regexp.escape.control', { token: 'regexp.escape.control', next: '@regexrange' }]],
[/(\()(\?:|\?=|\?!)/, ['regexp.escape.control', 'regexp.escape.control']],
[/[()]/, 'regexp.escape.control'],
[/@regexpctl/, 'regexp.escape.control'],
[/[^\\\/]/, 'regexp'],
[/@regexpesc/, 'regexp.escape'],
[/\\\./, 'regexp.invalid'],
[/(\/)([gimsuy]*)/, [{ token: 'regexp', bracket: '@close', next: '@pop' }, 'keyword.other']],
],
regexrange: [
[/-/, 'regexp.escape.control'],
[/\^/, 'regexp.invalid'],
[/@regexpesc/, 'regexp.escape'],
[/[^\]]/, 'regexp'],
[/\]/, { token: 'regexp.escape.control', next: '@pop', bracket: '@close' }]
],
string_double: [
[/[^\\"]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/"/, 'string', '@pop']
],
string_single: [
[/[^\\']+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/'/, 'string', '@pop']
],
string_backtick: [
[/\$\{/, { token: 'delimiter.bracket', next: '@bracketCounting' }],
[/[^\\`$]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/`/, 'string', '@pop']
],
bracketCounting: [
[/\{/, 'delimiter.bracket', '@bracketCounting'],
[/\}/, 'delimiter.bracket', '@pop'],
{ include: 'common' }
],
},
};
/***/ })
}]);

183
83.d7681b11.async.js Normal file
View File

@ -0,0 +1,183 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[83],{
/***/ "eXtt":
/*!********************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/vb/vb.js ***!
\********************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/vb/vb.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
lineComment: '\'',
blockComment: ['/*', '*/'],
},
brackets: [
['{', '}'], ['[', ']'], ['(', ')'], ['<', '>'],
['addhandler', 'end addhandler'],
['class', 'end class'],
['enum', 'end enum'],
['event', 'end event'],
['function', 'end function'],
['get', 'end get'],
['if', 'end if'],
['interface', 'end interface'],
['module', 'end module'],
['namespace', 'end namespace'],
['operator', 'end operator'],
['property', 'end property'],
['raiseevent', 'end raiseevent'],
['removehandler', 'end removehandler'],
['select', 'end select'],
['set', 'end set'],
['structure', 'end structure'],
['sub', 'end sub'],
['synclock', 'end synclock'],
['try', 'end try'],
['while', 'end while'],
['with', 'end with'],
['using', 'end using'],
['do', 'loop'],
['for', 'next']
],
autoClosingPairs: [
{ open: '{', close: '}', notIn: ['string', 'comment'] },
{ open: '[', close: ']', notIn: ['string', 'comment'] },
{ open: '(', close: ')', notIn: ['string', 'comment'] },
{ open: '"', close: '"', notIn: ['string', 'comment'] },
{ open: '<', close: '>', notIn: ['string', 'comment'] },
],
folding: {
markers: {
start: new RegExp("^\\s*#Region\\b"),
end: new RegExp("^\\s*#End Region\\b")
}
}
};
var language = {
defaultToken: '',
tokenPostfix: '.vb',
ignoreCase: true,
brackets: [
{ token: 'delimiter.bracket', open: '{', close: '}' },
{ token: 'delimiter.array', open: '[', close: ']' },
{ token: 'delimiter.parenthesis', open: '(', close: ')' },
{ token: 'delimiter.angle', open: '<', close: '>' },
// Special bracket statement pairs
// according to https://msdn.microsoft.com/en-us/library/tsw2a11z.aspx
{ token: 'keyword.tag-addhandler', open: 'addhandler', close: 'end addhandler' },
{ token: 'keyword.tag-class', open: 'class', close: 'end class' },
{ token: 'keyword.tag-enum', open: 'enum', close: 'end enum' },
{ token: 'keyword.tag-event', open: 'event', close: 'end event' },
{ token: 'keyword.tag-function', open: 'function', close: 'end function' },
{ token: 'keyword.tag-get', open: 'get', close: 'end get' },
{ token: 'keyword.tag-if', open: 'if', close: 'end if' },
{ token: 'keyword.tag-interface', open: 'interface', close: 'end interface' },
{ token: 'keyword.tag-module', open: 'module', close: 'end module' },
{ token: 'keyword.tag-namespace', open: 'namespace', close: 'end namespace' },
{ token: 'keyword.tag-operator', open: 'operator', close: 'end operator' },
{ token: 'keyword.tag-property', open: 'property', close: 'end property' },
{ token: 'keyword.tag-raiseevent', open: 'raiseevent', close: 'end raiseevent' },
{ token: 'keyword.tag-removehandler', open: 'removehandler', close: 'end removehandler' },
{ token: 'keyword.tag-select', open: 'select', close: 'end select' },
{ token: 'keyword.tag-set', open: 'set', close: 'end set' },
{ token: 'keyword.tag-structure', open: 'structure', close: 'end structure' },
{ token: 'keyword.tag-sub', open: 'sub', close: 'end sub' },
{ token: 'keyword.tag-synclock', open: 'synclock', close: 'end synclock' },
{ token: 'keyword.tag-try', open: 'try', close: 'end try' },
{ token: 'keyword.tag-while', open: 'while', close: 'end while' },
{ token: 'keyword.tag-with', open: 'with', close: 'end with' },
// Other pairs
{ token: 'keyword.tag-using', open: 'using', close: 'end using' },
{ token: 'keyword.tag-do', open: 'do', close: 'loop' },
{ token: 'keyword.tag-for', open: 'for', close: 'next' }
],
keywords: [
'AddHandler', 'AddressOf', 'Alias', 'And', 'AndAlso', 'As', 'Async', 'Boolean', 'ByRef', 'Byte', 'ByVal', 'Call',
'Case', 'Catch', 'CBool', 'CByte', 'CChar', 'CDate', 'CDbl', 'CDec', 'Char', 'CInt', 'Class', 'CLng',
'CObj', 'Const', 'Continue', 'CSByte', 'CShort', 'CSng', 'CStr', 'CType', 'CUInt', 'CULng', 'CUShort',
'Date', 'Decimal', 'Declare', 'Default', 'Delegate', 'Dim', 'DirectCast', 'Do', 'Double', 'Each', 'Else',
'ElseIf', 'End', 'EndIf', 'Enum', 'Erase', 'Error', 'Event', 'Exit', 'False', 'Finally', 'For', 'Friend',
'Function', 'Get', 'GetType', 'GetXMLNamespace', 'Global', 'GoSub', 'GoTo', 'Handles', 'If', 'Implements',
'Imports', 'In', 'Inherits', 'Integer', 'Interface', 'Is', 'IsNot', 'Let', 'Lib', 'Like', 'Long', 'Loop',
'Me', 'Mod', 'Module', 'MustInherit', 'MustOverride', 'MyBase', 'MyClass', 'NameOf', 'Namespace', 'Narrowing', 'New',
'Next', 'Not', 'Nothing', 'NotInheritable', 'NotOverridable', 'Object', 'Of', 'On', 'Operator', 'Option',
'Optional', 'Or', 'OrElse', 'Out', 'Overloads', 'Overridable', 'Overrides', 'ParamArray', 'Partial',
'Private', 'Property', 'Protected', 'Public', 'RaiseEvent', 'ReadOnly', 'ReDim', 'RemoveHandler', 'Resume',
'Return', 'SByte', 'Select', 'Set', 'Shadows', 'Shared', 'Short', 'Single', 'Static', 'Step', 'Stop',
'String', 'Structure', 'Sub', 'SyncLock', 'Then', 'Throw', 'To', 'True', 'Try', 'TryCast', 'TypeOf',
'UInteger', 'ULong', 'UShort', 'Using', 'Variant', 'Wend', 'When', 'While', 'Widening', 'With', 'WithEvents',
'WriteOnly', 'Xor'
],
tagwords: [
'If', 'Sub', 'Select', 'Try', 'Class', 'Enum',
'Function', 'Get', 'Interface', 'Module', 'Namespace', 'Operator', 'Set', 'Structure', 'Using', 'While', 'With',
'Do', 'Loop', 'For', 'Next', 'Property', 'Continue', 'AddHandler', 'RemoveHandler', 'Event', 'RaiseEvent', 'SyncLock'
],
// we include these common regular expressions
symbols: /[=><!~?;\.,:&|+\-*\/\^%]+/,
escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
integersuffix: /U?[DI%L&S@]?/,
floatsuffix: /[R#F!]?/,
// The main tokenizer for our languages
tokenizer: {
root: [
// whitespace
{ include: '@whitespace' },
// special ending tag-words
[/next(?!\w)/, { token: 'keyword.tag-for' }],
[/loop(?!\w)/, { token: 'keyword.tag-do' }],
// usual ending tags
[/end\s+(?!for|do)(addhandler|class|enum|event|function|get|if|interface|module|namespace|operator|property|raiseevent|removehandler|select|set|structure|sub|synclock|try|while|with|using)/, { token: 'keyword.tag-$1' }],
// identifiers, tagwords, and keywords
[/[a-zA-Z_]\w*/, {
cases: {
'@tagwords': { token: 'keyword.tag-$0' },
'@keywords': { token: 'keyword.$0' },
'@default': 'identifier'
}
}],
// Preprocessor directive
[/^\s*#\w+/, 'keyword'],
// numbers
[/\d*\d+e([\-+]?\d+)?(@floatsuffix)/, 'number.float'],
[/\d*\.\d+(e[\-+]?\d+)?(@floatsuffix)/, 'number.float'],
[/&H[0-9a-f]+(@integersuffix)/, 'number.hex'],
[/&0[0-7]+(@integersuffix)/, 'number.octal'],
[/\d+(@integersuffix)/, 'number'],
// date literal
[/#.*#/, 'number'],
// delimiters and operators
[/[{}()\[\]]/, '@brackets'],
[/@symbols/, 'delimiter'],
// strings
[/"/, 'string', '@string'],
],
whitespace: [
[/[ \t\r\n]+/, ''],
[/(\'|REM(?!\w)).*$/, 'comment'],
],
string: [
[/[^\\"]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/"C?/, 'string', '@pop']
],
},
};
/***/ })
}]);

109
84.2b7a8ebb.async.js Normal file
View File

@ -0,0 +1,109 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[84],{
/***/ "aH2L":
/*!**********************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/xml/xml.js ***!
\**********************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/xml/xml.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var conf = {
comments: {
blockComment: ['<!--', '-->'],
},
brackets: [
['<', '>']
],
autoClosingPairs: [
{ open: '<', close: '>' },
{ open: '\'', close: '\'' },
{ open: '"', close: '"' },
],
surroundingPairs: [
{ open: '<', close: '>' },
{ open: '\'', close: '\'' },
{ open: '"', close: '"' },
]
};
var language = {
defaultToken: '',
tokenPostfix: '.xml',
ignoreCase: true,
// Useful regular expressions
qualifiedName: /(?:[\w\.\-]+:)?[\w\.\-]+/,
tokenizer: {
root: [
[/[^<&]+/, ''],
{ include: '@whitespace' },
// Standard opening tag
[/(<)(@qualifiedName)/, [
{ token: 'delimiter' },
{ token: 'tag', next: '@tag' }
]],
// Standard closing tag
[/(<\/)(@qualifiedName)(\s*)(>)/, [
{ token: 'delimiter' },
{ token: 'tag' },
'',
{ token: 'delimiter' }
]],
// Meta tags - instruction
[/(<\?)(@qualifiedName)/, [
{ token: 'delimiter' },
{ token: 'metatag', next: '@tag' }
]],
// Meta tags - declaration
[/(<\!)(@qualifiedName)/, [
{ token: 'delimiter' },
{ token: 'metatag', next: '@tag' }
]],
// CDATA
[/<\!\[CDATA\[/, { token: 'delimiter.cdata', next: '@cdata' }],
[/&\w+;/, 'string.escape'],
],
cdata: [
[/[^\]]+/, ''],
[/\]\]>/, { token: 'delimiter.cdata', next: '@pop' }],
[/\]/, '']
],
tag: [
[/[ \t\r\n]+/, ''],
[/(@qualifiedName)(\s*=\s*)("[^"]*"|'[^']*')/, ['attribute.name', '', 'attribute.value']],
[/(@qualifiedName)(\s*=\s*)("[^">?\/]*|'[^'>?\/]*)(?=[\?\/]\>)/, ['attribute.name', '', 'attribute.value']],
[/(@qualifiedName)(\s*=\s*)("[^">]*|'[^'>]*)/, ['attribute.name', '', 'attribute.value']],
[/@qualifiedName/, 'attribute.name'],
[/\?>/, { token: 'delimiter', next: '@pop' }],
[/(\/)(>)/, [
{ token: 'tag' },
{ token: 'delimiter', next: '@pop' }
]],
[/>/, { token: 'delimiter', next: '@pop' }],
],
whitespace: [
[/[ \t\r\n]+/, ''],
[/<!--/, { token: 'comment', next: '@comment' }]
],
comment: [
[/[^<\-]+/, 'comment.content'],
[/-->/, { token: 'comment', next: '@pop' }],
[/<!--/, 'comment.content.invalid'],
[/[<\-]/, 'comment.content']
],
},
};
/***/ })
}]);

207
85.bfd535b6.async.js Normal file
View File

@ -0,0 +1,207 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[85],{
/***/ "EaLm":
/*!************************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/yaml/yaml.js ***!
\************************************************************************/
/*! exports provided: conf, language */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./node_modules/monaco-editor/esm/vs/basic-languages/yaml/yaml.contribution.js (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conf", function() { return conf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "language", function() { return language; });
var conf = {
comments: {
lineComment: '#'
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')']
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '"', close: '"' },
{ open: '\'', close: '\'' },
],
folding: {
offSide: true
}
};
var language = {
tokenPostfix: '.yaml',
brackets: [
{ token: 'delimiter.bracket', open: '{', close: '}' },
{ token: 'delimiter.square', open: '[', close: ']' }
],
keywords: ['true', 'True', 'TRUE', 'false', 'False', 'FALSE', 'null', 'Null', 'Null', '~'],
numberInteger: /(?:0|[+-]?[0-9]+)/,
numberFloat: /(?:0|[+-]?[0-9]+)(?:\.[0-9]+)?(?:e[-+][1-9][0-9]*)?/,
numberOctal: /0o[0-7]+/,
numberHex: /0x[0-9a-fA-F]+/,
numberInfinity: /[+-]?\.(?:inf|Inf|INF)/,
numberNaN: /\.(?:nan|Nan|NAN)/,
numberDate: /\d{4}-\d\d-\d\d([Tt ]\d\d:\d\d:\d\d(\.\d+)?(( ?[+-]\d\d?(:\d\d)?)|Z)?)?/,
escapes: /\\(?:[btnfr\\"']|[0-7][0-7]?|[0-3][0-7]{2})/,
tokenizer: {
root: [
{ include: '@whitespace' },
{ include: '@comment' },
// Directive
[/%[^ ]+.*$/, 'meta.directive'],
// Document Markers
[/---/, 'operators.directivesEnd'],
[/\.{3}/, 'operators.documentEnd'],
// Block Structure Indicators
[/[-?:](?= )/, 'operators'],
{ include: '@anchor' },
{ include: '@tagHandle' },
{ include: '@flowCollections' },
{ include: '@blockStyle' },
// Numbers
[/@numberInteger(?![ \t]*\S+)/, 'number'],
[/@numberFloat(?![ \t]*\S+)/, 'number.float'],
[/@numberOctal(?![ \t]*\S+)/, 'number.octal'],
[/@numberHex(?![ \t]*\S+)/, 'number.hex'],
[/@numberInfinity(?![ \t]*\S+)/, 'number.infinity'],
[/@numberNaN(?![ \t]*\S+)/, 'number.nan'],
[/@numberDate(?![ \t]*\S+)/, 'number.date'],
// Key:Value pair
[/(".*?"|'.*?'|.*?)([ \t]*)(:)( |$)/, ['type', 'white', 'operators', 'white']],
{ include: '@flowScalars' },
// String nodes
[/.+$/, {
cases: {
'@keywords': 'keyword',
'@default': 'string'
}
}]
],
// Flow Collection: Flow Mapping
object: [
{ include: '@whitespace' },
{ include: '@comment' },
// Flow Mapping termination
[/\}/, '@brackets', '@pop'],
// Flow Mapping delimiter
[/,/, 'delimiter.comma'],
// Flow Mapping Key:Value delimiter
[/:(?= )/, 'operators'],
// Flow Mapping Key:Value key
[/(?:".*?"|'.*?'|[^,\{\[]+?)(?=: )/, 'type'],
// Start Flow Style
{ include: '@flowCollections' },
{ include: '@flowScalars' },
// Scalar Data types
{ include: '@tagHandle' },
{ include: '@anchor' },
{ include: '@flowNumber' },
// Other value (keyword or string)
[/[^\},]+/, {
cases: {
'@keywords': 'keyword',
'@default': 'string'
}
}]
],
// Flow Collection: Flow Sequence
array: [
{ include: '@whitespace' },
{ include: '@comment' },
// Flow Sequence termination
[/\]/, '@brackets', '@pop'],
// Flow Sequence delimiter
[/,/, 'delimiter.comma'],
// Start Flow Style
{ include: '@flowCollections' },
{ include: '@flowScalars' },
// Scalar Data types
{ include: '@tagHandle' },
{ include: '@anchor' },
{ include: '@flowNumber' },
// Other value (keyword or string)
[/[^\],]+/, {
cases: {
'@keywords': 'keyword',
'@default': 'string'
}
}]
],
// First line of a Block Style
multiString: [
[/^( +).+$/, 'string', '@multiStringContinued.$1']
],
// Further lines of a Block Style
// Workaround for indentation detection
multiStringContinued: [
[/^( *).+$/, {
cases: {
'$1==$S2': 'string',
'@default': { token: '@rematch', next: '@popall' }
}
}]
],
whitespace: [
[/[ \t\r\n]+/, 'white']
],
// Only line comments
comment: [
[/#.*$/, 'comment']
],
// Start Flow Collections
flowCollections: [
[/\[/, '@brackets', '@array'],
[/\{/, '@brackets', '@object']
],
// Start Flow Scalars (quoted strings)
flowScalars: [
[/"([^"\\]|\\.)*$/, 'string.invalid'],
[/'([^'\\]|\\.)*$/, 'string.invalid'],
[/'[^']*'/, 'string'],
[/"/, 'string', '@doubleQuotedString']
],
doubleQuotedString: [
[/[^\\"]+/, 'string'],
[/@escapes/, 'string.escape'],
[/\\./, 'string.escape.invalid'],
[/"/, 'string', '@pop']
],
// Start Block Scalar
blockStyle: [
[/[>|][0-9]*[+-]?$/, 'operators', '@multiString']
],
// Numbers in Flow Collections (terminate with ,]})
flowNumber: [
[/@numberInteger(?=[ \t]*[,\]\}])/, 'number'],
[/@numberFloat(?=[ \t]*[,\]\}])/, 'number.float'],
[/@numberOctal(?=[ \t]*[,\]\}])/, 'number.octal'],
[/@numberHex(?=[ \t]*[,\]\}])/, 'number.hex'],
[/@numberInfinity(?=[ \t]*[,\]\}])/, 'number.infinity'],
[/@numberNaN(?=[ \t]*[,\]\}])/, 'number.nan'],
[/@numberDate(?=[ \t]*[,\]\}])/, 'number.date']
],
tagHandle: [
[/\![^ ]*/, 'tag']
],
anchor: [
[/[&*][^ ]+/, 'namespace']
]
}
};
/***/ })
}]);

1184
86.9f5667e5.async.js Normal file

File diff suppressed because it is too large Load Diff

View File

@ -87,6 +87,6 @@
gtag('config', 'UA-198293321-1');
</script> -->
<script src="/umi.1703b11f.js"></script>
<script src="/umi.e2130d79.js"></script>
</body>
</html>

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

View File

@ -0,0 +1,279 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[15],{
/***/ "43OI":
/*!*********************************************!*\
!*** ./src/pages/metting/banner/index.less ***!
\*********************************************/
/*! no static exports found */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
// extracted by mini-css-extract-plugin
/***/ }),
/***/ "5kjV":
/*!*****************************************!*\
!*** ./src/pages/metting/img/logo2.png ***!
\*****************************************/
/*! no static exports found */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports) {
module.exports = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAoCAYAAACM/rhtAAAAAXNSR0IArs4c6QAAA6BJREFUWEftmWtIFFEUx/93zVyzUNfdNQq1zWdfRCL64gNJJBJBiKIHWahRWGQZFhEZWBSlUmaaJmmEgkUSibIRQg8fX0IkIrJ1yzVKyXUdXUldtebGDO24pubsjqsVDgzcuXMev3vOnTPDGQKbw2QaWStbLssAiwQQrAPoStv7zhuTb6C0C6DaH670hsrDo8fqi1gHzKAlHQT5AF3hPBBRlkcoJZk+XvIyTpoHHDCPJlPgnvValBnnClGWRYrS2/0e6RseXuPyXdYBwMO5Pu2zTimGWVc2hDDmkWKAHLFPfaGk6S3CmEfbAYQtlEs7/bwjzODoMAgW+8GYjXuIiyC1c1ULKr4EKDXckiM4MT6B4sJivHn9ZgpLeEQ4jmUeg4uLiyRGyYBtrW0oKihCcEgQ1L6+PIyxtxf6jg/IOJmBiI0RiwvY3NiMirIKpB5KRVRMFA8z05yjlJIjuAQotQ4aOg24eP7ijBnMvpANzXqNo9nl9SSn2LrndO06tL5q5Y1u2rwJoRtChT0phXBeAK0Ap06c4od5BXlSmKbo/l+AAwyDmgc1+KjvBMv+mBYlhhng5xQK72n3lrm6IjAoEEnbk6BUKUVH2K4IZp85h+4vPfBR+oh2YCvYb+qHn78fci7niNYXDcgwDLIyshC/NR57kveIdmArWF1ZjYanDcgvzIdCoRBlQzSgqc+E05mn+RRxpyNH7aNacGfu9VzRaZ4T0GKxoL62HsZeI19G/AL8sE6jQVz8FvgH+AuvNt173RTm0LDJMtPVacDzZy/RZTDg86fPfBlS+6qRmJQIuVz+x7XOCVhz/yG09U+mGVGrVbhy7SrEFGqu/HD77/cjIXEbduzeKQ2w/HY5WppaUFFVIRiynRPzLk7dl4rI6EikHU4TbMw0NxPpnBFcArSJqkMRvHvnLppeNCEyJlLQ1+v0MA+aUVJegskP1mCoV6t5GeNXI/QdeuGDNT0tHZ5enggODRZstDS2IDo2GikHU6TtQe4hKC0qRZ+xTzDk5uaGXXt3ITYuFmI++bV1WtQ9rsPY2JhgQ6VW4ejxo0IlmI1yzj3oSL2bT50lQKnR/CdaH39v84jiLRfBSyA4KzUVztAnwAXSMzSklNPlnQBd5QwnDtuk+GaRTWisLeD9v1rADtubZ0VKgAPenu6VQhPdZB5NlgGlwKL3CkdY4LDS072KW7QAyF3w/eoJchwgCSBkoX9DGCAjWnacvalUrui2ZuQnVRoUWeadP14AAAAASUVORK5CYII="
/***/ }),
/***/ "AAUt":
/*!*****************************************!*\
!*** ./src/pages/metting/img/logo4.png ***!
\*****************************************/
/*! no static exports found */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports) {
module.exports = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAoCAYAAACM/rhtAAAAAXNSR0IArs4c6QAABUZJREFUWEfdmXtMU1ccx7+XlwIlWq28qUU3qUTd/nPKMBoSJVVCotk0G0xRAmMKytPBmDCnIQ4UFFAk0fkgWeY2E4J2+seCQYnoHwvDDgcKVGh5Ca0FaZVH73KO3kplZPeStrrdf7jNOT2/z/m9zrcHBpOegQFjgJObUwrMUICBDGBFk8ft9848BcuqAVY54coeX+Dp2c3ZYrgX3ZNnSWBQBLAe9gPhtbKRZZnU+XNnV5LZFFBvMMWywHnuM69l7DuJNZsRJxG7n2cej4z4O487tQLwtK9NYauzLEbMruYljM5gLAeYL4R93VGz2ZOMzmC6D0DuKJMC7TQzuiemETB404UxHfcQ8SArcFcOnf7/BjSOGHGn4Q6aGpvQqe6EXq+n3hWLxZDKpFjx/gqs/GAlPDxnnkEz8uDY6BhqqmtwXXkNY2PjEIlECFoYhHnz5lFAnU4HdYcaJqMJrq4u2KCIRFR0FFzdXAWnh2DAvt4+lJWUQqvpRog8BIooBUKXhcLZ2dnK+MTEBJpVzVDWKNHyVwsCAv2xZ18yfHx9BEEKAiRwBd8WgIQ2ZnsM1qxbw8tYXW0dqs5X0VBnf50tCJI3IAnrwQPfoK+3HxnZGVgSsoQXHDeptaUVRQVF8PH1xoGDebzDzRvw8k+XcaX6Cnbs2sHbcwSObMxgMECyQALiyXNnzmFT9CZs/mgzrw3yAiQhTd2zD4sWL8b+3P3TLqzX6dD5qAtajebF3y4tenp6sCpsFXYl7qLfO3LoCNrb2lBcVsKrunkB1v5Wi4vfX0RqZiqWv7fcCrC+7hZu3axH16NOGI0mq7FZs9zw/PkotsVsw/rI9XTs3h/3UFxYjNi4WKyLWPevXuQFWFJUgvaH7SguL55SrcQjD1ofIEgaRHtfQGAApFIppAulqLtRh0s/XLLaGKnulKQUyJfKkZyabBvA9OR0+Pr7IjM7c8qCuxN2w9vbG3mH8qaMVZ6qREN9A46fOg4vLy/LeGFBIXq7e3G09KhtAHfG7ERYeJglj7hVSUPOSMlA+NpwxMXHoaigkHpzb/o+2hvzcvJA8vJERakVyJnTZ1B/sx5nq87aF7Dx90acOHbCkmMJOxIwPj6OLR9vQeTGSCTGJVLQtKw0+wKmJ6fB199vSoiVNVfx84+/ICsnC/JQOf5UNUPd3oGI9RHo7+tH/lf52KDYgK2fbLUCfBHiHhwtPWYbD05XJBVlFbjbcBdlp8ssLYMUgVajxe1bt3H91+uI/zweqz9cbQGxS5FM12Zy9+dicGAQ0Zuj0dVJ+p4GGo0WZrPZApR/OJ9WNPfYpc0MDw+DVPLid141anJCJMUnWcGIRJ6QLQqmrYa0ncCgQPo+WUiQttT2sA0l5TZs1GT3rx91A48HUH25msosPz8/yBbJrFrJPyWX3Y467kwlYoEkf8aXGXhXoFh40NKKI4e/ox7Nzc+1vVggkJzcMhmN+JTIrbU85daNOlw4ewEiLxGFI8KB78PrqJu82OuCdWOUAkunEaz3Vc24+lKwkpwkR5sQOGJXMCAXbiL5r129Rhuzh4c7ZMHBEM8X073oB/VQd3RQ8eDi4kKbtsMk/2Rvcj+aVE0q2qD1+id0WCyeS6t52Yplb+ZHE9/8scW8GYXYFob5rvGfuPp4ey+PWKiIBw+DQQ5flztyHgMcZLqHhiSzWbd2gH0leR1JMZ0tFk+fOY0Fc1fAn728An4b0AgDywDbxXPcL1ou0QcMplgnoAJ443eFRjOQKJnjXkVPkskuo/fVY8xegFGAYRz9b4gOODFK86i5VCLx0HJcfwOROqdZhWijeAAAAABJRU5ErkJggg=="
/***/ }),
/***/ "RMEQ":
/*!****************************************!*\
!*** ./src/pages/metting/img/logo.png ***!
\****************************************/
/*! no static exports found */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
module.exports = __webpack_require__.p + "static/logo.e08ed7ab.png";
/***/ }),
/***/ "TJ9Y":
/*!******************************************************!*\
!*** ./src/pages/metting/img sync ^\.\/logo.*\.png$ ***!
\******************************************************/
/*! no static exports found */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
var map = {
"./logo.png": "RMEQ",
"./logo1-color.png": "iA9A",
"./logo1.png": "sXCt",
"./logo2-color.png": "w3po",
"./logo2.png": "5kjV",
"./logo3-color.png": "t7D2",
"./logo3.png": "VPM8",
"./logo4-color.png": "iiET",
"./logo4.png": "AAUt"
};
function webpackContext(req) {
var id = webpackContextResolve(req);
return __webpack_require__(id);
}
function webpackContextResolve(req) {
if(!__webpack_require__.o(map, req)) {
var e = new Error("Cannot find module '" + req + "'");
e.code = 'MODULE_NOT_FOUND';
throw e;
}
return map[req];
}
webpackContext.keys = function webpackContextKeys() {
return Object.keys(map);
};
webpackContext.resolve = webpackContextResolve;
module.exports = webpackContext;
webpackContext.id = "TJ9Y";
/***/ }),
/***/ "VPM8":
/*!*****************************************!*\
!*** ./src/pages/metting/img/logo3.png ***!
\*****************************************/
/*! no static exports found */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports) {
module.exports = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAoCAYAAACM/rhtAAAAAXNSR0IArs4c6QAABIhJREFUWEfdmW1MU2cUx/9PWYmFYq3UOBEQgUJBCVl0GD+aZWzpMCQkS/yg6MjiHAyREVC2ytsk+yAJMETNJFFhiR+26AyGsDj124KsGkF8CW+SOXFIueWWvohA7/I8W5sqlN6LbXHrp9t7n3vO7znnOS89JfD4mEz29bJQ2UE4oQdBHCAoPZ8H7ppYIQgjgNAxJxca14SHj7p0EdcFN/n8cxDUAUJY4EBESbYLAimOXLXie7qaAZp5xx4BOO/6LkpMYBcJTic+0agV58m4zRYVMivrBxAeWJ3SpAsCbE65M4lwvL0ZIPnSXg/WauEk4XjHAwC6YKmUqOc+4SYdNhAsd2B447ZQCwoSdxXU5f9fQLvNDmO3ET13ejAyPAKz2QyZTIbVq9WI2RCL1E2p2LY9A8qIiNeyuGQLzryYQWdHJ37p6ITd7lhUuVz+FvRZeuh3fgR5qHxJoJIAzRyHhrpGPP7jMVOmTdJiS8YW6FJ0UKlU7J51agr37t3Hre5bGOgfYPdiYmNw4IsDWBe1TjKkaECO41BztAYW3gK1Wo19n+5DWnraogrv9txF69lWTJgmsFK1EuVHy7H27bWSIEUBUrceqzrGLJeoTURBUQFUq/6xmK8PP8mjubEZgwODWB8dhYqaSknuFgXY/nM7Lv10iVmu4puKeXB0A8bfjdBoIqFNTprHTAOq8utKZsms7CzkfJzja1/u5z4BqfCy4lIWEEUlRUh/J32ecNO4CWXFZUjWJeOw4fCCysf+GkPXb13M1Tve2+E/wBvXbqDtbBviE+JhqDYsKFgMoGiiVxb6tGBDXQN67/Ri1+5dyPwwc0mAx789jvGxZwu+m5ikxf78/V75fQIeKjjEIreqtgqxG2KXBHik5AieeQFM2ZSC0vLSpQPm7c5jL9efqPcaucvq4jcesKTwS5jNk6JcrFQqkX8wH7rUl9tLTxfTet3S2iI6ZnyeQTFBMjc3hwttF3D91+usYdDv1CM7JxshISEM5PSJU+AnLW4ob6loIWqfgGLSjEvwbeNtnGs5B6vVytJSYXGh6IrjzaQ+AWmippE8OzvrNVF7CucmOJw5dQZDQ0Oorq12NwhPR5+iu6vb/4maKr/440VcuXzFa6l7dffU5RQoOiaaPZqammKNRkBKHVVAa21NRTWe/DmKuI1xzJJSmoWT3zVjoH+QtV2GKoP/mwUKSXMd7Whc7VZuXu6CddnTmrTdomeSdtu0BlM4zRqN6AimC32eQU9pFLKpvsndsCYkxOPd7RkvNaw8z+Phg4fzGlaafqT2gpIBXe5uv9yOq51XMT09vag1FGEKZH7wfvBafk8aGt03u26ir7cPI8OPWDKnOTBSE8mCY3PaZmzdthURwf7RJOkA+WGxpDPoB32SRfwnRh9v7vBIQB+1YC0IvpJs+yC8QIAaMmqxaFYIocOA8HozCn8DC7A+l81sdI2Ac/8dAftbzVLlCQTYq1Yp2txDdBPv2CMDTgPLPiu0O4HPNCrFD6ySeG6RzatnSBFA9CAk2H9DPIKMdDhfOJs0mrAnLq6/Af7/SlnywrlbAAAAAElFTkSuQmCC"
/***/ }),
/***/ "Y4+S":
/*!*********************************************!*\
!*** ./src/pages/metting/img/subBanner.png ***!
\*********************************************/
/*! no static exports found */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
module.exports = __webpack_require__.p + "static/subBanner.c94b8b58.png";
/***/ }),
/***/ "iA9A":
/*!***********************************************!*\
!*** ./src/pages/metting/img/logo1-color.png ***!
\***********************************************/
/*! no static exports found */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports) {
module.exports = "data:image/png;base64,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"
/***/ }),
/***/ "iiET":
/*!***********************************************!*\
!*** ./src/pages/metting/img/logo4-color.png ***!
\***********************************************/
/*! no static exports found */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports) {
module.exports = "data:image/png;base64,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"
/***/ }),
/***/ "ml2I":
/*!********************************************************!*\
!*** ./src/pages/metting/banner/index.jsx + 1 modules ***!
\********************************************************/
/*! exports provided: default */
/*! all exports used */
/*! ModuleConcatenation bailout: Cannot concat with ./src/.umi-production/core/umiExports.ts */
/*! ModuleConcatenation bailout: Cannot concat with ./src/pages/metting/info.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/react-router-dom/esm/react-router-dom.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/react-router/esm/react-router.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/react/index.js (<- Module is not an ECMAScript module) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);
// EXTERNAL MODULE: ./node_modules/react/index.js
var react = __webpack_require__("q1tI");
var react_default = /*#__PURE__*/__webpack_require__.n(react);
// EXTERNAL MODULE: ./src/pages/metting/banner/index.less
var banner = __webpack_require__("43OI");
// EXTERNAL MODULE: ./node_modules/react-router/esm/react-router.js
var react_router = __webpack_require__("Ty5D");
// EXTERNAL MODULE: ./node_modules/react-router-dom/esm/react-router-dom.js
var react_router_dom = __webpack_require__("55Ip");
// EXTERNAL MODULE: ./src/pages/metting/info.js
var info = __webpack_require__("PZZE");
// CONCATENATED MODULE: ./src/pages/metting/banner/menu.jsx
function Menu(props) {
var location = Object(react_router["k" /* useLocation */])();
var matchItem = function matchItem(item) {
if (location.pathname.indexOf("/track/") > -1) {
return item.indexOf("/track/") > -1;
} else {
return item === location.pathname;
}
};
return /*#__PURE__*/react_default.a.createElement("ul", {
className: "banners"
}, info["d" /* menu */] && (info["d" /* menu */] === null || info["d" /* menu */] === void 0 ? void 0 : info["d" /* menu */].length) > 0 && info["d" /* menu */].map(function (i, k) {
return /*#__PURE__*/react_default.a.createElement(react_router_dom["a" /* Link */], {
to: i.link,
key: k,
className: "".concat(matchItem(i.link) ? "active" : "")
}, /*#__PURE__*/react_default.a.createElement("img", {
src: __webpack_require__("TJ9Y")("./logo".concat(k + 1).concat(matchItem(i.link) ? "-color" : "", ".png"))
}), i.name);
}));
}
/* harmony default export */ var menu = (Menu);
// EXTERNAL MODULE: ./src/pages/metting/img/subBanner.png
var subBanner = __webpack_require__("Y4+S");
// EXTERNAL MODULE: ./src/.umi-production/core/umiExports.ts + 19 modules
var umiExports = __webpack_require__("9kvl");
// CONCATENATED MODULE: ./src/pages/metting/banner/index.jsx
function Banner(props) {
var _useModel = Object(umiExports["f" /* useModel */])('defaultConfig'),
mainInfo = _useModel.mainInfo;
return /*#__PURE__*/react_default.a.createElement("div", {
className: "mainroot"
}, /*#__PURE__*/react_default.a.createElement("div", {
className: "mainBanner"
}, /*#__PURE__*/react_default.a.createElement("div", {
className: "header"
}, /*#__PURE__*/react_default.a.createElement("img", {
src: mainInfo === null || mainInfo === void 0 ? void 0 : mainInfo.bannerList
}), /*#__PURE__*/react_default.a.createElement("div", {
className: "bannerContent"
}, /*#__PURE__*/react_default.a.createElement(menu, null)))), props.children);
}
/* harmony default export */ var metting_banner = __webpack_exports__["default"] = (Banner);
/***/ }),
/***/ "sXCt":
/*!*****************************************!*\
!*** ./src/pages/metting/img/logo1.png ***!
\*****************************************/
/*! no static exports found */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports) {
module.exports = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAoCAYAAACM/rhtAAAAAXNSR0IArs4c6QAABFlJREFUWEftmX9IW1cUx7832pqoq61GMMq6WPxFp+wP7cqgrKXgJpau3Tq6udWVtXTaNZ17dovD0iLdHFSKIURlShPQtQOpaxnrBCkMEUHK6DZm6rTV6GJXhYqa2LzEpr437mWRZGs0L7/sYBcC772ce87nnnPuuycnBF5jZobPkK2XfQQBpSBQA2Ki9/eRuyYPIYoTgNi9tE7UpyYk3PfYIp6L2XnXcRBcAMT4yIEEpJkXRcKlbJS3UWkGOGdzlotAu+c+IDWRFRIFAe8rNynayQOHIz3msewOgITI2pSmXRThENYJOWTWxjcD5ENp06MlLbaQWZvzdwB50TIp0c4QmZ13OkCw1hvDH7edelCUuKqoiocV0DZvg9vthjJVGbZFhA3w7sgdGHRN4HkelZpKFL1YFBbIsADeHLgJU5sRbvfjZaiyQ2+juOSVkCFDBuz+/gd0dX7LQHbu3onk5GRc67rG7otfLUZZeVlIkEEDLi0t4XL7ZfT+2MsADrx1AHv27mHXA/0DMLYZIQgCirYVokJTiZiYmKBAgwJ0uVxo0bfAPGhGbGwsjlYcxfaXtvsA3DbfRpOuCYuLi8jOyQKnrYZcLpcMKRmQ7tTGhkZMWieRmJgIDadBTm7OEw1b/7AyWbvNjjRVGmpO1yBpY5IkSEmA9ybvQdegw9zcHDN4kjsJVbpqRYMzD2YY5PTUNDYkbWCQq83xVhgw4JB5CAadgYUsKzsLJ6pOBOyNhYUFGBoNGL07iri4OFRrOWT78fo/VxsQYF9vHzpMHSzpC7cVspyTmk80b42tRtz66RZkMhmOHT/2r7x9UihWBbx65Squf3edzc0vyEd1TbWkHPIWpju/Rd+MX37+lT0++M5BlJSWrKhvRcCx0THU19X7KKirr8Pm5zYHBck7eHCaj31e6GfOnUHmlky/+lYEdD9yo6vzCnjeicHfBtlu1NZqkbc1uOqMbhgtp2UwuXm5UKam4N3Dh1ZMl1VD7Fna+S/OY2R4JGyApkumgKIQFsAJyzhu9NzAuGUCwpKAjGczsGv3LhS8UOAD4e3BqAFSo6e1tSyv6KlCjzT6KqLjk89OYWv+88uQawLY39cPU5sJr7+5H3v3v8ZgaHXT2tyKfW/sYx/PWFPAIx8cwY6XdzCW4aFhNHzZ8D+gT4L728WeED81HuQ+5Xx2pxRAWglxGo4ddRc7Lob3NdP5TSd6untYRZLuVcFQo1NT01Cp0paLB3piWK2TUCpTfH5AeZ6rM9U4+/nZ8ALSikR/QQ/LmCUgxf6EFPEKVJ2q8ltDBlXNeE+iRSj1RLBDvUUtqRIK+CQJFijUef+J1sfT2zwSYaYerAdBbaihiMR8Apwj9+12pVxcbwHEZyJhJGidIh66ZO5MTwv4vb9bwEHrC/NEkQCHNyUpvl5uos/YnOUy4CtgzXuFvABUKJMUl+iilwHpDetXu0kVQEpBSLT/hhiHjHQLjwSDUhn/pycifwEQQG5Z3B90jwAAAABJRU5ErkJggg=="
/***/ }),
/***/ "t7D2":
/*!***********************************************!*\
!*** ./src/pages/metting/img/logo3-color.png ***!
\***********************************************/
/*! no static exports found */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports) {
module.exports = "data:image/png;base64,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"
/***/ }),
/***/ "w3po":
/*!***********************************************!*\
!*** ./src/pages/metting/img/logo2-color.png ***!
\***********************************************/
/*! no static exports found */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports) {
module.exports = "data:image/png;base64,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"
/***/ })
}]);

File diff suppressed because one or more lines are too long

View File

@ -0,0 +1,537 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[17],{
/***/ "/zsF":
/*!*****************************************************!*\
!*** ./node_modules/antd/es/divider/style/index.js ***!
\*****************************************************/
/*! no exports provided */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony import */ var _style_index_less__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../style/index.less */ "cIOH");
/* harmony import */ var _style_index_less__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_style_index_less__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _index_less__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./index.less */ "bE4E");
/* harmony import */ var _index_less__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_index_less__WEBPACK_IMPORTED_MODULE_1__);
/***/ }),
/***/ "0ARD":
/*!*****************************************!*\
!*** ./src/pages/metting/img/empty.png ***!
\*****************************************/
/*! no static exports found */
/*! exports used: default */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
module.exports = __webpack_require__.p + "static/empty.eeea9add.png";
/***/ }),
/***/ "7zYu":
/*!*************************************************!*\
!*** ./src/pages/metting/information/index.jsx ***!
\*************************************************/
/*! exports provided: default */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./src/.umi-production/core/routes.ts (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var antd_es_spin_style__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! antd/es/spin/style */ "T2oS");
/* harmony import */ var antd_es_spin__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! antd/es/spin */ "W9HT");
/* harmony import */ var antd_es_divider_style__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! antd/es/divider/style */ "/zsF");
/* harmony import */ var antd_es_divider__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! antd/es/divider */ "PArb");
/* harmony import */ var antd_es_input_style__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! antd/es/input/style */ "5NDa");
/* harmony import */ var antd_es_input__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! antd/es/input */ "5rEg");
/* harmony import */ var D_projects_competitions_forgeplus_react_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./node_modules/@umijs/babel-preset-umi/node_modules/@babel/runtime/helpers/esm/slicedToArray */ "tJVT");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! react */ "q1tI");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_7___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_7__);
/* harmony import */ var _index_less__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./index.less */ "tuCT");
/* harmony import */ var _index_less__WEBPACK_IMPORTED_MODULE_8___default = /*#__PURE__*/__webpack_require__.n(_index_less__WEBPACK_IMPORTED_MODULE_8__);
/* harmony import */ var _info__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../info */ "PZZE");
/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ../api */ "Lj8O");
/* harmony import */ var _img_empty_png__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ../img/empty.png */ "0ARD");
/* harmony import */ var _img_empty_png__WEBPACK_IMPORTED_MODULE_11___default = /*#__PURE__*/__webpack_require__.n(_img_empty_png__WEBPACK_IMPORTED_MODULE_11__);
/* harmony import */ var umi__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! umi */ "9kvl");
/* harmony import */ var umi__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! umi */ "55Ip");
/* harmony import */ var _img_left_png__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ../img/left.png */ "oOC2");
/* harmony import */ var _img_left_png__WEBPACK_IMPORTED_MODULE_14___default = /*#__PURE__*/__webpack_require__.n(_img_left_png__WEBPACK_IMPORTED_MODULE_14__);
/* harmony import */ var _img_right_png__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ../img/right.png */ "Y8td");
/* harmony import */ var _img_right_png__WEBPACK_IMPORTED_MODULE_15___default = /*#__PURE__*/__webpack_require__.n(_img_right_png__WEBPACK_IMPORTED_MODULE_15__);
/* harmony import */ var _img_subBanner_png__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ../img/subBanner.png */ "Y4+S");
/* harmony import */ var _img_subBanner_png__WEBPACK_IMPORTED_MODULE_16___default = /*#__PURE__*/__webpack_require__.n(_img_subBanner_png__WEBPACK_IMPORTED_MODULE_16__);
/* harmony import */ var _img_search_png__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! ../img/search.png */ "h49j");
/* harmony import */ var _img_search_png__WEBPACK_IMPORTED_MODULE_17___default = /*#__PURE__*/__webpack_require__.n(_img_search_png__WEBPACK_IMPORTED_MODULE_17__);
/* harmony import */ var _utils_mettingUtil__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(/*! @/utils/mettingUtil */ "gnzr");
function Information() {
var _useState = Object(react__WEBPACK_IMPORTED_MODULE_7__["useState"])(false),
_useState2 = Object(D_projects_competitions_forgeplus_react_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_6__[/* default */ "a"])(_useState, 2),
isSpin = _useState2[0],
setIsSpin = _useState2[1];
var _useState3 = Object(react__WEBPACK_IMPORTED_MODULE_7__["useState"])([]),
_useState4 = Object(D_projects_competitions_forgeplus_react_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_6__[/* default */ "a"])(_useState3, 2),
informationList = _useState4[0],
setInformationList = _useState4[1];
var _useModel = Object(umi__WEBPACK_IMPORTED_MODULE_12__[/* useModel */ "f"])('defaultConfig'),
dirList = _useModel.dirList;
var _useState5 = Object(react__WEBPACK_IMPORTED_MODULE_7__["useState"])(0),
_useState6 = Object(D_projects_competitions_forgeplus_react_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_6__[/* default */ "a"])(_useState5, 2),
tabKey = _useState6[0],
setTabKey = _useState6[1];
var _useState7 = Object(react__WEBPACK_IMPORTED_MODULE_7__["useState"])([]),
_useState8 = Object(D_projects_competitions_forgeplus_react_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_6__[/* default */ "a"])(_useState7, 2),
positionNum = _useState8[0],
setPositionNum = _useState8[1];
var _useState9 = Object(react__WEBPACK_IMPORTED_MODULE_7__["useState"])(false),
_useState10 = Object(D_projects_competitions_forgeplus_react_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_6__[/* default */ "a"])(_useState9, 2),
showAnchor = _useState10[0],
setShowAnchor = _useState10[1];
var _useState11 = Object(react__WEBPACK_IMPORTED_MODULE_7__["useState"])(undefined),
_useState12 = Object(D_projects_competitions_forgeplus_react_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_6__[/* default */ "a"])(_useState11, 2),
title = _useState12[0],
setTitle = _useState12[1];
var _useState13 = Object(react__WEBPACK_IMPORTED_MODULE_7__["useState"])(undefined),
_useState14 = Object(D_projects_competitions_forgeplus_react_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_6__[/* default */ "a"])(_useState13, 2),
searchTitle = _useState14[0],
setSearchTitle = _useState14[1];
Object(react__WEBPACK_IMPORTED_MODULE_7__["useEffect"])(function () {
if (location.pathname === '/competitions/2024/information') {
window.addEventListener('scroll', throttleHandleScroll);
return ComponentWillUnmount;
} else {
ComponentWillUnmount();
}
}, [location.pathname, positionNum]);
function ComponentWillUnmount() {
window.removeEventListener("scroll", throttleHandleScroll);
}
function handleScroll() {
var scrollTop = document.documentElement.scrollTop; //滚动条滚动高度
setShowAnchor(scrollTop > 362);
if (scrollTop < 362) setTabKey(0);
if (positionNum && positionNum.length > 0) {
for (var i = 0; i < positionNum.length; i++) {
if (scrollTop <= positionNum[i] + 360) {
setTabKey(i);
return;
}
}
}
}
var throttleHandleScroll = Object(_utils_mettingUtil__WEBPACK_IMPORTED_MODULE_18__[/* throttle */ "a"])(handleScroll, 100);
Object(react__WEBPACK_IMPORTED_MODULE_7__["useEffect"])(function () {
if (JSON.stringify(dirList) !== '{}') {
getAllLists();
}
var anchor = document.getElementsByClassName("anchor");
if (anchor && anchor.length > 1) {
var arr = [];
for (var i = 0; i < anchor.length; i++) {
arr.push(anchor[i].getBoundingClientRect().top);
}
setPositionNum(arr);
}
}, [dirList, searchTitle]);
var getAllLists = function getAllLists() {
setIsSpin(true);
var requestList = [];
_info__WEBPACK_IMPORTED_MODULE_9__[/* information */ "c"].category.map(function (e) {
dirList[e.title] && requestList.push(getList(dirList[e.title], e.anchor, searchTitle));
});
Promise.all(requestList).then(function (res) {
var totalList = {};
res.map(function (e) {
totalList[e.name] = e.list;
});
setInformationList(totalList);
setIsSpin(false);
});
};
var getList = function getList(id, name, title) {
return new Promise(function (resolve, reject) {
Object(_api__WEBPACK_IMPORTED_MODULE_10__[/* getDocList */ "d"])(id).then(function (res) {
var list = res.rows;
list = title ? list.filter(function (i) {
return i.name.indexOf(title) > -1 || i.summary.indexOf(title) > -1;
}) : list;
list.forEach(function (e) {
if (e.publishTime) {
var time = e.publishTime.split('/');
e.date1 = "".concat(time[0], "\u5E74").concat(time[1], "\u6708");
e.date2 = "".concat(time[2], "\u65E5");
} else {
e.date1 = e.date2 = '-';
}
});
resolve({
name: name,
list: list
});
});
});
};
var scrollToAnchor = function scrollToAnchor(anchorName) {
if (anchorName) {
var anchorElement = document.getElementById(anchorName);
if (anchorElement) {
anchorElement.scrollIntoView({
block: 'start',
behavior: 'smooth'
});
}
}
};
return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("div", {
className: "information"
}, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("div", {
className: "tabPanel"
}, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement(antd_es_input__WEBPACK_IMPORTED_MODULE_5__[/* default */ "a"], {
className: "searchInput",
value: title
// onBlur={ (e) => { setTitle(e.target.value) } }
,
onChange: function onChange(e) {
setTitle(e.target.value);
},
onPressEnter: function onPressEnter() {
setSearchTitle(title);
},
placeholder: "\u8BF7\u641C\u7D22\u6587\u7AE0\u6807\u9898\u5173\u952E\u8BCD",
suffix: /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("img", {
src: _img_search_png__WEBPACK_IMPORTED_MODULE_17___default.a,
width: 16
}),
style: {
width: "213px"
}
})), _info__WEBPACK_IMPORTED_MODULE_9__[/* information */ "c"].category && showAnchor && /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("div", {
className: "anchorPart",
style: {
top: 362,
left: (document.documentElement.clientWidth - 1200) / 2 - 125
}
}, _info__WEBPACK_IMPORTED_MODULE_9__[/* information */ "c"].category.map(function (e, k) {
return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("li", {
key: k,
className: "".concat(k === tabKey ? "active" : ""),
onClick: function onClick() {
scrollToAnchor(e.anchor);
}
}, e.title);
})), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement(antd_es_spin__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"], {
spinning: isSpin
}, _info__WEBPACK_IMPORTED_MODULE_9__[/* information */ "c"].category.map(function (e) {
return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("div", {
className: "content",
key: e.anchor
}, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("div", {
className: "anchor",
id: e.anchor
}), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("div", {
style: {
textAlign: "center",
paddingTop: 18,
paddingBottom: 50
}
}, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("p", {
className: "homeMaintitle"
}, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("img", {
src: _img_left_png__WEBPACK_IMPORTED_MODULE_14___default.a
}), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("span", null, e.title), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("img", {
src: _img_right_png__WEBPACK_IMPORTED_MODULE_15___default.a
})), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("p", {
className: "homeSubtitle"
}, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("span", null, e.eng.toUpperCase()))), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("div", {
className: "content-wrapper"
}, informationList[e.anchor] && informationList[e.anchor].length > 0 ? informationList[e.anchor].map(function (e, k) {
return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("div", {
className: "content-item",
key: k
}, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("div", {
className: "item-left"
}, e.date2), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("div", {
className: "item-right"
}, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("p", {
className: "time"
}, e.date1), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement(antd_es_divider__WEBPACK_IMPORTED_MODULE_3__[/* default */ "a"], {
style: {
color: 'rgba(9, 37, 77, 0.1)',
margin: '0px'
}
}), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement(umi__WEBPACK_IMPORTED_MODULE_13__[/* Link */ "a"], {
to: "/competitions/2024/information/".concat(e.id),
className: "item-title task-hide"
}, e.name), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("p", {
className: "item-desc task-hide-2"
}, e.summary), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("a", {
href: "/competitions/2024/information/".concat(e.id),
className: "read-more"
}, "\u9605\u8BFB\u5168\u6587 ", /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("span", null, "\u2192"))));
}) : /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_7___default.a.createElement("img", {
className: "empty",
src: _img_empty_png__WEBPACK_IMPORTED_MODULE_11___default.a,
alt: ""
})));
})));
}
/* harmony default export */ __webpack_exports__["default"] = (Information);
/***/ }),
/***/ "Gytx":
/*!********************************************!*\
!*** ./node_modules/shallowequal/index.js ***!
\********************************************/
/*! no static exports found */
/*! exports used: default */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports) {
//
module.exports = function shallowEqual(objA, objB, compare, compareContext) {
var ret = compare ? compare.call(compareContext, objA, objB) : void 0;
if (ret !== void 0) {
return !!ret;
}
if (objA === objB) {
return true;
}
if (typeof objA !== "object" || !objA || typeof objB !== "object" || !objB) {
return false;
}
var keysA = Object.keys(objA);
var keysB = Object.keys(objB);
if (keysA.length !== keysB.length) {
return false;
}
var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);
// Test for A's keys different from B.
for (var idx = 0; idx < keysA.length; idx++) {
var key = keysA[idx];
if (!bHasOwnProperty(key)) {
return false;
}
var valueA = objA[key];
var valueB = objB[key];
ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;
if (ret === false || (ret === void 0 && valueA !== valueB)) {
return false;
}
}
return true;
};
/***/ }),
/***/ "PArb":
/*!***********************************************!*\
!*** ./node_modules/antd/es/divider/index.js ***!
\***********************************************/
/*! exports provided: default */
/*! exports used: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony import */ var _babel_runtime_helpers_extends__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/extends */ "pVnL");
/* harmony import */ var _babel_runtime_helpers_extends__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_extends__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "lSNA");
/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! react */ "q1tI");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_2__);
/* harmony import */ var classnames__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! classnames */ "TSYQ");
/* harmony import */ var classnames__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(classnames__WEBPACK_IMPORTED_MODULE_3__);
/* harmony import */ var _config_provider__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../config-provider */ "H84U");
var __rest = undefined && undefined.__rest || function (s, e) {
var t = {};
for (var p in s) {
if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
}
if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
}
return t;
};
var Divider = function Divider(props) {
return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_2__["createElement"](_config_provider__WEBPACK_IMPORTED_MODULE_4__[/* ConfigConsumer */ "a"], null, function (_ref) {
var _classNames;
var getPrefixCls = _ref.getPrefixCls,
direction = _ref.direction;
var customizePrefixCls = props.prefixCls,
_props$type = props.type,
type = _props$type === void 0 ? 'horizontal' : _props$type,
_props$orientation = props.orientation,
orientation = _props$orientation === void 0 ? 'center' : _props$orientation,
className = props.className,
children = props.children,
dashed = props.dashed,
plain = props.plain,
restProps = __rest(props, ["prefixCls", "type", "orientation", "className", "children", "dashed", "plain"]);
var prefixCls = getPrefixCls('divider', customizePrefixCls);
var orientationPrefix = orientation.length > 0 ? "-".concat(orientation) : orientation;
var hasChildren = !!children;
var classString = classnames__WEBPACK_IMPORTED_MODULE_3___default()(className, prefixCls, "".concat(prefixCls, "-").concat(type), (_classNames = {}, _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1___default()(_classNames, "".concat(prefixCls, "-with-text"), hasChildren), _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1___default()(_classNames, "".concat(prefixCls, "-with-text").concat(orientationPrefix), hasChildren), _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1___default()(_classNames, "".concat(prefixCls, "-dashed"), !!dashed), _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1___default()(_classNames, "".concat(prefixCls, "-plain"), !!plain), _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1___default()(_classNames, "".concat(prefixCls, "-rtl"), direction === 'rtl'), _classNames));
return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_2__["createElement"]("div", _babel_runtime_helpers_extends__WEBPACK_IMPORTED_MODULE_0___default()({
className: classString
}, restProps, {
role: "separator"
}), children && /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_2__["createElement"]("span", {
className: "".concat(prefixCls, "-inner-text")
}, children));
});
};
/* harmony default export */ __webpack_exports__["a"] = (Divider);
/***/ }),
/***/ "Y4+S":
/*!*********************************************!*\
!*** ./src/pages/metting/img/subBanner.png ***!
\*********************************************/
/*! no static exports found */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
module.exports = __webpack_require__.p + "static/subBanner.c94b8b58.png";
/***/ }),
/***/ "Y8td":
/*!*****************************************!*\
!*** ./src/pages/metting/img/right.png ***!
\*****************************************/
/*! no static exports found */
/*! exports used: default */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports) {
module.exports = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABkAAAAkCAYAAAB8DZEQAAAAAXNSR0IArs4c6QAAAxJJREFUSEu1Vk1PE1EUve81FJP6EXZ22wQjxGoUotWoMSL9BwYDVidiEVcuZckOl+5k51L+gelOFsRNXdikYCQI+AVIXJvAu/eaN2/edGbaTqEfkzTNbdOee945594noMdPcbDqiF5iPB/8mkE4qPQMZB5Y7pxbW2HEXM9AZs6vzQHSgiCCnoA8HVrNCYJlSZwExO6DFC5+TvUfJCuSOSOQwH11W/ji8JdFQfwM9J8TQ9eZPLmwnk8QltzuicACdY3JzNBqmhOJT6AoLVgzIJAaSHXxuIrZ9RIg5oHY6KBd5R1ZV5gUL23MMqo3RgPNwNPCqzsGcUY2solD/CiQU273lgkSgMuGO3PX/eFq8lRff1kSZ7WLpNZCa+CJ7jPqxMLTlzdeAfHLoAam+wCjThLvXNnMJYhWgEiGNUCjiWbkuqzNxE/e3B448Q/LQlHG6KAzUe8qk5M2LTw9urnESBNRFwVre2RtMZke3XzAzO+si/xuo64K1Mey8MzIVlpJrgriAf/MladBYFbVXHZMTfQS2rr6/b0kyvszKZBsk3Ss5aSd2eVc256TDAvuGTdJtnEV+q5yaw1+lJw4139kBVEZiJP+jtA/tt3aXBC6Ca/pRAAMrUF0qk+eOV0GxGwsg2YM4Qggzo2fr4HoRXCq+p1Gkh3VSh+VfmKP6/Ht33k4xJL1f9Q1cbU2gX2aguhU90GiKpDTdZsu5Kr6WeWvXg+lKcijW7+WJPFEo/0Ql3R3GnuuimVSuLPjSEVvjQ7ahrZbbz/4GQh/HnVVU5DJsb1Mn6IKKEzpjth21mDjxTIKZCN0XPPzLL992FsR+mppV2dkP0T3RaP9YV3VkEnh7p85oXBBMgEr8jZdYOO5m691HRXar6fu7eYk8rJEfbUMb7ZWdW2se7slMkZckEJ+NwVKVCRxJqrBsTXRpmgE8nBsf1EymaulzYDVxM9EYFbZW0hodnksTMhDj5ga/5uXhKVgHoxranfZ+FxE7lkNJq4ojO/PCqSz2iXutVKzVQqkftefKXN/8r/36uj35rf1R6Ux/wMtfnZYluT9lgAAAABJRU5ErkJggg=="
/***/ }),
/***/ "bE4E":
/*!*******************************************************!*\
!*** ./node_modules/antd/es/divider/style/index.less ***!
\*******************************************************/
/*! no static exports found */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
// extracted by mini-css-extract-plugin
/***/ }),
/***/ "gnzr":
/*!**********************************!*\
!*** ./src/utils/mettingUtil.js ***!
\**********************************/
/*! exports provided: throttle */
/*! exports used: throttle */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return throttle; });
function throttle(fn, delay) {
var timer = null; // 使用定时器实现
return function () {
var _this = this; // 当前 this 保存,以免后续处理中 this 丢失
if (!timer) {
fn.apply(_this, arguments);
timer = setTimeout(function () {
timer = null;
}, delay);
}
};
}
/***/ }),
/***/ "h49j":
/*!******************************************!*\
!*** ./src/pages/metting/img/search.png ***!
\******************************************/
/*! no static exports found */
/*! exports used: default */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports) {
module.exports = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAASCAYAAABSO15qAAAAAXNSR0IArs4c6QAAAiVJREFUOE+Vk8FrE1EQxr9vN9hUC6ZR0h4i2HYjJCmlAXsQBAl4qAfBgyKCoGDBi8cKejIFD0I8COYiCvXmpWJBQYuV/AHxYFt305rUFBskSW02BQ+K6Y684Na0aNm+2zDv+71v5s0QO45ZWI8TGBNgFEAYZJOQMoBpv9aR6e/vqrZL6AbZbNbXEx5KC3iDRIPgKxArKi8iw4CMiqCpUR+PGoFHrq4FUOJQeOgZwHOahvsVbWMi2df3o/2l90tfDx/QO9MCuSqCe/FI8LbKtwD5ZfuOiKRE5EI8cmhqZ1ntsXuX1M5HBwLPaZq1XnboJYKZqBG8uZvYzVlF+y0gRlXfiLJFdGT853ceSSS6G14AC8trx3XRc8oFraKdg0glFgme9SL+66JeAjhLq1Bfo8ZMdKB7Yo+AFwACtIp1IZnaKyBftCcFzqAClAhMeW3g9kYCqoSXIHtjRveI1xL+zI1Nag/4sbA+ppGPxWkm4sdCH7xA8kX7ikCeQuQEs6WSv2fz4IIAldrqXDKZTDZ3g6iJ3K/7cwBWYkYw2ZpE69O300LtNSDTtfL8pf9BlLhT96vuDwLNkbgRKm4tk1moXwYwSWIRxK3ql7kZF2SatS7u0y8KkCIZBmS2ujp/RuW3AMqJuVQ/SR8eQjAsUBspZRH4SBwF6CfwZlNkhmDadbsN4NbeAuk4RdAQQL2y6Di/3rlNtj43rsFxngBy958Abz/RuC6Q8G8W6vhxrxdjeAAAAABJRU5ErkJggg=="
/***/ }),
/***/ "oOC2":
/*!****************************************!*\
!*** ./src/pages/metting/img/left.png ***!
\****************************************/
/*! no static exports found */
/*! exports used: default */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports) {
module.exports = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABkAAAAkCAYAAAB8DZEQAAAAAXNSR0IArs4c6QAAAyFJREFUSEutVktPFEEQ7h4P3I0KPleCEgLJenAvhgNeFEEJHuVx4ChHb3rzKDePCrIOjxANv8AlGiIxrsFodAnGaLhilLCArphlqspM9/TsPHtnlLlMah79dVV931fNB67/JKa7AJmBxBgAM4gYWZpYfIeMq+/lfYprQYjED1z8iO4CcbH9nCE639v/0dpuQzWrBeHk2ZklM7F3KjKzgIn3dmbi7o3Rfo5kUeejr+1FPYibusxEZqCAVRzOUGQEbGzic9ttuxPxIE6pRC+che07BWL7vQJWvePIilvM6ppf7ahqQdxSOf1wM9DEMgOsYJVn819a1xSf4jPxsMqtvY81QRbJmAOMTqy2PfASNhokJasUbQ3AwsRKa3dQEZEgqlSiBwFWBWPFKm7BumFZ58c/ta8nA1EsUoyKiV3tADIC6s6vnC1E6TqcicuqmrL9Cg4+F714OPnhzM044wiBeAXoV3a0ThhSaQ9+XZj5eK6SGMRVtM0u4VVKJ2Hv4khV3KOcWWop6ezPnwkxj7LrexUDvJN/33JPa7BBxfu8qo6yyYJi5l1z513GMR2IYBN5nDQ65ohlxnguv5xxVZ2sXBGsivMqA2lg8m3zk3oZhGzFz6qa6YXcF+jp4+XMjaQAfoN02GTPB+lVzvxw7vZEPIC0/uc3dcyVMuX0IEm8CggNop78m1ORqq7bEx2ravMDxsxiRgyhtJfUCSqrqE07H8sAS5XtnZwaQulB+ncoPNk8sxygypFy5uuTWlVryzXYv0NqHsR41S3z1Yn7aXfvH1p92yRPGwFWSXsvTC0dCw2htIB8sG9bZFI7BLjnrDJQtWN26XRoCKUHubbl9MR/KuEAA+bS8cSq1vZk6OqWYJfqh2AV4NT0y6MjaXccO08Ge8vknnXFTMc11sCyM4Wm2CGUFpwP9ZbJzQIRDaBOc7GpmHYhfbl6NmVPpEeNTb9o/CdVa0GGr2w67MLi7sEfXfPz8mi5nxcf6t6we1IBxOzc88ZEQyjtBvjw5Q3iRKMzC4d9R8u0C+nLdWnj2ezCof9WtRZk5OL3JnPxyLf93Hlwrb/udaK4RF4QvgAAAABJRU5ErkJggg=="
/***/ }),
/***/ "tuCT":
/*!**************************************************!*\
!*** ./src/pages/metting/information/index.less ***!
\**************************************************/
/*! no static exports found */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
// extracted by mini-css-extract-plugin
/***/ })
}]);

View File

@ -0,0 +1,903 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[18],{
/***/ "/zsF":
/*!*****************************************************!*\
!*** ./node_modules/antd/es/divider/style/index.js ***!
\*****************************************************/
/*! no exports provided */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony import */ var _style_index_less__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../style/index.less */ "cIOH");
/* harmony import */ var _style_index_less__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_style_index_less__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _index_less__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./index.less */ "bE4E");
/* harmony import */ var _index_less__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_index_less__WEBPACK_IMPORTED_MODULE_1__);
/***/ }),
/***/ "1143":
/*!**************************************************!*\
!*** ./src/pages/metting/information/detail.jsx ***!
\**************************************************/
/*! exports provided: default */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./src/.umi-production/core/routes.ts (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var antd_es_divider_style__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! antd/es/divider/style */ "/zsF");
/* harmony import */ var antd_es_divider__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! antd/es/divider */ "PArb");
/* harmony import */ var antd_es_breadcrumb_style__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! antd/es/breadcrumb/style */ "sPJy");
/* harmony import */ var antd_es_breadcrumb__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! antd/es/breadcrumb */ "bE4q");
/* harmony import */ var D_projects_competitions_forgeplus_react_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./node_modules/@umijs/babel-preset-umi/node_modules/@babel/runtime/helpers/esm/slicedToArray */ "tJVT");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! react */ "q1tI");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_5__);
/* harmony import */ var _index_less__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./index.less */ "tuCT");
/* harmony import */ var _index_less__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(_index_less__WEBPACK_IMPORTED_MODULE_6__);
/* harmony import */ var _components_RenderHtml__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! @/components/RenderHtml */ "9Bee");
/* harmony import */ var umi__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! umi */ "Ty5D");
/* harmony import */ var js_base64__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! js-base64 */ "J66h");
/* harmony import */ var js_base64__WEBPACK_IMPORTED_MODULE_9___default = /*#__PURE__*/__webpack_require__.n(js_base64__WEBPACK_IMPORTED_MODULE_9__);
/* harmony import */ var _img_views_png__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ../img/views.png */ "7eeR");
/* harmony import */ var _img_views_png__WEBPACK_IMPORTED_MODULE_10___default = /*#__PURE__*/__webpack_require__.n(_img_views_png__WEBPACK_IMPORTED_MODULE_10__);
/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ../api */ "Lj8O");
/* harmony import */ var _info__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../info */ "PZZE");
function Detail() {
var location = Object(umi__WEBPACK_IMPORTED_MODULE_8__[/* useLocation */ "k"])();
var _ref = location.pathname.includes('information') ? Object(umi__WEBPACK_IMPORTED_MODULE_8__[/* useParams */ "l"])() : {
id: _info__WEBPACK_IMPORTED_MODULE_12__[/* defaultPage */ "b"][location.pathname]
},
id = _ref.id;
var _useState = Object(react__WEBPACK_IMPORTED_MODULE_5__["useState"])({}),
_useState2 = Object(D_projects_competitions_forgeplus_react_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_4__[/* default */ "a"])(_useState, 2),
detail = _useState2[0],
setDetail = _useState2[1];
var _useState3 = Object(react__WEBPACK_IMPORTED_MODULE_5__["useState"])(undefined),
_useState4 = Object(D_projects_competitions_forgeplus_react_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_4__[/* default */ "a"])(_useState3, 2),
cmsDir = _useState4[0],
setCmsDir = _useState4[1];
var _useState5 = Object(react__WEBPACK_IMPORTED_MODULE_5__["useState"])(undefined),
_useState6 = Object(D_projects_competitions_forgeplus_react_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_4__[/* default */ "a"])(_useState5, 2),
content = _useState6[0],
setContent = _useState6[1];
Object(react__WEBPACK_IMPORTED_MODULE_5__["useEffect"])(function () {
getDetail();
}, [id]);
var getDetail = function getDetail() {
Object(_api__WEBPACK_IMPORTED_MODULE_11__[/* getDocDetail */ "c"])(id).then(function (res) {
setDetail(res.data);
setCmsDir(res.data.cmsDir);
setContent(js_base64__WEBPACK_IMPORTED_MODULE_9__["Base64"].decode(res.data.content));
});
};
return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5___default.a.createElement("div", {
className: "detail"
}, detail && /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5___default.a.createElement("div", {
className: "detail-content"
}, location.pathname.includes('information') && /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5___default.a.createElement(antd_es_breadcrumb__WEBPACK_IMPORTED_MODULE_3__[/* default */ "a"], {
separator: ">"
}, cmsDir && /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5___default.a.createElement(antd_es_breadcrumb__WEBPACK_IMPORTED_MODULE_3__[/* default */ "a"].Item, {
href: "/competitions/2024/information"
}, cmsDir.name), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5___default.a.createElement(antd_es_breadcrumb__WEBPACK_IMPORTED_MODULE_3__[/* default */ "a"].Item, null, "\u6B63\u6587")), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5___default.a.createElement("div", {
className: "detail-info"
}, location.pathname.includes('information') && /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5___default.a.createElement(react__WEBPACK_IMPORTED_MODULE_5___default.a.Fragment, null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5___default.a.createElement("div", {
className: "info-text-main"
}, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5___default.a.createElement("p", {
className: "info-name"
}, detail.name), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5___default.a.createElement("ul", {
className: "info-ul-value"
}, cmsDir && /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5___default.a.createElement("li", null, "\u53D1\u5E03\u4E8E", cmsDir.createdAt), detail.visits && /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5___default.a.createElement("li", null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5___default.a.createElement("img", {
src: _img_views_png__WEBPACK_IMPORTED_MODULE_10___default.a,
alt: "",
className: "mr5"
}), detail.visits))), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5___default.a.createElement(antd_es_divider__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"], {
dashed: true
})), content ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5___default.a.createElement(_components_RenderHtml__WEBPACK_IMPORTED_MODULE_7__[/* default */ "a"], {
className: "informations_detail imageLayerParent",
value: content,
url: location
}) : /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5___default.a.createElement("span", null, "\u6682\u65E0\u8BE6\u60C5~"))));
}
/* harmony default export */ __webpack_exports__["default"] = (Detail);
/***/ }),
/***/ "7eeR":
/*!*****************************************!*\
!*** ./src/pages/metting/img/views.png ***!
\*****************************************/
/*! no static exports found */
/*! exports used: default */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports) {
module.exports = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA8AAAAMCAYAAAC9QufkAAAABHNCSVQICAgIfAhkiAAAAUVJREFUKFOlUTFuwkAQ3D0cap7AE/hB+AFEwXWcNhAJBKnjB2BBYSvtpbYjyA+cH/AEfhDq4LvN7qEjRxeJa3ze3ZnZmUO44mCIXa02HXNjBoAwBIKO7yHCngjqxWT0Hs6fwVnxkRBRikjaWqhfnuNaBoWwiZoeKhwiQZ8UpIun0VZ6DrzMK82gjvqJktns7iC1LC+nBDjgq/aKQmTbDQOVno/vNS6Lai0r8kDiV5IaAh2UirQxhrfBWobPfSeGNbLqnoHd0EtWlDwc993ab5uutQ0rnf79yfJqJ2DHcsHslHEnNSZKBcBg9/U22fDhzzPQ93wSz5yapN7mdYF67Hu3GI+mvm7bZsXJo9gM0i5TIhTfr61j69MHF5A9cNqPAKRZZC31y3c++RMC9oe38rb8xnynLw51q46RDkkvwGEg/7lfBf4FAFWjNrMSjaoAAAAASUVORK5CYII="
/***/ }),
/***/ "AOa7":
/*!**********************************************************!*\
!*** ./node_modules/antd/es/breadcrumb/style/index.less ***!
\**********************************************************/
/*! no static exports found */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
// extracted by mini-css-extract-plugin
/***/ }),
/***/ "HQEm":
/*!********************************************************!*\
!*** ./node_modules/@ant-design/icons/DownOutlined.js ***!
\********************************************************/
/*! no static exports found */
/*! exports used: default */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _DownOutlined = _interopRequireDefault(__webpack_require__(/*! ./lib/icons/DownOutlined */ "Sj0X"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
var _default = _DownOutlined;
exports.default = _default;
module.exports = _default;
/***/ }),
/***/ "J66h":
/*!******************************************!*\
!*** ./node_modules/js-base64/base64.js ***!
\******************************************/
/*! no static exports found */
/*! exports used: Base64 */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(global) {var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*
* base64.js
*
* Licensed under the BSD 3-Clause License.
* http://opensource.org/licenses/BSD-3-Clause
*
* References:
* http://en.wikipedia.org/wiki/Base64
*/
;(function (global, factory) {
true
? module.exports = factory(global)
: undefined
}((
typeof self !== 'undefined' ? self
: typeof window !== 'undefined' ? window
: typeof global !== 'undefined' ? global
: this
), function(global) {
'use strict';
// existing version for noConflict()
global = global || {};
var _Base64 = global.Base64;
var version = "2.6.4";
// constants
var b64chars
= 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
var b64tab = function(bin) {
var t = {};
for (var i = 0, l = bin.length; i < l; i++) t[bin.charAt(i)] = i;
return t;
}(b64chars);
var fromCharCode = String.fromCharCode;
// encoder stuff
var cb_utob = function(c) {
if (c.length < 2) {
var cc = c.charCodeAt(0);
return cc < 0x80 ? c
: cc < 0x800 ? (fromCharCode(0xc0 | (cc >>> 6))
+ fromCharCode(0x80 | (cc & 0x3f)))
: (fromCharCode(0xe0 | ((cc >>> 12) & 0x0f))
+ fromCharCode(0x80 | ((cc >>> 6) & 0x3f))
+ fromCharCode(0x80 | ( cc & 0x3f)));
} else {
var cc = 0x10000
+ (c.charCodeAt(0) - 0xD800) * 0x400
+ (c.charCodeAt(1) - 0xDC00);
return (fromCharCode(0xf0 | ((cc >>> 18) & 0x07))
+ fromCharCode(0x80 | ((cc >>> 12) & 0x3f))
+ fromCharCode(0x80 | ((cc >>> 6) & 0x3f))
+ fromCharCode(0x80 | ( cc & 0x3f)));
}
};
var re_utob = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g;
var utob = function(u) {
return u.replace(re_utob, cb_utob);
};
var cb_encode = function(ccc) {
var padlen = [0, 2, 1][ccc.length % 3],
ord = ccc.charCodeAt(0) << 16
| ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8)
| ((ccc.length > 2 ? ccc.charCodeAt(2) : 0)),
chars = [
b64chars.charAt( ord >>> 18),
b64chars.charAt((ord >>> 12) & 63),
padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63),
padlen >= 1 ? '=' : b64chars.charAt(ord & 63)
];
return chars.join('');
};
var btoa = global.btoa && typeof global.btoa == 'function'
? function(b){ return global.btoa(b) } : function(b) {
if (b.match(/[^\x00-\xFF]/)) throw new RangeError(
'The string contains invalid characters.'
);
return b.replace(/[\s\S]{1,3}/g, cb_encode);
};
var _encode = function(u) {
return btoa(utob(String(u)));
};
var mkUriSafe = function (b64) {
return b64.replace(/[+\/]/g, function(m0) {
return m0 == '+' ? '-' : '_';
}).replace(/=/g, '');
};
var encode = function(u, urisafe) {
return urisafe ? mkUriSafe(_encode(u)) : _encode(u);
};
var encodeURI = function(u) { return encode(u, true) };
var fromUint8Array;
if (global.Uint8Array) fromUint8Array = function(a, urisafe) {
// return btoa(fromCharCode.apply(null, a));
var b64 = '';
for (var i = 0, l = a.length; i < l; i += 3) {
var a0 = a[i], a1 = a[i+1], a2 = a[i+2];
var ord = a0 << 16 | a1 << 8 | a2;
b64 += b64chars.charAt( ord >>> 18)
+ b64chars.charAt((ord >>> 12) & 63)
+ ( typeof a1 != 'undefined'
? b64chars.charAt((ord >>> 6) & 63) : '=')
+ ( typeof a2 != 'undefined'
? b64chars.charAt( ord & 63) : '=');
}
return urisafe ? mkUriSafe(b64) : b64;
};
// decoder stuff
var re_btou = /[\xC0-\xDF][\x80-\xBF]|[\xE0-\xEF][\x80-\xBF]{2}|[\xF0-\xF7][\x80-\xBF]{3}/g;
var cb_btou = function(cccc) {
switch(cccc.length) {
case 4:
var cp = ((0x07 & cccc.charCodeAt(0)) << 18)
| ((0x3f & cccc.charCodeAt(1)) << 12)
| ((0x3f & cccc.charCodeAt(2)) << 6)
| (0x3f & cccc.charCodeAt(3)),
offset = cp - 0x10000;
return (fromCharCode((offset >>> 10) + 0xD800)
+ fromCharCode((offset & 0x3FF) + 0xDC00));
case 3:
return fromCharCode(
((0x0f & cccc.charCodeAt(0)) << 12)
| ((0x3f & cccc.charCodeAt(1)) << 6)
| (0x3f & cccc.charCodeAt(2))
);
default:
return fromCharCode(
((0x1f & cccc.charCodeAt(0)) << 6)
| (0x3f & cccc.charCodeAt(1))
);
}
};
var btou = function(b) {
return b.replace(re_btou, cb_btou);
};
var cb_decode = function(cccc) {
var len = cccc.length,
padlen = len % 4,
n = (len > 0 ? b64tab[cccc.charAt(0)] << 18 : 0)
| (len > 1 ? b64tab[cccc.charAt(1)] << 12 : 0)
| (len > 2 ? b64tab[cccc.charAt(2)] << 6 : 0)
| (len > 3 ? b64tab[cccc.charAt(3)] : 0),
chars = [
fromCharCode( n >>> 16),
fromCharCode((n >>> 8) & 0xff),
fromCharCode( n & 0xff)
];
chars.length -= [0, 0, 2, 1][padlen];
return chars.join('');
};
var _atob = global.atob && typeof global.atob == 'function'
? function(a){ return global.atob(a) } : function(a){
return a.replace(/\S{1,4}/g, cb_decode);
};
var atob = function(a) {
return _atob(String(a).replace(/[^A-Za-z0-9\+\/]/g, ''));
};
var _decode = function(a) { return btou(_atob(a)) };
var _fromURI = function(a) {
return String(a).replace(/[-_]/g, function(m0) {
return m0 == '-' ? '+' : '/'
}).replace(/[^A-Za-z0-9\+\/]/g, '');
};
var decode = function(a){
return _decode(_fromURI(a));
};
var toUint8Array;
if (global.Uint8Array) toUint8Array = function(a) {
return Uint8Array.from(atob(_fromURI(a)), function(c) {
return c.charCodeAt(0);
});
};
var noConflict = function() {
var Base64 = global.Base64;
global.Base64 = _Base64;
return Base64;
};
// export Base64
global.Base64 = {
VERSION: version,
atob: atob,
btoa: btoa,
fromBase64: decode,
toBase64: encode,
utob: utob,
encode: encode,
encodeURI: encodeURI,
btou: btou,
decode: decode,
noConflict: noConflict,
fromUint8Array: fromUint8Array,
toUint8Array: toUint8Array
};
// if ES5 is available, make Base64.extendString() available
if (typeof Object.defineProperty === 'function') {
var noEnum = function(v){
return {value:v,enumerable:false,writable:true,configurable:true};
};
global.Base64.extendString = function () {
Object.defineProperty(
String.prototype, 'fromBase64', noEnum(function () {
return decode(this)
}));
Object.defineProperty(
String.prototype, 'toBase64', noEnum(function (urisafe) {
return encode(this, urisafe)
}));
Object.defineProperty(
String.prototype, 'toBase64URI', noEnum(function () {
return encode(this, true)
}));
};
}
//
// export Base64 to the namespace
//
if (global['Meteor']) { // Meteor.js
Base64 = global.Base64;
}
// module.exports and AMD are mutually exclusive.
// module.exports has precedence.
if ( true && module.exports) {
module.exports.Base64 = global.Base64;
}
else if (true) {
// AMD. Register as an anonymous module.
!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function(){ return global.Base64 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
}
// that's it!
return {Base64: global.Base64}
}));
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ "yLpj")))
/***/ }),
/***/ "PArb":
/*!***********************************************!*\
!*** ./node_modules/antd/es/divider/index.js ***!
\***********************************************/
/*! exports provided: default */
/*! exports used: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony import */ var _babel_runtime_helpers_extends__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/extends */ "pVnL");
/* harmony import */ var _babel_runtime_helpers_extends__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_extends__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "lSNA");
/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! react */ "q1tI");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_2__);
/* harmony import */ var classnames__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! classnames */ "TSYQ");
/* harmony import */ var classnames__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(classnames__WEBPACK_IMPORTED_MODULE_3__);
/* harmony import */ var _config_provider__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../config-provider */ "H84U");
var __rest = undefined && undefined.__rest || function (s, e) {
var t = {};
for (var p in s) {
if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
}
if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
}
return t;
};
var Divider = function Divider(props) {
return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_2__["createElement"](_config_provider__WEBPACK_IMPORTED_MODULE_4__[/* ConfigConsumer */ "a"], null, function (_ref) {
var _classNames;
var getPrefixCls = _ref.getPrefixCls,
direction = _ref.direction;
var customizePrefixCls = props.prefixCls,
_props$type = props.type,
type = _props$type === void 0 ? 'horizontal' : _props$type,
_props$orientation = props.orientation,
orientation = _props$orientation === void 0 ? 'center' : _props$orientation,
className = props.className,
children = props.children,
dashed = props.dashed,
plain = props.plain,
restProps = __rest(props, ["prefixCls", "type", "orientation", "className", "children", "dashed", "plain"]);
var prefixCls = getPrefixCls('divider', customizePrefixCls);
var orientationPrefix = orientation.length > 0 ? "-".concat(orientation) : orientation;
var hasChildren = !!children;
var classString = classnames__WEBPACK_IMPORTED_MODULE_3___default()(className, prefixCls, "".concat(prefixCls, "-").concat(type), (_classNames = {}, _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1___default()(_classNames, "".concat(prefixCls, "-with-text"), hasChildren), _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1___default()(_classNames, "".concat(prefixCls, "-with-text").concat(orientationPrefix), hasChildren), _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1___default()(_classNames, "".concat(prefixCls, "-dashed"), !!dashed), _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1___default()(_classNames, "".concat(prefixCls, "-plain"), !!plain), _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1___default()(_classNames, "".concat(prefixCls, "-rtl"), direction === 'rtl'), _classNames));
return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_2__["createElement"]("div", _babel_runtime_helpers_extends__WEBPACK_IMPORTED_MODULE_0___default()({
className: classString
}, restProps, {
role: "separator"
}), children && /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_2__["createElement"]("span", {
className: "".concat(prefixCls, "-inner-text")
}, children));
});
};
/* harmony default export */ __webpack_exports__["a"] = (Divider);
/***/ }),
/***/ "Sj0X":
/*!******************************************************************!*\
!*** ./node_modules/@ant-design/icons/lib/icons/DownOutlined.js ***!
\******************************************************************/
/*! no static exports found */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "TqRt");
var _typeof = __webpack_require__(/*! @babel/runtime/helpers/typeof */ "cDf5");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _objectSpread2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/objectSpread2 */ "3tO9"));
var React = _interopRequireWildcard(__webpack_require__(/*! react */ "q1tI"));
var _DownOutlined = _interopRequireDefault(__webpack_require__(/*! @ant-design/icons-svg/lib/asn/DownOutlined */ "XuBP"));
var _AntdIcon = _interopRequireDefault(__webpack_require__(/*! ../components/AntdIcon */ "KQxl"));
function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
// GENERATE BY ./scripts/generate.ts
// DON NOT EDIT IT MANUALLY
var DownOutlined = function DownOutlined(props, ref) {
return /*#__PURE__*/React.createElement(_AntdIcon.default, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, props), {}, {
ref: ref,
icon: _DownOutlined.default
}));
};
var RefIcon = /*#__PURE__*/React.forwardRef(DownOutlined);
if (false) {}
var _default = exports.default = RefIcon;
/***/ }),
/***/ "XuBP":
/*!********************************************************************!*\
!*** ./node_modules/@ant-design/icons-svg/lib/asn/DownOutlined.js ***!
\********************************************************************/
/*! no static exports found */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
// This icon file is generated automatically.
Object.defineProperty(exports, "__esModule", { value: true });
var DownOutlined = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M884 256h-75c-5.1 0-9.9 2.5-12.9 6.6L512 654.2 227.9 262.6c-3-4.1-7.8-6.6-12.9-6.6h-75c-6.5 0-10.3 7.4-6.5 12.7l352.6 486.1c12.8 17.6 39 17.6 51.7 0l352.6-486.1c3.9-5.3.1-12.7-6.4-12.7z" } }] }, "name": "down", "theme": "outlined" };
exports.default = DownOutlined;
/***/ }),
/***/ "bE4E":
/*!*******************************************************!*\
!*** ./node_modules/antd/es/divider/style/index.less ***!
\*******************************************************/
/*! no static exports found */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
// extracted by mini-css-extract-plugin
/***/ }),
/***/ "bE4q":
/*!**************************************************************!*\
!*** ./node_modules/antd/es/breadcrumb/index.js + 3 modules ***!
\**************************************************************/
/*! exports provided: default */
/*! exports used: default */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/@ant-design/icons/DownOutlined.js (<- Module is not an ECMAScript module) */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/@babel/runtime/helpers/defineProperty.js (<- Module is not an ECMAScript module) */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/@babel/runtime/helpers/extends.js (<- Module is not an ECMAScript module) */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/@babel/runtime/helpers/toConsumableArray.js (<- Module is not an ECMAScript module) */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/antd/es/_util/devWarning.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/antd/es/_util/reactNode.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/antd/es/config-provider/context.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/antd/es/dropdown/dropdown.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/antd/es/menu/index.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/classnames/index.js (<- Module is not an ECMAScript module) */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/rc-util/es/Children/toArray.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/react/index.js (<- Module is not an ECMAScript module) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/extends.js
var helpers_extends = __webpack_require__("pVnL");
var extends_default = /*#__PURE__*/__webpack_require__.n(helpers_extends);
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/defineProperty.js
var defineProperty = __webpack_require__("lSNA");
var defineProperty_default = /*#__PURE__*/__webpack_require__.n(defineProperty);
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/toConsumableArray.js
var toConsumableArray = __webpack_require__("RIqP");
var toConsumableArray_default = /*#__PURE__*/__webpack_require__.n(toConsumableArray);
// EXTERNAL MODULE: ./node_modules/react/index.js
var react = __webpack_require__("q1tI");
// EXTERNAL MODULE: ./node_modules/classnames/index.js
var classnames = __webpack_require__("TSYQ");
var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
// EXTERNAL MODULE: ./node_modules/rc-util/es/Children/toArray.js
var toArray = __webpack_require__("Zm9Q");
// EXTERNAL MODULE: ./node_modules/@ant-design/icons/DownOutlined.js
var DownOutlined = __webpack_require__("HQEm");
var DownOutlined_default = /*#__PURE__*/__webpack_require__.n(DownOutlined);
// EXTERNAL MODULE: ./node_modules/antd/es/dropdown/dropdown.js + 4 modules
var dropdown = __webpack_require__("XBQK");
// EXTERNAL MODULE: ./node_modules/antd/es/config-provider/context.js + 1 modules
var context = __webpack_require__("H84U");
// CONCATENATED MODULE: ./node_modules/antd/es/breadcrumb/BreadcrumbItem.js
var __rest = undefined && undefined.__rest || function (s, e) {
var t = {};
for (var p in s) {
if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
}
if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
}
return t;
};
var BreadcrumbItem_BreadcrumbItem = function BreadcrumbItem(_a) {
var customizePrefixCls = _a.prefixCls,
_a$separator = _a.separator,
separator = _a$separator === void 0 ? '/' : _a$separator,
children = _a.children,
overlay = _a.overlay,
dropdownProps = _a.dropdownProps,
restProps = __rest(_a, ["prefixCls", "separator", "children", "overlay", "dropdownProps"]);
var _React$useContext = react["useContext"](context["b" /* ConfigContext */]),
getPrefixCls = _React$useContext.getPrefixCls;
var prefixCls = getPrefixCls('breadcrumb', customizePrefixCls);
/**
* if overlay is have
* Wrap a DropDown
*/
var renderBreadcrumbNode = function renderBreadcrumbNode(breadcrumbItem) {
if (overlay) {
return /*#__PURE__*/react["createElement"](dropdown["a" /* default */], extends_default()({
overlay: overlay,
placement: "bottomCenter"
}, dropdownProps), /*#__PURE__*/react["createElement"]("span", {
className: "".concat(prefixCls, "-overlay-link")
}, breadcrumbItem, /*#__PURE__*/react["createElement"](DownOutlined_default.a, null)));
}
return breadcrumbItem;
};
var link;
if ('href' in restProps) {
link = /*#__PURE__*/react["createElement"]("a", extends_default()({
className: "".concat(prefixCls, "-link")
}, restProps), children);
} else {
link = /*#__PURE__*/react["createElement"]("span", extends_default()({
className: "".concat(prefixCls, "-link")
}, restProps), children);
} // wrap to dropDown
link = renderBreadcrumbNode(link);
if (children) {
return /*#__PURE__*/react["createElement"]("span", null, link, separator && separator !== '' && /*#__PURE__*/react["createElement"]("span", {
className: "".concat(prefixCls, "-separator")
}, separator));
}
return null;
};
BreadcrumbItem_BreadcrumbItem.__ANT_BREADCRUMB_ITEM = true;
/* harmony default export */ var breadcrumb_BreadcrumbItem = (BreadcrumbItem_BreadcrumbItem);
// CONCATENATED MODULE: ./node_modules/antd/es/breadcrumb/BreadcrumbSeparator.js
var BreadcrumbSeparator_BreadcrumbSeparator = function BreadcrumbSeparator(_ref) {
var children = _ref.children;
var _React$useContext = react["useContext"](context["b" /* ConfigContext */]),
getPrefixCls = _React$useContext.getPrefixCls;
var prefixCls = getPrefixCls('breadcrumb');
return /*#__PURE__*/react["createElement"]("span", {
className: "".concat(prefixCls, "-separator")
}, children || '/');
};
BreadcrumbSeparator_BreadcrumbSeparator.__ANT_BREADCRUMB_SEPARATOR = true;
/* harmony default export */ var breadcrumb_BreadcrumbSeparator = (BreadcrumbSeparator_BreadcrumbSeparator);
// EXTERNAL MODULE: ./node_modules/antd/es/menu/index.js + 16 modules
var menu = __webpack_require__("BvKs");
// EXTERNAL MODULE: ./node_modules/antd/es/_util/devWarning.js
var devWarning = __webpack_require__("uaoM");
// EXTERNAL MODULE: ./node_modules/antd/es/_util/reactNode.js
var reactNode = __webpack_require__("0n0R");
// CONCATENATED MODULE: ./node_modules/antd/es/breadcrumb/Breadcrumb.js
var Breadcrumb_rest = undefined && undefined.__rest || function (s, e) {
var t = {};
for (var p in s) {
if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
}
if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
}
return t;
};
function getBreadcrumbName(route, params) {
if (!route.breadcrumbName) {
return null;
}
var paramsKeys = Object.keys(params).join('|');
var name = route.breadcrumbName.replace(new RegExp(":(".concat(paramsKeys, ")"), 'g'), function (replacement, key) {
return params[key] || replacement;
});
return name;
}
function defaultItemRender(route, params, routes, paths) {
var isLastItem = routes.indexOf(route) === routes.length - 1;
var name = getBreadcrumbName(route, params);
return isLastItem ? /*#__PURE__*/react["createElement"]("span", null, name) : /*#__PURE__*/react["createElement"]("a", {
href: "#/".concat(paths.join('/'))
}, name);
}
var getPath = function getPath(path, params) {
path = (path || '').replace(/^\//, '');
Object.keys(params).forEach(function (key) {
path = path.replace(":".concat(key), params[key]);
});
return path;
};
var Breadcrumb_addChildPath = function addChildPath(paths) {
var childPath = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
var params = arguments.length > 2 ? arguments[2] : undefined;
var originalPaths = toConsumableArray_default()(paths);
var path = getPath(childPath, params);
if (path) {
originalPaths.push(path);
}
return originalPaths;
};
var Breadcrumb_Breadcrumb = function Breadcrumb(_a) {
var customizePrefixCls = _a.prefixCls,
_a$separator = _a.separator,
separator = _a$separator === void 0 ? '/' : _a$separator,
style = _a.style,
className = _a.className,
routes = _a.routes,
children = _a.children,
_a$itemRender = _a.itemRender,
itemRender = _a$itemRender === void 0 ? defaultItemRender : _a$itemRender,
_a$params = _a.params,
params = _a$params === void 0 ? {} : _a$params,
restProps = Breadcrumb_rest(_a, ["prefixCls", "separator", "style", "className", "routes", "children", "itemRender", "params"]);
var _React$useContext = react["useContext"](context["b" /* ConfigContext */]),
getPrefixCls = _React$useContext.getPrefixCls,
direction = _React$useContext.direction;
var crumbs;
var prefixCls = getPrefixCls('breadcrumb', customizePrefixCls);
if (routes && routes.length > 0) {
// generated by route
var paths = [];
crumbs = routes.map(function (route) {
var path = getPath(route.path, params);
if (path) {
paths.push(path);
} // generated overlay by route.children
var overlay;
if (route.children && route.children.length) {
overlay = /*#__PURE__*/react["createElement"](menu["a" /* default */], null, route.children.map(function (child) {
return /*#__PURE__*/react["createElement"](menu["a" /* default */].Item, {
key: child.path || child.breadcrumbName
}, itemRender(child, params, routes, Breadcrumb_addChildPath(paths, child.path, params)));
}));
}
return /*#__PURE__*/react["createElement"](breadcrumb_BreadcrumbItem, {
overlay: overlay,
separator: separator,
key: path || route.breadcrumbName
}, itemRender(route, params, routes, paths));
});
} else if (children) {
crumbs = Object(toArray["a" /* default */])(children).map(function (element, index) {
if (!element) {
return element;
}
Object(devWarning["a" /* default */])(element.type && (element.type.__ANT_BREADCRUMB_ITEM === true || element.type.__ANT_BREADCRUMB_SEPARATOR === true), 'Breadcrumb', "Only accepts Breadcrumb.Item and Breadcrumb.Separator as it's children");
return Object(reactNode["a" /* cloneElement */])(element, {
separator: separator,
key: index
});
});
}
var breadcrumbClassName = classnames_default()(className, prefixCls, defineProperty_default()({}, "".concat(prefixCls, "-rtl"), direction === 'rtl'));
return /*#__PURE__*/react["createElement"]("div", extends_default()({
className: breadcrumbClassName,
style: style
}, restProps), crumbs);
};
Breadcrumb_Breadcrumb.Item = breadcrumb_BreadcrumbItem;
Breadcrumb_Breadcrumb.Separator = breadcrumb_BreadcrumbSeparator;
/* harmony default export */ var breadcrumb_Breadcrumb = (Breadcrumb_Breadcrumb);
// CONCATENATED MODULE: ./node_modules/antd/es/breadcrumb/index.js
/* harmony default export */ var breadcrumb = __webpack_exports__["a"] = (breadcrumb_Breadcrumb);
/***/ }),
/***/ "sPJy":
/*!********************************************************!*\
!*** ./node_modules/antd/es/breadcrumb/style/index.js ***!
\********************************************************/
/*! no exports provided */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony import */ var _style_index_less__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../style/index.less */ "cIOH");
/* harmony import */ var _style_index_less__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_style_index_less__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _index_less__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./index.less */ "AOa7");
/* harmony import */ var _index_less__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_index_less__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _menu_style__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../menu/style */ "lUTK");
/* harmony import */ var _dropdown_style__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../dropdown/style */ "qVdP");
/***/ }),
/***/ "tuCT":
/*!**************************************************!*\
!*** ./src/pages/metting/information/index.less ***!
\**************************************************/
/*! no static exports found */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
// extracted by mini-css-extract-plugin
/***/ })
}]);

View File

@ -0,0 +1,624 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[19],{
/***/ "HEqF":
/*!**************************************************************!*\
!*** ./src/pages/metting/organization/index.jsx + 1 modules ***!
\**************************************************************/
/*! exports provided: default */
/*! all exports used */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/@umijs/babel-preset-umi/node_modules/@babel/runtime/helpers/esm/objectSpread2.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/@umijs/babel-preset-umi/node_modules/@babel/runtime/helpers/esm/slicedToArray.js */
/*! ModuleConcatenation bailout: Cannot concat with ./src/components/RenderHtml/index.tsx */
/*! ModuleConcatenation bailout: Cannot concat with ./src/pages/metting/api.js */
/*! ModuleConcatenation bailout: Cannot concat with ./src/pages/metting/info.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/antd/es/spin/index.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/antd/es/spin/style/index.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/antd/es/tooltip/index.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/antd/es/tooltip/style/index.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/js-base64/base64.js (<- Module is not an ECMAScript module) */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/react/index.js (<- Module is not an ECMAScript module) */
/*! ModuleConcatenation bailout: Cannot concat with ./src/pages/metting/img/left.png (<- Module is not an ECMAScript module) */
/*! ModuleConcatenation bailout: Cannot concat with ./src/pages/metting/img/logo.png (<- Module is not an ECMAScript module) */
/*! ModuleConcatenation bailout: Cannot concat with ./src/pages/metting/img/orz2.png (<- Module is not an ECMAScript module) */
/*! ModuleConcatenation bailout: Cannot concat with ./src/pages/metting/img/right.png (<- Module is not an ECMAScript module) */
/*! ModuleConcatenation bailout: Cannot concat with ./src/pages/metting/img/team.png (<- Module is not an ECMAScript module) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);
// EXTERNAL MODULE: ./node_modules/antd/es/spin/style/index.js
var style = __webpack_require__("T2oS");
// EXTERNAL MODULE: ./node_modules/antd/es/spin/index.js
var spin = __webpack_require__("W9HT");
// EXTERNAL MODULE: ./node_modules/@umijs/babel-preset-umi/node_modules/@babel/runtime/helpers/esm/objectSpread2.js
var objectSpread2 = __webpack_require__("k1fw");
// EXTERNAL MODULE: ./node_modules/@umijs/babel-preset-umi/node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
var slicedToArray = __webpack_require__("tJVT");
// EXTERNAL MODULE: ./src/pages/metting/organization/index.less
var metting_organization = __webpack_require__("Ymsf");
// EXTERNAL MODULE: ./node_modules/react/index.js
var react = __webpack_require__("q1tI");
var react_default = /*#__PURE__*/__webpack_require__.n(react);
// EXTERNAL MODULE: ./node_modules/antd/es/tooltip/style/index.js
var tooltip_style = __webpack_require__("5Dmo");
// EXTERNAL MODULE: ./node_modules/antd/es/tooltip/index.js + 17 modules
var tooltip = __webpack_require__("3S7+");
// EXTERNAL MODULE: ./src/pages/metting/memberitem/index.less
var memberitem = __webpack_require__("mh/j");
// CONCATENATED MODULE: ./src/pages/metting/memberitem/index.jsx
function MemberItem(props) {
var className = props.className,
data = props.data;
return /*#__PURE__*/react_default.a.createElement("div", {
className: "".concat(className, " member-item")
}, data.name && /*#__PURE__*/react_default.a.createElement(react_default.a.Fragment, null, /*#__PURE__*/react_default.a.createElement("img", {
src: data.imageUrl,
alt: "",
className: "head-img"
}), /*#__PURE__*/react_default.a.createElement("span", {
className: "task-hide"
}, data.name), /*#__PURE__*/react_default.a.createElement(tooltip["a" /* default */], {
title: data.introduction
}, /*#__PURE__*/react_default.a.createElement("p", {
className: "task-hide-2"
}, data.introduction)), /*#__PURE__*/react_default.a.createElement("div", {
className: "line"
})));
}
/* harmony default export */ var metting_memberitem = (MemberItem);
// EXTERNAL MODULE: ./src/pages/metting/api.js + 39 modules
var api = __webpack_require__("Lj8O");
// EXTERNAL MODULE: ./src/pages/metting/info.js
var info = __webpack_require__("PZZE");
// EXTERNAL MODULE: ./node_modules/js-base64/base64.js
var base64 = __webpack_require__("J66h");
// EXTERNAL MODULE: ./src/components/RenderHtml/index.tsx + 4 modules
var RenderHtml = __webpack_require__("9Bee");
// EXTERNAL MODULE: ./src/pages/metting/img/orz2.png
var orz2 = __webpack_require__("Jjym");
var orz2_default = /*#__PURE__*/__webpack_require__.n(orz2);
// EXTERNAL MODULE: ./src/pages/metting/img/logo.png
var logo = __webpack_require__("RMEQ");
var logo_default = /*#__PURE__*/__webpack_require__.n(logo);
// EXTERNAL MODULE: ./src/pages/metting/img/team.png
var team = __webpack_require__("YNic");
var team_default = /*#__PURE__*/__webpack_require__.n(team);
// EXTERNAL MODULE: ./src/pages/metting/img/left.png
var left = __webpack_require__("oOC2");
var left_default = /*#__PURE__*/__webpack_require__.n(left);
// EXTERNAL MODULE: ./src/pages/metting/img/right.png
var right = __webpack_require__("Y8td");
var right_default = /*#__PURE__*/__webpack_require__.n(right);
// CONCATENATED MODULE: ./src/pages/metting/organization/index.jsx
function Organization() {
var _useState = Object(react["useState"])(false),
_useState2 = Object(slicedToArray["a" /* default */])(_useState, 2),
isSpin = _useState2[0],
setIsSpin = _useState2[1];
var _useState3 = Object(react["useState"])([]),
_useState4 = Object(slicedToArray["a" /* default */])(_useState3, 2),
organization = _useState4[0],
setOrganization = _useState4[1];
var _useState5 = Object(react["useState"])([]),
_useState6 = Object(slicedToArray["a" /* default */])(_useState5, 2),
partner = _useState6[0],
setPartner = _useState6[1];
var _useState7 = Object(react["useState"])([]),
_useState8 = Object(slicedToArray["a" /* default */])(_useState7, 2),
orz = _useState8[0],
setOrz = _useState8[1];
Object(react["useEffect"])(function () {
getList();
getPartner();
Init();
}, []);
var getPartner = function getPartner() {
Object(api["f" /* getPartnerList */])().then(function (res) {
var rows = (res === null || res === void 0 ? void 0 : res.rows.length) > 0 ? res === null || res === void 0 ? void 0 : res.rows.filter(function (i) {
return i.typeName.includes("高校");
}) : [];
setPartner(rows);
}).catch(console.error());
};
var getList = function getList() {
setIsSpin(true);
Object(api["e" /* getOrganization */])().then(function (res) {
var rows = res === null || res === void 0 ? void 0 : res.rows;
rows = rows.map(function (i) {
var members = i.zoneMemberList && i.zoneMemberList.length > 0 ? i.zoneMemberList.filter(function (e) {
return e.memberLevel !== "主席";
}) : i.zoneMemberList;
return Object(objectSpread2["a" /* default */])(Object(objectSpread2["a" /* default */])({}, i), {}, {
unPresident: members.length > 0 ? members.map(function (e) {
return e.name;
}) : []
});
});
setOrganization(rows);
setIsSpin(false);
});
};
var Init = function Init() {
Object(api["d" /* getDocList */])(658).then(function (res) {
var _res$rows;
if ((res === null || res === void 0 ? void 0 : (_res$rows = res.rows) === null || _res$rows === void 0 ? void 0 : _res$rows.length) > 0) {
var arr = [];
for (var i = 0; i < (res === null || res === void 0 ? void 0 : res.rows.length); i++) {
var e = res === null || res === void 0 ? void 0 : res.rows[i];
arr.push(getDetailForId(e.id));
}
Promise.all(arr).then(function (res) {
setOrz(res);
});
}
});
};
var getDetailForId = function getDetailForId(id) {
return new Promise(function (resolve, reject) {
Object(api["c" /* getDocDetail */])(id).then(function (res) {
var detail = res.data;
resolve({
detail: detail
});
});
});
};
return /*#__PURE__*/react_default.a.createElement("div", {
className: "organization"
}, /*#__PURE__*/react_default.a.createElement("div", {
className: "orzLogo"
}, /*#__PURE__*/react_default.a.createElement("img", {
src: logo_default.a,
alt: "",
height: 84
}), /*#__PURE__*/react_default.a.createElement("div", {
className: "orzDesc"
}, /*#__PURE__*/react_default.a.createElement("img", {
src: orz2_default.a,
alt: "",
width: 138
}), /*#__PURE__*/react_default.a.createElement("div", {
className: "descCon"
}, /*#__PURE__*/react_default.a.createElement("img", {
src: team_default.a,
width: 33
}), "CCF\u5F00\u6E90\u53D1\u5C55\u59D4\u5458\u4F1A\u662F\u4E00\u4E2A\u81F4\u529B\u4E8E\u63A8\u52A8\u5F00\u6E90\u6587\u5316\u3001\u6280\u672F\u3001\u6559\u80B2\u548C\u4EA7\u4E1A\u53D1\u5C55\u7684\u4E13\u4E1A\u7EC4\u7EC7\u3002\u91CD\u70B9\u805A\u7126\u5171\u540C\u6253\u9020\u5F00\u6E90\u3001\u5F00\u653E\u3001\u4E2D\u7ACB\u7684\u4EA7\u5B66\u7814\u534F\u540C\u5F00\u6E90\u521B\u65B0\u670D\u52A1\u5E73\u53F0\uFF0C\u63A2\u7D22\u5EFA\u7ACBCCF\u5F00\u6E90\u9879\u76EE\u5B75\u5316\u673A\u5236\uFF0C\u57F9\u80B2\u539F\u59CB\u5F00\u6E90\u521B\u65B0\u9879\u76EE\uFF0C\u4F9D\u6258CCF\u8054\u63A5\u79D1\u6559\u8D44\u6E90\u3001\u4EA7\u4E1A\u8D44\u6E90\u548C\u793E\u4F1A\u8D44\u6E90\u7B49\uFF0C\u5F62\u6210\u4EA7\u3001\u6559\u3001\u7814\u8054\u52A8\u7684\u5F00\u6E90\u521B\u65B0\u6A21\u5F0F\uFF0C\u63A8\u52A8CCF\u5F00\u6E90\u54C1\u724C\u5EFA\u8BBE\u548C\u5F00\u6E90\u793E\u533A\u8FD0\u8425\uFF0C\u4E3ACCF\u4F1A\u5458\u4E43\u81F3\u5168\u7403\u5F00\u6E90\u521B\u65B0\u5B9E\u8DF5\u8005\u63D0\u4F9B\u9AD8\u6C34\u5E73\u7684\u5F00\u6E90\u521B\u65B0\u670D\u52A1\uFF0C\u52A9\u529B\u6211\u56FD\u5F00\u6E90\u751F\u6001\u5EFA\u8BBE\u7684\u53D1\u5C55\u3002"))), /*#__PURE__*/react_default.a.createElement("p", {
className: "homeMaintitle",
style: {
margin: "50px auto 0px"
}
}, /*#__PURE__*/react_default.a.createElement("img", {
src: left_default.a
}), /*#__PURE__*/react_default.a.createElement("span", null, "\u7EC4\u7EC7\u67B6\u6784"), /*#__PURE__*/react_default.a.createElement("img", {
src: right_default.a
})), /*#__PURE__*/react_default.a.createElement("p", {
className: "homeSubtitle"
}, /*#__PURE__*/react_default.a.createElement("span", null, "ORGANIZARIONAL STRUCTURE")), /*#__PURE__*/react_default.a.createElement(spin["a" /* default */], {
spinning: isSpin
}, orz && orz.length > 0 && orz.map(function (i, k) {
var detail = i.detail;
return /*#__PURE__*/react_default.a.createElement(react_default.a.Fragment, null, /*#__PURE__*/react_default.a.createElement("p", {
className: "orzTitle"
}, /*#__PURE__*/react_default.a.createElement("img", {
src: team_default.a,
width: 33,
style: {
marginRight: 13
}
}), detail.name), /*#__PURE__*/react_default.a.createElement("div", {
className: "module",
key: k
}, detail.content ? /*#__PURE__*/react_default.a.createElement(RenderHtml["a" /* default */], {
className: "informations_detail imageLayerParent",
value: base64["Base64"].decode(detail.content),
url: location
}) : ""));
})), (partner === null || partner === void 0 ? void 0 : partner.length) > 0 ? /*#__PURE__*/react_default.a.createElement("div", {
style: {
textAlign: "center",
paddingTop: 68,
paddingBottom: 50
}
}, /*#__PURE__*/react_default.a.createElement("p", {
className: "homeMaintitle",
style: {
width: 224,
margin: "0px auto"
}
}, /*#__PURE__*/react_default.a.createElement("img", {
src: left_default.a
}), /*#__PURE__*/react_default.a.createElement("span", null, "\u5408\u4F5C\u9AD8\u6821"), /*#__PURE__*/react_default.a.createElement("img", {
src: right_default.a
})), /*#__PURE__*/react_default.a.createElement("p", {
className: "homeSubtitle"
}, /*#__PURE__*/react_default.a.createElement("span", null, "PARTNERS")), /*#__PURE__*/react_default.a.createElement("div", {
className: "partnersLogo"
}, partner.map(function (i, k) {
return i.zonePartnersList && i.zonePartnersList.length > 0 ? i.zonePartnersList.map(function (e, key) {
return /*#__PURE__*/react_default.a.createElement("a", {
key: k
}, /*#__PURE__*/react_default.a.createElement("img", {
src: e.logo,
alt: ""
}));
}) : "";
}))) : "");
}
/* harmony default export */ var pages_metting_organization = __webpack_exports__["default"] = (Organization);
/***/ }),
/***/ "J66h":
/*!******************************************!*\
!*** ./node_modules/js-base64/base64.js ***!
\******************************************/
/*! no static exports found */
/*! exports used: Base64 */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(global) {var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*
* base64.js
*
* Licensed under the BSD 3-Clause License.
* http://opensource.org/licenses/BSD-3-Clause
*
* References:
* http://en.wikipedia.org/wiki/Base64
*/
;(function (global, factory) {
true
? module.exports = factory(global)
: undefined
}((
typeof self !== 'undefined' ? self
: typeof window !== 'undefined' ? window
: typeof global !== 'undefined' ? global
: this
), function(global) {
'use strict';
// existing version for noConflict()
global = global || {};
var _Base64 = global.Base64;
var version = "2.6.4";
// constants
var b64chars
= 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
var b64tab = function(bin) {
var t = {};
for (var i = 0, l = bin.length; i < l; i++) t[bin.charAt(i)] = i;
return t;
}(b64chars);
var fromCharCode = String.fromCharCode;
// encoder stuff
var cb_utob = function(c) {
if (c.length < 2) {
var cc = c.charCodeAt(0);
return cc < 0x80 ? c
: cc < 0x800 ? (fromCharCode(0xc0 | (cc >>> 6))
+ fromCharCode(0x80 | (cc & 0x3f)))
: (fromCharCode(0xe0 | ((cc >>> 12) & 0x0f))
+ fromCharCode(0x80 | ((cc >>> 6) & 0x3f))
+ fromCharCode(0x80 | ( cc & 0x3f)));
} else {
var cc = 0x10000
+ (c.charCodeAt(0) - 0xD800) * 0x400
+ (c.charCodeAt(1) - 0xDC00);
return (fromCharCode(0xf0 | ((cc >>> 18) & 0x07))
+ fromCharCode(0x80 | ((cc >>> 12) & 0x3f))
+ fromCharCode(0x80 | ((cc >>> 6) & 0x3f))
+ fromCharCode(0x80 | ( cc & 0x3f)));
}
};
var re_utob = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g;
var utob = function(u) {
return u.replace(re_utob, cb_utob);
};
var cb_encode = function(ccc) {
var padlen = [0, 2, 1][ccc.length % 3],
ord = ccc.charCodeAt(0) << 16
| ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8)
| ((ccc.length > 2 ? ccc.charCodeAt(2) : 0)),
chars = [
b64chars.charAt( ord >>> 18),
b64chars.charAt((ord >>> 12) & 63),
padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63),
padlen >= 1 ? '=' : b64chars.charAt(ord & 63)
];
return chars.join('');
};
var btoa = global.btoa && typeof global.btoa == 'function'
? function(b){ return global.btoa(b) } : function(b) {
if (b.match(/[^\x00-\xFF]/)) throw new RangeError(
'The string contains invalid characters.'
);
return b.replace(/[\s\S]{1,3}/g, cb_encode);
};
var _encode = function(u) {
return btoa(utob(String(u)));
};
var mkUriSafe = function (b64) {
return b64.replace(/[+\/]/g, function(m0) {
return m0 == '+' ? '-' : '_';
}).replace(/=/g, '');
};
var encode = function(u, urisafe) {
return urisafe ? mkUriSafe(_encode(u)) : _encode(u);
};
var encodeURI = function(u) { return encode(u, true) };
var fromUint8Array;
if (global.Uint8Array) fromUint8Array = function(a, urisafe) {
// return btoa(fromCharCode.apply(null, a));
var b64 = '';
for (var i = 0, l = a.length; i < l; i += 3) {
var a0 = a[i], a1 = a[i+1], a2 = a[i+2];
var ord = a0 << 16 | a1 << 8 | a2;
b64 += b64chars.charAt( ord >>> 18)
+ b64chars.charAt((ord >>> 12) & 63)
+ ( typeof a1 != 'undefined'
? b64chars.charAt((ord >>> 6) & 63) : '=')
+ ( typeof a2 != 'undefined'
? b64chars.charAt( ord & 63) : '=');
}
return urisafe ? mkUriSafe(b64) : b64;
};
// decoder stuff
var re_btou = /[\xC0-\xDF][\x80-\xBF]|[\xE0-\xEF][\x80-\xBF]{2}|[\xF0-\xF7][\x80-\xBF]{3}/g;
var cb_btou = function(cccc) {
switch(cccc.length) {
case 4:
var cp = ((0x07 & cccc.charCodeAt(0)) << 18)
| ((0x3f & cccc.charCodeAt(1)) << 12)
| ((0x3f & cccc.charCodeAt(2)) << 6)
| (0x3f & cccc.charCodeAt(3)),
offset = cp - 0x10000;
return (fromCharCode((offset >>> 10) + 0xD800)
+ fromCharCode((offset & 0x3FF) + 0xDC00));
case 3:
return fromCharCode(
((0x0f & cccc.charCodeAt(0)) << 12)
| ((0x3f & cccc.charCodeAt(1)) << 6)
| (0x3f & cccc.charCodeAt(2))
);
default:
return fromCharCode(
((0x1f & cccc.charCodeAt(0)) << 6)
| (0x3f & cccc.charCodeAt(1))
);
}
};
var btou = function(b) {
return b.replace(re_btou, cb_btou);
};
var cb_decode = function(cccc) {
var len = cccc.length,
padlen = len % 4,
n = (len > 0 ? b64tab[cccc.charAt(0)] << 18 : 0)
| (len > 1 ? b64tab[cccc.charAt(1)] << 12 : 0)
| (len > 2 ? b64tab[cccc.charAt(2)] << 6 : 0)
| (len > 3 ? b64tab[cccc.charAt(3)] : 0),
chars = [
fromCharCode( n >>> 16),
fromCharCode((n >>> 8) & 0xff),
fromCharCode( n & 0xff)
];
chars.length -= [0, 0, 2, 1][padlen];
return chars.join('');
};
var _atob = global.atob && typeof global.atob == 'function'
? function(a){ return global.atob(a) } : function(a){
return a.replace(/\S{1,4}/g, cb_decode);
};
var atob = function(a) {
return _atob(String(a).replace(/[^A-Za-z0-9\+\/]/g, ''));
};
var _decode = function(a) { return btou(_atob(a)) };
var _fromURI = function(a) {
return String(a).replace(/[-_]/g, function(m0) {
return m0 == '-' ? '+' : '/'
}).replace(/[^A-Za-z0-9\+\/]/g, '');
};
var decode = function(a){
return _decode(_fromURI(a));
};
var toUint8Array;
if (global.Uint8Array) toUint8Array = function(a) {
return Uint8Array.from(atob(_fromURI(a)), function(c) {
return c.charCodeAt(0);
});
};
var noConflict = function() {
var Base64 = global.Base64;
global.Base64 = _Base64;
return Base64;
};
// export Base64
global.Base64 = {
VERSION: version,
atob: atob,
btoa: btoa,
fromBase64: decode,
toBase64: encode,
utob: utob,
encode: encode,
encodeURI: encodeURI,
btou: btou,
decode: decode,
noConflict: noConflict,
fromUint8Array: fromUint8Array,
toUint8Array: toUint8Array
};
// if ES5 is available, make Base64.extendString() available
if (typeof Object.defineProperty === 'function') {
var noEnum = function(v){
return {value:v,enumerable:false,writable:true,configurable:true};
};
global.Base64.extendString = function () {
Object.defineProperty(
String.prototype, 'fromBase64', noEnum(function () {
return decode(this)
}));
Object.defineProperty(
String.prototype, 'toBase64', noEnum(function (urisafe) {
return encode(this, urisafe)
}));
Object.defineProperty(
String.prototype, 'toBase64URI', noEnum(function () {
return encode(this, true)
}));
};
}
//
// export Base64 to the namespace
//
if (global['Meteor']) { // Meteor.js
Base64 = global.Base64;
}
// module.exports and AMD are mutually exclusive.
// module.exports has precedence.
if ( true && module.exports) {
module.exports.Base64 = global.Base64;
}
else if (true) {
// AMD. Register as an anonymous module.
!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function(){ return global.Base64 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
}
// that's it!
return {Base64: global.Base64}
}));
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ "yLpj")))
/***/ }),
/***/ "Jjym":
/*!****************************************!*\
!*** ./src/pages/metting/img/orz2.png ***!
\****************************************/
/*! no static exports found */
/*! exports used: default */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
module.exports = __webpack_require__.p + "static/orz2.d05d53fd.png";
/***/ }),
/***/ "RMEQ":
/*!****************************************!*\
!*** ./src/pages/metting/img/logo.png ***!
\****************************************/
/*! no static exports found */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
module.exports = __webpack_require__.p + "static/logo.e08ed7ab.png";
/***/ }),
/***/ "Y8td":
/*!*****************************************!*\
!*** ./src/pages/metting/img/right.png ***!
\*****************************************/
/*! no static exports found */
/*! exports used: default */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports) {
module.exports = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABkAAAAkCAYAAAB8DZEQAAAAAXNSR0IArs4c6QAAAxJJREFUSEu1Vk1PE1EUve81FJP6EXZ22wQjxGoUotWoMSL9BwYDVidiEVcuZckOl+5k51L+gelOFsRNXdikYCQI+AVIXJvAu/eaN2/edGbaTqEfkzTNbdOee945594noMdPcbDqiF5iPB/8mkE4qPQMZB5Y7pxbW2HEXM9AZs6vzQHSgiCCnoA8HVrNCYJlSZwExO6DFC5+TvUfJCuSOSOQwH11W/ji8JdFQfwM9J8TQ9eZPLmwnk8QltzuicACdY3JzNBqmhOJT6AoLVgzIJAaSHXxuIrZ9RIg5oHY6KBd5R1ZV5gUL23MMqo3RgPNwNPCqzsGcUY2solD/CiQU273lgkSgMuGO3PX/eFq8lRff1kSZ7WLpNZCa+CJ7jPqxMLTlzdeAfHLoAam+wCjThLvXNnMJYhWgEiGNUCjiWbkuqzNxE/e3B448Q/LQlHG6KAzUe8qk5M2LTw9urnESBNRFwVre2RtMZke3XzAzO+si/xuo64K1Mey8MzIVlpJrgriAf/MladBYFbVXHZMTfQS2rr6/b0kyvszKZBsk3Ss5aSd2eVc256TDAvuGTdJtnEV+q5yaw1+lJw4139kBVEZiJP+jtA/tt3aXBC6Ca/pRAAMrUF0qk+eOV0GxGwsg2YM4Qggzo2fr4HoRXCq+p1Gkh3VSh+VfmKP6/Ht33k4xJL1f9Q1cbU2gX2aguhU90GiKpDTdZsu5Kr6WeWvXg+lKcijW7+WJPFEo/0Ql3R3GnuuimVSuLPjSEVvjQ7ahrZbbz/4GQh/HnVVU5DJsb1Mn6IKKEzpjth21mDjxTIKZCN0XPPzLL992FsR+mppV2dkP0T3RaP9YV3VkEnh7p85oXBBMgEr8jZdYOO5m691HRXar6fu7eYk8rJEfbUMb7ZWdW2se7slMkZckEJ+NwVKVCRxJqrBsTXRpmgE8nBsf1EymaulzYDVxM9EYFbZW0hodnksTMhDj5ga/5uXhKVgHoxranfZ+FxE7lkNJq4ojO/PCqSz2iXutVKzVQqkftefKXN/8r/36uj35rf1R6Ux/wMtfnZYluT9lgAAAABJRU5ErkJggg=="
/***/ }),
/***/ "YNic":
/*!****************************************!*\
!*** ./src/pages/metting/img/team.png ***!
\****************************************/
/*! no static exports found */
/*! exports used: default */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports) {
module.exports = "data:image/png;base64,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"
/***/ }),
/***/ "Ymsf":
/*!***************************************************!*\
!*** ./src/pages/metting/organization/index.less ***!
\***************************************************/
/*! no static exports found */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
// extracted by mini-css-extract-plugin
/***/ }),
/***/ "mh/j":
/*!*************************************************!*\
!*** ./src/pages/metting/memberitem/index.less ***!
\*************************************************/
/*! no static exports found */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
// extracted by mini-css-extract-plugin
/***/ }),
/***/ "oOC2":
/*!****************************************!*\
!*** ./src/pages/metting/img/left.png ***!
\****************************************/
/*! no static exports found */
/*! exports used: default */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports) {
module.exports = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABkAAAAkCAYAAAB8DZEQAAAAAXNSR0IArs4c6QAAAyFJREFUSEutVktPFEEQ7h4P3I0KPleCEgLJenAvhgNeFEEJHuVx4ChHb3rzKDePCrIOjxANv8AlGiIxrsFodAnGaLhilLCArphlqspM9/TsPHtnlLlMah79dVV931fNB67/JKa7AJmBxBgAM4gYWZpYfIeMq+/lfYprQYjED1z8iO4CcbH9nCE639v/0dpuQzWrBeHk2ZklM7F3KjKzgIn3dmbi7o3Rfo5kUeejr+1FPYibusxEZqCAVRzOUGQEbGzic9ttuxPxIE6pRC+che07BWL7vQJWvePIilvM6ppf7ahqQdxSOf1wM9DEMgOsYJVn819a1xSf4jPxsMqtvY81QRbJmAOMTqy2PfASNhokJasUbQ3AwsRKa3dQEZEgqlSiBwFWBWPFKm7BumFZ58c/ta8nA1EsUoyKiV3tADIC6s6vnC1E6TqcicuqmrL9Cg4+F714OPnhzM044wiBeAXoV3a0ThhSaQ9+XZj5eK6SGMRVtM0u4VVKJ2Hv4khV3KOcWWop6ezPnwkxj7LrexUDvJN/33JPa7BBxfu8qo6yyYJi5l1z513GMR2IYBN5nDQ65ohlxnguv5xxVZ2sXBGsivMqA2lg8m3zk3oZhGzFz6qa6YXcF+jp4+XMjaQAfoN02GTPB+lVzvxw7vZEPIC0/uc3dcyVMuX0IEm8CggNop78m1ORqq7bEx2ravMDxsxiRgyhtJfUCSqrqE07H8sAS5XtnZwaQulB+ncoPNk8sxygypFy5uuTWlVryzXYv0NqHsR41S3z1Yn7aXfvH1p92yRPGwFWSXsvTC0dCw2htIB8sG9bZFI7BLjnrDJQtWN26XRoCKUHubbl9MR/KuEAA+bS8cSq1vZk6OqWYJfqh2AV4NT0y6MjaXccO08Ge8vknnXFTMc11sCyM4Wm2CGUFpwP9ZbJzQIRDaBOc7GpmHYhfbl6NmVPpEeNTb9o/CdVa0GGr2w67MLi7sEfXfPz8mi5nxcf6t6we1IBxOzc88ZEQyjtBvjw5Q3iRKMzC4d9R8u0C+nLdWnj2ezCof9WtRZk5OL3JnPxyLf93Hlwrb/udaK4RF4QvgAAAABJRU5ErkJggg=="
/***/ })
}]);

View File

@ -0,0 +1,455 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[20],{
/***/ "2yHG":
/*!*******************************************!*\
!*** ./src/pages/metting/track/index.jsx ***!
\*******************************************/
/*! exports provided: default */
/*! all exports used */
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./src/.umi-production/core/routes.ts (referenced with import()) */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var D_projects_competitions_forgeplus_react_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./node_modules/@umijs/babel-preset-umi/node_modules/@babel/runtime/helpers/esm/slicedToArray */ "tJVT");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ "q1tI");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _index_less__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./index.less */ "F5PU");
/* harmony import */ var _index_less__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_index_less__WEBPACK_IMPORTED_MODULE_2__);
/* harmony import */ var _components_RenderHtml__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @/components/RenderHtml */ "9Bee");
/* harmony import */ var umi__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! umi */ "Ty5D");
/* harmony import */ var umi__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! umi */ "55Ip");
/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../api */ "Lj8O");
/* harmony import */ var js_base64__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! js-base64 */ "J66h");
/* harmony import */ var js_base64__WEBPACK_IMPORTED_MODULE_7___default = /*#__PURE__*/__webpack_require__.n(js_base64__WEBPACK_IMPORTED_MODULE_7__);
/* harmony import */ var _utils_mettingUtil__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! @/utils/mettingUtil */ "gnzr");
function Track(props) {
var _useState = Object(react__WEBPACK_IMPORTED_MODULE_1__["useState"])(0),
_useState2 = Object(D_projects_competitions_forgeplus_react_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(_useState, 2),
tabKey = _useState2[0],
setTabKey = _useState2[1];
var _useState3 = Object(react__WEBPACK_IMPORTED_MODULE_1__["useState"])(undefined),
_useState4 = Object(D_projects_competitions_forgeplus_react_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(_useState3, 2),
content = _useState4[0],
setContent = _useState4[1];
var _useState5 = Object(react__WEBPACK_IMPORTED_MODULE_1__["useState"])(undefined),
_useState6 = Object(D_projects_competitions_forgeplus_react_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(_useState5, 2),
dealContent = _useState6[0],
setDealContent = _useState6[1];
var _useState7 = Object(react__WEBPACK_IMPORTED_MODULE_1__["useState"])(false),
_useState8 = Object(D_projects_competitions_forgeplus_react_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(_useState7, 2),
showAnchor = _useState8[0],
setShowAnchor = _useState8[1];
var _useState9 = Object(react__WEBPACK_IMPORTED_MODULE_1__["useState"])(false),
_useState10 = Object(D_projects_competitions_forgeplus_react_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(_useState9, 2),
anchor = _useState10[0],
setAnchor = _useState10[1];
var _useState11 = Object(react__WEBPACK_IMPORTED_MODULE_1__["useState"])([]),
_useState12 = Object(D_projects_competitions_forgeplus_react_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(_useState11, 2),
menu = _useState12[0],
setMenu = _useState12[1];
var _useParams = Object(umi__WEBPACK_IMPORTED_MODULE_4__[/* useParams */ "l"])(),
id = _useParams.id;
Object(react__WEBPACK_IMPORTED_MODULE_1__["useEffect"])(function () {
if (location.pathname.indexOf('/competitions/2024/track') > -1) {
window.addEventListener('scroll', throttleHandleScroll);
return ComponentWillUnmount;
} else {
ComponentWillUnmount();
}
}, [location.pathname]);
function ComponentWillUnmount() {
window.removeEventListener("scroll", throttleHandleScroll);
}
function handleScroll() {
var scrollTop = document.documentElement.scrollTop; //滚动条滚动高度
setShowAnchor(scrollTop > 320);
if (scrollTop < 320) {
setAnchor("");
}
}
var throttleHandleScroll = Object(_utils_mettingUtil__WEBPACK_IMPORTED_MODULE_8__[/* throttle */ "a"])(handleScroll, 100);
Object(react__WEBPACK_IMPORTED_MODULE_1__["useEffect"])(function () {
if (id) {
setTabKey(id);
getDetail();
}
}, [id]);
var getDetail = function getDetail() {
Object(_api__WEBPACK_IMPORTED_MODULE_6__[/* getDocDetail */ "c"])(id).then(function (res) {
var content = js_base64__WEBPACK_IMPORTED_MODULE_7__["Base64"].decode(res.data.content);
setContent(content);
});
};
var scrollToAnchor = function scrollToAnchor(anchorName) {
if (anchorName) {
var anchorElement = document.getElementById(anchorName);
if (anchorElement) {
setAnchor(anchorName);
anchorElement.scrollIntoView({
block: 'start',
behavior: 'smooth'
});
}
}
};
Object(react__WEBPACK_IMPORTED_MODULE_1__["useEffect"])(function () {
if (content) {
var c = content;
var hTagsRegex = /<h([1-6])(.*?)>(.*?)<\/h\1>/g;
var match;
var list = [];
while (match = hTagsRegex.exec(content)) {
list.push({
level: +match[1],
id: match[3]
});
c = c.replace("".concat(match[0]), "<div id=\"".concat(match[3], "\"></div>").concat(match[0]));
}
setMenu(list);
setDealContent(c);
}
}, [content]);
return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement("div", {
className: "track"
}, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement("div", {
className: "tabPanel"
}, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement("div", {
className: "tab"
}, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement(umi__WEBPACK_IMPORTED_MODULE_5__[/* Link */ "a"], {
key: 633,
to: "/competitions/2024/track/633",
className: "tab-item ".concat(tabKey === "633" ? "active" : "")
}, "\u5F00\u6E90\u9879\u76EE\u8D21\u732E\u8D5B\u9053"), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement(umi__WEBPACK_IMPORTED_MODULE_5__[/* Link */ "a"], {
key: 634,
to: "/competitions/2024/track/634",
className: "tab-item ".concat(tabKey === "634" ? "active" : "")
}, "\u5F00\u6E90\u4EFB\u52A1\u6311\u6218\u8D5B\u9053"), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement(umi__WEBPACK_IMPORTED_MODULE_5__[/* Link */ "a"], {
key: 635,
to: "/competitions/2024/track/635",
className: "tab-item ".concat(tabKey === "635" ? "active" : "")
}, "\u5F00\u6E90\u6848\u4F8B\u6559\u5B66\u8D5B\u9053"), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement(umi__WEBPACK_IMPORTED_MODULE_5__[/* Link */ "a"], {
key: 636,
to: "/competitions/2024/track/636",
className: "tab-item ".concat(tabKey === "636" ? "active" : "")
}, "\u5F00\u6E90\u4EE3\u7801\u8BC4\u6CE8\u8D5B\u9053"))), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement("div", {
className: "detail-info"
}, (menu === null || menu === void 0 ? void 0 : menu.length) > 0 && showAnchor ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement("ul", {
className: "menuPanel",
style: {
top: 320,
left: (document.documentElement.clientWidth - 1200) / 2 - 225
}
}, menu.map(function (i, k) {
return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement("li", {
key: k,
style: {
paddingLeft: "".concat(i.level * 10, "px")
},
className: "".concat(anchor === i.id ? "active" : "")
}, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement("a", {
onClick: function onClick() {
return scrollToAnchor(i.id);
}
}, i === null || i === void 0 ? void 0 : i.id));
})) : "", dealContent ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement(_components_RenderHtml__WEBPACK_IMPORTED_MODULE_3__[/* default */ "a"], {
className: "informations_detail imageLayerParent",
value: dealContent,
url: location
}) : /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement("span", null, "\u6682\u65E0\u8BE6\u60C5~")));
}
/* harmony default export */ __webpack_exports__["default"] = (Track);
/***/ }),
/***/ "F5PU":
/*!********************************************!*\
!*** ./src/pages/metting/track/index.less ***!
\********************************************/
/*! no static exports found */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
// extracted by mini-css-extract-plugin
/***/ }),
/***/ "J66h":
/*!******************************************!*\
!*** ./node_modules/js-base64/base64.js ***!
\******************************************/
/*! no static exports found */
/*! exports used: Base64 */
/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(global) {var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*
* base64.js
*
* Licensed under the BSD 3-Clause License.
* http://opensource.org/licenses/BSD-3-Clause
*
* References:
* http://en.wikipedia.org/wiki/Base64
*/
;(function (global, factory) {
true
? module.exports = factory(global)
: undefined
}((
typeof self !== 'undefined' ? self
: typeof window !== 'undefined' ? window
: typeof global !== 'undefined' ? global
: this
), function(global) {
'use strict';
// existing version for noConflict()
global = global || {};
var _Base64 = global.Base64;
var version = "2.6.4";
// constants
var b64chars
= 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
var b64tab = function(bin) {
var t = {};
for (var i = 0, l = bin.length; i < l; i++) t[bin.charAt(i)] = i;
return t;
}(b64chars);
var fromCharCode = String.fromCharCode;
// encoder stuff
var cb_utob = function(c) {
if (c.length < 2) {
var cc = c.charCodeAt(0);
return cc < 0x80 ? c
: cc < 0x800 ? (fromCharCode(0xc0 | (cc >>> 6))
+ fromCharCode(0x80 | (cc & 0x3f)))
: (fromCharCode(0xe0 | ((cc >>> 12) & 0x0f))
+ fromCharCode(0x80 | ((cc >>> 6) & 0x3f))
+ fromCharCode(0x80 | ( cc & 0x3f)));
} else {
var cc = 0x10000
+ (c.charCodeAt(0) - 0xD800) * 0x400
+ (c.charCodeAt(1) - 0xDC00);
return (fromCharCode(0xf0 | ((cc >>> 18) & 0x07))
+ fromCharCode(0x80 | ((cc >>> 12) & 0x3f))
+ fromCharCode(0x80 | ((cc >>> 6) & 0x3f))
+ fromCharCode(0x80 | ( cc & 0x3f)));
}
};
var re_utob = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g;
var utob = function(u) {
return u.replace(re_utob, cb_utob);
};
var cb_encode = function(ccc) {
var padlen = [0, 2, 1][ccc.length % 3],
ord = ccc.charCodeAt(0) << 16
| ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8)
| ((ccc.length > 2 ? ccc.charCodeAt(2) : 0)),
chars = [
b64chars.charAt( ord >>> 18),
b64chars.charAt((ord >>> 12) & 63),
padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63),
padlen >= 1 ? '=' : b64chars.charAt(ord & 63)
];
return chars.join('');
};
var btoa = global.btoa && typeof global.btoa == 'function'
? function(b){ return global.btoa(b) } : function(b) {
if (b.match(/[^\x00-\xFF]/)) throw new RangeError(
'The string contains invalid characters.'
);
return b.replace(/[\s\S]{1,3}/g, cb_encode);
};
var _encode = function(u) {
return btoa(utob(String(u)));
};
var mkUriSafe = function (b64) {
return b64.replace(/[+\/]/g, function(m0) {
return m0 == '+' ? '-' : '_';
}).replace(/=/g, '');
};
var encode = function(u, urisafe) {
return urisafe ? mkUriSafe(_encode(u)) : _encode(u);
};
var encodeURI = function(u) { return encode(u, true) };
var fromUint8Array;
if (global.Uint8Array) fromUint8Array = function(a, urisafe) {
// return btoa(fromCharCode.apply(null, a));
var b64 = '';
for (var i = 0, l = a.length; i < l; i += 3) {
var a0 = a[i], a1 = a[i+1], a2 = a[i+2];
var ord = a0 << 16 | a1 << 8 | a2;
b64 += b64chars.charAt( ord >>> 18)
+ b64chars.charAt((ord >>> 12) & 63)
+ ( typeof a1 != 'undefined'
? b64chars.charAt((ord >>> 6) & 63) : '=')
+ ( typeof a2 != 'undefined'
? b64chars.charAt( ord & 63) : '=');
}
return urisafe ? mkUriSafe(b64) : b64;
};
// decoder stuff
var re_btou = /[\xC0-\xDF][\x80-\xBF]|[\xE0-\xEF][\x80-\xBF]{2}|[\xF0-\xF7][\x80-\xBF]{3}/g;
var cb_btou = function(cccc) {
switch(cccc.length) {
case 4:
var cp = ((0x07 & cccc.charCodeAt(0)) << 18)
| ((0x3f & cccc.charCodeAt(1)) << 12)
| ((0x3f & cccc.charCodeAt(2)) << 6)
| (0x3f & cccc.charCodeAt(3)),
offset = cp - 0x10000;
return (fromCharCode((offset >>> 10) + 0xD800)
+ fromCharCode((offset & 0x3FF) + 0xDC00));
case 3:
return fromCharCode(
((0x0f & cccc.charCodeAt(0)) << 12)
| ((0x3f & cccc.charCodeAt(1)) << 6)
| (0x3f & cccc.charCodeAt(2))
);
default:
return fromCharCode(
((0x1f & cccc.charCodeAt(0)) << 6)
| (0x3f & cccc.charCodeAt(1))
);
}
};
var btou = function(b) {
return b.replace(re_btou, cb_btou);
};
var cb_decode = function(cccc) {
var len = cccc.length,
padlen = len % 4,
n = (len > 0 ? b64tab[cccc.charAt(0)] << 18 : 0)
| (len > 1 ? b64tab[cccc.charAt(1)] << 12 : 0)
| (len > 2 ? b64tab[cccc.charAt(2)] << 6 : 0)
| (len > 3 ? b64tab[cccc.charAt(3)] : 0),
chars = [
fromCharCode( n >>> 16),
fromCharCode((n >>> 8) & 0xff),
fromCharCode( n & 0xff)
];
chars.length -= [0, 0, 2, 1][padlen];
return chars.join('');
};
var _atob = global.atob && typeof global.atob == 'function'
? function(a){ return global.atob(a) } : function(a){
return a.replace(/\S{1,4}/g, cb_decode);
};
var atob = function(a) {
return _atob(String(a).replace(/[^A-Za-z0-9\+\/]/g, ''));
};
var _decode = function(a) { return btou(_atob(a)) };
var _fromURI = function(a) {
return String(a).replace(/[-_]/g, function(m0) {
return m0 == '-' ? '+' : '/'
}).replace(/[^A-Za-z0-9\+\/]/g, '');
};
var decode = function(a){
return _decode(_fromURI(a));
};
var toUint8Array;
if (global.Uint8Array) toUint8Array = function(a) {
return Uint8Array.from(atob(_fromURI(a)), function(c) {
return c.charCodeAt(0);
});
};
var noConflict = function() {
var Base64 = global.Base64;
global.Base64 = _Base64;
return Base64;
};
// export Base64
global.Base64 = {
VERSION: version,
atob: atob,
btoa: btoa,
fromBase64: decode,
toBase64: encode,
utob: utob,
encode: encode,
encodeURI: encodeURI,
btou: btou,
decode: decode,
noConflict: noConflict,
fromUint8Array: fromUint8Array,
toUint8Array: toUint8Array
};
// if ES5 is available, make Base64.extendString() available
if (typeof Object.defineProperty === 'function') {
var noEnum = function(v){
return {value:v,enumerable:false,writable:true,configurable:true};
};
global.Base64.extendString = function () {
Object.defineProperty(
String.prototype, 'fromBase64', noEnum(function () {
return decode(this)
}));
Object.defineProperty(
String.prototype, 'toBase64', noEnum(function (urisafe) {
return encode(this, urisafe)
}));
Object.defineProperty(
String.prototype, 'toBase64URI', noEnum(function () {
return encode(this, true)
}));
};
}
//
// export Base64 to the namespace
//
if (global['Meteor']) { // Meteor.js
Base64 = global.Base64;
}
// module.exports and AMD are mutually exclusive.
// module.exports has precedence.
if ( true && module.exports) {
module.exports.Base64 = global.Base64;
}
else if (true) {
// AMD. Register as an anonymous module.
!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function(){ return global.Base64 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
}
// that's it!
return {Base64: global.Base64}
}));
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ "yLpj")))
/***/ }),
/***/ "gnzr":
/*!**********************************!*\
!*** ./src/utils/mettingUtil.js ***!
\**********************************/
/*! exports provided: throttle */
/*! exports used: throttle */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return throttle; });
function throttle(fn, delay) {
var timer = null; // 使用定时器实现
return function () {
var _this = this; // 当前 this 保存,以免后续处理中 this 丢失
if (!timer) {
fn.apply(_this, arguments);
timer = setTimeout(function () {
timer = null;
}, delay);
}
};
}
/***/ })
}]);

141196
umi.e2130d79.js Normal file

File diff suppressed because one or more lines are too long

View File

@ -54,7 +54,7 @@
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/classnames/index.js (<- Module is not an ECMAScript module) */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/omit.js/es/index.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/rc-resize-observer/es/index.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/rc-util/es/omit.js because of ./node_modules/rc-tabs/node_modules/rc-menu/es/Menu.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/rc-util/es/omit.js because of ./node_modules/rc-tabs/node_modules/rc-menu/es/MenuItem.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/rc-util/es/ref.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/react/index.js (<- Module is not an ECMAScript module) */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/shallowequal/index.js (<- Module is not an ECMAScript module) */

File diff suppressed because one or more lines are too long

View File

@ -4878,7 +4878,7 @@ var _default = exports.default = RefIcon;
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/antd/es/config-provider/context.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/antd/es/grid/hooks/useBreakpoint.js because of ./node_modules/antd/es/table/Table.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/antd/es/locale-provider/LocaleReceiver.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/antd/es/select/index.js because of ./src/components/markdown-editor/code-block/index.tsx */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/antd/es/select/index.js because of ./src/pages/Competitions/Detail/Competitionbonus.tsx */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/classnames/index.js (<- Module is not an ECMAScript module) */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/rc-pagination/es/locale/en_US.js */
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/rc-pagination/es/locale/zh_CN.js */

File diff suppressed because it is too large Load Diff