@elice/material-exercise 1.231212.0 → 1.231228.0

package/es/components/shared/monaco-editor/editor-languages/typescript/index.js

@@ -22,7 +22,7 @@ function setDocumentFormattingEditProvider() {
  * Set TypeScript compiler options.
  */
 function setCompilerOptions() {
-  var compilerOptions = {
+  const compilerOptions = {
     allowNonTsExtensions: true,
     allowSyntheticDefaultImports: true,
     target: monaco.languages.typescript.ScriptTarget.ES2016,
@@ -31,7 +31,7 @@ function setCompilerOptions() {
     lib: ['dom', 'dom.iterable', 'es2020'],
     noEmit: true
   };
-  var compilerOptionsReact = Object.assign(Object.assign({}, compilerOptions), {
+  const compilerOptionsReact = Object.assign(Object.assign({}, compilerOptions), {
     jsx: monaco.languages.typescript.JsxEmit.React,
     jsxFactory: 'React.createElement',
     esModuleInterop: true
@@ -43,7 +43,7 @@ function setCompilerOptions() {
  * Set TypeScript diagnostics options.
  */
 function setDiagnosticsOptions() {
-  var diagnosticsOptions = {
+  const diagnosticsOptions = {
     noSuggestionDiagnostics: false,
     noSemanticValidation: true,
     noSyntaxValidation: true

package/es/components/shared/monaco-editor/hooks/useEditorOptions.js

@@ -1,4 +1,3 @@
-import { slicedToArray as _slicedToArray } from '../../../../_virtual/_rollupPluginBabelHelpers.js';
 import { useState } from 'react';
 import { useDeepCompareEffect } from 'react-use';
 import { MONACO_EDITOR_FONT_FAMILY } from '../constants/monaco/preferences.js';
@@ -11,8 +10,8 @@ import { normalizeMonacoPreference } from '../utils/monacoPreference.js';
 /**
  * Get editor options from props and preferences.
  */
-var getEditorOptions = function getEditorOptions(props) {
-  var normalized = normalizeMonacoPreference(props.preference);
+const getEditorOptions = props => {
+  const normalized = normalizeMonacoPreference(props.preference);
   return Object.assign(Object.assign({}, normalized), {
     tabSize: normalized.detectIndentation ? undefined : normalized.tabSize,
     // font
@@ -71,14 +70,9 @@ var getEditorOptions = function getEditorOptions(props) {
 /**
  * Hook to get editor options from props.
  */
-var useEditorOptions = function useEditorOptions(props) {
-  var _useState = useState(getEditorOptions(props)),
-    _useState2 = _slicedToArray(_useState, 2),
-    editorOptions = _useState2[0],
-    setEditorOptions = _useState2[1];
-  useDeepCompareEffect(function () {
-    return setEditorOptions(getEditorOptions(props));
-  }, [props]);
+const useEditorOptions = props => {
+  const [editorOptions, setEditorOptions] = useState(getEditorOptions(props));
+  useDeepCompareEffect(() => setEditorOptions(getEditorOptions(props)), [props]);
   return editorOptions;
 };
 

package/es/components/shared/monaco-editor/utils/emmet/abbreviationActions.js

@@ -2,7 +2,7 @@
  * Validate if the given position is valid for emmet abbreviation.
  */
 function isValidEmmetToken(tokens, index, syntax, language) {
-  var currentTokenType = tokens[index].type;
+  const currentTokenType = tokens[index].type;
   switch (syntax) {
     case 'html':
       return currentTokenType === 'text.html.basic';
@@ -19,25 +19,27 @@ function isValidEmmetToken(tokens, index, syntax, language) {
  * @see https://github.com/microsoft/vscode/blob/50140a53cc2088f478a5560683ccd354f2d5f431/extensions/emmet/src/abbreviationActions.ts#L438
  */
 function isValidLocationForEmmetAbbreviation(model, position, syntax, language) {
-  var column = position.column,
-    lineNumber = position.lineNumber;
+  const {
+    column,
+    lineNumber
+  } = position;
   // get current line's tokens
-  var _tokenization =
+  const _tokenization =
   // monaco-editor < 0.34.0
   model._tokenization ||
   // monaco-editor >= 0.34.0
   model.tokenization._tokenization;
-  var _tokenizationStateStore = _tokenization._tokenizationStateStore;
-  var _tokenizationSupport =
+  const _tokenizationStateStore = _tokenization._tokenizationStateStore;
+  const _tokenizationSupport =
   // monaco-editor >= 0.32.0
   _tokenizationStateStore.tokenizationSupport ||
   // monaco-editor < 0.32.0
   _tokenization._tokenizationSupport;
-  var state = _tokenizationStateStore.getBeginState(lineNumber - 1).clone();
-  var tokenizationResult = _tokenizationSupport.tokenize(model.getLineContent(lineNumber), true, state, 0);
-  var tokens = tokenizationResult.tokens;
+  const state = _tokenizationStateStore.getBeginState(lineNumber - 1).clone();
+  const tokenizationResult = _tokenizationSupport.tokenize(model.getLineContent(lineNumber), true, state, 0);
+  const tokens = tokenizationResult.tokens;
   // get token type at current column
-  for (var i = tokens.length - 1; i >= 0; i--) {
+  for (let i = tokens.length - 1; i >= 0; i--) {
     if (column - 1 > tokens[i].offset) {
       // return true if current token is valid for emmet
       if (isValidEmmetToken(tokens, i, syntax)) {

package/es/components/shared/monaco-editor/utils/emmet/registerProvider.js

@@ -9,18 +9,12 @@ function registerProvider(_monaco, languages, syntax) {
   if (!_monaco) {
     return;
   }
-  var providers = languages.map(function (language) {
-    return _monaco.languages.registerCompletionItemProvider(language, {
-      triggerCharacters: LANGUAGE_MODES[MAPPED_MODES[language] || language],
-      provideCompletionItems: function provideCompletionItems(model, position) {
-        return isValidLocationForEmmetAbbreviation(model, position, syntax) ? doComplete(_monaco, model, position, syntax, DEFAULT_CONFIG) : undefined;
-      }
-    });
-  });
-  return function () {
-    providers.forEach(function (provider) {
-      return provider.dispose();
-    });
+  const providers = languages.map(language => _monaco.languages.registerCompletionItemProvider(language, {
+    triggerCharacters: LANGUAGE_MODES[MAPPED_MODES[language] || language],
+    provideCompletionItems: (model, position) => isValidLocationForEmmetAbbreviation(model, position, syntax) ? doComplete(_monaco, model, position, syntax, DEFAULT_CONFIG) : undefined
+  }));
+  return () => {
+    providers.forEach(provider => provider.dispose());
   };
 }
 

package/es/components/shared/monaco-editor/utils/grammar/index.js

@@ -1,7 +1,5 @@
-import { asyncToGenerator as _asyncToGenerator, regeneratorRuntime as _regeneratorRuntime } from '../../../../../_virtual/_rollupPluginBabelHelpers.js';
 import { Registry } from 'monaco-textmate';
 import { TM_LANGUAGES } from '../../constants/grammars/index.js';
-import '../../constants/monaco/preferences.js';
 import { initOnigasm } from './onigasm.js';
 import { wireTmGrammars } from './textmate.js';
 
@@ -10,8 +8,8 @@ import { wireTmGrammars } from './textmate.js';
  */
 function createGrammarMap() {
   // {language => scopeName}
-  var grammars = new Map();
-  TM_LANGUAGES.forEach(function (tm) {
+  const grammars = new Map();
+  TM_LANGUAGES.forEach(tm => {
     grammars.set(tm.language, tm.scopeName);
   });
   return grammars;
@@ -21,76 +19,34 @@ function createGrammarMap() {
  */
 function createGrammarRegistry() {
   return new Registry({
-    getGrammarDefinition: function () {
-      var _getGrammarDefinition = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(scopeName) {
-        var lang, definition;
-        return _regeneratorRuntime().wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              _context.prev = 0;
-              lang = TM_LANGUAGES.find(function (l) {
-                return l.scopeName === scopeName;
-              });
-              if (lang) {
-                _context.next = 4;
-                break;
-              }
-              throw Error("no language found for scopeName: ".concat(scopeName));
-            case 4:
-              _context.next = 6;
-              return lang.getDefinition();
-            case 6:
-              definition = _context.sent;
-              return _context.abrupt("return", {
-                format: 'json',
-                content: JSON.stringify(definition)
-              });
-            case 10:
-              _context.prev = 10;
-              _context.t0 = _context["catch"](0);
-              return _context.abrupt("return", {
-                format: 'json',
-                content: '{}'
-              });
-            case 13:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, null, [[0, 10]]);
-      }));
-      function getGrammarDefinition(_x) {
-        return _getGrammarDefinition.apply(this, arguments);
+    getGrammarDefinition: async scopeName => {
+      try {
+        const lang = TM_LANGUAGES.find(l => l.scopeName === scopeName);
+        if (!lang) {
+          throw Error(`no language found for scopeName: ${scopeName}`);
+        }
+        const definition = await lang.getDefinition();
+        return {
+          format: 'json',
+          content: JSON.stringify(definition)
+        };
+      } catch (_) {
+        return {
+          format: 'json',
+          content: '{}'
+        };
       }
-      return getGrammarDefinition;
-    }()
+    }
   });
 }
 /**
  *
  */
-function initMonacoGrammars () {
-  return _ref.apply(this, arguments);
-}
-function _ref() {
-  _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
-    var grammars, registry;
-    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-      while (1) switch (_context2.prev = _context2.next) {
-        case 0:
-          _context2.next = 2;
-          return initOnigasm();
-        case 2:
-          grammars = createGrammarMap();
-          registry = createGrammarRegistry();
-          _context2.next = 6;
-          return wireTmGrammars(registry, grammars);
-        case 6:
-        case "end":
-          return _context2.stop();
-      }
-    }, _callee2);
-  }));
-  return _ref.apply(this, arguments);
+async function initMonacoGrammars () {
+  await initOnigasm();
+  const grammars = createGrammarMap();
+  const registry = createGrammarRegistry();
+  await wireTmGrammars(registry, grammars);
 }
 
 export { initMonacoGrammars as default };

package/es/components/shared/monaco-editor/utils/grammar/onigasm.js

@@ -1,33 +1,14 @@
-import { asyncToGenerator as _asyncToGenerator, regeneratorRuntime as _regeneratorRuntime } from '../../../../../_virtual/_rollupPluginBabelHelpers.js';
 import { loadWASM } from 'onigasm';
 
-var ONIGASM_WASM = 'https://static.elice.io/vendors/onigasm@2.2.5/onigasm.wasm';
+const ONIGASM_WASM = 'https://static.elice.io/vendors/onigasm@2.2.5/onigasm.wasm';
 /**
  * Init onigasm wasm.
  */
-function initOnigasm() {
-  return _initOnigasm.apply(this, arguments);
-}
-function _initOnigasm() {
-  _initOnigasm = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
-    return _regeneratorRuntime().wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          if (window.__elice_monaco_editor_tm_init__) {
-            _context.next = 4;
-            break;
-          }
-          _context.next = 3;
-          return loadWASM(ONIGASM_WASM);
-        case 3:
-          window.__elice_monaco_editor_tm_init__ = true;
-        case 4:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee);
-  }));
-  return _initOnigasm.apply(this, arguments);
+async function initOnigasm() {
+  if (!window.__elice_monaco_editor_tm_init__) {
+    await loadWASM(ONIGASM_WASM);
+    window.__elice_monaco_editor_tm_init__ = true;
+  }
 }
 
 export { initOnigasm };

package/es/components/shared/monaco-editor/utils/grammar/textmate.js

@@ -1,4 +1,3 @@
-import { asyncToGenerator as _asyncToGenerator, regeneratorRuntime as _regeneratorRuntime, createClass as _createClass, classCallCheck as _classCallCheck } from '../../../../../_virtual/_rollupPluginBabelHelpers.js';
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import { INITIAL } from 'monaco-textmate';
 
@@ -6,32 +5,23 @@ import { INITIAL } from 'monaco-textmate';
  * TokenizerState
  * -ref: https://github.com/codesandbox/codesandbox-client/blob/389073613e06eee944231f4aeef9dfa746c1b947/packages/app/src/embed/components/Content/Monaco/grammars/set-grammars.js#L3-L27
  */
-var TokenizerState = /*#__PURE__*/function () {
-  function TokenizerState(_ruleStack) {
-    _classCallCheck(this, TokenizerState);
+class TokenizerState {
+  constructor(_ruleStack) {
     this._ruleStack = _ruleStack;
   }
-  _createClass(TokenizerState, [{
-    key: "ruleStack",
-    get: function get() {
-      return this._ruleStack;
-    }
-  }, {
-    key: "clone",
-    value: function clone() {
-      return new TokenizerState(this._ruleStack);
-    }
-  }, {
-    key: "equals",
-    value: function equals(other) {
-      if (!other || !(other instanceof TokenizerState) || other !== this || other._ruleStack !== this._ruleStack) {
-        return false;
-      }
-      return true;
+  get ruleStack() {
+    return this._ruleStack;
+  }
+  clone() {
+    return new TokenizerState(this._ruleStack);
+  }
+  equals(other) {
+    if (!other || !(other instanceof TokenizerState) || other !== this || other._ruleStack !== this._ruleStack) {
+      return false;
     }
-  }]);
-  return TokenizerState;
-}();
+    return true;
+  }
+}
 /**
  * Wires up monaco-editor with monaco-textmate
  *
@@ -40,50 +30,28 @@ var TokenizerState = /*#__PURE__*/function () {
  * @param languages `Map` of language ids (string) to TM names (string)
  */
 function wireTmGrammars(registry, languages) {
-  return Promise.all(Array.from(languages.keys()).map( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(languageId) {
-      var _a, grammarScopeName, grammar;
-      return _regeneratorRuntime().wrap(function _callee$(_context) {
-        while (1) switch (_context.prev = _context.next) {
-          case 0:
-            _context.prev = 0;
-            grammarScopeName = (_a = languages.get(languageId)) !== null && _a !== void 0 ? _a : 'plaintext';
-            _context.next = 4;
-            return registry.loadGrammar(grammarScopeName);
-          case 4:
-            grammar = _context.sent;
-            monaco.languages.setTokensProvider(languageId, {
-              getInitialState: function getInitialState() {
-                return new TokenizerState(INITIAL);
-              },
-              tokenize: function tokenize(line, state) {
-                var res = grammar.tokenizeLine(line, state.ruleStack);
-                return {
-                  endState: new TokenizerState(res.ruleStack),
-                  tokens: res.tokens.map(function (token) {
-                    return Object.assign(Object.assign({}, token), {
-                      // TODO: At the moment, monaco-editor doesn't seem to accept array of scopes
-                      scopes: token.scopes[token.scopes.length - 1]
-                    });
-                  })
-                };
-              }
-            });
-            _context.next = 10;
-            break;
-          case 8:
-            _context.prev = 8;
-            _context.t0 = _context["catch"](0);
-          case 10:
-          case "end":
-            return _context.stop();
+  return Promise.all(Array.from(languages.keys()).map(async languageId => {
+    var _a;
+    try {
+      const grammarScopeName = (_a = languages.get(languageId)) !== null && _a !== void 0 ? _a : 'plaintext';
+      const grammar = await registry.loadGrammar(grammarScopeName);
+      monaco.languages.setTokensProvider(languageId, {
+        getInitialState: () => new TokenizerState(INITIAL),
+        tokenize: (line, state) => {
+          const res = grammar.tokenizeLine(line, state.ruleStack);
+          return {
+            endState: new TokenizerState(res.ruleStack),
+            tokens: res.tokens.map(token => Object.assign(Object.assign({}, token), {
+              // TODO: At the moment, monaco-editor doesn't seem to accept array of scopes
+              scopes: token.scopes[token.scopes.length - 1]
+            }))
+          };
         }
-      }, _callee, null, [[0, 8]]);
-    }));
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }()));
+      });
+    } catch (_) {
+      // console.warn(_);
+    }
+  }));
 }
 
 export { wireTmGrammars };

package/es/components/shared/monaco-editor/utils/monacoLanguage.js

@@ -5,7 +5,7 @@ import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
  *
  * keyvalue: {extension -> language id}
  */
-var monacoLanguageMap = new Map();
+const monacoLanguageMap = new Map();
 /**
  * Initialize monaco language map.
  */
@@ -14,9 +14,9 @@ function initLanguageMap() {
     return;
   }
   // get languages from `monaco.languages`.
-  monaco.languages.getLanguages().forEach(function (supportLang) {
+  monaco.languages.getLanguages().forEach(supportLang => {
     var _a;
-    (_a = supportLang.extensions) === null || _a === void 0 ? void 0 : _a.forEach(function (ext) {
+    (_a = supportLang.extensions) === null || _a === void 0 ? void 0 : _a.forEach(ext => {
       monacoLanguageMap.set(ext.slice(1), supportLang.id);
     });
   });
@@ -31,8 +31,8 @@ function getLanguageFromFilename(filename) {
   var _a;
   initLanguageMap();
   if (filename) {
-    var extension = ((_a = filename.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
-    var monacoLang = monacoLanguageMap.get(extension);
+    const extension = ((_a = filename.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
+    const monacoLang = monacoLanguageMap.get(extension);
     if (monacoLang) {
       return monacoLang;
     }

package/es/components/shared/monaco-editor/utils/monacoPreference.js

@@ -1,16 +1,14 @@
-import { typeof as _typeof } from '../../../../_virtual/_rollupPluginBabelHelpers.js';
 import { DEFAULT_MONACO_EDITOR_PREFERENCE } from '../constants/monaco/preferences.js';
 
 /**
  * Normalize monaco editor preferences for elice exercise.
  */
-function normalizeMonacoPreference() {
-  var raw = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+function normalizeMonacoPreference(raw = {}) {
   try {
     // deep copy normalized preference.
-    var normalized = JSON.parse(JSON.stringify(DEFAULT_MONACO_EDITOR_PREFERENCE));
-    Object.keys(DEFAULT_MONACO_EDITOR_PREFERENCE).forEach(function (key) {
-      if (raw[key] !== null && raw[key] !== undefined && _typeof(normalized[key]) === _typeof(raw[key])) {
+    const normalized = JSON.parse(JSON.stringify(DEFAULT_MONACO_EDITOR_PREFERENCE));
+    Object.keys(DEFAULT_MONACO_EDITOR_PREFERENCE).forEach(key => {
+      if (raw[key] !== null && raw[key] !== undefined && typeof normalized[key] === typeof raw[key]) {
         normalized[key] = raw[key];
       }
     });

package/es/components/shared/monaco-editor/utils/prettier/config.js

@@ -1,7 +1,7 @@
 /**
  * Default prettier config.
  */
-var DEFAULT_PRETTIER_CONFIG = Object.freeze({
+const DEFAULT_PRETTIER_CONFIG = Object.freeze({
   arrowParens: 'avoid',
   bracketSpacing: true,
   endOfLine: 'auto',
@@ -14,7 +14,7 @@ var DEFAULT_PRETTIER_CONFIG = Object.freeze({
 /**
  * Global prettier config source.
  */
-var prettierConfigSource = {
+const prettierConfigSource = {
   config: Object.assign({}, DEFAULT_PRETTIER_CONFIG)
 };
 

package/es/components/shared/monaco-editor/utils/prettier/index.js

@@ -1,35 +1,15 @@
-import { asyncToGenerator as _asyncToGenerator, regeneratorRuntime as _regeneratorRuntime } from '../../../../../_virtual/_rollupPluginBabelHelpers.js';
 import { prettierConfigSource } from './config.js';
 
 /**
  * Run prettier on the given text.
  */
-function prettier (_x, _x2) {
-  return _ref.apply(this, arguments);
-}
-function _ref() {
-  _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(value, options) {
-    var prettier;
-    return _regeneratorRuntime().wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          _context.prev = 0;
-          _context.next = 3;
-          return import('prettier/standalone');
-        case 3:
-          prettier = _context.sent;
-          return _context.abrupt("return", prettier.format(value, Object.assign(Object.assign({}, options), prettierConfigSource.config)));
-        case 7:
-          _context.prev = 7;
-          _context.t0 = _context["catch"](0);
-          return _context.abrupt("return", value);
-        case 10:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee, null, [[0, 7]]);
-  }));
-  return _ref.apply(this, arguments);
+async function prettier (value, options) {
+  try {
+    const prettier = await import('prettier/standalone');
+    return prettier.format(value, Object.assign(Object.assign({}, options), prettierConfigSource.config));
+  } catch (_) {
+    return value;
+  }
 }
 
 export { prettier as default };

package/es/components/shared/monaco-editor/utils/theme/convert.js

@@ -32,19 +32,17 @@ function getBase(type) {
  *
  */
 function convertToMonacoTheme(theme) {
-  var _theme$tokenColors = theme.tokenColors,
-    tokenColors = _theme$tokenColors === void 0 ? [] : _theme$tokenColors,
-    _theme$colors = theme.colors,
-    colors = _theme$colors === void 0 ? {} : _theme$colors;
-  Object.keys(colors).forEach(function (c) {
+  const {
+    tokenColors = [],
+    colors = {}
+  } = theme;
+  Object.keys(colors).forEach(c => {
     if (!colors[c]) {
       delete colors[c];
     }
   });
-  var rules = tokenColors.filter(function (t) {
-    return t.scope && t.settings && t.settings.foreground !== 'inherit' && t.settings.background !== 'inherit';
-  }).reduce(function (acc, token) {
-    var settings = {};
+  const rules = tokenColors.filter(t => t.scope && t.settings && t.settings.foreground !== 'inherit' && t.settings.background !== 'inherit').reduce((acc, token) => {
+    const settings = {};
     if (token.settings.foreground) {
       settings.foreground = sanitizeColor(token.settings.foreground);
     }
@@ -54,21 +52,17 @@ function convertToMonacoTheme(theme) {
     if (token.settings.fontStyle) {
       settings.fontStyle = token.settings.fontStyle;
     }
-    var scope = typeof token.scope === 'string' ? token.scope.split(',').map(function (a) {
-      return a.trim();
-    }) : token.scope;
-    scope.forEach(function (s) {
-      return acc.push(Object.assign({
-        token: s
-      }, settings));
-    });
+    const scope = typeof token.scope === 'string' ? token.scope.split(',').map(a => a.trim()) : token.scope;
+    scope.forEach(s => acc.push(Object.assign({
+      token: s
+    }, settings)));
     return acc;
   }, []);
   return {
     base: getBase(theme.type),
     inherit: true,
-    colors: colors,
-    rules: rules
+    colors,
+    rules
   };
 }
 

package/es/components/shared/monaco-editor/utils/theme/index.js

@@ -1,31 +1,12 @@
-import { asyncToGenerator as _asyncToGenerator, regeneratorRuntime as _regeneratorRuntime } from '../../../../../_virtual/_rollupPluginBabelHelpers.js';
 import { VSCODE_THEMES } from '../../constants/themes/index.js';
 import { convertToMonacoTheme } from './convert.js';
 
 /**
  * Import theme of vscode.
  */
-function importTheme(_x) {
-  return _importTheme.apply(this, arguments);
-}
-function _importTheme() {
-  _importTheme = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(theme) {
-    var _a;
-    return _regeneratorRuntime().wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          return _context.abrupt("return", ((_a = VSCODE_THEMES.find(function (t) {
-            return t.id === theme;
-          })) !== null && _a !== void 0 ? _a : VSCODE_THEMES[0]).getTheme().then(function (themeData) {
-            return convertToMonacoTheme(themeData);
-          }));
-        case 1:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee);
-  }));
-  return _importTheme.apply(this, arguments);
+async function importTheme(theme) {
+  var _a;
+  return ((_a = VSCODE_THEMES.find(t => t.id === theme)) !== null && _a !== void 0 ? _a : VSCODE_THEMES[0]).getTheme().then(themeData => convertToMonacoTheme(themeData));
 }
 
 export { importTheme };