@difizen/libro-codemirror 0.0.0-snapshot-20241017072317

package/es/config.d.ts

@@ -0,0 +1,189 @@
+import type { Extension } from '@codemirror/state';
+import { Compartment, StateEffect } from '@codemirror/state';
+import type { KeyBinding } from '@codemirror/view';
+import { EditorView } from '@codemirror/view';
+import type { IEditorConfig } from '@difizen/libro-code-editor';
+import type { IOptions } from './editor.js';
+/**
+ * The configuration options for a codemirror editor.
+ */
+export interface CodeMirrorConfig extends IEditorConfig {
+    /**
+     * The mode to use.
+     */
+    mode?: string;
+    /**
+     * content mimetype
+     */
+    mimetype?: string;
+    /**
+     * Whether to use the context-sensitive indentation that the mode provides
+     * (or just indent the same as the line before).
+     */
+    smartIndent?: boolean;
+    /**
+     * Configures whether the editor should re-indent the current line when a
+     * character is typed that might change its proper indentation
+     * (only works if the mode supports indentation).
+     */
+    electricChars?: boolean;
+    /**
+     * Configures the keymap to use. The default is "default", which is the
+     * only keymap defined in codemirror.js itself.
+     * Extra keymaps are found in the CodeMirror keymap directory.
+     */
+    keyMap?: string;
+    /**
+     * Can be used to specify extra keybindings for the editor, alongside the
+     * ones defined by keyMap. Should be either null, or a valid keymap value.
+     */
+    extraKeys?: KeyBinding[] | null;
+    /**
+     * Can be used to add extra gutters (beyond or instead of the line number
+     * gutter).
+     * Should be an array of CSS class names, each of which defines a width
+     * (and optionally a background),
+     * and which will be used to draw the background of the gutters.
+     * May include the CodeMirror-linenumbers class, in order to explicitly
+     * set the position of the line number gutter
+     * (it will default to be to the right of all other gutters).
+     * These class names are the keys passed to setGutterMarker.
+     */
+    gutters?: string[];
+    /**
+     * Determines whether the gutter scrolls along with the content
+     * horizontally (false)
+     * or whether it stays fixed during horizontal scrolling (true,
+     * the default).
+     */
+    fixedGutter?: boolean;
+    /**
+     * Whether the cursor should be drawn when a selection is active.
+     */
+    showCursorWhenSelecting?: boolean;
+    /**
+     * When fixedGutter is on, and there is a horizontal scrollbar, by default
+     * the gutter will be visible to the left of this scrollbar. If this
+     * option is set to true, it will be covered by an element with class
+     * CodeMirror-gutter-filler.
+     */
+    coverGutterNextToScrollbar?: boolean;
+    /**
+     * Controls whether drag-and-drop is enabled.
+     */
+    dragDrop?: boolean;
+    /**
+     * Explicitly set the line separator for the editor.
+     * By default (value null), the document will be split on CRLFs as well as
+     * lone CRs and LFs, and a single LF will be used as line separator in all
+     * output (such as getValue). When a specific string is given, lines will
+     * only be split on that string, and output will, by default, use that
+     * same separator.
+     */
+    lineSeparator?: string | null;
+    /**
+     * Chooses a scrollbar implementation. The default is "native", showing
+     * native scrollbars. The core library also provides the "null" style,
+     * which completely hides the scrollbars. Addons can implement additional
+     * scrollbar models.
+     */
+    scrollbarStyle?: string;
+    /**
+     * When enabled, which is the default, doing copy or cut when there is no
+     * selection will copy or cut the whole lines that have cursors on them.
+     */
+    lineWiseCopyCut?: boolean;
+    /**
+     * Whether to scroll past the end of the buffer.
+     */
+    scrollPastEnd?: boolean;
+    /**
+     * Whether to give the wrapper of the line that contains the cursor the class
+     * cm-activeLine.
+     */
+    styleActiveLine?: boolean;
+    /**
+     * Whether to causes the selected text to be marked with the CSS class
+     * CodeMirror-selectedtext. Useful to change the colour of the selection
+     * (in addition to the background).
+     */
+    styleSelectedText?: boolean;
+    /**
+     * Defines the mouse cursor appearance when hovering over the selection.
+     * It can be set to a string, like "pointer", or to true,
+     * in which case the "default" (arrow) cursor will be used.
+     */
+    selectionPointer?: boolean | string;
+    highlightActiveLineGutter?: boolean;
+    highlightSpecialChars?: boolean;
+    history?: boolean;
+    drawSelection?: boolean;
+    dropCursor?: boolean;
+    allowMultipleSelections?: boolean;
+    autocompletion?: boolean;
+    rectangularSelection?: boolean;
+    crosshairCursor?: boolean;
+    highlightSelectionMatches?: boolean;
+    foldGutter?: boolean;
+    syntaxHighlighting?: boolean;
+    /**
+     * 是否从kernel获取completion
+     */
+    jupyterKernelCompletion?: boolean;
+    /**
+     * 是否从kernel获取tooltip
+     */
+    jupyterKernelTooltip?: boolean;
+    indentationMarkers?: boolean;
+    hyperLink?: boolean;
+    /**
+     * 是否开启tab触发completion和tooltip
+     */
+    tabEditorFunction?: boolean;
+    lspCompletion?: boolean;
+    lspTooltip?: boolean;
+    lspLint?: boolean;
+    placeholder?: HTMLElement | string;
+}
+/**
+ * Builds an extension in a compartment that can
+ * be reconfigured.
+ */
+interface IConfigurableBuilder {
+    of: <T>(value: T) => Extension;
+    reconfigure: <T>(value: T) => StateEffect<unknown>;
+}
+/**
+ * Editor configuration: provides APIs to get and reconfigure CodeMirror 6
+ * extensions from option names. Also allows to register new themes and
+ * inject ne extensions in already configured editor instances.
+ */
+export declare class EditorConfiguration {
+    constructor(options: IOptions);
+    /**
+     * Reconfigures the extension mapped with key with the provided value.
+     */
+    reconfigureExtension<T>(view: EditorView, key: string, value: T): void;
+    /**
+     * Reconfigures all the extensions mapped with the options from the
+     * provided partial configuration.
+     */
+    reconfigureExtensions(view: EditorView, config: Partial<CodeMirrorConfig>): void;
+    /**
+     * Appends extensions to the top-level configuration of the
+     * editor.
+     */
+    injectExtension(view: EditorView, ext: Extension): void;
+    /**
+     * Returns the list of initial extensions of an editor
+     * based on the provided configuration.
+     */
+    getInitialExtensions(config: CodeMirrorConfig): Extension[];
+    protected updateThemeOverload(config: Partial<CodeMirrorConfig> | Record<string, any>): Extension;
+    protected get(key: string): IConfigurableBuilder | undefined;
+    protected _configurableBuilderMap: Map<string, IConfigurableBuilder>;
+    protected _themeOverloaderSpec: Record<string, Record<string, string>>;
+    protected _themeOverloader: Compartment;
+}
+export {};
+//# sourceMappingURL=config.d.ts.map

