@elice/material-exercise 1.220803.0

package/es/components/shared/monaco-editor/MonacoEditor.js

@@ -0,0 +1,355 @@
+import React, { forwardRef } from 'react';
+import { base } from '@elice/design-tokens';
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import styled from 'styled-components';
+import initGrammars from './utils/grammar/index.js';
+import { cssRemoteMarker } from './utils/remoteMarker/styles.js';
+import { DEFAULT_MONACO_EDITOR_PREFERENCE } from './constants/monaco/preferences.js';
+import { useMonacoEventChange } from './editor-hooks/useMonacoEventChange.js';
+import { useMonacoEventCursor } from './editor-hooks/useMonacoEventCursor.js';
+import { useMonacoEventScroll } from './editor-hooks/useMonacoEventScroll.js';
+import { useMonacoMarkers } from './editor-hooks/useMonacoMarkers.js';
+import { useMonacoOptions } from './editor-hooks/useMonacoOptions.js';
+import { useMonacoTheme } from './editor-hooks/useMonacoTheme.js';
+import configEditorLanguages from './editor-languages/index.js';
+import { useEditorOptions } from './hooks/useEditorOptions.js';
+import { getLanguageFromFilename } from './utils/monacoLanguage.js';
+
+//
+//
+
+const StyledMonacoEditorWrapper = styled.div.withConfig({
+  componentId: "sc-1j3uyex-0"
+})(["width:100%;height:100%;"]);
+const StyledMonacoEditor = styled.div.withConfig({
+  componentId: "sc-1j3uyex-1"
+})(["width:100%;height:100%;background-color:", ";", ""], base.color.navy9, cssRemoteMarker); //
+//
+//
+
+/**
+ *
+ */
+
+const MonacoEditor = forwardRef(({
+  defaultValue = '',
+  filename = '/noname.txt',
+  preference = DEFAULT_MONACO_EDITOR_PREFERENCE,
+  markers = [],
+  width = '100%',
+  height = '100%',
+  noLanguageIntellisense = false,
+  onLoad,
+  onChange,
+  onSave,
+  onCursor,
+  onScroll,
+  onThemeChange
+}, ref) => {
+  /** Ref of element which wraps editor. */
+  const editorElRef = React.useRef(null);
+  /** Ref of editor exposed APIs. */
+
+  const editorApis = React.useRef({});
+  /** Ref of monaco editor. */
+
+  const editor = React.useRef(null);
+  /** Editor options. */
+
+  const editorOptions = useEditorOptions({
+    width,
+    height,
+    preference,
+    noLanguageIntellisense
+  });
+  /** Ref for preventing change event. */
+
+  const suppress = React.useRef(false);
+  /** Is editor ready? */
+
+  const [isReady, setReady] = React.useState(false);
+  /**
+   * Get model of editor.
+   */
+
+  const getMonacoModel = () => {
+    const uri = monaco.Uri.file(filename || '/noname.txt');
+    return monaco.editor.getModel(uri);
+  };
+  /**
+   * Has editor undo/redo history?
+   * @public
+   */
+
+
+  const hasHistory = () => {
+    var _a;
+
+    return (((_a = getMonacoModel()) === null || _a === void 0 ? void 0 : _a.getAlternativeVersionId()) || 0) > 1;
+  };
+  /**
+   * Clear editor undo/redo history.
+   * @public
+   */
+
+
+  const clearHistory = () => {
+    getMonacoModel();
+  };
+  /**
+   * Get current value of editor.
+   * @public
+   */
+
+
+  const getValue = () => {
+    var _a;
+
+    return ((_a = getMonacoModel()) === null || _a === void 0 ? void 0 : _a.getValue()) || '';
+  };
+  /**
+   * Get value in range of editor.
+   * @public
+   */
+
+
+  const getValueInRange = (from, to) => {
+    const model = getMonacoModel();
+
+    if (!model) {
+      return '';
+    }
+
+    if (from === to) {
+      return '';
+    }
+
+    const startPosition = model.getPositionAt(from);
+    const endPosition = model.getPositionAt(to);
+    return model.getValueInRange({
+      startLineNumber: startPosition.lineNumber,
+      startColumn: startPosition.column,
+      endLineNumber: endPosition.lineNumber,
+      endColumn: endPosition.column
+    });
+  };
+  /**
+   * Set (overwrite) value to editor.
+   * @public
+   */
+
+
+  const setValue = newValue => {
+    if (!editor.current) {
+      return;
+    } // Replace value EOL as LF.
+
+
+    newValue = newValue.replace(/\r\n/g, '\n');
+    const uri = monaco.Uri.file(filename || '/noname.txt');
+    const model = monaco.editor.getModel(uri);
+
+    if (model && !model.isDisposed()) {
+      // Override EOL as LF to prevent error at Windows env.
+      model.setEOL(monaco.editor.EndOfLineSequence.LF); // Overwirte current whole value with new one.
+
+      if (typeof newValue === 'string') {
+        suppress.current = true;
+        editor.current.pushUndoStop();
+        model.pushEditOperations([], [{
+          range: model.getFullModelRange(),
+          text: newValue,
+          forceMoveMarkers: true
+        }], () => null);
+        editor.current.pushUndoStop();
+        suppress.current = false;
+        editor.current.setModel(model);
+        editor.current.focus();
+      }
+    } // If model has not created yet for this file,
+    // create new model.
+    else {
+      const lang = getLanguageFromFilename(filename);
+      const newModel = monaco.editor.createModel(newValue, lang, uri);
+      newModel.setEOL(monaco.editor.EndOfLineSequence.LF);
+      editor.current.setModel(newModel);
+    }
+  };
+  /**
+   * Insert value at specific position.
+   * @public
+   */
+
+
+  const insertValue = (index, newValue) => {
+    if (!editor.current) {
+      return;
+    } // Replace value EOL as LF.
+
+
+    newValue = newValue.replace(/\r\n/g, '\n');
+    const model = getMonacoModel();
+
+    if (model) {
+      const position = model.getPositionAt(index);
+      suppress.current = true;
+      editor.current.pushUndoStop();
+      model.pushEditOperations([], [{
+        range: new monaco.Range(position.lineNumber, position.column, position.lineNumber, position.column),
+        text: newValue,
+        forceMoveMarkers: true
+      }], () => null);
+      editor.current.pushUndoStop();
+      suppress.current = false;
+    }
+  };
+  /**
+   * Remove value at specific range.
+   * @public
+   */
+
+
+  const removeValue = (from, to) => {
+    if (!editor.current) {
+      return;
+    }
+
+    const model = getMonacoModel();
+
+    if (model) {
+      const startPosition = model.getPositionAt(from);
+      const endPosition = model.getPositionAt(to);
+      suppress.current = true;
+      editor.current.pushUndoStop();
+      model.pushEditOperations([], [{
+        range: new monaco.Range(startPosition.lineNumber, startPosition.column, endPosition.lineNumber, endPosition.column),
+        text: '',
+        forceMoveMarkers: true
+      }], () => null);
+      editor.current.pushUndoStop();
+      suppress.current = false;
+    }
+  };
+  /**
+   * Set selection of editor with specific range.
+   * @public
+   */
+
+
+  const setSelection = (from, to) => {
+    var _a;
+
+    const model = getMonacoModel();
+
+    if (model) {
+      const markerStartPosition = model.getPositionAt(from);
+      const markerEndPosition = model.getPositionAt(to);
+      (_a = editor.current) === null || _a === void 0 ? void 0 : _a.setSelection(new monaco.Range(markerStartPosition.lineNumber, markerStartPosition.column, markerEndPosition.lineNumber, markerEndPosition.column));
+    }
+  };
+  /**
+   * Scroll editor to specific `scrollTop`.
+   * @public
+   */
+
+
+  const scrollTo = scrollTop => {
+    var _a;
+
+    (_a = editor.current) === null || _a === void 0 ? void 0 : _a.setScrollTop(scrollTop);
+  }; //
+  // Editor hooks.
+  //
+
+
+  useMonacoOptions(editor, editorOptions);
+  useMonacoTheme(preference.theme, onThemeChange);
+  useMonacoEventChange(editor, onChange, suppress, [isReady]);
+  useMonacoEventCursor(editor, onCursor, [isReady]);
+  useMonacoEventScroll(editor, onScroll, [isReady]);
+  const remoteMarker = useMonacoMarkers(editor, markers); //
+  // Init and dispose editor.
+  //
+
+  React.useEffect(() => {
+    try {
+      if (!editorElRef.current) {
+        return;
+      } // pre-config monaco editor
+
+
+      configEditorLanguages();
+      initGrammars().catch(console.warn); // create monaco editor instance and render it.
+
+      editor.current = monaco.editor.create(editorElRef.current, Object.assign(Object.assign({}, editorOptions), {
+        value: defaultValue,
+        language: getLanguageFromFilename(filename)
+      })); // add keyboard shortcut.
+
+      editor.current.addCommand(monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyS, () => {
+        var _a, _b, _c;
+
+        (_b = (_a = editor.current) === null || _a === void 0 ? void 0 : _a.getAction('editor.action.formatDocument')) === null || _b === void 0 ? void 0 : _b.run();
+
+        if (typeof onSave === 'function') {
+          const content = ((_c = getMonacoModel()) === null || _c === void 0 ? void 0 : _c.getValue()) || '';
+          onSave(content);
+        }
+      });
+      remoteMarker.init(); // emit on load event.
+
+      if (typeof onLoad === 'function') {
+        onLoad(editor.current);
+      }
+
+      setReady(true);
+    } catch (_) {
+      setReady(false);
+    }
+
+    return () => {
+      var _a;
+
+      setReady(false); // dispose remote marker
+
+      remoteMarker.dispose(); // dispose editor
+
+      if (typeof ((_a = editor.current) === null || _a === void 0 ? void 0 : _a.dispose) === 'function') {
+        editor.current.dispose();
+      }
+    };
+  }, // eslint-disable-next-line react-hooks/exhaustive-deps
+  []); //
+  // Set value whenevet filename or value changed.
+  //
+
+  React.useEffect(() => setValue(defaultValue), // eslint-disable-next-line react-hooks/exhaustive-deps
+  [filename, defaultValue]); //
+  //
+  //
+
+  editorApis.current.editor = editor.current;
+  editorApis.current.getMonacoModel = getMonacoModel;
+  editorApis.current.hasHistory = hasHistory;
+  editorApis.current.clearHistory = clearHistory;
+  editorApis.current.getValue = getValue;
+  editorApis.current.getValueInRange = getValueInRange;
+  editorApis.current.setValue = setValue;
+  editorApis.current.insertValue = insertValue;
+  editorApis.current.removeValue = removeValue;
+  editorApis.current.setSelection = setSelection;
+  editorApis.current.scrollTo = scrollTo;
+  React.useImperativeHandle(ref, () => editorApis.current, [editorApis]); //
+  //
+  //
+
+  return React.createElement(StyledMonacoEditorWrapper, null, React.createElement(StyledMonacoEditor, {
+    style: {
+      width,
+      height
+    },
+    ref: editorElRef
+  }));
+});
+
+export { MonacoEditor as default };

