@difizen/libro-codemirror 0.0.2-alpha.0

package/es/config.d.ts

@@ -0,0 +1,184 @@
+import type { Extension } 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;
+    /**
+     * The theme to style the editor with. see editortheme.ts for an example
+     * of how to design a theme for CodeMirror 6.
+     */
+    theme?: 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;
+}
+/**
+ * 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[];
+    private updateThemeOverload;
+    private get;
+    private _configurableBuilderMap;
+    private _themeOverloaderSpec;
+    private _themeOverloader;
+}
+//# 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":"AAcA,OAAO,KAAK,EAAE,SAAS,EAAS,MAAM,mBAAmB,CAAC;AAE1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAOL,UAAU,EAKX,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAShE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAQ5C;;GAEG;AACH,MAAM,WAAW,gBAAiB,SAAQ,aAAa;IACrD;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAKf;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,SAAS,CAAC,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC;IAEhC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;OAEG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAElC;;;;;OAKG;IACH,0BAA0B,CAAC,EAAE,OAAO,CAAC;IAErC;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAE9B;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B;;OAEG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;OAGG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAGpC,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;OAEG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC;;OAEG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;OAEG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,WAAW,CAAC,EAAE,WAAW,GAAG,MAAM,CAAC;CACpC;AA8MD;;;;GAIG;AACH,qBAAa,mBAAmB;gBAClB,OAAO,EAAE,QAAQ;IA+F7B;;OAEG;IACH,oBAAoB,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAgBtE;;;OAGG;IACH,qBAAqB,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,IAAI;IAiBhF;;;OAGG;IACH,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,SAAS,GAAG,IAAI;IAMvD;;;OAGG;IACH,oBAAoB,CAAC,MAAM,EAAE,gBAAgB,GAAG,SAAS,EAAE;IAyD3D,OAAO,CAAC,mBAAmB;IA4C3B,OAAO,CAAC,GAAG;IAIX,OAAO,CAAC,uBAAuB,CAAoC;IACnE,OAAO,CAAC,oBAAoB,CAAyC;IACrE,OAAO,CAAC,gBAAgB,CAAc;CACvC"}

package/es/config.js

@@ -0,0 +1,473 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+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(_e2) { throw _e2; }, 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(_e3) { didErr = true; err = _e3; }, 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(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+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(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+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(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { defaultKeymap, historyKeymap, history } 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, rectangularSelection, dropCursor, drawSelection, highlightSpecialChars, highlightActiveLineGutter, EditorView, highlightActiveLine, keymap, lineNumbers, placeholder } from '@codemirror/view';
+import { closeBrackets, closeBracketsKeymap, autocompletion, 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 { 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()]]);
+    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));
+      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;
+}();