text: exports.ids = [5];
  exports.modules = {
  
  /***/ "../../node_modules/monaco-editor/esm/vs/basic-languages/typescript/typescript.js":
  /*!*******************************************************************************************************************!*\
    !*** /Users/panyuqi/Documents/webgl/g/node_modules/monaco-editor/esm/vs/basic-languages/typescript/typescript.js ***!
    \*******************************************************************************************************************/
  /*! exports provided: conf, language */
  /***/ (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 _fillers_monaco_editor_core_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../fillers/monaco-editor-core.js */ "../../node_modules/monaco-editor/esm/vs/basic-languages/fillers/monaco-editor-core.js");
  /*---------------------------------------------------------------------------------------------
   *  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: [
          ['{', '}'],
          ['[', ']'],
          ['(', ')']
      ],
      onEnterRules: [
          {
              // e.g. /** | */
              beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
              afterText: /^\s*\*\/$/,
              action: {
                  indentAction: _fillers_monaco_editor_core_js__WEBPACK_IMPORTED_MODULE_0__["languages"].IndentAction.IndentOutdent,
                  appendText: ' * '
              }
          },
          {
              // e.g. /** ...|
              beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
              action: {
                  indentAction: _fillers_monaco_editor_core_js__WEBPACK_IMPORTED_MODULE_0__["languages"].IndentAction.None,
                  appendText: ' * '
              }
          },
          {
              // e.g.  * ...|
              beforeText: /^(\t|(\ \ ))*\ \*(\ ([^\*]|\*(?!\/))*)?$/,
              action: {
                  indentAction: _fillers_monaco_editor_core_js__WEBPACK_IMPORTED_MODULE_0__["languages"].IndentAction.None,
                  appendText: '* '
              }
          },
          {
              // e.g.  */|
              beforeText: /^(\t|(\ \ ))*\ \*\/\s*$/,
              action: {
                  indentAction: _fillers_monaco_editor_core_js__WEBPACK_IMPORTED_MODULE_0__["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: [
          // Should match the keys of textToKeywordObj in
          // https://github.com/microsoft/TypeScript/blob/master/src/compiler/scanner.ts
          'abstract',
          'any',
          'as',
          'asserts',
          'bigint',
          'boolean',
          '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',
          'number',
          'object',
          'package',
          'private',
          'protected',
          'public',
          'readonly',
          'require',
          'global',
          'return',
          'set',
          'static',
          'string',
          'super',
          'switch',
          'symbol',
          'this',
          'throw',
          'true',
          'try',
          'type',
          'typeof',
          'undefined',
          'unique',
          'unknown',
          'var',
          'void',
          'while',
          'with',
          'yield',
          'async',
          'await',
          'of'
      ],
      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: {
                          '@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' }
          ]
      }
  };
  
  
  /***/ })
  
  };;
  //# sourceMappingURL=5.render-page.js.map