package/es/components/shared/monaco-editor/MonacoEditorLazy.d.ts

@@ -0,0 +1,3 @@
+import type MonacoEditor from './MonacoEditor';
+declare const MonacoEditorLazy: typeof MonacoEditor;
+export default MonacoEditorLazy;

package/es/components/shared/monaco-editor/MonacoEditorLazy.js

@@ -0,0 +1,17 @@
+import React, { forwardRef } from 'react';
+import ExerciseFileShimmer from '../exercise-shimmer/ExerciseFileShimmer.js';
+import '../exercise-shimmer/ExerciseFileTabsShimmer.js';
+import '../exercise-shimmer/ExerciseFileTabShimmer.js';
+import '../exercise-shimmer/ExerciseFileTreeListShimmer.js';
+import '../exercise-shimmer/ExerciseFileTreeListItemShimmer.js';
+
+const AsyncMonacoEditor = React.lazy(() => import('./MonacoEditor.js'));
+const MonacoEditorLazy = forwardRef((props, ref) => {
+  return React.createElement(React.Suspense, {
+    fallback: React.createElement(ExerciseFileShimmer, null)
+  }, React.createElement(AsyncMonacoEditor, Object.assign({}, props, {
+    ref: ref
+  })));
+});
+
+export { MonacoEditorLazy as default };