package/es/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"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"}

package/es/config.js

@@ -0,0 +1,482 @@
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { defaultKeymap, history, historyKeymap } from '@codemirror/commands';
+import { pythonLanguage } from '@codemirror/lang-python';
+import { bracketMatching, defaultHighlightStyle, foldGutter, foldKeymap, indentOnInput, indentUnit, syntaxHighlighting } from '@codemirror/language';
+import { lintKeymap } from '@codemirror/lint';
+import { highlightSelectionMatches } from '@codemirror/search';
+import { Compartment, EditorState, StateEffect } from '@codemirror/state';
+import { crosshairCursor, drawSelection, dropCursor, EditorView, highlightActiveLine, highlightActiveLineGutter, highlightSpecialChars, keymap, lineNumbers, placeholder, rectangularSelection } from '@codemirror/view';
+import { autocompletion, closeBrackets, closeBracketsKeymap, completionKeymap } from "./auto-complete/index.js";
+import { kernelCompletions } from "./completion.js";
+import { hyperLink } from "./hyperlink.js";
+import { indentationMarkers } from "./indentation-markers/index.js";
+import { FoldIcon, UnFoldIcon } from "./libro-icon.js";
+import { lspPythonCompletion } from "./lsp/completion.js";
+import { formatKeymap } from "./lsp/format.js";
+import { lspLint, lspTooltip } from "./lsp/index.js";
+import { ensure } from "./mode.js";
+import { getTheme, defaultTheme } from "./theme.js";
+import { tabTooltip, tooltipKeymap } from "./tooltip.js";
+
+/**
+ * The configuration options for a codemirror editor.
+ */
+
+/**
+ * Extension builder (we use the same trick as in CM Extension
+ * to emulate empty interface)
+ */
+/**
+ * Builder for extensions from value of type T
+ */
+var ExtensionBuilder = /*#__PURE__*/function () {
+  function ExtensionBuilder() {
+    _classCallCheck(this, ExtensionBuilder);
+  }
+  _createClass(ExtensionBuilder, [{
+    key: "extensionBuilder",
+    get: function get() {
+      return this;
+    }
+  }]);
+  return ExtensionBuilder;
+}();
+/**
+ * Extension builder that simply forwards a value as an extension.
+ */
+var ExtensionForwarder = /*#__PURE__*/function (_ExtensionBuilder) {
+  _inherits(ExtensionForwarder, _ExtensionBuilder);
+  var _super = _createSuper(ExtensionForwarder);
+  function ExtensionForwarder() {
+    _classCallCheck(this, ExtensionForwarder);
+    return _super.apply(this, arguments);
+  }
+  _createClass(ExtensionForwarder, [{
+    key: "of",
+    value: function of(value) {
+      return value;
+    }
+  }]);
+  return ExtensionForwarder;
+}(ExtensionBuilder);
+/**
+ * Extension builder that builds an extension from a facet.
+ */
+var FacetWrapper = /*#__PURE__*/function (_ExtensionBuilder2) {
+  _inherits(FacetWrapper, _ExtensionBuilder2);
+  var _super2 = _createSuper(FacetWrapper);
+  function FacetWrapper(facet) {
+    var _this;
+    _classCallCheck(this, FacetWrapper);
+    _this = _super2.call(this);
+    _this._facet = facet;
+    return _this;
+  }
+  _createClass(FacetWrapper, [{
+    key: "of",
+    value: function of(value) {
+      return this._facet.of(value);
+    }
+  }]);
+  return FacetWrapper;
+}(ExtensionBuilder);
+/**
+ * Extension builder that provides an extension depending
+ * on a boolean value.
+ */
+var ConditionalExtension = /*#__PURE__*/function (_ExtensionBuilder3) {
+  _inherits(ConditionalExtension, _ExtensionBuilder3);
+  var _super3 = _createSuper(ConditionalExtension);
+  function ConditionalExtension(truthy) {
+    var _this2;
+    var falsy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    _classCallCheck(this, ConditionalExtension);
+    _this2 = _super3.call(this);
+    _this2._truthy = truthy;
+    _this2._falsy = falsy;
+    return _this2;
+  }
+  _createClass(ConditionalExtension, [{
+    key: "of",
+    value: function of(value) {
+      return value ? this._truthy : this._falsy;
+    }
+  }]);
+  return ConditionalExtension;
+}(ExtensionBuilder);
+/**
+ * Extension builds that provides an extension depending on
+ * conditional function operating on a value.
+ */
+var GenConditionalExtension = /*#__PURE__*/function (_ExtensionBuilder4) {
+  _inherits(GenConditionalExtension, _ExtensionBuilder4);
+  var _super4 = _createSuper(GenConditionalExtension);
+  function GenConditionalExtension(fn, truthy) {
+    var _this3;
+    var falsy = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+    _classCallCheck(this, GenConditionalExtension);
+    _this3 = _super4.call(this);
+    _this3._fn = fn;
+    _this3._builder = new ConditionalExtension(truthy, falsy);
+    return _this3;
+  }
+  _createClass(GenConditionalExtension, [{
+    key: "of",
+    value: function of(value) {
+      return this._builder.of(this._fn(value));
+    }
+  }]);
+  return GenConditionalExtension;
+}(ExtensionBuilder);
+/**
+ * Builds an extension in a compartment that can
+ * be reconfigured.
+ */
+/**
+ * IConfigurableBuilder implementation *
+ */
+var ConfigurableBuilder = /*#__PURE__*/function () {
+  function ConfigurableBuilder(builder) {
+    _classCallCheck(this, ConfigurableBuilder);
+    this._compartment = new Compartment();
+    this._builder = builder;
+  }
+  _createClass(ConfigurableBuilder, [{
+    key: "of",
+    value: function of(value) {
+      return this._compartment.of(this._builder.of(value));
+    }
+  }, {
+    key: "reconfigure",
+    value: function reconfigure(value) {
+      return this._compartment.reconfigure(this._builder.of(value));
+    }
+  }]);
+  return ConfigurableBuilder;
+}();
+/*
+ * Specific builder for themes. Provide a default theme and
+ * allows to register new themes.
+ */
+var ThemeBuilder = /*#__PURE__*/function () {
+  function ThemeBuilder() {
+    _classCallCheck(this, ThemeBuilder);
+    this._compartment = new Compartment();
+  }
+  _createClass(ThemeBuilder, [{
+    key: "of",
+    value: function of(value) {
+      var v = value;
+      return this._compartment.of(getTheme(v));
+    }
+  }, {
+    key: "reconfigure",
+    value: function reconfigure(value) {
+      var v = value;
+      return this._compartment.reconfigure(getTheme(v));
+    }
+  }]);
+  return ThemeBuilder;
+}();
+/*
+ * Specific builder for themes. Provide a default theme and
+ * allows to register new themes.
+ */
+var PlaceHolderBuilder = /*#__PURE__*/function () {
+  function PlaceHolderBuilder() {
+    _classCallCheck(this, PlaceHolderBuilder);
+    this._compartment = new Compartment();
+  }
+  _createClass(PlaceHolderBuilder, [{
+    key: "of",
+    value: function of(value) {
+      var v = value;
+      return this._compartment.of(placeholder(v));
+    }
+  }, {
+    key: "reconfigure",
+    value: function reconfigure(value) {
+      var v = value;
+      return this._compartment.reconfigure(placeholder(v));
+    }
+  }]);
+  return PlaceHolderBuilder;
+}();
+/**
+ * Creates a ConfigurableBuilder based on an ExtensionForwarder.
+ */
+function createForwarderBuilder() {
+  return new ConfigurableBuilder(new ExtensionForwarder());
+}
+
+/**
+ * Creates a ConfigurableBuilder based on a Facet.
+ */
+function createConfigurableBuilder(facet) {
+  return new ConfigurableBuilder(new FacetWrapper(facet));
+}
+
+/**
+ * Creates a ConditionalBuilder from two extensions.
+ */
+function createConditionalBuilder(truthy) {
+  var falsy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  return new ConfigurableBuilder(new ConditionalExtension(truthy, falsy));
+}
+
+/**
+ * Creates a ConditionalBuilder based on two extensions and a
+ * conditional function.
+ */
+function createGenConditionalBuilder(fn, truthy) {
+  var falsy = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  return new ConfigurableBuilder(new GenConditionalExtension(fn, truthy, falsy));
+}
+
+/**
+ * Creates a theme builder.
+ */
+function createThemeBuilder() {
+  return new ThemeBuilder();
+}
+
+/**
+ * Creates a theme builder.
+ */
+function createPlaceHolderBuilder() {
+  return new PlaceHolderBuilder();
+}
+
+/**
+ * Editor configuration: provides APIs to get and reconfigure CodeMirror 6
+ * extensions from option names. Also allows to register new themes and
+ * inject ne extensions in already configured editor instances.
+ */
+export var EditorConfiguration = /*#__PURE__*/function () {
+  function EditorConfiguration(options) {
+    var _options$config;
+    _classCallCheck(this, EditorConfiguration);
+    // Order does not matter
+    this._configurableBuilderMap = new Map([['tabSize', createConfigurableBuilder(EditorState.tabSize)], ['readOnly', createConfigurableBuilder(EditorState.readOnly)], ['editable', createConfigurableBuilder(EditorView.editable)], ['keymap', createConfigurableBuilder(keymap)], ['indentUnit', createConfigurableBuilder(indentUnit)], ['smartIndent', createConditionalBuilder(indentOnInput())], ['autoClosingBrackets', createConditionalBuilder(closeBrackets())], ['matchBrackets', createConditionalBuilder(bracketMatching())], ['styleActiveLine', createConditionalBuilder(highlightActiveLine())], ['lineNumbers', createConditionalBuilder(lineNumbers())], ['lineWrap', createGenConditionalBuilder(function (a) {
+      return a !== 'off';
+    }, EditorView.lineWrapping)], ['language', createForwarderBuilder()], ['theme', createThemeBuilder()],
+    // addtional
+    ['highlightActiveLineGutter', createConditionalBuilder(highlightActiveLineGutter())], ['highlightSpecialChars', createConditionalBuilder(highlightSpecialChars())], ['history', createConditionalBuilder(history())], ['drawSelection', createConditionalBuilder(drawSelection())], ['dropCursor', createConditionalBuilder(dropCursor())], ['allowMultipleSelections', createConfigurableBuilder(EditorState.allowMultipleSelections)], ['autocompletion', createConditionalBuilder(autocompletion({
+      activateOnTyping: ((_options$config = options.config) === null || _options$config === void 0 ? void 0 : _options$config.lspCompletion) === true
+    }))], ['rectangularSelection', createConditionalBuilder(rectangularSelection())], ['crosshairCursor', createConditionalBuilder(crosshairCursor())], ['highlightSelectionMatches', createConditionalBuilder(highlightSelectionMatches())], ['foldGutter', createConditionalBuilder(foldGutter({
+      markerDOM: function markerDOM(open) {
+        if (open) {
+          var iconElement = document.createElement('div');
+          iconElement.innerHTML = FoldIcon;
+          iconElement.style.display = 'flex';
+          iconElement.style.cursor = 'pointer';
+          return iconElement;
+        } else {
+          var _iconElement = document.createElement('div');
+          _iconElement.innerHTML = UnFoldIcon;
+          _iconElement.style.cursor = 'pointer';
+          return _iconElement;
+        }
+      }
+    }))], ['syntaxHighlighting', createConditionalBuilder(syntaxHighlighting(defaultHighlightStyle, {
+      fallback: true
+    }))], ['jupyterKernelCompletion', createConditionalBuilder(pythonLanguage.data.of({
+      autocomplete: kernelCompletions(options.completionProvider)
+    }))], ['jupyterKernelTooltip', createConditionalBuilder(tabTooltip(options.tooltipProvider))], ['indentationMarkers', createConditionalBuilder(indentationMarkers())], ['hyperLink', createConditionalBuilder(hyperLink)], ['placeholder', createPlaceHolderBuilder()], ['lspTooltip', createConditionalBuilder(lspTooltip({
+      lspProvider: options.lspProvider
+    }))], ['lspLint', createConditionalBuilder(lspLint({
+      lspProvider: options.lspProvider
+    }))], ['lspCompletion', createConditionalBuilder(lspPythonCompletion({
+      lspProvider: options.lspProvider
+    }))]]);
+    this._themeOverloaderSpec = {
+      '&': {},
+      '.cm-line': {}
+    };
+    this._themeOverloader = new Compartment();
+  }
+
+  /**
+   * Reconfigures the extension mapped with key with the provided value.
+   */
+  _createClass(EditorConfiguration, [{
+    key: "reconfigureExtension",
+    value: function reconfigureExtension(view, key, value) {
+      var builder = this.get(key);
+      if (builder) {
+        view.dispatch({
+          effects: builder.reconfigure(value)
+        });
+      } else {
+        var config = {};
+        config[key] = value;
+        var themeOverload = this.updateThemeOverload(config);
+        view.dispatch({
+          effects: this._themeOverloader.reconfigure(themeOverload)
+        });
+      }
+    }
+
+    /**
+     * Reconfigures all the extensions mapped with the options from the
+     * provided partial configuration.
+     */
+  }, {
+    key: "reconfigureExtensions",
+    value: function reconfigureExtensions(view, config) {
+      var eff = [];
+      for (var _i = 0, _Object$entries = Object.entries(config); _i < _Object$entries.length; _i++) {
+        var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+          key = _Object$entries$_i[0],
+          _value = _Object$entries$_i[1];
+        var builder = this.get(key);
+        if (builder) {
+          eff.push(builder.reconfigure(_value));
+        }
+      }
+      var themeOverload = this.updateThemeOverload(config);
+      eff.push(this._themeOverloader.reconfigure(themeOverload));
+      view.dispatch({
+        effects: eff
+      });
+    }
+
+    /**
+     * Appends extensions to the top-level configuration of the
+     * editor.
+     */
+  }, {
+    key: "injectExtension",
+    value: function injectExtension(view, ext) {
+      view.dispatch({
+        effects: StateEffect.appendConfig.of(ext)
+      });
+    }
+
+    /**
+     * Returns the list of initial extensions of an editor
+     * based on the provided configuration.
+     */
+  }, {
+    key: "getInitialExtensions",
+    value: function getInitialExtensions(config) {
+      var _config$mimetype,
+        _this4 = this;
+      var keys = Object.keys(config).filter(function (v) {
+        return v !== 'insertSpaces' && v !== 'extraKeys';
+      });
+      var extensions = [];
+      var _iterator = _createForOfIteratorHelper(keys),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var k = _step.value;
+          var _builder = this.get(k);
+          if (_builder) {
+            var _value2 = config[k];
+            extensions.push(_builder.of(_value2));
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      var libroDefaultKeymap = defaultKeymap.filter(function (item) {
+        return item.key !== 'Mod-Enter';
+      });
+      if (!config.theme) {
+        extensions.push(defaultTheme());
+      }
+      var builder = this.get('keymap');
+      var initialKeymap = [].concat(_toConsumableArray(libroDefaultKeymap), _toConsumableArray(closeBracketsKeymap), _toConsumableArray(historyKeymap), _toConsumableArray(foldKeymap), _toConsumableArray(completionKeymap), _toConsumableArray(lintKeymap), _toConsumableArray(tooltipKeymap), _toConsumableArray(formatKeymap));
+      var keymapExt = builder.of(config.extraKeys ? [initialKeymap].concat(_toConsumableArray(config.extraKeys)) : _toConsumableArray(initialKeymap));
+      var indentBuilder = this.get('indentUnit');
+      var insertExt = indentBuilder.of(config.insertSpaces ? ' '.repeat(config.tabSize) : '\t');
+      var themeOverload = this.updateThemeOverload(config);
+      extensions.push(this._themeOverloader.of(themeOverload), insertExt, keymapExt);
+      ensure((_config$mimetype = config === null || config === void 0 ? void 0 : config.mimetype) !== null && _config$mimetype !== void 0 ? _config$mimetype : 'text/x-python').then(function (spec) {
+        if (spec) {
+          var _this4$get;
+          extensions.push((_this4$get = _this4.get('language')) === null || _this4$get === void 0 ? void 0 : _this4$get.of(spec.support));
+        }
+        return undefined;
+      }).catch(function (error) {
+        console.error('Could not load language parser:');
+        console.error(error);
+      });
+      return extensions;
+    }
+  }, {
+    key: "updateThemeOverload",
+    value: function updateThemeOverload(config) {
+      var fontFamily = config.fontFamily,
+        fontSize = config.fontSize,
+        lineHeight = config.lineHeight,
+        lineWrap = config.lineWrap,
+        wordWrapColumn = config.wordWrapColumn;
+      var needUpdate = false;
+      var parentStyle = {};
+      if (fontSize) {
+        parentStyle['fontSize'] = fontSize + 'px';
+        needUpdate = true;
+      }
+      if (fontFamily) {
+        parentStyle['fontFamily'] = fontFamily;
+        needUpdate = true;
+      }
+      if (lineHeight) {
+        parentStyle['lineHeight'] = lineHeight.toString();
+        needUpdate = true;
+      }
+      var lineStyle = {};
+      if (lineWrap === 'wordWrapColumn') {
+        lineStyle['width'] = wordWrapColumn + 'ch';
+        needUpdate = true;
+      } else if (lineWrap === 'bounded') {
+        lineStyle['maxWidth'] = wordWrapColumn + 'ch';
+        needUpdate = true;
+      }
+      if (needUpdate) {
+        var newThemeSpec = {
+          '&': parentStyle,
+          '.cm-line': lineStyle
+        };
+        this._themeOverloaderSpec = _objectSpread(_objectSpread({}, this._themeOverloaderSpec), newThemeSpec);
+      }
+      return EditorView.theme(this._themeOverloaderSpec);
+    }
+  }, {
+    key: "get",
+    value: function get(key) {
+      return this._configurableBuilderMap.get(key);
+    }
+  }]);
+  return EditorConfiguration;
+}();