@difizen/libro-codemirror 0.0.2-alpha.0

package/es/auto-complete/state.js

@@ -0,0 +1,452 @@
+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 _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 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 _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); }
+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 _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; }
+/* eslint-disable @typescript-eslint/no-this-alias */
+/* eslint-disable @typescript-eslint/no-use-before-define */
+/* eslint-disable @typescript-eslint/no-parameter-properties */
+/* eslint-disable @typescript-eslint/parameter-properties */
+/* eslint-disable prefer-const */
+
+import { StateField, StateEffect } from '@codemirror/state';
+import { EditorView, showTooltip } from '@codemirror/view';
+import { Option, cur, asSource, ensureAnchor, CompletionContext } from "./completion.js";
+import { completionConfig } from "./config.js";
+import { FuzzyMatcher } from "./filter.js";
+import { completionTooltip } from "./tooltip.js";
+
+// Used to pick a preferred option when two options with the same
+// label occur in the result.
+function score(option) {
+  return (option.boost || 0) * 100 + (option.apply ? 10 : 0) + (option.info ? 5 : 0) + (option.type ? 1 : 0);
+}
+function sortOptions(active, state) {
+  var options = [],
+    i = 0;
+  var _iterator = _createForOfIteratorHelper(active),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var a = _step.value;
+      if (a.hasResult()) {
+        if (a.result.filter === false) {
+          var getMatch = a.result.getMatch;
+          var _iterator3 = _createForOfIteratorHelper(a.result.options),
+            _step3;
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              var option = _step3.value;
+              var match = [1e9 - i++];
+              if (getMatch) {
+                var _iterator4 = _createForOfIteratorHelper(getMatch(option)),
+                  _step4;
+                try {
+                  for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+                    var n = _step4.value;
+                    match.push(n);
+                  }
+                } catch (err) {
+                  _iterator4.e(err);
+                } finally {
+                  _iterator4.f();
+                }
+              }
+              options.push(new Option(option, a, match));
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+        } else {
+          var matcher = new FuzzyMatcher(state.sliceDoc(a.from, a.to)),
+            _match = void 0;
+          var _iterator5 = _createForOfIteratorHelper(a.result.options),
+            _step5;
+          try {
+            for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+              var _option = _step5.value;
+              if (_match = matcher.match(_option.label)) {
+                if (_option.boost !== undefined) {
+                  _match[0] += _option.boost;
+                }
+                options.push(new Option(_option, a, _match));
+              }
+            }
+          } catch (err) {
+            _iterator5.e(err);
+          } finally {
+            _iterator5.f();
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var result = [],
+    prev = null;
+  var compare = state.facet(completionConfig).compareCompletions;
+  var _iterator2 = _createForOfIteratorHelper(options.sort(function (a, b) {
+      return b.match[0] - a.match[0] || compare(a.completion, b.completion);
+    })),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var opt = _step2.value;
+      if (!prev || prev.label !== opt.completion.label || prev.detail !== opt.completion.detail || prev.type !== null && opt.completion.type !== null && prev.type !== opt.completion.type || prev.apply !== opt.completion.apply) {
+        result.push(opt);
+      } else if (score(opt.completion) > score(prev)) {
+        result[result.length - 1] = opt;
+      }
+      prev = opt.completion;
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return result;
+}
+var CompletionDialog = /*#__PURE__*/function () {
+  function CompletionDialog(options, attrs, tooltip, timestamp, selected) {
+    _classCallCheck(this, CompletionDialog);
+    this.options = options;
+    this.attrs = attrs;
+    this.tooltip = tooltip;
+    this.timestamp = timestamp;
+    this.selected = selected;
+  }
+  _createClass(CompletionDialog, [{
+    key: "setSelected",
+    value: function setSelected(selected, id) {
+      return selected === this.selected || selected >= this.options.length ? this : new CompletionDialog(this.options, makeAttrs(id, selected), this.tooltip, this.timestamp, selected);
+    }
+  }, {
+    key: "map",
+    value: function map(changes) {
+      return new CompletionDialog(this.options, this.attrs, _objectSpread(_objectSpread({}, this.tooltip), {}, {
+        pos: changes.mapPos(this.tooltip.pos)
+      }), this.timestamp, this.selected);
+    }
+  }], [{
+    key: "build",
+    value: function build(active, state, id, prev, conf) {
+      var options = sortOptions(active, state);
+      if (!options.length) {
+        return null;
+      }
+      var selected = state.facet(completionConfig).selectOnOpen ? 0 : -1;
+      if (prev && prev.selected !== selected && prev.selected !== -1) {
+        var selectedValue = prev.options[prev.selected].completion;
+        for (var i = 0; i < options.length; i++) {
+          if (options[i].completion === selectedValue) {
+            selected = i;
+            break;
+          }
+        }
+      }
+      return new CompletionDialog(options, makeAttrs(id, selected), {
+        pos: active.reduce(function (a, b) {
+          return b.hasResult() ? Math.min(a, b.from) : a;
+        }, 1e8),
+        create: completionTooltip(completionState),
+        above: conf.aboveCursor
+      }, prev ? prev.timestamp : Date.now(), selected);
+    }
+  }]);
+  return CompletionDialog;
+}();
+export var CompletionState = /*#__PURE__*/function () {
+  function CompletionState(active, id, open) {
+    _classCallCheck(this, CompletionState);
+    this.active = active;
+    this.id = id;
+    this.open = open;
+  }
+  _createClass(CompletionState, [{
+    key: "update",
+    value: function update(tr) {
+      var _this = this;
+      var state = tr.state,
+        conf = state.facet(completionConfig);
+      var sources = conf.override || state.languageDataAt('autocomplete', cur(state)).map(asSource);
+      var active = sources.map(function (source) {
+        var value = _this.active.find(function (s) {
+          return s.source === source;
+        }) || new ActiveSource(source, _this.active.some(function (a) {
+          return a.state !== State.Inactive;
+        }) ? State.Pending : State.Inactive);
+        return value.update(tr, conf);
+      });
+      if (active.length === this.active.length && active.every(function (a, i) {
+        return a === _this.active[i];
+      })) {
+        active = this.active;
+      }
+      var open = tr.selection || active.some(function (a) {
+        return a.hasResult() && tr.changes.touchesRange(a.from, a.to);
+      }) || !sameResults(active, this.active) ? CompletionDialog.build(active, state, this.id, this.open, conf) : this.open && tr.docChanged ? this.open.map(tr.changes) : this.open;
+      if (!open && active.every(function (a) {
+        return a.state !== State.Pending;
+      }) && active.some(function (a) {
+        return a.hasResult();
+      })) {
+        active = active.map(function (a) {
+          return a.hasResult() ? new ActiveSource(a.source, State.Inactive) : a;
+        });
+      }
+      var _iterator6 = _createForOfIteratorHelper(tr.effects),
+        _step6;
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var effect = _step6.value;
+          if (effect.is(setSelectedEffect)) {
+            open = open && open.setSelected(effect.value, this.id);
+          }
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+      return active === this.active && open === this.open ? this : new CompletionState(active, this.id, open);
+    }
+  }, {
+    key: "tooltip",
+    get: function get() {
+      return this.open ? this.open.tooltip : null;
+    }
+  }, {
+    key: "attrs",
+    get: function get() {
+      return this.open ? this.open.attrs : baseAttrs;
+    }
+  }], [{
+    key: "start",
+    value: function start() {
+      return new CompletionState(none, 'cm-ac-' + Math.floor(Math.random() * 2e6).toString(36), null);
+    }
+  }]);
+  return CompletionState;
+}();
+function sameResults(a, b) {
+  if (a === b) {
+    return true;
+  }
+  for (var iA = 0, iB = 0;;) {
+    while (iA < a.length && !a[iA].hasResult) {
+      iA++;
+    }
+    while (iB < b.length && !b[iB].hasResult) {
+      iB++;
+    }
+    var endA = iA === a.length,
+      endB = iB === b.length;
+    if (endA || endB) {
+      return endA === endB;
+    }
+    if (a[iA++].result !== b[iB++].result) {
+      return false;
+    }
+  }
+}
+var baseAttrs = {
+  'aria-autocomplete': 'list'
+};
+function makeAttrs(id, selected) {
+  var result = {
+    'aria-autocomplete': 'list',
+    'aria-haspopup': 'listbox',
+    'aria-controls': id
+  };
+  if (selected > -1) {
+    result['aria-activedescendant'] = id + '-' + selected;
+  }
+  return result;
+}
+var none = [];
+export var State = /*#__PURE__*/function (State) {
+  State[State["Inactive"] = 0] = "Inactive";
+  State[State["Pending"] = 1] = "Pending";
+  State[State["Result"] = 2] = "Result";
+  return State;
+}({});
+export function getUserEvent(tr) {
+  return tr.isUserEvent('input.type') ? 'input' : tr.isUserEvent('delete.backward') ? 'delete' : null;
+}
+export var ActiveSource = /*#__PURE__*/function () {
+  function ActiveSource(source, state) {
+    var explicitPos = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+    _classCallCheck(this, ActiveSource);
+    this.source = source;
+    this.state = state;
+    this.explicitPos = explicitPos;
+  }
+  _createClass(ActiveSource, [{
+    key: "hasResult",
+    value: function hasResult() {
+      return false;
+    }
+  }, {
+    key: "update",
+    value: function update(tr, conf) {
+      var event = getUserEvent(tr),
+        value = this;
+      if (event) {
+        value = value.handleUserEvent(tr, event, conf);
+      } else if (tr.docChanged) {
+        value = value.handleChange(tr);
+      } else if (tr.selection && value.state !== State.Inactive) {
+        value = new ActiveSource(value.source, State.Inactive);
+      }
+      var _iterator7 = _createForOfIteratorHelper(tr.effects),
+        _step7;
+      try {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var effect = _step7.value;
+          if (effect.is(startCompletionEffect)) {
+            value = new ActiveSource(value.source, State.Pending, effect.value ? cur(tr.state) : -1);
+          } else if (effect.is(closeCompletionEffect)) {
+            value = new ActiveSource(value.source, State.Inactive);
+          } else if (effect.is(setActiveEffect)) {
+            var _iterator8 = _createForOfIteratorHelper(effect.value),
+              _step8;
+            try {
+              for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+                var _active = _step8.value;
+                if (_active.source === value.source) {
+                  value = _active;
+                }
+              }
+            } catch (err) {
+              _iterator8.e(err);
+            } finally {
+              _iterator8.f();
+            }
+          }
+        }
+      } catch (err) {
+        _iterator7.e(err);
+      } finally {
+        _iterator7.f();
+      }
+      return value;
+    }
+  }, {
+    key: "handleUserEvent",
+    value: function handleUserEvent(tr, type, conf) {
+      return type === 'delete' || !conf.activateOnTyping ? this.map(tr.changes) : new ActiveSource(this.source, State.Pending);
+    }
+  }, {
+    key: "handleChange",
+    value: function handleChange(tr) {
+      return tr.changes.touchesRange(cur(tr.startState)) ? new ActiveSource(this.source, State.Inactive) : this.map(tr.changes);
+    }
+  }, {
+    key: "map",
+    value: function map(changes) {
+      return changes.empty || this.explicitPos < 0 ? this : new ActiveSource(this.source, this.state, changes.mapPos(this.explicitPos));
+    }
+  }]);
+  return ActiveSource;
+}();
+export var ActiveResult = /*#__PURE__*/function (_ActiveSource) {
+  _inherits(ActiveResult, _ActiveSource);
+  var _super = _createSuper(ActiveResult);
+  function ActiveResult(source, explicitPos, result, from, to) {
+    var _this2;
+    _classCallCheck(this, ActiveResult);
+    _this2 = _super.call(this, source, State.Result, explicitPos);
+    _this2.result = result;
+    _this2.from = from;
+    _this2.to = to;
+    return _this2;
+  }
+  _createClass(ActiveResult, [{
+    key: "hasResult",
+    value: function hasResult() {
+      return true;
+    }
+  }, {
+    key: "handleUserEvent",
+    value: function handleUserEvent(tr, type, conf) {
+      var from = tr.changes.mapPos(this.from),
+        to = tr.changes.mapPos(this.to, 1);
+      var pos = cur(tr.state);
+      if ((this.explicitPos < 0 ? pos <= from : pos < this.from) || pos > to || type === 'delete' && cur(tr.startState) === this.from) {
+        return new ActiveSource(this.source, type === 'input' && conf.activateOnTyping ? State.Pending : State.Inactive);
+      }
+      var explicitPos = this.explicitPos < 0 ? -1 : tr.changes.mapPos(this.explicitPos),
+        updated;
+      if (checkValid(this.result.validFor, tr.state, from, to)) {
+        return new ActiveResult(this.source, explicitPos, this.result, from, to);
+      }
+      if (this.result.update && (updated = this.result.update(this.result, from, to, new CompletionContext(tr.state, pos, explicitPos >= 0)))) {
+        var _updated$to;
+        return new ActiveResult(this.source, explicitPos, updated, updated.from, (_updated$to = updated.to) !== null && _updated$to !== void 0 ? _updated$to : cur(tr.state));
+      }
+      return new ActiveSource(this.source, State.Pending, explicitPos);
+    }
+  }, {
+    key: "handleChange",
+    value: function handleChange(tr) {
+      return tr.changes.touchesRange(this.from, this.to) ? new ActiveSource(this.source, State.Inactive) : this.map(tr.changes);
+    }
+  }, {
+    key: "map",
+    value: function map(mapping) {
+      return mapping.empty ? this : new ActiveResult(this.source, this.explicitPos < 0 ? -1 : mapping.mapPos(this.explicitPos), this.result, mapping.mapPos(this.from), mapping.mapPos(this.to, 1));
+    }
+  }]);
+  return ActiveResult;
+}(ActiveSource);
+function checkValid(validFor, state, from, to) {
+  if (!validFor) {
+    return false;
+  }
+  var text = state.sliceDoc(from, to);
+  return typeof validFor === 'function' ? validFor(text, from, to, state) : ensureAnchor(validFor, true).test(text);
+}
+export var startCompletionEffect = StateEffect.define();
+export var closeCompletionEffect = StateEffect.define();
+export var setActiveEffect = StateEffect.define({
+  map: function map(sources, mapping) {
+    return sources.map(function (s) {
+      return s.map(mapping);
+    });
+  }
+});
+export var setSelectedEffect = StateEffect.define();
+export var completionState = StateField.define({
+  create: function create() {
+    return CompletionState.start();
+  },
+  update: function update(value, tr) {
+    return value.update(tr);
+  },
+  provide: function provide(f) {
+    return [showTooltip.from(f, function (val) {
+      return val.tooltip;
+    }), EditorView.contentAttributes.from(f, function (state) {
+      return state.attrs;
+    })];
+  }
+});