package/es/components/shared/monaco-editor/MonacoEditorPerferenceForm.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import type { MonacoEditorPreference } from './constants';
+export interface PerferenceFormProps {
+    value: Partial<MonacoEditorPreference>;
+    locale?: string;
+    onChange?: (value: Required<MonacoEditorPreference>) => void;
+}
+declare const _default: (props: PerferenceFormProps) => JSX.Element;
+export default _default;

package/es/components/shared/monaco-editor/MonacoEditorPerferenceForm.js

@@ -0,0 +1,304 @@
+import React from 'react';
+import { useIntl, FormattedMessage } from 'react-intl';
+import { useDeepCompareEffect } from 'react-use';
+import { Select, Text, Vspace, AntSwitch } from '@elice/blocks';
+import { base } from '@elice/design-tokens';
+import { MaterialIntlProvider } from '@elice/material-shared-utils';
+import styled from 'styled-components';
+import { VSCODE_THEMES } from './constants/themes/index.js';
+import phrasesEn from './locales/en.json.js';
+import phrasesKo from './locales/ko.json.js';
+import { MONACO_EDITOR_PREFERENCE_OPTIONS_FONT_SIZES, MONACO_EDITOR_RENDER_WHITESPACE_OPTIONS, MONACO_EDITOR_PREFERENCE_OPTIONS_TAB_SIZES } from './constants/monaco/preferences.js';
+import 'monaco-editor/esm/vs/editor/editor.api';
+import { normalizeMonacoPreference } from './utils/monacoPreference.js';
+
+const StyledPreferenceBodyItem = styled.div.withConfig({
+  componentId: "sc-1bwf6gs-0"
+})(["display:flex;justify-content:space-between;align-items:center;margin-bottom:1rem;min-height:2rem;color:white;&:last-child{margin-bottom:0;}"]);
+const StyledSelect = styled(Select).withConfig({
+  componentId: "sc-1bwf6gs-1"
+})(["> div{background:", " !important;border-color:", " !important;}select{padding:0 !important;height:2rem !important;color:#fff !important;> option{background:", " !important;}}"], base.color.navy8, base.color.navy7, base.color.navy8);
+
+const MonacoEditorPerferenceForm = ({
+  value,
+  onChange
+}) => {
+  const intl = useIntl();
+  const [preference, setPreference] = React.useState(normalizeMonacoPreference(value));
+  /**
+   * Update preference from form.
+   */
+
+  const updatePreference = newPreference => {
+    setPreference(prev => normalizeMonacoPreference(Object.assign(Object.assign({}, prev), newPreference)));
+  }; //
+  // Update state from value.
+  //
+
+
+  useDeepCompareEffect(() => setPreference(normalizeMonacoPreference(value)), [value]); //
+  // Emit change event.
+  //
+
+  useDeepCompareEffect(() => {
+    if (typeof onChange === 'function') {
+      onChange(preference);
+    }
+  }, [preference]);
+  /**
+   * appearance > theme
+   */
+
+  const renderPreferenceItemTheme = () => {
+    return React.createElement(StyledPreferenceBodyItem, null, React.createElement(Text, {
+      role: "navy",
+      size: "tiny",
+      block: true
+    }, React.createElement(FormattedMessage, {
+      id: "monacoEditorPerferenceForm.displaying.item.theme.name"
+    })), React.createElement(StyledSelect, {
+      value: preference.theme,
+      size: "small",
+      width: "xsmall",
+      onChange: value => {
+        updatePreference({
+          theme: value
+        });
+      }
+    }, VSCODE_THEMES.map(({
+      id,
+      name
+    }) => React.createElement("option", {
+      key: id,
+      value: id
+    }, name))));
+  };
+  /**
+   * appearance > font size
+   */
+
+
+  const renderPreferenceItemFontSize = () => {
+    return React.createElement(StyledPreferenceBodyItem, null, React.createElement(Text, {
+      role: "navy",
+      size: "tiny",
+      block: true
+    }, React.createElement(FormattedMessage, {
+      id: "monacoEditorPerferenceForm.displaying.item.fontSize.name"
+    })), React.createElement(StyledSelect, {
+      value: preference.fontSize,
+      size: "small",
+      width: "xsmall",
+      onChange: value => {
+        updatePreference({
+          fontSize: Number(value)
+        });
+      }
+    }, MONACO_EDITOR_PREFERENCE_OPTIONS_FONT_SIZES.map(size => React.createElement("option", {
+      key: size,
+      value: size
+    }, size))));
+  };
+  /**
+   * appearance > word wrap
+   */
+
+
+  const renderPreferenceItemWordWrap = () => {
+    return React.createElement(StyledPreferenceBodyItem, null, React.createElement(Text, {
+      role: "navy",
+      size: "tiny",
+      block: true
+    }, React.createElement(FormattedMessage, {
+      id: "monacoEditorPerferenceForm.displaying.item.wordWrap.name"
+    })), React.createElement(AntSwitch, {
+      checked: preference.wordWrap === 'on',
+      onChange: value => {
+        updatePreference({
+          wordWrap: value ? 'on' : 'off'
+        });
+      }
+    }));
+  };
+  /**
+   * appearance > white space
+   */
+
+
+  const renderPreferenceItemWhiteSpace = () => {
+    return React.createElement(StyledPreferenceBodyItem, null, React.createElement(Text, {
+      role: "navy",
+      size: "tiny",
+      block: true
+    }, React.createElement(FormattedMessage, {
+      id: "monacoEditorPerferenceForm.displaying.item.renderWhiteSpace.name"
+    })), React.createElement(StyledSelect, {
+      value: preference.renderWhitespace,
+      size: "small",
+      width: "xsmall",
+      onChange: value => {
+        updatePreference({
+          renderWhitespace: value
+        });
+      }
+    }, MONACO_EDITOR_RENDER_WHITESPACE_OPTIONS.map(option => React.createElement("option", {
+      key: option,
+      value: option
+    }, intl.formatMessage({
+      id: `monacoEditorPerferenceForm.displaying.item.renderWhiteSpace.value.${option}`
+    })))));
+  };
+  /**
+   * appearance > minimap
+   */
+
+
+  const renderPreferenceItemMinimap = () => {
+    var _a;
+
+    return React.createElement(StyledPreferenceBodyItem, null, React.createElement(Text, {
+      role: "navy",
+      size: "tiny",
+      block: true
+    }, React.createElement(FormattedMessage, {
+      id: "monacoEditorPerferenceForm.displaying.item.minimap.name"
+    })), React.createElement(AntSwitch, {
+      checked: (_a = preference.minimap) === null || _a === void 0 ? void 0 : _a.enabled,
+      onChange: value => {
+        updatePreference({
+          minimap: {
+            enabled: value
+          }
+        });
+      }
+    }));
+  };
+  /**
+   * appearance > cursor smooth caret animation
+   */
+
+
+  const renderPreferenceItemCursorSmoothCaretAnimation = () => {
+    return React.createElement(StyledPreferenceBodyItem, null, React.createElement(Text, {
+      role: "navy",
+      size: "tiny",
+      block: true
+    }, React.createElement(FormattedMessage, {
+      id: "monacoEditorPerferenceForm.displaying.item.cursorSmoothCaretAnimation.name"
+    })), React.createElement(AntSwitch, {
+      checked: preference.cursorSmoothCaretAnimation,
+      onChange: value => {
+        updatePreference({
+          cursorSmoothCaretAnimation: value
+        });
+      }
+    }));
+  };
+  /**
+   * text editing > auto closing brackets
+   */
+
+
+  const renderPreferenceItemAutoClosingBrackets = () => {
+    return React.createElement(StyledPreferenceBodyItem, null, React.createElement(Text, {
+      role: "navy",
+      size: "tiny",
+      block: true
+    }, React.createElement(FormattedMessage, {
+      id: "monacoEditorPerferenceForm.textEditing.item.autoClosingBrackets.name"
+    })), React.createElement(AntSwitch, {
+      checked: preference.autoClosingBrackets === 'always',
+      onChange: value => {
+        updatePreference({
+          autoClosingBrackets: value ? 'always' : 'never'
+        });
+      }
+    }));
+  };
+  /**
+   * text editing > detect indentation
+   */
+
+
+  const renderPreferenceItemDetectIndentation = () => {
+    return React.createElement(StyledPreferenceBodyItem, null, React.createElement(Text, {
+      role: "navy",
+      size: "tiny",
+      block: true
+    }, React.createElement(FormattedMessage, {
+      id: "monacoEditorPerferenceForm.textEditing.item.detectIndentation.name"
+    })), React.createElement(AntSwitch, {
+      checked: preference.detectIndentation,
+      onChange: value => {
+        updatePreference({
+          detectIndentation: value
+        });
+      }
+    }));
+  };
+  /**
+   * text editing > tab size
+   */
+
+
+  const renderPreferenceItemTabSize = () => {
+    return React.createElement(StyledPreferenceBodyItem, null, React.createElement(Text, {
+      role: preference.detectIndentation ? 'grey6' : 'info',
+      block: true,
+      size: "small"
+    }, React.createElement(FormattedMessage, {
+      id: "monacoEditorPerferenceForm.textEditing.item.tabSize.name"
+    })), React.createElement(StyledSelect, {
+      value: preference.tabSize,
+      size: "small",
+      width: "xsmall",
+      disabled: preference.detectIndentation,
+      onChange: value => {
+        updatePreference({
+          tabSize: Number(value)
+        });
+      }
+    }, MONACO_EDITOR_PREFERENCE_OPTIONS_TAB_SIZES.map(size => React.createElement("option", {
+      key: size,
+      value: size
+    }, size))));
+  }; //
+  //
+  //
+
+
+  return React.createElement(React.Fragment, null, React.createElement(Text, {
+    role: "lightgrey",
+    size: "small",
+    bold: true
+  }, React.createElement(FormattedMessage, {
+    id: "monacoEditorPerferenceForm.displaying.title"
+  })), React.createElement(Vspace, {
+    height: 1
+  }), renderPreferenceItemTheme(), renderPreferenceItemFontSize(), renderPreferenceItemWordWrap(), renderPreferenceItemWhiteSpace(), renderPreferenceItemMinimap(), renderPreferenceItemCursorSmoothCaretAnimation(), React.createElement(Vspace, {
+    height: 2
+  }), React.createElement(Text, {
+    role: "lightgrey",
+    size: "small",
+    bold: true
+  }, React.createElement(FormattedMessage, {
+    id: "monacoEditorPerferenceForm.textEditing.title"
+  })), React.createElement(Vspace, {
+    height: 1
+  }), renderPreferenceItemAutoClosingBrackets(), renderPreferenceItemDetectIndentation(), renderPreferenceItemTabSize());
+}; //
+//
+//
+
+
+var MonacoEditorPerference = (props => {
+  return React.createElement(MaterialIntlProvider, {
+    locale: props.locale,
+    phrases: {
+      en: phrasesEn,
+      ko: phrasesKo
+    }
+  }, React.createElement(MonacoEditorPerferenceForm, Object.assign({}, props)));
+});
+
+export { MonacoEditorPerference as default };

