gitlink competition

This commit is contained in:
xiaoxiaoqiong 2022-04-03 13:49:06 +08:00
parent 6ee1d6a6b9
commit 46871143a0
844 changed files with 1026804 additions and 100241 deletions

88
.gitignore vendored
View File

@ -1,88 +0,0 @@
# Logs
logs
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*
yarn.lock
# Runtime data
pids
*.pid
*.seed
*.pid.lock
# Ignore master key for decrypting credentials and more.
/config/master.key
/config/database.yml
/.idea/*
# Directory for instrumented libs generated by jscoverage/JSCover
lib-cov
# Coverage directory used by tools like istanbul
coverage
# nyc test coverage
.nyc_output
# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
.grunt
# Bower dependency directory (https://bower.io/)
bower_components
# node-waf configuration
.lock-wscript
# Compiled binary addons (https://nodejs.org/api/addons.html)
build/
# Dependency directories
node_modules/
jspm_packages/
# TypeScript v1 declaration files
typings/
# Optional npm cache directory
.npm
# Optional eslint cache
.eslintcache
# Optional REPL history
.node_repl_history
# Output of 'npm pack'
*.tgz
# Yarn Integrity file
.yarn-integrity
# dotenv environment variables file
.env
# parcel-bundler cache (https://parceljs.org/)
.cache
# next.js build output
.next
# nuxt.js build output
.nuxt
# vuepress build output
.vuepress/dist
# Serverless directories
.serverless/
# FuseBox cache
.fusebox/
#DynamoDB Local files
.dynamodb/
.DS_Store
.idea/*

12982
19.24729045.async.js Normal file

File diff suppressed because one or more lines are too long

271
20.cc291365.async.js Normal file
View File

@ -0,0 +1,271 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[20,79],{
/***/ "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
21.2329b082.async.js Normal file

File diff suppressed because it is too large Load Diff

18533
22.ef8b9ab5.async.js Normal file

File diff suppressed because one or more lines are too long

8878
23.2f1b1a41.async.js Normal file

File diff suppressed because it is too large Load Diff

1457
24.fb07df7a.async.js Normal file

File diff suppressed because it is too large Load Diff

114
25.a0d109f5.async.js Normal file
View File