package/es/auto-complete/theme.d.ts

@@ -0,0 +1,6 @@
+export declare const enum Info {
+    Margin = 30,
+    Width = 400
+}
+export declare const baseTheme: import("@codemirror/state").Extension;
+//# sourceMappingURL=theme.d.ts.map

package/es/auto-complete/theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../src/auto-complete/theme.ts"],"names":[],"mappings":"AAEA,0BAAkB,IAAI;IACpB,MAAM,KAAK;IACX,KAAK,MAAM;CACZ;AAED,eAAO,MAAM,SAAS,uCAsHpB,CAAC"}

package/es/auto-complete/theme.js

@@ -0,0 +1,151 @@
+import { EditorView } from '@codemirror/view';
+export var Info = /*#__PURE__*/function (Info) {
+  Info[Info["Margin"] = 30] = "Margin";
+  Info[Info["Width"] = 400] = "Width";
+  return Info;
+}({});
+export var baseTheme = EditorView.baseTheme({
+  '.cm-tooltip.cm-tooltip-autocomplete': {
+    '& > ul': {
+      fontFamily: 'monospace',
+      whiteSpace: 'nowrap',
+      overflow: 'hidden auto',
+      maxWidth_fallback: '700px',
+      maxWidth: 'min(700px, 95vw)',
+      minWidth: '250px',
+      maxHeight: '10em',
+      listStyle: 'none',
+      margin: 0,
+      padding: 0,
+      '& > li': {
+        overflowX: 'hidden',
+        textOverflow: 'ellipsis',
+        cursor: 'pointer',
+        padding: '1px 3px',
+        lineHeight: 1.2
+      }
+    }
+  },
+  '&light .cm-tooltip-autocomplete ul li[aria-selected]': {
+    background: '#17c',
+    color: 'white'
+  },
+  '&dark .cm-tooltip-autocomplete ul li[aria-selected]': {
+    background: '#347',
+    color: 'white'
+  },
+  '.cm-completionListIncompleteTop:before, .cm-completionListIncompleteBottom:after': {
+    content: '"···"',
+    opacity: 0.5,
+    display: 'block',
+    textAlign: 'center'
+  },
+  '.cm-tooltip.cm-completionInfo': {
+    position: 'absolute',
+    padding: '3px 9px',
+    width: 'max-content',
+    maxWidth: "".concat(Info.Width, "px"),
+    boxSizing: 'border-box',
+    maxHeight: '500px',
+    overflow: 'auto'
+  },
+  '.cm-completionInfo.cm-completionInfo-left': {
+    right: '100%'
+  },
+  '.cm-completionInfo.cm-completionInfo-right': {
+    left: '100%'
+  },
+  '.cm-completionInfo.cm-completionInfo-left-narrow': {
+    right: "".concat(Info.Margin, "px")
+  },
+  '.cm-completionInfo.cm-completionInfo-right-narrow': {
+    left: "".concat(Info.Margin, "px")
+  },
+  '&light .cm-snippetField': {
+    backgroundColor: '#00000022'
+  },
+  '&dark .cm-snippetField': {
+    backgroundColor: '#ffffff22'
+  },
+  '.cm-snippetFieldPosition': {
+    verticalAlign: 'text-top',
+    width: 0,
+    height: '1.15em',
+    display: 'inline-block',
+    margin: '0 -0.7px -.7em',
+    borderLeft: '1.4px dotted #888'
+  },
+  '.cm-completionMatchedText': {
+    textDecoration: 'underline'
+  },
+  '.cm-completionDetail': {
+    marginLeft: '0.5em',
+    fontStyle: 'italic'
+  },
+  '.cm-completionIcon': {
+    fontSize: '90%',
+    width: '.8em',
+    display: 'inline-block',
+    textAlign: 'center',
+    paddingRight: '.6em',
+    opacity: '0.6'
+  },
+  '.cm-completionIcon-function, .cm-completionIcon-method': {
+    '&:after': {
+      content: "'ƒ'"
+    }
+  },
+  '.cm-completionIcon-class': {
+    '&:after': {
+      content: "'○'"
+    }
+  },
+  '.cm-completionIcon-interface': {
+    '&:after': {
+      content: "'◌'"
+    }
+  },
+  '.cm-completionIcon-variable': {
+    '&:after': {
+      content: "'𝑥'"
+    }
+  },
+  '.cm-completionIcon-constant': {
+    '&:after': {
+      content: "'𝐶'"
+    }
+  },
+  '.cm-completionIcon-type': {
+    '&:after': {
+      content: "'𝑡'"
+    }
+  },
+  '.cm-completionIcon-enum': {
+    '&:after': {
+      content: "'∪'"
+    }
+  },
+  '.cm-completionIcon-property': {
+    '&:after': {
+      content: "'□'"
+    }
+  },
+  '.cm-completionIcon-keyword': {
+    '&:after': {
+      content: "'\uD83D\uDD11\uFE0E'"
+    } // Disable emoji rendering
+  },
+
+  '.cm-completionIcon-namespace': {
+    '&:after': {
+      content: "'▢'"
+    }
+  },
+  '.cm-completionIcon-text': {
+    '&:after': {
+      content: "'abc'",
+      fontSize: '50%',
+      verticalAlign: 'middle'
+    }
+  }
+});

package/es/auto-complete/tooltip.d.ts

@@ -0,0 +1,5 @@
+import type { StateField } from '@codemirror/state';
+import type { EditorView, TooltipView } from '@codemirror/view';
+import type { CompletionState } from './state.js';
+export declare function completionTooltip(stateField: StateField<CompletionState>): (view: EditorView) => TooltipView;
+//# sourceMappingURL=tooltip.d.ts.map

package/es/auto-complete/tooltip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooltip.d.ts","sourceRoot":"","sources":["../../src/auto-complete/tooltip.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAe,MAAM,mBAAmB,CAAC;AACjE,OAAO,KAAK,EAAE,UAAU,EAAc,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAO5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAyWlD,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,UAAU,CAAC,eAAe,CAAC,UACzD,UAAU,KAAG,WAAW,CACvC"}