package/es/components/shared/monaco-editor/constants/grammars/JSON.tmLanguage.json.js

@@ -0,0 +1,3 @@
+const information_for_contributors=["This file has been converted from https://github.com/microsoft/vscode-JSON.tmLanguage/blob/master/JSON.tmLanguage","If you want to provide a fix or improvement, please create a pull request against the original repository.","Once accepted there, we are happy to receive an update request."];const version="https://github.com/microsoft/vscode-JSON.tmLanguage/commit/9bd83f1c252b375e957203f21793316203f61f70";const name="JSON (Javascript Next)";const scopeName="source.json";const patterns=[{include:"#value"}];const repository={array:{begin:"\\[",beginCaptures:{"0":{name:"punctuation.definition.array.begin.json"}},end:"\\]",endCaptures:{"0":{name:"punctuation.definition.array.end.json"}},name:"meta.structure.array.json",patterns:[{include:"#value"},{match:",",name:"punctuation.separator.array.json"},{match:"[^\\s\\]]",name:"invalid.illegal.expected-array-separator.json"}]},comments:{patterns:[{begin:"/\\*\\*(?!/)",captures:{"0":{name:"punctuation.definition.comment.json"}},end:"\\*/",name:"comment.block.documentation.json"},{begin:"/\\*",captures:{"0":{name:"punctuation.definition.comment.json"}},end:"\\*/",name:"comment.block.json"},{captures:{"1":{name:"punctuation.definition.comment.json"}},match:"(//).*$\\n?",name:"comment.line.double-slash.js"}]},constant:{match:"\\b(?:true|false|null)\\b",name:"constant.language.json"},number:{match:"(?x)        # turn on extended mode\n  -?        # an optional minus\n  (?:\n    0       # a zero\n    |       # ...or...\n    [1-9]   # a 1-9 character\n    \\d*     # followed by zero or more digits\n  )\n  (?:\n    (?:\n      \\.    # a period\n      \\d+   # followed by one or more digits\n    )?\n    (?:\n      [eE]  # an e character\n      [+-]? # followed by an option +/-\n      \\d+   # followed by one or more digits\n    )?      # make exponent optional\n  )?        # make decimal portion optional",name:"constant.numeric.json"},object:{begin:"\\{",beginCaptures:{"0":{name:"punctuation.definition.dictionary.begin.json"}},end:"\\}",endCaptures:{"0":{name:"punctuation.definition.dictionary.end.json"}},name:"meta.structure.dictionary.json",patterns:[{comment:"the JSON object key",include:"#objectkey"},{include:"#comments"},{begin:":",beginCaptures:{"0":{name:"punctuation.separator.dictionary.key-value.json"}},end:"(,)|(?=\\})",endCaptures:{"1":{name:"punctuation.separator.dictionary.pair.json"}},name:"meta.structure.dictionary.value.json",patterns:[{comment:"the JSON object value",include:"#value"},{match:"[^\\s,]",name:"invalid.illegal.expected-dictionary-separator.json"}]},{match:"[^\\s\\}]",name:"invalid.illegal.expected-dictionary-separator.json"}]},string:{begin:"\"",beginCaptures:{"0":{name:"punctuation.definition.string.begin.json"}},end:"\"",endCaptures:{"0":{name:"punctuation.definition.string.end.json"}},name:"string.quoted.double.json",patterns:[{include:"#stringcontent"}]},objectkey:{begin:"\"",beginCaptures:{"0":{name:"punctuation.support.type.property-name.begin.json"}},end:"\"",endCaptures:{"0":{name:"punctuation.support.type.property-name.end.json"}},name:"string.json support.type.property-name.json",patterns:[{include:"#stringcontent"}]},stringcontent:{patterns:[{match:"(?x)                # turn on extended mode\n  \\\\                # a literal backslash\n  (?:               # ...followed by...\n    [\"\\\\/bfnrt]     # one of these characters\n    |               # ...or...\n    u               # a u\n    [0-9a-fA-F]{4}) # and four hex digits",name:"constant.character.escape.json"},{match:"\\\\.",name:"invalid.illegal.unrecognized-string-escape.json"}]},value:{patterns:[{include:"#constant"},{include:"#number"},{include:"#string"},{include:"#array"},{include:"#object"},{include:"#comments"}]}};var JSON_tmLanguage = {information_for_contributors:information_for_contributors,version:version,name:name,scopeName:scopeName,patterns:patterns,repository:repository};
+
+export { JSON_tmLanguage as default, information_for_contributors, name, patterns, repository, scopeName, version };