@ -0,0 +1,114 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[25],{
/***/ "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
26.7c7e7071.async.js Normal file
View File

@ -0,0 +1,304 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[26],{
/***/ "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
27.166a58e7.async.js Normal file
View File

@ -0,0 +1,75 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[27],{
/***/ "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
28.14f5abf9.async.js Normal file
View File

@ -0,0 +1,116 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[28],{
/***/ "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
29.1d8bc06c.async.js Normal file
View File

@ -0,0 +1,130 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[29],{
/***/ "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
30.0ee59578.async.js Normal file
View File

@ -0,0 +1,782 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[30],{
/***/ "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
31.d5887f1d.async.js Normal file
View File

@ -0,0 +1,190 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[31],{
/***/ "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
32.1c6f1c5b.async.js Normal file
View File

@ -0,0 +1,204 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[32],{
/***/ "/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
33.21ecd820.async.js Normal file
View File

@ -0,0 +1,75 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[33],{
/***/ "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
34.86718798.async.js Normal file
View File

@ -0,0 +1,191 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[34],{
/***/ "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
35.26c1d613.async.js Normal file
View File

@ -0,0 +1,129 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[35],{
/***/ "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
36.da74844c.async.js Normal file
View File

@ -0,0 +1,158 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[36],{
/***/ "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
37.116cf847.async.js Normal file
View File

@ -0,0 +1,190 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[37],{
/***/ "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
38.b1f00a5a.async.js Normal file
View File

@ -0,0 +1,149 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[38],{
/***/ "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
39.b873d6bc.async.js Normal file
View File

@ -0,0 +1,214 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[39],{
/***/ "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
40.f9c606df.async.js Normal file
View File

@ -0,0 +1,191 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[40],{
/***/ "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
41.9b68c58c.async.js Normal file
View File

@ -0,0 +1,88 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[41],{
/***/ "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
42.0d599b54.async.js Normal file
View File

@ -0,0 +1,155 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[42],{
/***/ "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
43.0857e569.async.js Normal file
View File

@ -0,0 +1,165 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[43],{
/***/ "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
44.20714cf8.async.js Normal file
View File

@ -0,0 +1,164 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[44],{
/***/ "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
45.d8ceb50b.async.js Normal file
View File

@ -0,0 +1,135 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[45],{
/***/ "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
46.f4f5b960.async.js Normal file
View File

@ -0,0 +1,198 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[46],{
/***/ "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
47.75071b0c.async.js Normal file
View File

@ -0,0 +1,150 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[47],{
/***/ "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
48.54c266f1.async.js Normal file
View File

@ -0,0 +1,188 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[48],{
/***/ "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
49.12456089.async.js Normal file
View File

@ -0,0 +1,233 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[49],{
/***/ "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
]
}
};
/***/ })
}]);

342
5.b1988a56.async.js Normal file
View File

@ -0,0 +1,342 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[5],{
/***/ "fhwZ":
/*!**********************************************************************!*\
!*** ./node_modules/monaco-editor/esm/vs/basic-languages/cpp/cpp.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/cpp/cpp.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 = {
defaultToken: '',
tokenPostfix: '.cpp',
brackets: [
{ token: 'delimiter.curly', open: '{', close: '}' },
{ token: 'delimiter.parenthesis', open: '(', close: ')' },
{ token: 'delimiter.square', open: '[', close: ']' },
{ token: 'delimiter.angle', open: '<', close: '>' }
],
keywords: [
'abstract',
'amp',
'array',
'auto',
'bool',
'break',
'case',
'catch',
'char',
'class',
'const',
'constexpr',
'const_cast',
'continue',
'cpu',
'decltype',
'default',
'delegate',
'delete',
'do',
'double',
'dynamic_cast',
'each',
'else',
'enum',
'event',
'explicit',
'export',
'extern',
'false',
'final',
'finally',
'float',
'for',
'friend',
'gcnew',
'generic',
'goto',
'if',
'in',
'initonly',
'inline',
'int',
'interface',
'interior_ptr',
'internal',
'literal',
'long',
'mutable',
'namespace',
'new',
'noexcept',
'nullptr',
'__nullptr',
'operator',
'override',
'partial',
'pascal',
'pin_ptr',
'private',
'property',
'protected',
'public',
'ref',
'register',
'reinterpret_cast',
'restrict',
'return',
'safe_cast',
'sealed',
'short',
'signed',
'sizeof',
'static',
'static_assert',
'static_cast',
'struct',
'switch',
'template',
'this',
'thread_local',
'throw',
'tile_static',
'true',
'try',
'typedef',
'typeid',
'typename',
'union',
'unsigned',
'using',
'virtual',
'void',
'volatile',
'wchar_t',
'where',
'while',
'_asm',
'_based',
'_cdecl',
'_declspec',
'_fastcall',
'_if_exists',
'_if_not_exists',
'_inline',
'_multiple_inheritance',
'_pascal',
'_single_inheritance',
'_stdcall',
'_virtual_inheritance',
'_w64',
'__abstract',
'__alignof',
'__asm',
'__assume',
'__based',
'__box',
'__builtin_alignof',
'__cdecl',
'__clrcall',
'__declspec',
'__delegate',
'__event',
'__except',
'__fastcall',
'__finally',
'__forceinline',
'__gc',
'__hook',
'__identifier',
'__if_exists',
'__if_not_exists',
'__inline',
'__int128',
'__int16',
'__int32',
'__int64',
'__int8',
'__interface',
'__leave',
'__m128',
'__m128d',
'__m128i',
'__m256',
'__m256d',
'__m256i',
'__m64',
'__multiple_inheritance',
'__newslot',
'__nogc',
'__noop',
'__nounwind',
'__novtordisp',
'__pascal',
'__pin',
'__pragma',
'__property',
'__ptr32',
'__ptr64',
'__raise',
'__restrict',
'__resume',
'__sealed',
'__single_inheritance',
'__stdcall',
'__super',
'__thiscall',
'__try',
'__try_cast',
'__typeof',
'__unaligned',
'__unhook',
'__uuidof',
'__value',
'__virtual_inheritance',
'__w64',
'__wchar_t'
],
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]?/,
encoding: /u|u8|U|L/,
// The main tokenizer for our languages
tokenizer: {
root: [
// C++ 11 Raw String
[/@encoding?R\"(?:([^ ()\\\t]*))\(/, { token: 'string.raw.begin', next: '@raw.$1' }],
// identifiers and keywords
[/[a-zA-Z_]\w*/, {
cases: {
'@keywords': { token: 'keyword.$0' },
'@default': 'identifier'
}
}],
// whitespace
{ include: '@whitespace' },
// [[ attributes ]].
[/\[\[.*\]\]/, 'annotation'],
[/^\s*#include/, { token: 'keyword.directive.include', next: '@include' }],
// Preprocessor directive
[/^\s*#\s*\w+/, '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']
],
raw: [
[/(.*)(\))(?:([^ ()\\\t]*))(\")/, {
cases: {
'$3==$S2': ['string.raw', 'string.raw.end', 'string.raw.end', { token: 'string.raw.end', next: '@pop' }],
'@default': ['string.raw', 'string.raw', 'string.raw', 'string.raw']
}
}
],
[/.*/, 'string.raw']
],
include: [
[/(\s*)(<)([^<>]*)(>)/, ['', 'keyword.directive.include.begin', 'string.include.identifier', { token: 'keyword.directive.include.end', next: '@pop' }]],
[/(\s*)(")([^"]*)(")/, ['', 'keyword.directive.include.begin', 'string.include.identifier', { token: 'keyword.directive.include.end', next: '@pop' }]]
]
},
};
/***/ })
}]);

201
50.3dc853a7.async.js Normal file
View File

@ -0,0 +1,201 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[50],{
/***/ "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
51.7678861a.async.js Normal file
View File

@ -0,0 +1,151 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[51],{
/***/ "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
52.e8a9d73d.async.js Normal file
View File

@ -0,0 +1,131 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[52],{
/***/ "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
53.4ea7154f.async.js Normal file
View File

@ -0,0 +1,633 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[53],{
/***/ "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
54.90dff04d.async.js Normal file
View File

@ -0,0 +1,269 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[54],{
/***/ "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
55.7d590261.async.js Normal file
View File

@ -0,0 +1,298 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[55],{
/***/ "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
56.71f7538d.async.js Normal file
View File

@ -0,0 +1,632 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[56],{
/***/ "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
57.ac4386ae.async.js Normal file
View File

@ -0,0 +1,926 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[57],{
/***/ "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
58.ec19ab72.async.js Normal file
View File

@ -0,0 +1,191 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[58],{
/***/ "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
59.ca985166.async.js Normal file
View File

@ -0,0 +1,247 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[59],{
/***/ "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
60.d8871b82.async.js Normal file
View File

@ -0,0 +1,263 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[60],{
/***/ "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
61.2b2b47b1.async.js Normal file
View File

@ -0,0 +1,238 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[61],{
/***/ "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
62.abc7fdbc.async.js Normal file
View File

@ -0,0 +1,292 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[62],{
/***/ "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
63.18f4eca2.async.js Normal file
View File

@ -0,0 +1,141 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[63],{
/***/ "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
64.ed263a8e.async.js Normal file
View File

@ -0,0 +1,227 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[64],{
/***/ "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
65.7ee1997b.async.js Normal file
View File

@ -0,0 +1,163 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[65],{
/***/ "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
66.e1af0246.async.js Normal file
View File

@ -0,0 +1,411 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[66],{
/***/ "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
67.57a1150f.async.js Normal file
View File

@ -0,0 +1,174 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[67],{
/***/ "/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
68.8e7aba91.async.js Normal file
View File

@ -0,0 +1,116 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[68],{
/***/ "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
69.beaabd0e.async.js Normal file
View File

@ -0,0 +1,126 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[69],{
/***/ "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
70.e079ddd4.async.js Normal file
View File

@ -0,0 +1,263 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[70],{
/***/ "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
71.91f85ec9.async.js Normal file
View File

@ -0,0 +1,227 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[71],{
/***/ "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
72.7628894b.async.js Normal file

File diff suppressed because one or more lines are too long

176
73.d0496dcc.async.js Normal file
View File

@ -0,0 +1,176 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[73],{
/***/ "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
74.21aa9877.async.js Normal file

File diff suppressed because it is too large Load Diff

257
75.16c67ba8.async.js Normal file
View File

@ -0,0 +1,257 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[75],{
/***/ "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
76.c1878604.async.js Normal file
View File

@ -0,0 +1,179 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[76],{
/***/ "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
77.ca974cf1.async.js Normal file
View File

@ -0,0 +1,151 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[77],{
/***/ "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
78.04ce4d1b.async.js Normal file
View File

@ -0,0 +1,293 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[78],{
/***/ "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
79.a7f6af09.async.js Normal file
View File

@ -0,0 +1,219 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[79],{
/***/ "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
80.ea1e44e5.async.js Normal file
View File

@ -0,0 +1,183 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[80],{
/***/ "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
81.8f9c49fe.async.js Normal file
View File

@ -0,0 +1,109 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[81],{
/***/ "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
82.ba554fab.async.js Normal file
View File

@ -0,0 +1,207 @@
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[82],{
/***/ "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
83.c048402c.async.js Normal file

File diff suppressed because it is too large Load Diff

View File

@ -1,399 +0,0 @@
{
"static/css/0.d9d88bd2.chunk.css": "/react/build/static/css/0.d9d88bd2.chunk.css",
"./static/js/0.38cc2216.chunk.js": "/react/build/./static/js/0.38cc2216.chunk.js",
"static/css/1.0ba7a726.chunk.css": "/react/build/static/css/1.0ba7a726.chunk.css",
"./static/js/1.9de07cbc.chunk.js": "/react/build/./static/js/1.9de07cbc.chunk.js",
"./static/js/2.d659edf3.chunk.js": "/react/build/./static/js/2.d659edf3.chunk.js",
"static/css/3.d01698e8.chunk.css": "/react/build/static/css/3.d01698e8.chunk.css",
"./static/js/3.1f347c4c.chunk.js": "/react/build/./static/js/3.1f347c4c.chunk.js",
"static/css/4.2254a4a8.chunk.css": "/react/build/static/css/4.2254a4a8.chunk.css",
"./static/js/4.4d2d662b.chunk.js": "/react/build/./static/js/4.4d2d662b.chunk.js",
"static/css/5.8bc7b323.chunk.css": "/react/build/static/css/5.8bc7b323.chunk.css",
"./static/js/5.2aca745f.chunk.js": "/react/build/./static/js/5.2aca745f.chunk.js",
"./static/js/6.6aa4f89d.chunk.js": "/react/build/./static/js/6.6aa4f89d.chunk.js",
"static/css/7.bbfdfc43.chunk.css": "/react/build/static/css/7.bbfdfc43.chunk.css",
"./static/js/7.8462b447.chunk.js": "/react/build/./static/js/7.8462b447.chunk.js",
"static/css/8.1632b9c8.chunk.css": "/react/build/static/css/8.1632b9c8.chunk.css",
"./static/js/8.882648e1.chunk.js": "/react/build/./static/js/8.882648e1.chunk.js",
"static/css/9.6e0686d9.chunk.css": "/react/build/static/css/9.6e0686d9.chunk.css",
"./static/js/9.fd42b255.chunk.js": "/react/build/./static/js/9.fd42b255.chunk.js",
"static/css/10.d4345223.chunk.css": "/react/build/static/css/10.d4345223.chunk.css",
"./static/js/10.08552af4.chunk.js": "/react/build/./static/js/10.08552af4.chunk.js",
"static/css/11.1c5f3a58.chunk.css": "/react/build/static/css/11.1c5f3a58.chunk.css",
"./static/js/11.b3ae549c.chunk.js": "/react/build/./static/js/11.b3ae549c.chunk.js",
"static/css/12.ae349a22.chunk.css": "/react/build/static/css/12.ae349a22.chunk.css",
"./static/js/12.732d3701.chunk.js": "/react/build/./static/js/12.732d3701.chunk.js",
"static/css/13.30f998e5.chunk.css": "/react/build/static/css/13.30f998e5.chunk.css",
"./static/js/13.bdb2638e.chunk.js": "/react/build/./static/js/13.bdb2638e.chunk.js",
"static/css/14.1e970b46.chunk.css": "/react/build/static/css/14.1e970b46.chunk.css",
"./static/js/14.47d6b04d.chunk.js": "/react/build/./static/js/14.47d6b04d.chunk.js",
"static/css/15.cf56d612.chunk.css": "/react/build/static/css/15.cf56d612.chunk.css",
"./static/js/15.5eff19c4.chunk.js": "/react/build/./static/js/15.5eff19c4.chunk.js",
"static/css/16.a27fa9ba.chunk.css": "/react/build/static/css/16.a27fa9ba.chunk.css",
"./static/js/16.4d4bfc8b.chunk.js": "/react/build/./static/js/16.4d4bfc8b.chunk.js",
"static/css/17.d0c774b5.chunk.css": "/react/build/static/css/17.d0c774b5.chunk.css",
"./static/js/17.de7604c0.chunk.js": "/react/build/./static/js/17.de7604c0.chunk.js",
"static/css/18.7bd7b9f3.chunk.css": "/react/build/static/css/18.7bd7b9f3.chunk.css",
"./static/js/18.99b2f967.chunk.js": "/react/build/./static/js/18.99b2f967.chunk.js",
"static/css/19.012aec0d.chunk.css": "/react/build/static/css/19.012aec0d.chunk.css",
"./static/js/19.64cbc4fc.chunk.js": "/react/build/./static/js/19.64cbc4fc.chunk.js",
"static/css/20.e5544bad.chunk.css": "/react/build/static/css/20.e5544bad.chunk.css",
"./static/js/20.bfbd5ffe.chunk.js": "/react/build/./static/js/20.bfbd5ffe.chunk.js",
"./static/js/21.6da4d475.chunk.js": "/react/build/./static/js/21.6da4d475.chunk.js",
"static/css/22.db9266b0.chunk.css": "/react/build/static/css/22.db9266b0.chunk.css",
"./static/js/22.12e0dd3b.chunk.js": "/react/build/./static/js/22.12e0dd3b.chunk.js",
"static/css/23.0b7937b6.chunk.css": "/react/build/static/css/23.0b7937b6.chunk.css",
"./static/js/23.2b12e836.chunk.js": "/react/build/./static/js/23.2b12e836.chunk.js",
"./static/js/24.23597b79.chunk.js": "/react/build/./static/js/24.23597b79.chunk.js",
"static/css/25.92df39ea.chunk.css": "/react/build/static/css/25.92df39ea.chunk.css",
"./static/js/25.865cccee.chunk.js": "/react/build/./static/js/25.865cccee.chunk.js",
"./static/js/26.e9e9c6fc.chunk.js": "/react/build/./static/js/26.e9e9c6fc.chunk.js",
"static/css/27.75aaa133.chunk.css": "/react/build/static/css/27.75aaa133.chunk.css",
"./static/js/27.8968b5ae.chunk.js": "/react/build/./static/js/27.8968b5ae.chunk.js",
"static/css/28.41a244df.chunk.css": "/react/build/static/css/28.41a244df.chunk.css",
"./static/js/28.f1d36958.chunk.js": "/react/build/./static/js/28.f1d36958.chunk.js",
"./static/js/29.fc579b75.chunk.js": "/react/build/./static/js/29.fc579b75.chunk.js",
"static/css/30.6959641e.chunk.css": "/react/build/static/css/30.6959641e.chunk.css",
"./static/js/30.392e284c.chunk.js": "/react/build/./static/js/30.392e284c.chunk.js",
"static/css/31.33342a61.chunk.css": "/react/build/static/css/31.33342a61.chunk.css",
"./static/js/31.7c482b29.chunk.js": "/react/build/./static/js/31.7c482b29.chunk.js",
"static/css/32.8b23fd13.chunk.css": "/react/build/static/css/32.8b23fd13.chunk.css",
"./static/js/32.1bf7b1a8.chunk.js": "/react/build/./static/js/32.1bf7b1a8.chunk.js",
"static/css/33.976e1469.chunk.css": "/react/build/static/css/33.976e1469.chunk.css",
"./static/js/33.6834d83e.chunk.js": "/react/build/./static/js/33.6834d83e.chunk.js",
"static/css/34.1909b232.chunk.css": "/react/build/static/css/34.1909b232.chunk.css",
"./static/js/34.11fca591.chunk.js": "/react/build/./static/js/34.11fca591.chunk.js",
"static/css/35.c1a97940.chunk.css": "/react/build/static/css/35.c1a97940.chunk.css",
"./static/js/35.1bed6651.chunk.js": "/react/build/./static/js/35.1bed6651.chunk.js",
"static/css/36.ba58843c.chunk.css": "/react/build/static/css/36.ba58843c.chunk.css",
"./static/js/36.1d8750e5.chunk.js": "/react/build/./static/js/36.1d8750e5.chunk.js",
"static/css/37.df5720eb.chunk.css": "/react/build/static/css/37.df5720eb.chunk.css",
"./static/js/37.7895936e.chunk.js": "/react/build/./static/js/37.7895936e.chunk.js",
"static/css/38.d7c1d404.chunk.css": "/react/build/static/css/38.d7c1d404.chunk.css",
"./static/js/38.b594cda3.chunk.js": "/react/build/./static/js/38.b594cda3.chunk.js",
"static/css/39.2626b3f1.chunk.css": "/react/build/static/css/39.2626b3f1.chunk.css",
"./static/js/39.43e31700.chunk.js": "/react/build/./static/js/39.43e31700.chunk.js",
"static/css/40.2626b3f1.chunk.css": "/react/build/static/css/40.2626b3f1.chunk.css",
"./static/js/40.6e19d654.chunk.js": "/react/build/./static/js/40.6e19d654.chunk.js",
"static/css/41.2626b3f1.chunk.css": "/react/build/static/css/41.2626b3f1.chunk.css",
"./static/js/41.bd1a4a5b.chunk.js": "/react/build/./static/js/41.bd1a4a5b.chunk.js",
"static/css/42.2626b3f1.chunk.css": "/react/build/static/css/42.2626b3f1.chunk.css",
"./static/js/42.0fa9bf00.chunk.js": "/react/build/./static/js/42.0fa9bf00.chunk.js",
"static/css/43.2626b3f1.chunk.css": "/react/build/static/css/43.2626b3f1.chunk.css",
"./static/js/43.61e4dbcc.chunk.js": "/react/build/./static/js/43.61e4dbcc.chunk.js",
"static/css/44.59b01c1c.chunk.css": "/react/build/static/css/44.59b01c1c.chunk.css",
"./static/js/44.7c3fd2ee.chunk.js": "/react/build/./static/js/44.7c3fd2ee.chunk.js",
"./static/js/45.edfa1964.chunk.js": "/react/build/./static/js/45.edfa1964.chunk.js",
"static/css/46.98447f32.chunk.css": "/react/build/static/css/46.98447f32.chunk.css",
"./static/js/46.df9bb833.chunk.js": "/react/build/./static/js/46.df9bb833.chunk.js",
"static/css/47.98447f32.chunk.css": "/react/build/static/css/47.98447f32.chunk.css",
"./static/js/47.2dfecd07.chunk.js": "/react/build/./static/js/47.2dfecd07.chunk.js",
"static/css/48.68faae98.chunk.css": "/react/build/static/css/48.68faae98.chunk.css",
"./static/js/48.e9c4c8e3.chunk.js": "/react/build/./static/js/48.e9c4c8e3.chunk.js",
"static/css/49.c3744d8e.chunk.css": "/react/build/static/css/49.c3744d8e.chunk.css",
"./static/js/49.93e9a528.chunk.js": "/react/build/./static/js/49.93e9a528.chunk.js",
"./static/js/50.c507c922.chunk.js": "/react/build/./static/js/50.c507c922.chunk.js",
"static/css/51.080d6958.chunk.css": "/react/build/static/css/51.080d6958.chunk.css",
"./static/js/51.1662030d.chunk.js": "/react/build/./static/js/51.1662030d.chunk.js",
"./static/js/52.2a448ff5.chunk.js": "/react/build/./static/js/52.2a448ff5.chunk.js",
"./static/js/53.31e60498.chunk.js": "/react/build/./static/js/53.31e60498.chunk.js",
"static/css/54.2b4fa75d.chunk.css": "/react/build/static/css/54.2b4fa75d.chunk.css",
"./static/js/54.c9a46188.chunk.js": "/react/build/./static/js/54.c9a46188.chunk.js",
"static/css/55.fd0c85ec.chunk.css": "/react/build/static/css/55.fd0c85ec.chunk.css",
"./static/js/55.51f06bff.chunk.js": "/react/build/./static/js/55.51f06bff.chunk.js",
"static/css/56.4f215d24.chunk.css": "/react/build/static/css/56.4f215d24.chunk.css",
"./static/js/56.25054407.chunk.js": "/react/build/./static/js/56.25054407.chunk.js",
"static/css/57.94fbef24.chunk.css": "/react/build/static/css/57.94fbef24.chunk.css",
"./static/js/57.d3e720bf.chunk.js": "/react/build/./static/js/57.d3e720bf.chunk.js",
"static/css/58.ff2c3b14.chunk.css": "/react/build/static/css/58.ff2c3b14.chunk.css",
"./static/js/58.3cd48dd7.chunk.js": "/react/build/./static/js/58.3cd48dd7.chunk.js",
"static/css/59.0af82a8e.chunk.css": "/react/build/static/css/59.0af82a8e.chunk.css",
"./static/js/59.fe3389c7.chunk.js": "/react/build/./static/js/59.fe3389c7.chunk.js",
"static/css/60.3e0abc39.chunk.css": "/react/build/static/css/60.3e0abc39.chunk.css",
"./static/js/60.29987b41.chunk.js": "/react/build/./static/js/60.29987b41.chunk.js",
"static/css/61.1b6ed5c5.chunk.css": "/react/build/static/css/61.1b6ed5c5.chunk.css",
"./static/js/61.2cc62d12.chunk.js": "/react/build/./static/js/61.2cc62d12.chunk.js",
"static/css/62.67a9b0d6.chunk.css": "/react/build/static/css/62.67a9b0d6.chunk.css",
"./static/js/62.60eb38ba.chunk.js": "/react/build/./static/js/62.60eb38ba.chunk.js",
"static/css/63.b61fdef2.chunk.css": "/react/build/static/css/63.b61fdef2.chunk.css",
"./static/js/63.2575fd00.chunk.js": "/react/build/./static/js/63.2575fd00.chunk.js",
"static/css/64.1d3b7a8d.chunk.css": "/react/build/static/css/64.1d3b7a8d.chunk.css",
"./static/js/64.e029828c.chunk.js": "/react/build/./static/js/64.e029828c.chunk.js",
"static/css/65.1ff4022b.chunk.css": "/react/build/static/css/65.1ff4022b.chunk.css",
"./static/js/65.c81b0c53.chunk.js": "/react/build/./static/js/65.c81b0c53.chunk.js",
"static/css/66.e7e39c50.chunk.css": "/react/build/static/css/66.e7e39c50.chunk.css",
"./static/js/66.0c8035ec.chunk.js": "/react/build/./static/js/66.0c8035ec.chunk.js",
"./static/js/67.15c042c9.chunk.js": "/react/build/./static/js/67.15c042c9.chunk.js",
"static/css/68.2fa85927.chunk.css": "/react/build/static/css/68.2fa85927.chunk.css",
"./static/js/68.2b51ecf7.chunk.js": "/react/build/./static/js/68.2b51ecf7.chunk.js",
"static/css/69.05177416.chunk.css": "/react/build/static/css/69.05177416.chunk.css",
"./static/js/69.c59f6352.chunk.js": "/react/build/./static/js/69.c59f6352.chunk.js",
"static/css/70.330fa4e3.chunk.css": "/react/build/static/css/70.330fa4e3.chunk.css",
"./static/js/70.c5a81a2e.chunk.js": "/react/build/./static/js/70.c5a81a2e.chunk.js",
"static/css/71.520bfea6.chunk.css": "/react/build/static/css/71.520bfea6.chunk.css",
"./static/js/71.3c84b9a3.chunk.js": "/react/build/./static/js/71.3c84b9a3.chunk.js",
"static/css/72.a5678b8f.chunk.css": "/react/build/static/css/72.a5678b8f.chunk.css",
"./static/js/72.07f27821.chunk.js": "/react/build/./static/js/72.07f27821.chunk.js",
"static/css/73.9d206204.chunk.css": "/react/build/static/css/73.9d206204.chunk.css",
"./static/js/73.de249b1b.chunk.js": "/react/build/./static/js/73.de249b1b.chunk.js",
"./static/js/74.c7555bb7.chunk.js": "/react/build/./static/js/74.c7555bb7.chunk.js",
"static/css/75.ea97577b.chunk.css": "/react/build/static/css/75.ea97577b.chunk.css",
"./static/js/75.ebc9889d.chunk.js": "/react/build/./static/js/75.ebc9889d.chunk.js",
"static/css/76.2cfa3592.chunk.css": "/react/build/static/css/76.2cfa3592.chunk.css",
"./static/js/76.7e006098.chunk.js": "/react/build/./static/js/76.7e006098.chunk.js",
"static/css/77.b2109eb4.chunk.css": "/react/build/static/css/77.b2109eb4.chunk.css",
"./static/js/77.1467742a.chunk.js": "/react/build/./static/js/77.1467742a.chunk.js",
"static/css/78.1819b82d.chunk.css": "/react/build/static/css/78.1819b82d.chunk.css",
"./static/js/78.e53f62da.chunk.js": "/react/build/./static/js/78.e53f62da.chunk.js",
"static/css/79.61b37499.chunk.css": "/react/build/static/css/79.61b37499.chunk.css",
"./static/js/79.0db90219.chunk.js": "/react/build/./static/js/79.0db90219.chunk.js",
"static/css/80.61b37499.chunk.css": "/react/build/static/css/80.61b37499.chunk.css",
"./static/js/80.e559b8a1.chunk.js": "/react/build/./static/js/80.e559b8a1.chunk.js",
"static/css/81.802376aa.chunk.css": "/react/build/static/css/81.802376aa.chunk.css",
"./static/js/81.764e5979.chunk.js": "/react/build/./static/js/81.764e5979.chunk.js",
"static/css/82.92df39ea.chunk.css": "/react/build/static/css/82.92df39ea.chunk.css",
"./static/js/82.d2b548af.chunk.js": "/react/build/./static/js/82.d2b548af.chunk.js",
"static/css/83.1926e8da.chunk.css": "/react/build/static/css/83.1926e8da.chunk.css",
"./static/js/83.1397db65.chunk.js": "/react/build/./static/js/83.1397db65.chunk.js",
"static/css/84.72690062.chunk.css": "/react/build/static/css/84.72690062.chunk.css",
"./static/js/84.f90c90dc.chunk.js": "/react/build/./static/js/84.f90c90dc.chunk.js",
"./static/js/85.bfb508e1.chunk.js": "/react/build/./static/js/85.bfb508e1.chunk.js",
"static/css/86.4054f41b.chunk.css": "/react/build/static/css/86.4054f41b.chunk.css",
"./static/js/86.bf43383c.chunk.js": "/react/build/./static/js/86.bf43383c.chunk.js",
"static/css/87.f4de1d43.chunk.css": "/react/build/static/css/87.f4de1d43.chunk.css",
"./static/js/87.f8b86b5a.chunk.js": "/react/build/./static/js/87.f8b86b5a.chunk.js",
"static/css/88.d16cbade.chunk.css": "/react/build/static/css/88.d16cbade.chunk.css",
"./static/js/88.c67b97e5.chunk.js": "/react/build/./static/js/88.c67b97e5.chunk.js",
"static/css/89.2276e27f.chunk.css": "/react/build/static/css/89.2276e27f.chunk.css",
"./static/js/89.97b57d93.chunk.js": "/react/build/./static/js/89.97b57d93.chunk.js",
"static/css/90.c2f5b906.chunk.css": "/react/build/static/css/90.c2f5b906.chunk.css",
"./static/js/90.d3038559.chunk.js": "/react/build/./static/js/90.d3038559.chunk.js",
"static/css/91.fd3fa2e9.chunk.css": "/react/build/static/css/91.fd3fa2e9.chunk.css",
"./static/js/91.861bcc26.chunk.js": "/react/build/./static/js/91.861bcc26.chunk.js",
"./static/js/92.3ad04ab0.chunk.js": "/react/build/./static/js/92.3ad04ab0.chunk.js",
"static/css/93.6ec10da0.chunk.css": "/react/build/static/css/93.6ec10da0.chunk.css",
"./static/js/93.b5383dfd.chunk.js": "/react/build/./static/js/93.b5383dfd.chunk.js",
"static/css/94.92df39ea.chunk.css": "/react/build/static/css/94.92df39ea.chunk.css",
"./static/js/94.066a5fc1.chunk.js": "/react/build/./static/js/94.066a5fc1.chunk.js",
"static/css/95.92df39ea.chunk.css": "/react/build/static/css/95.92df39ea.chunk.css",
"./static/js/95.6a4663c6.chunk.js": "/react/build/./static/js/95.6a4663c6.chunk.js",
"./static/js/96.33c3003a.chunk.js": "/react/build/./static/js/96.33c3003a.chunk.js",
"./static/js/97.4d58f6ed.chunk.js": "/react/build/./static/js/97.4d58f6ed.chunk.js",
"./static/js/98.cf8af97d.chunk.js": "/react/build/./static/js/98.cf8af97d.chunk.js",
"static/css/99.3598c90d.chunk.css": "/react/build/static/css/99.3598c90d.chunk.css",
"./static/js/99.21457e50.chunk.js": "/react/build/./static/js/99.21457e50.chunk.js",
"static/css/100.b6f629c2.chunk.css": "/react/build/static/css/100.b6f629c2.chunk.css",
"./static/js/100.fc4af1ad.chunk.js": "/react/build/./static/js/100.fc4af1ad.chunk.js",
"static/css/101.9d206204.chunk.css": "/react/build/static/css/101.9d206204.chunk.css",
"./static/js/101.2db1caa5.chunk.js": "/react/build/./static/js/101.2db1caa5.chunk.js",
"static/css/102.632d7855.chunk.css": "/react/build/static/css/102.632d7855.chunk.css",
"./static/js/102.b7ee5c30.chunk.js": "/react/build/./static/js/102.b7ee5c30.chunk.js",
"static/css/103.ebddf6de.chunk.css": "/react/build/static/css/103.ebddf6de.chunk.css",
"./static/js/103.447d1f02.chunk.js": "/react/build/./static/js/103.447d1f02.chunk.js",
"static/css/104.e2a8a600.chunk.css": "/react/build/static/css/104.e2a8a600.chunk.css",
"./static/js/104.5e1e92d6.chunk.js": "/react/build/./static/js/104.5e1e92d6.chunk.js",
"static/css/105.9d206204.chunk.css": "/react/build/static/css/105.9d206204.chunk.css",
"./static/js/105.f321fb14.chunk.js": "/react/build/./static/js/105.f321fb14.chunk.js",
"static/css/106.9d206204.chunk.css": "/react/build/static/css/106.9d206204.chunk.css",
"./static/js/106.803a42ce.chunk.js": "/react/build/./static/js/106.803a42ce.chunk.js",
"static/css/107.92df39ea.chunk.css": "/react/build/static/css/107.92df39ea.chunk.css",
"./static/js/107.8c208a60.chunk.js": "/react/build/./static/js/107.8c208a60.chunk.js",
"./static/js/108.a0a22f46.chunk.js": "/react/build/./static/js/108.a0a22f46.chunk.js",
"static/css/109.11a04942.chunk.css": "/react/build/static/css/109.11a04942.chunk.css",
"./static/js/109.0b0b354a.chunk.js": "/react/build/./static/js/109.0b0b354a.chunk.js",
"./static/js/110.52c656b4.chunk.js": "/react/build/./static/js/110.52c656b4.chunk.js",
"./static/js/111.3a955a9d.chunk.js": "/react/build/./static/js/111.3a955a9d.chunk.js",
"./static/js/112.0170893b.chunk.js": "/react/build/./static/js/112.0170893b.chunk.js",
"./static/js/113.8ea9fce8.chunk.js": "/react/build/./static/js/113.8ea9fce8.chunk.js",
"static/css/114.3edde0c7.chunk.css": "/react/build/static/css/114.3edde0c7.chunk.css",
"./static/js/114.c021ac69.chunk.js": "/react/build/./static/js/114.c021ac69.chunk.js",
"static/css/115.6959641e.chunk.css": "/react/build/static/css/115.6959641e.chunk.css",
"./static/js/115.4e600cac.chunk.js": "/react/build/./static/js/115.4e600cac.chunk.js",
"./static/js/116.efdde353.chunk.js": "/react/build/./static/js/116.efdde353.chunk.js",
"static/css/117.2f409942.chunk.css": "/react/build/static/css/117.2f409942.chunk.css",
"./static/js/117.9e9b37d0.chunk.js": "/react/build/./static/js/117.9e9b37d0.chunk.js",
"./static/js/118.0cea1b84.chunk.js": "/react/build/./static/js/118.0cea1b84.chunk.js",
"./static/js/119.64d762d7.chunk.js": "/react/build/./static/js/119.64d762d7.chunk.js",
"./static/js/120.cc2cf38f.chunk.js": "/react/build/./static/js/120.cc2cf38f.chunk.js",
"./static/js/121.0ec26eb3.chunk.js": "/react/build/./static/js/121.0ec26eb3.chunk.js",
"static/css/122.1ff4022b.chunk.css": "/react/build/static/css/122.1ff4022b.chunk.css",
"./static/js/122.e8744ac0.chunk.js": "/react/build/./static/js/122.e8744ac0.chunk.js",
"static/css/123.fd96c397.chunk.css": "/react/build/static/css/123.fd96c397.chunk.css",
"./static/js/123.d62c507b.chunk.js": "/react/build/./static/js/123.d62c507b.chunk.js",
"static/css/124.188a7db8.chunk.css": "/react/build/static/css/124.188a7db8.chunk.css",
"./static/js/124.0efba3cd.chunk.js": "/react/build/./static/js/124.0efba3cd.chunk.js",
"static/css/125.af9850ad.chunk.css": "/react/build/static/css/125.af9850ad.chunk.css",
"./static/js/125.984e9423.chunk.js": "/react/build/./static/js/125.984e9423.chunk.js",
"static/css/126.6959641e.chunk.css": "/react/build/static/css/126.6959641e.chunk.css",
"./static/js/126.1e1c6b0d.chunk.js": "/react/build/./static/js/126.1e1c6b0d.chunk.js",
"static/css/127.6959641e.chunk.css": "/react/build/static/css/127.6959641e.chunk.css",
"./static/js/127.ce9a385e.chunk.js": "/react/build/./static/js/127.ce9a385e.chunk.js",
"static/css/128.6959641e.chunk.css": "/react/build/static/css/128.6959641e.chunk.css",
"./static/js/128.f2b66603.chunk.js": "/react/build/./static/js/128.f2b66603.chunk.js",
"static/css/129.f2060fe7.chunk.css": "/react/build/static/css/129.f2060fe7.chunk.css",
"./static/js/129.e53ef67f.chunk.js": "/react/build/./static/js/129.e53ef67f.chunk.js",
"static/css/130.0485185f.chunk.css": "/react/build/static/css/130.0485185f.chunk.css",
"./static/js/130.803453b6.chunk.js": "/react/build/./static/js/130.803453b6.chunk.js",
"static/css/131.9d206204.chunk.css": "/react/build/static/css/131.9d206204.chunk.css",
"./static/js/131.4f4d8f60.chunk.js": "/react/build/./static/js/131.4f4d8f60.chunk.js",
"./static/js/132.34a2259c.chunk.js": "/react/build/./static/js/132.34a2259c.chunk.js",
"./static/js/133.85d8a606.chunk.js": "/react/build/./static/js/133.85d8a606.chunk.js",
"./static/js/134.9d070f9e.chunk.js": "/react/build/./static/js/134.9d070f9e.chunk.js",
"./static/js/135.1bcde502.chunk.js": "/react/build/./static/js/135.1bcde502.chunk.js",
"./static/js/136.ef38bcee.chunk.js": "/react/build/./static/js/136.ef38bcee.chunk.js",
"./static/js/137.bce33c57.chunk.js": "/react/build/./static/js/137.bce33c57.chunk.js",
"./static/js/138.30c9bf3e.chunk.js": "/react/build/./static/js/138.30c9bf3e.chunk.js",
"./static/js/139.471b727e.chunk.js": "/react/build/./static/js/139.471b727e.chunk.js",
"./static/js/140.2cf678ec.chunk.js": "/react/build/./static/js/140.2cf678ec.chunk.js",
"./static/js/141.63765328.chunk.js": "/react/build/./static/js/141.63765328.chunk.js",
"./static/js/142.0027ca78.chunk.js": "/react/build/./static/js/142.0027ca78.chunk.js",
"./static/js/143.cd908a95.chunk.js": "/react/build/./static/js/143.cd908a95.chunk.js",
"./static/js/144.39906bf7.chunk.js": "/react/build/./static/js/144.39906bf7.chunk.js",
"./static/js/145.7b278c6b.chunk.js": "/react/build/./static/js/145.7b278c6b.chunk.js",
"./static/js/146.6ca0e3da.chunk.js": "/react/build/./static/js/146.6ca0e3da.chunk.js",
"./static/js/147.dbf0f839.chunk.js": "/react/build/./static/js/147.dbf0f839.chunk.js",
"./static/js/148.07f78d0f.chunk.js": "/react/build/./static/js/148.07f78d0f.chunk.js",
"./static/js/149.4917012a.chunk.js": "/react/build/./static/js/149.4917012a.chunk.js",
"./static/js/150.7215ad62.chunk.js": "/react/build/./static/js/150.7215ad62.chunk.js",
"./static/js/151.186a4889.chunk.js": "/react/build/./static/js/151.186a4889.chunk.js",
"./static/js/152.122c87bb.chunk.js": "/react/build/./static/js/152.122c87bb.chunk.js",
"./static/js/153.b44f586e.chunk.js": "/react/build/./static/js/153.b44f586e.chunk.js",
"./static/js/154.2db89a53.chunk.js": "/react/build/./static/js/154.2db89a53.chunk.js",
"./static/js/155.a77fae47.chunk.js": "/react/build/./static/js/155.a77fae47.chunk.js",
"./static/js/156.37dbc7bb.chunk.js": "/react/build/./static/js/156.37dbc7bb.chunk.js",
"./static/js/157.36f425bc.chunk.js": "/react/build/./static/js/157.36f425bc.chunk.js",
"./static/js/158.2e4db6de.chunk.js": "/react/build/./static/js/158.2e4db6de.chunk.js",
"./static/js/159.5d3126e8.chunk.js": "/react/build/./static/js/159.5d3126e8.chunk.js",
"./static/js/160.409d5e55.chunk.js": "/react/build/./static/js/160.409d5e55.chunk.js",
"./static/js/161.4f559e88.chunk.js": "/react/build/./static/js/161.4f559e88.chunk.js",
"./static/js/162.64c02d80.chunk.js": "/react/build/./static/js/162.64c02d80.chunk.js",
"./static/js/163.7cbab30b.chunk.js": "/react/build/./static/js/163.7cbab30b.chunk.js",
"./static/js/164.22383137.chunk.js": "/react/build/./static/js/164.22383137.chunk.js",
"./static/js/165.77813baa.chunk.js": "/react/build/./static/js/165.77813baa.chunk.js",
"./static/js/166.423280ce.chunk.js": "/react/build/./static/js/166.423280ce.chunk.js",
"./static/js/167.f1258091.chunk.js": "/react/build/./static/js/167.f1258091.chunk.js",
"./static/js/168.c49a96e6.chunk.js": "/react/build/./static/js/168.c49a96e6.chunk.js",
"./static/js/169.6460fd6c.chunk.js": "/react/build/./static/js/169.6460fd6c.chunk.js",
"./static/js/170.cdf35b6b.chunk.js": "/react/build/./static/js/170.cdf35b6b.chunk.js",
"./static/js/171.4c42c6ae.chunk.js": "/react/build/./static/js/171.4c42c6ae.chunk.js",
"./static/js/172.d990fdef.chunk.js": "/react/build/./static/js/172.d990fdef.chunk.js",
"./static/js/173.3c0ceead.chunk.js": "/react/build/./static/js/173.3c0ceead.chunk.js",
"./static/js/174.2b2c02f1.chunk.js": "/react/build/./static/js/174.2b2c02f1.chunk.js",
"./static/js/175.4fd67b66.chunk.js": "/react/build/./static/js/175.4fd67b66.chunk.js",
"./static/js/176.f501f20e.chunk.js": "/react/build/./static/js/176.f501f20e.chunk.js",
"./static/js/177.911d323c.chunk.js": "/react/build/./static/js/177.911d323c.chunk.js",
"./static/js/178.ad0e70b9.chunk.js": "/react/build/./static/js/178.ad0e70b9.chunk.js",
"./static/js/179.aae90537.chunk.js": "/react/build/./static/js/179.aae90537.chunk.js",
"./static/js/180.e0443fc8.chunk.js": "/react/build/./static/js/180.e0443fc8.chunk.js",
"./static/js/181.3b72d5d9.chunk.js": "/react/build/./static/js/181.3b72d5d9.chunk.js",
"./static/js/182.13b011e9.chunk.js": "/react/build/./static/js/182.13b011e9.chunk.js",
"./static/js/183.e83932d5.chunk.js": "/react/build/./static/js/183.e83932d5.chunk.js",
"./static/js/184.fba4c92a.chunk.js": "/react/build/./static/js/184.fba4c92a.chunk.js",
"./static/js/185.26003958.chunk.js": "/react/build/./static/js/185.26003958.chunk.js",
"./static/js/186.3a26d9d6.chunk.js": "/react/build/./static/js/186.3a26d9d6.chunk.js",
"./static/js/187.b1aa5de5.chunk.js": "/react/build/./static/js/187.b1aa5de5.chunk.js",
"./static/js/188.47fc125f.chunk.js": "/react/build/./static/js/188.47fc125f.chunk.js",
"./static/js/189.99779198.chunk.js": "/react/build/./static/js/189.99779198.chunk.js",
"./static/js/190.b6b0cd5b.chunk.js": "/react/build/./static/js/190.b6b0cd5b.chunk.js",
"./static/js/191.9b7c6545.chunk.js": "/react/build/./static/js/191.9b7c6545.chunk.js",
"./static/js/192.00b4a614.chunk.js": "/react/build/./static/js/192.00b4a614.chunk.js",
"./static/js/193.35021ed8.chunk.js": "/react/build/./static/js/193.35021ed8.chunk.js",
"main.css": "/react/build/static/css/main.b0997c8b.chunk.css",
"main.js": "/react/build/./static/js/main.0fa88be5.chunk.js",
"runtime~main.js": "/react/build/./static/js/runtime~main.7d6e2d24.js",
"./static/js/117.9e9b37d0.chunk.js.LICENSE.txt": "/react/build/./static/js/117.9e9b37d0.chunk.js.LICENSE.txt",
"./static/js/146.6ca0e3da.chunk.js.LICENSE.txt": "/react/build/./static/js/146.6ca0e3da.chunk.js.LICENSE.txt",
"./static/js/188.47fc125f.chunk.js.LICENSE.txt": "/react/build/./static/js/188.47fc125f.chunk.js.LICENSE.txt",
"./static/js/2.d659edf3.chunk.js.LICENSE.txt": "/react/build/./static/js/2.d659edf3.chunk.js.LICENSE.txt",
"./static/js/33.6834d83e.chunk.js.LICENSE.txt": "/react/build/./static/js/33.6834d83e.chunk.js.LICENSE.txt",
"./static/js/34.11fca591.chunk.js.LICENSE.txt": "/react/build/./static/js/34.11fca591.chunk.js.LICENSE.txt",
"./static/js/8.882648e1.chunk.js.LICENSE.txt": "/react/build/./static/js/8.882648e1.chunk.js.LICENSE.txt",
"./static/js/main.0fa88be5.chunk.js.LICENSE.txt": "/react/build/./static/js/main.0fa88be5.chunk.js.LICENSE.txt",
"css.worker.js": "/react/build/css.worker.js",
"editor.worker.js": "/react/build/editor.worker.js",
"html.worker.js": "/react/build/html.worker.js",
"index.html": "/react/build/index.html",
"json.worker.js": "/react/build/json.worker.js",
"static/media/Index.scss": "/react/build/static/media/typebg.b2b0ea32.png",
"static/media/2-2-1.png": "/react/build/static/media/2-2-1.afd0f2f5.png",
"static/media/2-2-2.png": "/react/build/static/media/2-2-2.26bc3301.png",
"static/media/2-2-3.png": "/react/build/static/media/2-2-3.6d6ce99c.png",
"static/media/2-2-head.png": "/react/build/static/media/2-2-head.5e69dbb2.png",
"static/media/2-3-1.png": "/react/build/static/media/2-3-1.bcb33d47.png",
"static/media/2-3-2.png": "/react/build/static/media/2-3-2.84718f27.png",
"static/media/2-3-3.png": "/react/build/static/media/2-3-3.db9fe021.png",
"static/media/2-3-4.png": "/react/build/static/media/2-3-4.15673036.png",
"static/media/2-6-1.png": "/react/build/static/media/2-6-1.302b729e.png",
"static/media/2-6-2.png": "/react/build/static/media/2-6-2.b262b91e.png",
"static/media/3-1.png": "/react/build/static/media/3-1.9fdda521.png",
"static/media/3-2.png": "/react/build/static/media/3-2.47050941.png",
"static/media/3-3.png": "/react/build/static/media/3-3.c767aae7.png",
"static/media/3-4.png": "/react/build/static/media/3-4.92820cbc.png",
"static/media/4-1.png": "/react/build/static/media/4-1.79fa159d.png",
"static/media/4-2.png": "/react/build/static/media/4-2.9c066e75.png",
"static/media/4-3.png": "/react/build/static/media/4-3.a1487a5b.png",
"static/media/4-4.png": "/react/build/static/media/4-4.5eb40734.png",
"static/media/49.png": "/react/build/static/media/49.b03e6efe.png",
"static/media/BJHKHT.png": "/react/build/static/media/BJHKHT.f065403a.png",
"static/media/CEC.png": "/react/build/static/media/CEC.3b748059.png",
"static/media/GFKJ.png": "/react/build/static/media/GFKJ.eb30c414.png",
"static/media/HSKY.png": "/react/build/static/media/HSKY.2e76ba44.png",
"static/media/ISCAS.png": "/react/build/static/media/ISCAS.851fcfda.png",
"static/media/KYRJLM.png": "/react/build/static/media/KYRJLM.2d659e5c.png",
"static/media/katex.min.css": "/react/build/static/media/KaTeX_Typewriter-Regular.d3c8e68f.woff",
"static/media/LC.png": "/react/build/static/media/LC.f247fdb8.png",
"static/media/LSLM.png": "/react/build/static/media/LSLM.99387946.png",
"static/media/ML.png": "/react/build/static/media/ML.08d278e2.png",
"static/media/NJDX.png": "/react/build/static/media/NJDX.bb34b326.png",
"static/media/QH.png": "/react/build/static/media/QH.b57a0131.png",
"static/media/SHJT.png": "/react/build/static/media/SHJT.426bf0c7.png",
"static/media/TX.png": "/react/build/static/media/TX.b703476c.png",
"static/media/WXYJY.png": "/react/build/static/media/WXYJY.21e40191.png",
"static/media/XH.png": "/react/build/static/media/XH.a0a88f17.png",
"static/media/XJY.png": "/react/build/static/media/XJY.b4c57bf1.png",
"static/media/YKD.png": "/react/build/static/media/YKD.4f7e2766.png",
"static/media/ZC.png": "/react/build/static/media/ZC.ad056aa5.png",
"static/media/achievements.png": "/react/build/static/media/achievements.f20b7e39.png",
"static/media/ball.png": "/react/build/static/media/ball.24214b6e.png",
"static/media/AboutUs.scss": "/react/build/static/media/joinUs.26ec28cd.png",
"static/media/banner.png": "/react/build/static/media/banner.f7da2db1.png",
"static/media/banner_list.jpg": "/react/build/static/media/banner_list.e02c5e16.jpg",
"static/media/beijing.png": "/react/build/static/media/beijing.bfcd5b0e.png",
"static/media/LoginRegisterPage.scss": "/react/build/static/media/rightBg.55f14f0c.png",
"static/media/codeafter.png": "/react/build/static/media/codeafter.c3088c74.png",
"static/media/computer.png": "/react/build/static/media/computer.4fe86b12.png",
"static/media/earth.png": "/react/build/static/media/earth.050b1435.png",
"static/media/fun1.png": "/react/build/static/media/fun1.c99ffa49.png",
"static/media/fun2.png": "/react/build/static/media/fun2.12f22bca.png",
"static/media/fun3.png": "/react/build/static/media/fun3.75c280e6.png",
"static/media/fun4.png": "/react/build/static/media/fun4.f499794e.png",
"static/media/fun5.png": "/react/build/static/media/fun5.96b44942.png",
"static/media/head.png": "/react/build/static/media/head.52aa3fc8.png",
"static/media/huake.png": "/react/build/static/media/huake.63b6a34d.png",
"static/media/huawei.png": "/react/build/static/media/huawei.73ec7c22.png",
"static/media/Teaching.scss": "/react/build/static/media/image22.d4d77f6c.svg",
"static/media/img1.png": "/react/build/static/media/img1.e0beda57.png",
"static/media/img10.png": "/react/build/static/media/img10.64149a3d.png",
"static/media/img15.png": "/react/build/static/media/img15.87a3556c.png",
"static/media/img16.png": "/react/build/static/media/img16.32badab9.png",
"static/media/img17.png": "/react/build/static/media/img17.c25d5edc.png",
"static/media/img18.png": "/react/build/static/media/img18.4963efc1.png",
"static/media/img2.png": "/react/build/static/media/img2.ae303051.png",
"static/media/img3.png": "/react/build/static/media/img3.cee3ac5b.png",
"static/media/img4.png": "/react/build/static/media/img4.53c937cb.png",
"static/media/img5.png": "/react/build/static/media/img5.ca3a2287.png",
"static/media/img6.png": "/react/build/static/media/img6.8f81bf78.png",
"static/media/img7.png": "/react/build/static/media/img7.e4a68e6e.png",
"static/media/img8.png": "/react/build/static/media/img8.10500e00.png",
"static/media/img9.png": "/react/build/static/media/img9.d25372ba.png",
"static/media/jijinhui.png": "/react/build/static/media/jijinhui.041fb524.png",
"static/media/logo.png": "/react/build/static/media/logo.35cca493.png",
"static/media/mulan.png": "/react/build/static/media/mulan.690d2289.png",
"static/media/slick-theme.css": "/react/build/static/media/slick.c94f7671.ttf",
"static/media/subtitle.png": "/react/build/static/media/subtitle.5019e086.png",
"static/media/index.scss": "/react/build/static/media/taskbar.49a40f3a.png",
"static/media/xigongye.png": "/react/build/static/media/xigongye.d51231d3.png",
"static/media/xiuos.png": "/react/build/static/media/xiuos.67682257.png",
"ts.worker.js": "/react/build/ts.worker.js",
"ts.worker.js.LICENSE.txt": "/react/build/ts.worker.js.LICENSE.txt"
}

File diff suppressed because it is too large Load Diff

View File

@ -1,239 +0,0 @@
/*******************************************************************************
* KindEditor - WYSIWYG HTML Editor for Internet
* Copyright (C) 2006-2011 kindsoft.net
*
* @author Roddy <luolonghao@gmail.com>
* @site http://www.kindsoft.net/
* @licence http://www.kindsoft.net/license.php
*******************************************************************************/
KindEditor.lang({
imagedirectupload:'本地图片',
more: '切换到更多功能',
less: '切换到简单功能',
source : 'HTML代码',
preview : '预览',
undo : '后退(Ctrl+Z)',
redo : '前进(Ctrl+Y)',
cut : '剪切(Ctrl+X)',
copy : '复制(Ctrl+C)',
paste : '粘贴(Ctrl+V)',
plainpaste : '粘贴为无格式文本',
wordpaste : '从Word粘贴',
selectall : '全选(Ctrl+A)',
justifyleft : '左对齐',
justifycenter : '居中',
justifyright : '右对齐',
justifyfull : '两端对齐',
insertorderedlist : '编号',
insertunorderedlist : '项目符号',
indent : '增加缩进',
outdent : '减少缩进',
subscript : '下标',
superscript : '上标',
formatblock : '段落',
fontname : '字体',
fontsize : '文字大小',
forecolor : '文字颜色',
hilitecolor : '文字背景',
bold : '粗体(Ctrl+B)',
italic : '斜体(Ctrl+I)',
underline : '下划线(Ctrl+U)',
strikethrough : '删除线',
removeformat : '删除格式',
image : '图片',
multiimage : '批量图片上传',
flash : 'Flash',
media : '视音频',
table : '表格',
tablecell : '单元格',
hr : '插入横线',
emoticons : '插入表情',
link : '超级链接',
unlink : '取消超级链接',
fullscreen : '全屏显示',
about : '关于',
print : '打印(Ctrl+P)',
filemanager : '文件空间',
code : '插入程序代码',
map : 'Google地图',
baidumap : '百度地图',
lineheight : '行距',
clearhtml : '清理HTML代码',
pagebreak : '插入分页符',
quickformat : '一键排版',
insertfile : '插入文件',
template : '插入模板',
anchor : '锚点',
yes : '确定',
no : '取消',
close : '关闭',
editImage : '图片属性',
deleteImage : '删除图片',
editFlash : 'Flash属性',
deleteFlash : '删除Flash',
editMedia : '视音频属性',
deleteMedia : '删除视音频',
editLink : '超级链接属性',
deleteLink : '取消超级链接',
editAnchor : '锚点属性',
deleteAnchor : '删除锚点',
tableprop : '表格属性',
tablecellprop : '单元格属性',
tableinsert : '插入表格',
tabledelete : '删除表格',
tablecolinsertleft : '左侧插入列',
tablecolinsertright : '右侧插入列',
tablerowinsertabove : '上方插入行',
tablerowinsertbelow : '下方插入行',
tablerowmerge : '向下合并单元格',
tablecolmerge : '向右合并单元格',
tablerowsplit : '拆分行',
tablecolsplit : '拆分列',
tablecoldelete : '删除列',
tablerowdelete : '删除行',
noColor : '无颜色',
pleaseSelectFile : '请选择文件。',
invalidImg : "请输入有效的URL地址。\n只允许jpg,gif,bmp,png格式。",
invalidMedia : "请输入有效的URL地址。\n只允许swf,flv,mp3,wav,wma,wmv,mid,avi,mpg,asf,rm,rmvb格式。",
invalidWidth : "宽度必须为数字。",
invalidHeight : "高度必须为数字。",
invalidBorder : "边框必须为数字。",
invalidUrl : "请输入有效的URL地址。",
invalidRows : '行数为必选项只允许输入大于0的数字。',
invalidCols : '列数为必选项只允许输入大于0的数字。',
invalidPadding : '边距必须为数字。',
invalidSpacing : '间距必须为数字。',
invalidJson : '服务器发生故障。',
uploadSuccess : '上传成功。',
cutError : '您的浏览器安全设置不允许使用剪切操作,请使用快捷键(Ctrl+X)来完成。',
copyError : '您的浏览器安全设置不允许使用复制操作,请使用快捷键(Ctrl+C)来完成。',
pasteError : '您的浏览器安全设置不允许使用粘贴操作,请使用快捷键(Ctrl+V)来完成。',
ajaxLoading : '加载中,请稍候 ...',
uploadLoading : '上传中,请稍候 ...',
uploadError : '上传错误',
'plainpaste.comment' : '请使用快捷键(Ctrl+V)把内容粘贴到下面的方框里。',
'wordpaste.comment' : '请使用快捷键(Ctrl+V)把内容粘贴到下面的方框里。',
'code.pleaseInput' : '请输入程序代码。',
'link.url' : 'URL',
'link.linkType' : '打开类型',
'link.newWindow' : '新窗口',
'link.selfWindow' : '当前窗口',
'flash.url' : 'URL',
'flash.width' : '宽度',
'flash.height' : '高度',
'flash.upload' : '上传',
'flash.viewServer' : '文件空间',
'media.url' : 'URL',
'media.width' : '宽度',
'media.height' : '高度',
'media.autostart' : '自动播放',
'media.upload' : '上传',
'media.viewServer' : '文件空间',
'image.remoteImage' : '网络图片',
'image.localImage' : '本地上传',
'image.remoteUrl' : '图片地址',
'image.localUrl' : '上传文件',
'image.size' : '图片大小',
'image.width' : '宽',
'image.height' : '高',
'image.resetSize' : '重置大小',
'image.align' : '对齐方式',
'image.defaultAlign' : '默认方式',
'image.leftAlign' : '左对齐',
'image.rightAlign' : '右对齐',
'image.imgTitle' : '图片说明',
'image.upload' : '浏览...',
'image.viewServer' : '图片空间',
'multiimage.uploadDesc' : '允许用户同时上传<%=uploadLimit%>张图片,单张图片容量不超过<%=sizeLimit%>',
'multiimage.startUpload' : '开始上传',
'multiimage.clearAll' : '全部清空',
'multiimage.insertAll' : '全部插入',
'multiimage.queueLimitExceeded' : '文件数量超过限制。',
'multiimage.fileExceedsSizeLimit' : '文件大小超过限制。',
'multiimage.zeroByteFile' : '无法上传空文件。',
'multiimage.invalidFiletype' : '文件类型不正确。',
'multiimage.unknownError' : '发生异常,无法上传。',
'multiimage.pending' : '等待上传',
'multiimage.uploadError' : '上传失败',
'filemanager.emptyFolder' : '空文件夹',
'filemanager.moveup' : '移到上一级文件夹',
'filemanager.viewType' : '显示方式:',
'filemanager.viewImage' : '缩略图',
'filemanager.listImage' : '详细信息',
'filemanager.orderType' : '排序方式:',
'filemanager.fileName' : '名称',
'filemanager.fileSize' : '大小',
'filemanager.fileType' : '类型',
'insertfile.url' : 'URL',
'insertfile.title' : '文件说明',
'insertfile.upload' : '上传',
'insertfile.viewServer' : '文件空间',
'table.cells' : '单元格数',
'table.rows' : '行数',
'table.cols' : '列数',
'table.size' : '大小',
'table.width' : '宽度',
'table.height' : '高度',
'table.percent' : '%',
'table.px' : 'px',
'table.space' : '边距间距',
'table.padding' : '边距',
'table.spacing' : '间距',
'table.align' : '对齐方式',
'table.textAlign' : '水平对齐',
'table.verticalAlign' : '垂直对齐',
'table.alignDefault' : '默认',
'table.alignLeft' : '左对齐',
'table.alignCenter' : '居中',
'table.alignRight' : '右对齐',
'table.alignTop' : '顶部',
'table.alignMiddle' : '中部',
'table.alignBottom' : '底部',
'table.alignBaseline' : '基线',
'table.border' : '边框',
'table.borderWidth' : '边框',
'table.borderColor' : '颜色',
'table.backgroundColor' : '背景颜色',
'map.address' : '地址: ',
'map.search' : '搜索',
'baidumap.address' : '地址: ',
'baidumap.search' : '搜索',
'baidumap.insertDynamicMap' : '插入动态地图',
'anchor.name' : '锚点名称',
'formatblock.formatBlock' : {
h1 : '标题 1',
h2 : '标题 2',
h3 : '标题 3',
h4 : '标题 4',
p : '正 文'
},
'fontname.fontName' : {
'SimSun' : '宋体',
'NSimSun' : '新宋体',
'FangSong_GB2312' : '仿宋_GB2312',
'KaiTi_GB2312' : '楷体_GB2312',
'SimHei' : '黑体',
'Microsoft YaHei' : '微软雅黑',
'Arial' : 'Arial',
'Arial Black' : 'Arial Black',
'Times New Roman' : 'Times New Roman',
'Courier New' : 'Courier New',
'Tahoma' : 'Tahoma',
'Verdana' : 'Verdana'
},
'lineheight.lineHeight' : [
{'1' : '单倍行距'},
{'1.5' : '1.5倍行距'},
{'2' : '2倍行距'},
{'2.5' : '2.5倍行距'},
{'3' : '3倍行距'}
],
'template.selectTemplate' : '可选模板',
'template.replaceContent' : '替换当前内容',
'template.fileList' : {
'1.html' : '图片和文字',
'2.html' : '表格',
'3.html' : '项目编号'
}
}, 'zh_CN');

View File

@ -1,71 +0,0 @@
/*******************************************************************************
* KindEditor - WYSIWYG HTML Editor for Internet
* Copyright (C) 2006-2011 kindsoft.net
*
* @author Roddy <luolonghao@gmail.com>
* @site http://www.kindsoft.net/
* @licence http://www.kindsoft.net/license.php
*******************************************************************************/
KindEditor.plugin('autoheight', function(K) {
var self = this;
//self.autoHeightMode = true;
if (!self.autoHeightMode) {
return;
}
var minHeight;
function hideScroll() {
var edit = self.edit;
var body = edit.doc.body;
edit.iframe[0].scroll = 'no';
body.style.overflowY = 'hidden';
}
function resetHeight() {
var edit = self.edit;
var body = edit.doc.body;
edit.iframe.height(minHeight);
//最高418 超过用滚动条
self.resize(null, Math.max(
(K.IE ? body.scrollHeight : body.offsetHeight) > 385 ? 385+33 : (K.IE ? body.scrollHeight : body.offsetHeight)
+ 33, minHeight));
if( self.height == "418px" ){
edit.iframe[0].scroll = 'yes';
body.style.overflowY = 'auto';
}
else{
hideScroll();
}
}
function init() {
minHeight = K.removeUnit(self.height);
self.edit.afterChange(resetHeight);
hideScroll();
var edit = self.edit;
var body = edit.doc.body;
edit.iframe.height(minHeight);
self.resize(null, Math.max(
((K.IE ? body.scrollHeight : body.offsetHeight) > 250 ? 250 : (K.IE ? body.scrollHeight : body.offsetHeight)) //限制初始化太高的情况
+ 33, minHeight));
}
if (self.isCreated) {
init();
} else {
self.afterCreate(init);
}
});
/*
* 如何实现真正的自动高度
* 修改编辑器高度之后再次获取body内容高度时最小值只会是当前iframe的设置高度这样就导致高度只增不减
* 所以每次获取body内容高度之前先将iframe的高度重置为最小高度这样就能获取body的实际高度
* 由此就实现了真正的自动高度
* 测试chromefirefoxIE9IE8
* */

View File

@ -1,56 +0,0 @@
.ke-content {
font-family: "微软雅黑","宋体";
}
.ke-content pre {
font-size:9pt;
font-family:Courier New,Arial;
border:1px solid #ddd;
border-left:5px solid #6CE26C;
background:#f6f6f6;
padding:5px;
}
.ke-content code {
margin: 0 2px;
padding: 0 5px;
white-space: nowrap;
border: 1px solid #DDD;
background-color: #F6F6F6;
border-radius: 3px;
}
.ke-content pre>code {
margin: 0;
padding: 0;
white-space: pre;
border: none;
background: transparent;
}
.ke-content pre code {
background-color: transparent;
border: none;
}
.ke-content p {
/*margin: 0 0 15px 0;*/
/*margin-bottom:15pt;*/
line-height:1.5;
/*letter-spacing: 1px;*/
}
.ke-content div.ref {border:1px solid #ddd;margin:0 0 10px 0;padding:2px;font-size:9pt;background:#ffe;}
.ke-content div.ref h4 {margin:0;padding:1px 3px;background:#CC9966;color:#fff;font-size:9pt;font-weight:normal;}
.ke-content div.ref .ref_body {margin:0;padding:2px;line-height:20px;color:#666;font-size:9pt;}
.ke-content blockquote{background: none;border: none;padding: 0px;margin: 0 0 0 40px;}
span.at {color:#269ac9;}
span.at a{color:#269ac9;text-decoration: none;}
/*yk*/
.ke-content ol li{list-style-type: decimal;}
.ke-content ul li{list-style-type: disc;}
.ke-content ol,.ke-content ul,.ke-content h1,.ke-content h2,.ke-content h3,.ke-content h4{margin-top:0;margin-bottom: 0;}
.ke-content a{color: #136ec2;}
.ke-content a:link,.ke-content a:visited{text-decoration:none;}

View File

@ -1,361 +0,0 @@
// Generated by CoffeeScript 1.9.0
/*
paste.js is an interface to read data ( text / image ) from clipboard in different browsers. It also contains several hacks.
https://github.com/layerssss/paste.js
*/
(function() {
var $, Paste, createHiddenEditable, dataURLtoBlob;
$ = window.jQuery;
$.paste = function(pasteContainer) {
var pm;
if (typeof console !== "undefined" && console !== null) {
console.log("DEPRECATED: This method is deprecated. Please use $.fn.pastableNonInputable() instead.");
}
pm = Paste.mountNonInputable(pasteContainer);
return pm._container;
};
$.fn.pastableNonInputable = function() {
var el, _i, _len;
for (_i = 0, _len = this.length; _i < _len; _i++) {
el = this[_i];
Paste.mountNonInputable(el);
}
return this;
};
$.fn.pastableTextarea = function() {
var el, _i, _len;
for (_i = 0, _len = this.length; _i < _len; _i++) {
el = this[_i];
Paste.mountTextarea(el);
}
return this;
};
$.fn.pastableContenteditable = function() {
var el, _i, _len;
for (_i = 0, _len = this.length; _i < _len; _i++) {
el = this[_i];
Paste.mountContenteditable(el);
}
return this;
};
dataURLtoBlob = function(dataURL, sliceSize) {
var b64Data, byteArray, byteArrays, byteCharacters, byteNumbers, contentType, i, m, offset, slice, _ref;
if (sliceSize == null) {
sliceSize = 512;
}
if (!(m = dataURL.match(/^data\:([^\;]+)\;base64\,(.+)$/))) {
return null;
}
_ref = m, m = _ref[0], contentType = _ref[1], b64Data = _ref[2];
byteCharacters = atob(b64Data);
byteArrays = [];
offset = 0;
while (offset < byteCharacters.length) {
slice = byteCharacters.slice(offset, offset + sliceSize);
byteNumbers = new Array(slice.length);
i = 0;
while (i < slice.length) {
byteNumbers[i] = slice.charCodeAt(i);
i++;
}
byteArray = new Uint8Array(byteNumbers);
byteArrays.push(byteArray);
offset += sliceSize;
}
return new Blob(byteArrays, {
type: contentType
});
};
createHiddenEditable = function() {
return $(document.createElement('div')).attr('contenteditable', true).css({
width: 1,
height: 1,
position: 'fixed',
left: -100,
overflow: 'hidden'
});
};
Paste = (function() {
Paste.prototype._target = null;
Paste.prototype._container = null;
Paste.mountNonInputable = function(nonInputable) {
var paste;
paste = new Paste(createHiddenEditable().appendTo(nonInputable), nonInputable);
$(nonInputable).on('click', (function(_this) {
return function() {
return paste._container.focus();
};
})(this));
paste._container.on('focus', (function(_this) {
return function() {
return $(nonInputable).addClass('pastable-focus');
};
})(this));
return paste._container.on('blur', (function(_this) {
return function() {
return $(nonInputable).removeClass('pastable-focus');
};
})(this));
};
Paste.mountTextarea = function(textarea) {
var ctlDown, paste;
if (-1 !== navigator.userAgent.toLowerCase().indexOf('chrome')) {
return this.mountContenteditable(textarea);
}
paste = new Paste(createHiddenEditable().insertBefore(textarea), textarea);
ctlDown = false;
$(textarea).on('keyup', function(ev) {
var _ref;
if ((_ref = ev.keyCode) === 17 || _ref === 224) {
return ctlDown = false;
}
});
$(textarea).on('keydown', function(ev) {
var _ref;
if ((_ref = ev.keyCode) === 17 || _ref === 224) {
ctlDown = true;
}
if (ctlDown && ev.keyCode === 86) {
return paste._container.focus();
}
});
$(paste._target).on('pasteImage', (function(_this) {
return function() {
return $(textarea).focus();
};
})(this));
$(paste._target).on('pasteText', (function(_this) {
return function() {
return $(textarea).focus();
};
})(this));
$(textarea).on('focus', (function(_this) {
return function() {
return $(textarea).addClass('pastable-focus');
};
})(this));
return $(textarea).on('blur', (function(_this) {
return function() {
return $(textarea).removeClass('pastable-focus');
};
})(this));
};
Paste.mountContenteditable = function(contenteditable) {
var paste;
paste = new Paste(contenteditable, contenteditable);
$(contenteditable).on('focus', (function(_this) {
return function() {
return $(contenteditable).addClass('pastable-focus');
};
})(this));
return $(contenteditable).on('blur', (function(_this) {
return function() {
return $(contenteditable).removeClass('pastable-focus');
};
})(this));
};
function Paste(_at__container, _at__target) {
this._container = _at__container;
this._target = _at__target;
this._container = $(this._container);
this._target = $(this._target).addClass('pastable');
this._container.on('paste', (function(_this) {
return function(ev) {
var clipboardData, file, item, reader, text, _i, _j, _len, _len1, _ref, _ref1, _ref2, _ref3, _results;
if (((_ref = ev.originalEvent) != null ? _ref.clipboardData : void 0) != null) {
clipboardData = ev.originalEvent.clipboardData;
if (clipboardData.items) {
_ref1 = clipboardData.items;
for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
item = _ref1[_i];
if (item.type.match(/^image\//)) {
reader = new FileReader();
reader.onload = function(event) {
return _this._handleImage(event.target.result);
};
reader.readAsDataURL(item.getAsFile());
}
if (item.type === 'text/plain') {
item.getAsString(function(string) {
return _this._target.trigger('pasteText', {
text: string
});
});
}
}
} else {
if (-1 !== Array.prototype.indexOf.call(clipboardData.types, 'text/plain')) {
text = clipboardData.getData('Text');
_this._target.trigger('pasteText', {
text: text
});
}
_this._checkImagesInContainer(function(src) {
return _this._handleImage(src);
});
}
}
if (clipboardData = window.clipboardData) {
if ((_ref2 = (text = clipboardData.getData('Text'))) != null ? _ref2.length : void 0) {
return _this._target.trigger('pasteText', {
text: text
});
} else {
_ref3 = clipboardData.files;
_results = [];
for (_j = 0, _len1 = _ref3.length; _j < _len1; _j++) {
file = _ref3[_j];
_this._handleImage(URL.createObjectURL(file));
_results.push(_this._checkImagesInContainer(function() {}));
}
return _results;
}
}
};
})(this));
}
Paste.prototype._handleImage = function(src) {
var loader;
loader = new Image();
loader.onload = (function(_this) {
return function() {
var blob, canvas, ctx, dataURL;
canvas = document.createElement('canvas');
canvas.width = loader.width;
canvas.height = loader.height;
ctx = canvas.getContext('2d');
ctx.drawImage(loader, 0, 0, canvas.width, canvas.height);
dataURL = null;
try {
dataURL = canvas.toDataURL('image/png');
blob = dataURLtoBlob(dataURL);
} catch (_error) {}
if (dataURL) {
return _this._target.trigger('pasteImage', {
blob: blob,
dataURL: dataURL,
width: loader.width,
height: loader.height
});
}
};
})(this);
return loader.src = src;
};
Paste.prototype._checkImagesInContainer = function(cb) {
var img, timespan, _i, _len, _ref;
timespan = Math.floor(1000 * Math.random());
_ref = this._container.find('img');
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
img = _ref[_i];
img["_paste_marked_" + timespan] = true;
}
return setTimeout((function(_this) {
return function() {
var _j, _len1, _ref1, _results;
_ref1 = _this._container.find('img');
_results = [];
for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
img = _ref1[_j];
if (!img["_paste_marked_" + timespan]) {
cb(img.src);
}
//firefox问题处理因为采用了 pastableContenteditable 模式,故只需要删除默认的粘贴
if ($(img).attr('src').startsWith('data:image/')) {
_results.push($(img).remove());
};
}
return _results;
};
})(this), 1);
};
return Paste;
})();
}).call(this);
KindEditor.plugin('paste', function(K) {
var editor = this,
name = 'paste';
if(editor.edit == undefined || editor.edit.iframe == undefined){
return;
}
var contentWindow = editor.edit.iframe[0].contentWindow;
//var contentWindow = editor.iframeDoc;
//var contentWindow = document.getElementsByTagName('iframe')[0].contentWindow;
var nodeBody = contentWindow.document.getElementsByTagName('body')[0];
console.log(nodeBody);
$(nodeBody).pastableContenteditable();
dataURItoBlob = function(dataURI) {
// convert base64/URLEncoded data component to raw binary data held in a string
var byteString;
if (dataURI.split(',')[0].indexOf('base64') >= 0)
byteString = atob(dataURI.split(',')[1]);
else
byteString = unescape(dataURI.split(',')[1]);
// separate out the mime component
var mimeString = dataURI.split(',')[0].split(':')[1].split(';')[0];
// write the bytes of the string to a typed array
var ia = new Uint8Array(byteString.length);
for (var i = 0; i < byteString.length; i++) {
ia[i] = byteString.charCodeAt(i);
}
return new Blob([ia], {type:mimeString});
};
$(nodeBody).on('pasteImage', function(ev, data) {
console.log('pasteImage');
console.log("dataURL: " + data.dataURL);
console.log("width: " + data.width);
console.log("height: " + data.height);
var blob = dataURItoBlob(data.dataURL);
if (data.blob !== null) {
var data = new FormData();
// data.append("imgFile",blob, "imageFilename.png");
data.append("file",blob, "imageFilename.png");
console.log(data);
$.ajax({
url: '/kindeditor/upload?dir=image',
url: '/api/attachments.json',
contentType: false,
type: 'POST',
data: data,
processData: false,
success: function(data) {
console.log(data);
// editor.exec('insertimage', JSON.parse(data).url);
// /api/attachments/227362
editor.exec('insertimage', '/api/attachments/' + data.id);
}
});
}
});
return;
});

File diff suppressed because it is too large Load Diff

File diff suppressed because one or more lines are too long

View File

@ -1,539 +0,0 @@
/* Logo 字体 */
@font-face {
font-family: "iconfont logo";
src: url('https://at.alicdn.com/t/font_985780_km7mi63cihi.eot?t=1545807318834');
src: url('https://at.alicdn.com/t/font_985780_km7mi63cihi.eot?t=1545807318834#iefix') format('embedded-opentype'),
url('https://at.alicdn.com/t/font_985780_km7mi63cihi.woff?t=1545807318834') format('woff'),
url('https://at.alicdn.com/t/font_985780_km7mi63cihi.ttf?t=1545807318834') format('truetype'),
url('https://at.alicdn.com/t/font_985780_km7mi63cihi.svg?t=1545807318834#iconfont') format('svg');
}
.logo {
font-family: "iconfont logo";
font-size: 160px;
font-style: normal;
-webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale;
}
/* tabs */
.nav-tabs {
position: relative;
}
.nav-tabs .nav-more {
position: absolute;
right: 0;
bottom: 0;
height: 42px;
line-height: 42px;
color: #666;
}
#tabs {
border-bottom: 1px solid #eee;
}
#tabs li {
cursor: pointer;
width: 100px;
height: 40px;
line-height: 40px;
text-align: center;
font-size: 16px;
border-bottom: 2px solid transparent;
position: relative;
z-index: 1;
margin-bottom: -1px;
color: #666;
}
#tabs .active {
border-bottom-color: #f00;
color: #222;
}
.tab-container .content {
display: none;
}
/* 页面布局 */
.main {
padding: 30px 100px;
width: 960px;
margin: 0 auto;
}
.main .logo {
color: #333;
text-align: left;
margin-bottom: 30px;
line-height: 1;
height: 110px;
margin-top: -50px;
overflow: hidden;
*zoom: 1;
}
.main .logo a {
font-size: 160px;
color: #333;
}
.helps {
margin-top: 40px;
}
.helps pre {
padding: 20px;
margin: 10px 0;
border: solid 1px #e7e1cd;
background-color: #fffdef;
overflow: auto;
}
.icon_lists {
width: 100% !important;
overflow: hidden;
*zoom: 1;
}
.icon_lists li {
width: 100px;
margin-bottom: 10px;
margin-right: 20px;
text-align: center;
list-style: none !important;
cursor: default;
}
.icon_lists li .code-name {
line-height: 1.2;
}
.icon_lists .icon {
display: block;
height: 100px;
line-height: 100px;
font-size: 42px;
margin: 10px auto;
color: #333;
-webkit-transition: font-size 0.25s linear, width 0.25s linear;
-moz-transition: font-size 0.25s linear, width 0.25s linear;
transition: font-size 0.25s linear, width 0.25s linear;
}
.icon_lists .icon:hover {
font-size: 100px;
}
.icon_lists .svg-icon {
/* 通过设置 font-size 来改变图标大小 */
width: 1em;
/* 图标和文字相邻时,垂直对齐 */
vertical-align: -0.15em;
/* 通过设置 color 来改变 SVG 的颜色/fill */
fill: currentColor;
/* path stroke 溢出 viewBox 部分在 IE 下会显示
normalize.css 中也包含这行 */
overflow: hidden;
}
.icon_lists li .name,
.icon_lists li .code-name {
color: #666;
}
/* markdown 样式 */
.markdown {
color: #666;
font-size: 14px;
line-height: 1.8;
}
.highlight {
line-height: 1.5;
}
.markdown img {
vertical-align: middle;
max-width: 100%;
}
.markdown h1 {
color: #404040;
font-weight: 500;
line-height: 40px;
margin-bottom: 24px;
}
.markdown h2,
.markdown h3,
.markdown h4,
.markdown h5,
.markdown h6 {
color: #404040;
margin: 1.6em 0 0.6em 0;
font-weight: 500;
clear: both;
}
.markdown h1 {
font-size: 28px;
}
.markdown h2 {
font-size: 22px;
}
.markdown h3 {
font-size: 16px;
}
.markdown h4 {
font-size: 14px;
}
.markdown h5 {
font-size: 12px;
}
.markdown h6 {
font-size: 12px;
}
.markdown hr {
height: 1px;
border: 0;
background: #e9e9e9;
margin: 16px 0;
clear: both;
}
.markdown p {
margin: 1em 0;
}
.markdown>p,
.markdown>blockquote,
.markdown>.highlight,
.markdown>ol,
.markdown>ul {
width: 80%;
}
.markdown ul>li {
list-style: circle;
}
.markdown>ul li,
.markdown blockquote ul>li {
margin-left: 20px;
padding-left: 4px;
}
.markdown>ul li p,
.markdown>ol li p {
margin: 0.6em 0;
}
.markdown ol>li {
list-style: decimal;
}
.markdown>ol li,
.markdown blockquote ol>li {
margin-left: 20px;
padding-left: 4px;
}
.markdown code {
margin: 0 3px;
padding: 0 5px;
background: #eee;
border-radius: 3px;
}
.markdown strong,
.markdown b {
font-weight: 600;
}
.markdown>table {
border-collapse: collapse;
border-spacing: 0px;
empty-cells: show;
border: 1px solid #e9e9e9;
width: 95%;
margin-bottom: 24px;
}
.markdown>table th {
white-space: nowrap;
color: #333;
font-weight: 600;
}
.markdown>table th,
.markdown>table td {
border: 1px solid #e9e9e9;
padding: 8px 16px;
text-align: left;
}
.markdown>table th {
background: #F7F7F7;
}
.markdown blockquote {
font-size: 90%;
color: #999;
border-left: 4px solid #e9e9e9;
padding-left: 0.8em;
margin: 1em 0;
}
.markdown blockquote p {
margin: 0;
}
.markdown .anchor {
opacity: 0;
transition: opacity 0.3s ease;
margin-left: 8px;
}
.markdown .waiting {
color: #ccc;
}
.markdown h1:hover .anchor,
.markdown h2:hover .anchor,
.markdown h3:hover .anchor,
.markdown h4:hover .anchor,
.markdown h5:hover .anchor,
.markdown h6:hover .anchor {
opacity: 1;
display: inline-block;
}
.markdown>br,
.markdown>p>br {
clear: both;
}
.hljs {
display: block;
background: white;
padding: 0.5em;
color: #333333;
overflow-x: auto;
}
.hljs-comment,
.hljs-meta {
color: #969896;
}
.hljs-string,
.hljs-variable,
.hljs-template-variable,
.hljs-strong,
.hljs-emphasis,
.hljs-quote {
color: #df5000;
}
.hljs-keyword,
.hljs-selector-tag,
.hljs-type {
color: #a71d5d;
}
.hljs-literal,
.hljs-symbol,
.hljs-bullet,
.hljs-attribute {
color: #0086b3;
}
.hljs-section,
.hljs-name {
color: #63a35c;
}
.hljs-tag {
color: #333333;
}
.hljs-title,
.hljs-attr,
.hljs-selector-id,
.hljs-selector-class,
.hljs-selector-attr,
.hljs-selector-pseudo {
color: #795da3;
}
.hljs-addition {
color: #55a532;
background-color: #eaffea;
}
.hljs-deletion {
color: #bd2c00;
background-color: #ffecec;
}
.hljs-link {
text-decoration: underline;
}
/* 代码高亮 */
/* PrismJS 1.15.0
https://prismjs.com/download.html#themes=prism&languages=markup+css+clike+javascript */
/**
* prism.js default theme for JavaScript, CSS and HTML
* Based on dabblet (http://dabblet.com)
* @author Lea Verou
*/
code[class*="language-"],
pre[class*="language-"] {
color: black;
background: none;
text-shadow: 0 1px white;
font-family: Consolas, Monaco, 'Andale Mono', 'Ubuntu Mono', monospace;
text-align: left;
white-space: pre;
word-spacing: normal;
word-break: normal;
word-wrap: normal;
line-height: 1.5;
-moz-tab-size: 4;
-o-tab-size: 4;
tab-size: 4;
-webkit-hyphens: none;
-moz-hyphens: none;
-ms-hyphens: none;
hyphens: none;
}
pre[class*="language-"]::-moz-selection,
pre[class*="language-"] ::-moz-selection,
code[class*="language-"]::-moz-selection,
code[class*="language-"] ::-moz-selection {
text-shadow: none;
background: #b3d4fc;
}
pre[class*="language-"]::selection,
pre[class*="language-"] ::selection,
code[class*="language-"]::selection,
code[class*="language-"] ::selection {
text-shadow: none;
background: #b3d4fc;
}
@media print {
code[class*="language-"],
pre[class*="language-"] {
text-shadow: none;
}
}
/* Code blocks */
pre[class*="language-"] {
padding: 1em;
margin: .5em 0;
overflow: auto;
}
:not(pre)>code[class*="language-"],
pre[class*="language-"] {
background: #f5f2f0;
}
/* Inline code */
:not(pre)>code[class*="language-"] {
padding: .1em;
border-radius: .3em;
white-space: normal;
}
.token.comment,
.token.prolog,
.token.doctype,
.token.cdata {
color: slategray;
}
.token.punctuation {
color: #999;
}
.namespace {
opacity: .7;
}
.token.property,
.token.tag,
.token.boolean,
.token.number,
.token.constant,
.token.symbol,
.token.deleted {
color: #905;
}
.token.selector,
.token.attr-name,
.token.string,
.token.char,
.token.builtin,
.token.inserted {
color: #690;
}
.token.operator,
.token.entity,
.token.url,
.language-css .token.string,
.style .token.string {
color: #9a6e3a;
background: hsla(0, 0%, 100%, .5);
}
.token.atrule,
.token.attr-value,
.token.keyword {
color: #07a;
}
.token.function,
.token.class-name {
color: #DD4A68;
}
.token.regex,
.token.important,
.token.variable {
color: #e90;
}
.token.important,
.token.bold {
font-weight: bold;
}
.token.italic {
font-style: italic;
}
.token.entity {
cursor: help;
}

File diff suppressed because one or more lines are too long

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because one or more lines are too long

File diff suppressed because it is too large Load Diff

Binary file not shown.

Binary file not shown.

Binary file not shown.

View File

@ -1,111 +0,0 @@
.CodeMirror-merge {
position: relative;
white-space: pre;
}
.CodeMirror-merge, .CodeMirror-merge .CodeMirror {
min-height:50px;
}
.CodeMirror-merge-2pane .CodeMirror-merge-pane { width: 48%; }
.CodeMirror-merge-2pane .CodeMirror-merge-gap { width: 4%; }
.CodeMirror-merge-3pane .CodeMirror-merge-pane { width: 31%; }
.CodeMirror-merge-3pane .CodeMirror-merge-gap { width: 3.5%; }
.CodeMirror-merge-pane {
display: inline-block;
white-space: normal;
vertical-align: top;
}
.CodeMirror-merge-pane-rightmost {
position: absolute;
right: 0px;
z-index: 1;
}
.CodeMirror-merge-gap {
z-index: 2;
display: inline-block;
height: 100%;
-moz-box-sizing: border-box;
box-sizing: border-box;
overflow: hidden;
position: relative;
background: #515151;
}
.CodeMirror-merge-scrolllock-wrap {
position: absolute;
bottom: 0; left: 50%;
}
.CodeMirror-merge-scrolllock {
position: relative;
left: -50%;
cursor: pointer;
color: #d8d8d8;
line-height: 1;
}
.CodeMirror-merge-copybuttons-left, .CodeMirror-merge-copybuttons-right {
position: absolute;
left: 0; top: 0;
right: 0; bottom: 0;
line-height: 1;
}
.CodeMirror-merge-copy {
position: absolute;
cursor: pointer;
color: #ce374b;
z-index: 3;
}
.CodeMirror-merge-copy-reverse {
position: absolute;
cursor: pointer;
color: #44c;
}
.CodeMirror-merge-copybuttons-left .CodeMirror-merge-copy { left: 2px; }
.CodeMirror-merge-copybuttons-right .CodeMirror-merge-copy { right: 2px; }
.CodeMirror-merge-r-inserted, .CodeMirror-merge-l-inserted {
background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAACCAYAAACddGYaAAAAGUlEQVQI12MwuCXy3+CWyH8GBgYGJgYkAABZbAQ9ELXurwAAAABJRU5ErkJggg==);
background-position: bottom left;
background-repeat: repeat-x;
}
.CodeMirror-merge-r-deleted, .CodeMirror-merge-l-deleted {
background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAACCAYAAACddGYaAAAAGUlEQVQI12M4Kyb2/6yY2H8GBgYGJgYkAABURgPz6Ks7wQAAAABJRU5ErkJggg==);
background-position: bottom left;
background-repeat: repeat-x;
}
.CodeMirror-merge-r-chunk { background: #9a6868; }
.CodeMirror-merge-r-chunk-start { /*border-top: 1px solid #ee8; */}
.CodeMirror-merge-r-chunk-end {/* border-bottom: 1px solid #ee8; */}
.CodeMirror-merge-r-connect { fill:#9a6868;}
.CodeMirror-merge-l-chunk { background: #eef; }
.CodeMirror-merge-l-chunk-start { border-top: 1px solid #88e; }
.CodeMirror-merge-l-chunk-end { border-bottom: 1px solid #88e; }
.CodeMirror-merge-l-connect { fill: #eef; stroke: #88e; stroke-width: 1px; }
.CodeMirror-merge-l-chunk.CodeMirror-merge-r-chunk { background: #dfd; }
.CodeMirror-merge-l-chunk-start.CodeMirror-merge-r-chunk-start { border-top: 1px solid #4e4; }
.CodeMirror-merge-l-chunk-end.CodeMirror-merge-r-chunk-end { border-bottom: 1px solid #4e4; }
.CodeMirror-merge-collapsed-widget:before {
content: "(...)";
}
.CodeMirror-merge-collapsed-widget {
cursor: pointer;
color: #88b;
background: #eef;
border: 1px solid #ddf;
font-size: 90%;
padding: 0 3px;
border-radius: 4px;
}
.CodeMirror-merge-collapsed-line .CodeMirror-gutter-elt { display: none; }

File diff suppressed because one or more lines are too long

Binary file not shown.

Before

Width:  |  Height:  |  Size: 27 KiB

Binary file not shown.

Binary file not shown.

File diff suppressed because it is too large Load Diff

Before

Width:  |  Height:  |  Size: 434 KiB

Binary file not shown.

Binary file not shown.

Binary file not shown.

File diff suppressed because one or more lines are too long

BIN
images/chrome.jpg Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 6.1 KiB

BIN
images/firefox.jpg Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 24 KiB

Some files were not shown because too many files have changed in this diff Show More