@difizen/libro-codemirror 0.0.2-alpha.0

package/es/auto-complete/index.js

@@ -0,0 +1,107 @@
+/* eslint-disable @typescript-eslint/no-use-before-define */
+
+import { Prec } from '@codemirror/state';
+import { keymap } from '@codemirror/view';
+import { indentOrCompletion, indentOrTooltip } from "../indent.js";
+import { completionConfig } from "./config.js";
+import { completionState, State, setSelectedEffect } from "./state.js";
+import { baseTheme } from "./theme.js";
+import { completionPlugin, moveCompletionSelection, acceptCompletion, closeCompletion } from "./view.js";
+export * from "./snippet.js";
+export * from "./completion.js";
+export * from "./view.js";
+export * from "./word.js";
+export * from "./closebrackets.js";
+
+/// Returns an extension that enables autocompletion.
+export function autocompletion() {
+  var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return [completionState, completionConfig.of(config), completionPlugin, completionKeymapExt, baseTheme];
+}
+
+/// Basic keybindings for autocompletion.
+///
+///  - Ctrl-Space: [`startCompletion`](#autocomplete.startCompletion)
+///  - Escape: [`closeCompletion`](#autocomplete.closeCompletion)
+///  - ArrowDown: [`moveCompletionSelection`](#autocomplete.moveCompletionSelection)`(true)`
+///  - ArrowUp: [`moveCompletionSelection`](#autocomplete.moveCompletionSelection)`(false)`
+///  - PageDown: [`moveCompletionSelection`](#autocomplete.moveCompletionSelection)`(true, "page")`
+///  - PageDown: [`moveCompletionSelection`](#autocomplete.moveCompletionSelection)`(true, "page")`
+///  - Enter: [`acceptCompletion`](#autocomplete.acceptCompletion)
+export var completionKeymap = [{
+  key: 'Tab',
+  run: indentOrCompletion,
+  shift: indentOrTooltip
+}, {
+  key: 'Escape',
+  run: closeCompletion
+}, {
+  key: 'ArrowDown',
+  run: moveCompletionSelection(true)
+}, {
+  key: 'ArrowUp',
+  run: moveCompletionSelection(false)
+}, {
+  key: 'PageDown',
+  run: moveCompletionSelection(true, 'page')
+}, {
+  key: 'PageUp',
+  run: moveCompletionSelection(false, 'page')
+}, {
+  key: 'Enter',
+  run: acceptCompletion
+}];
+var completionKeymapExt = Prec.highest(keymap.computeN([completionConfig], function (state) {
+  return state.facet(completionConfig).defaultKeymap ? [completionKeymap] : [];
+}));
+
+/// Get the current completion status. When completions are available,
+/// this will return `"active"`. When completions are pending (in the
+/// process of being queried), this returns `"pending"`. Otherwise, it
+/// returns `null`.
+export function completionStatus(state) {
+  var cState = state.field(completionState, false);
+  return cState && cState.active.some(function (a) {
+    return a.state === State.Pending;
+  }) ? 'pending' : cState && cState.active.some(function (a) {
+    return a.state !== State.Inactive;
+  }) ? 'active' : null;
+}
+var completionArrayCache = new WeakMap();
+
+/// Returns the available completions as an array.
+export function currentCompletions(state) {
+  var _state$field;
+  var open = (_state$field = state.field(completionState, false)) === null || _state$field === void 0 ? void 0 : _state$field.open;
+  if (!open) {
+    return [];
+  }
+  var completions = completionArrayCache.get(open.options);
+  if (!completions) {
+    completionArrayCache.set(open.options, completions = open.options.map(function (o) {
+      return o.completion;
+    }));
+  }
+  return completions;
+}
+
+/// Return the currently selected completion, if any.
+export function selectedCompletion(state) {
+  var _state$field2;
+  var open = (_state$field2 = state.field(completionState, false)) === null || _state$field2 === void 0 ? void 0 : _state$field2.open;
+  return open && open.selected >= 0 ? open.options[open.selected].completion : null;
+}
+
+/// Returns the currently selected position in the active completion
+/// list, or null if no completions are active.
+export function selectedCompletionIndex(state) {
+  var _state$field3;
+  var open = (_state$field3 = state.field(completionState, false)) === null || _state$field3 === void 0 ? void 0 : _state$field3.open;
+  return open && open.selected >= 0 ? open.selected : null;
+}
+
+/// Create an effect that can be attached to a transaction to change
+/// the currently selected completion.
+export function setSelectedCompletion(index) {
+  return setSelectedEffect.of(index);
+}

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

@@ -0,0 +1,14 @@
+import type { EditorState, Transaction, StateCommand } from '@codemirror/state';
+import { Facet } from '@codemirror/state';
+import type { KeyBinding } from '@codemirror/view';
+import type { Completion } from './completion.js';
+export declare function snippet(template: string): (editor: {
+    state: EditorState;
+    dispatch: (tr: Transaction) => void;
+}, _completion: Completion, from: number, to: number) => void;
+export declare const clearSnippet: StateCommand;
+export declare const nextSnippetField: StateCommand;
+export declare const prevSnippetField: StateCommand;
+export declare const snippetKeymap: Facet<readonly KeyBinding[], readonly KeyBinding[]>;
+export declare function snippetCompletion(template: string, completion: Completion): Completion;
+//# sourceMappingURL=snippet.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"snippet.d.ts","sourceRoot":"","sources":["../../src/auto-complete/snippet.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAEV,WAAW,EACX,WAAW,EAEX,YAAY,EACb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAML,KAAK,EAEN,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAiB,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGlE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAmPlD,wBAAgB,OAAO,CAAC,QAAQ,EAAE,MAAM;WAGnB,WAAW;mBAAiB,WAAW,KAAK,IAAI;gBACpD,UAAU,QACjB,MAAM,MACR,MAAM,UA0Bb;AAqBD,eAAO,MAAM,YAAY,EAAE,YAO1B,CAAC;AAGF,eAAO,MAAM,gBAAgB,cAAe,CAAC;AAG7C,eAAO,MAAM,gBAAgB,cAAgB,CAAC;AAY9C,eAAO,MAAM,aAAa,qDAMzB,CAAC;AASF,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,UAAU,GACrB,UAAU,CAEZ"}

package/es/auto-complete/snippet.js

@@ -0,0 +1,447 @@
+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 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 _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 _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; }
+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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+/* eslint-disable @typescript-eslint/no-use-before-define */
+/* eslint-disable @typescript-eslint/no-shadow */
+/* eslint-disable prefer-const */
+/* eslint-disable no-param-reassign */
+/* eslint-disable @typescript-eslint/no-parameter-properties */
+/* eslint-disable @typescript-eslint/parameter-properties */
+import { indentUnit } from '@codemirror/language';
+import { StateField, StateEffect, EditorSelection, Text, Prec, Facet, MapMode } from '@codemirror/state';
+import { Decoration, WidgetType, EditorView, keymap } from '@codemirror/view';
+import { baseTheme } from "./theme.js";
+var FieldPos = /*#__PURE__*/_createClass(function FieldPos(field, line, from, to) {
+  _classCallCheck(this, FieldPos);
+  this.field = field;
+  this.line = line;
+  this.from = from;
+  this.to = to;
+});
+var FieldRange = /*#__PURE__*/function () {
+  function FieldRange(field, from, to) {
+    _classCallCheck(this, FieldRange);
+    this.field = field;
+    this.from = from;
+    this.to = to;
+  }
+  _createClass(FieldRange, [{
+    key: "map",
+    value: function map(changes) {
+      var from = changes.mapPos(this.from, -1, MapMode.TrackDel);
+      var to = changes.mapPos(this.to, 1, MapMode.TrackDel);
+      return from === null || to === null ? null : new FieldRange(this.field, from, to);
+    }
+  }]);
+  return FieldRange;
+}();
+var Snippet = /*#__PURE__*/function () {
+  function Snippet(lines, fieldPositions) {
+    _classCallCheck(this, Snippet);
+    this.lines = lines;
+    this.fieldPositions = fieldPositions;
+  }
+  _createClass(Snippet, [{
+    key: "instantiate",
+    value: function instantiate(state, pos) {
+      var text = [],
+        lineStart = [pos];
+      var lineObj = state.doc.lineAt(pos),
+        baseIndent = /^\s*/.exec(lineObj.text)[0];
+      var _iterator = _createForOfIteratorHelper(this.lines),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _line = _step.value;
+          if (text.length) {
+            var indent = baseIndent,
+              tabs = /^\t*/.exec(_line)[0].length;
+            for (var i = 0; i < tabs; i++) {
+              indent += state.facet(indentUnit);
+            }
+            lineStart.push(pos + indent.length - tabs);
+            _line = indent + _line.slice(tabs);
+          }
+          text.push(_line);
+          pos += _line.length + 1;
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      var ranges = this.fieldPositions.map(function (pos) {
+        return new FieldRange(pos.field, lineStart[pos.line] + pos.from, lineStart[pos.line] + pos.to);
+      });
+      return {
+        text: text,
+        ranges: ranges
+      };
+    }
+  }], [{
+    key: "parse",
+    value: function parse(template) {
+      var fields = [];
+      var lines = [],
+        positions = [],
+        m;
+      var _iterator2 = _createForOfIteratorHelper(template.split(/\r\n?|\n/)),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _line2 = _step2.value;
+          while (m = /[#$]\{(?:(\d+)(?::([^}]*))?|([^}]*))\}/.exec(_line2)) {
+            var seq = m[1] ? +m[1] : null,
+              name = m[2] || m[3] || '',
+              found = -1;
+            for (var i = 0; i < fields.length; i++) {
+              if (seq !== null ? fields[i].seq === seq : name ? fields[i].name === name : false) {
+                found = i;
+              }
+            }
+            if (found < 0) {
+              var _i = 0;
+              while (_i < fields.length && (seq === null || fields[_i].seq !== null && fields[_i].seq < seq)) {
+                _i++;
+              }
+              fields.splice(_i, 0, {
+                seq: seq,
+                name: name
+              });
+              found = _i;
+              var _iterator3 = _createForOfIteratorHelper(positions),
+                _step3;
+              try {
+                for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                  var pos = _step3.value;
+                  if (pos.field >= found) {
+                    pos.field++;
+                  }
+                }
+              } catch (err) {
+                _iterator3.e(err);
+              } finally {
+                _iterator3.f();
+              }
+            }
+            positions.push(new FieldPos(found, lines.length, m.index, m.index + name.length));
+            _line2 = _line2.slice(0, m.index) + name + _line2.slice(m.index + m[0].length);
+          }
+          for (var esc; esc = /([$#])\\{/.exec(_line2);) {
+            _line2 = _line2.slice(0, esc.index) + esc[1] + '{' + _line2.slice(esc.index + esc[0].length);
+            var _iterator4 = _createForOfIteratorHelper(positions),
+              _step4;
+            try {
+              for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+                var _pos = _step4.value;
+                if (_pos.line === lines.length && _pos.from > esc.index) {
+                  _pos.from--;
+                  _pos.to--;
+                }
+              }
+            } catch (err) {
+              _iterator4.e(err);
+            } finally {
+              _iterator4.f();
+            }
+          }
+          lines.push(_line2);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return new Snippet(lines, positions);
+    }
+  }]);
+  return Snippet;
+}();
+var fieldMarker = Decoration.widget({
+  widget: new ( /*#__PURE__*/function (_WidgetType) {
+    _inherits(_class, _WidgetType);
+    var _super = _createSuper(_class);
+    function _class() {
+      _classCallCheck(this, _class);
+      return _super.apply(this, arguments);
+    }
+    _createClass(_class, [{
+      key: "toDOM",
+      value: function toDOM() {
+        var span = document.createElement('span');
+        span.className = 'cm-snippetFieldPosition';
+        return span;
+      }
+    }, {
+      key: "ignoreEvent",
+      value: function ignoreEvent() {
+        return false;
+      }
+    }]);
+    return _class;
+  }(WidgetType))()
+});
+var fieldRange = Decoration.mark({
+  class: 'cm-snippetField'
+});
+var ActiveSnippet = /*#__PURE__*/function () {
+  function ActiveSnippet(ranges, active) {
+    _classCallCheck(this, ActiveSnippet);
+    this.ranges = ranges;
+    this.active = active;
+    this.deco = Decoration.set(ranges.map(function (r) {
+      return (r.from === r.to ? fieldMarker : fieldRange).range(r.from, r.to);
+    }));
+  }
+  _createClass(ActiveSnippet, [{
+    key: "map",
+    value: function map(changes) {
+      var ranges = [];
+      var _iterator5 = _createForOfIteratorHelper(this.ranges),
+        _step5;
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var r = _step5.value;
+          var mapped = r.map(changes);
+          if (!mapped) {
+            return null;
+          }
+          ranges.push(mapped);
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
+      return new ActiveSnippet(ranges, this.active);
+    }
+  }, {
+    key: "selectionInsideField",
+    value: function selectionInsideField(sel) {
+      var _this = this;
+      return sel.ranges.every(function (range) {
+        return _this.ranges.some(function (r) {
+          return r.field === _this.active && r.from <= range.from && r.to >= range.to;
+        });
+      });
+    }
+  }]);
+  return ActiveSnippet;
+}();
+var setActive = StateEffect.define({
+  map: function map(value, changes) {
+    return value && value.map(changes);
+  }
+});
+var moveToField = StateEffect.define();
+var snippetState = StateField.define({
+  create: function create() {
+    return null;
+  },
+  update: function update(value, tr) {
+    var _iterator6 = _createForOfIteratorHelper(tr.effects),
+      _step6;
+    try {
+      for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+        var effect = _step6.value;
+        if (effect.is(setActive)) {
+          return effect.value;
+        }
+        if (effect.is(moveToField) && value) {
+          return new ActiveSnippet(value.ranges, effect.value);
+        }
+      }
+    } catch (err) {
+      _iterator6.e(err);
+    } finally {
+      _iterator6.f();
+    }
+    if (value && tr.docChanged) {
+      value = value.map(tr.changes);
+    }
+    if (value && tr.selection && !value.selectionInsideField(tr.selection)) {
+      value = null;
+    }
+    return value;
+  },
+  provide: function provide(f) {
+    return EditorView.decorations.from(f, function (val) {
+      return val ? val.deco : Decoration.none;
+    });
+  }
+});
+function fieldSelection(ranges, field) {
+  return EditorSelection.create(ranges.filter(function (r) {
+    return r.field === field;
+  }).map(function (r) {
+    return EditorSelection.range(r.from, r.to);
+  }));
+}
+
+/// Convert a snippet template to a function that can
+/// [apply](#autocomplete.Completion.apply) it. Snippets are written
+/// using syntax like this:
+///
+///     "for (let ${index} = 0; ${index} < ${end}; ${index}++) {\n\t${}\n}"
+///
+/// Each `${}` placeholder (you may also use `#{}`) indicates a field
+/// that the user can fill in. Its name, if any, will be the default
+/// content for the field.
+///
+/// When the snippet is activated by calling the returned function,
+/// the code is inserted at the given position. Newlines in the
+/// template are indented by the indentation of the start line, plus
+/// one [indent unit](#language.indentUnit) per tab character after
+/// the newline.
+///
+/// On activation, (all instances of) the first field are selected.
+/// The user can move between fields with Tab and Shift-Tab as long as
+/// the fields are active. Moving to the last field or moving the
+/// cursor out of the current field deactivates the fields.
+///
+/// The order of fields defaults to textual order, but you can add
+/// numbers to placeholders (`${1}` or `${1:defaultText}`) to provide
+/// a custom order.
+///
+/// To include a literal `${` or `#{` in your template, put a
+/// backslash after the dollar or hash and before the brace (`$\\{`).
+/// This will be removed and the sequence will not be interpreted as a
+/// placeholder.
+export function snippet(template) {
+  var snippet = Snippet.parse(template);
+  return function (editor, _completion, from, to) {
+    var _snippet$instantiate = snippet.instantiate(editor.state, from),
+      text = _snippet$instantiate.text,
+      ranges = _snippet$instantiate.ranges;
+    var spec = {
+      changes: {
+        from: from,
+        to: to,
+        insert: Text.of(text)
+      },
+      scrollIntoView: true
+    };
+    if (ranges.length) {
+      spec.selection = fieldSelection(ranges, 0);
+    }
+    if (ranges.length > 1) {
+      var _active = new ActiveSnippet(ranges, 0);
+      var effects = spec.effects = [setActive.of(_active)];
+      if (editor.state.field(snippetState, false) === undefined) {
+        effects.push(StateEffect.appendConfig.of([snippetState, addSnippetKeymap, snippetPointerHandler, baseTheme]));
+      }
+    }
+    editor.dispatch(editor.state.update(spec));
+  };
+}
+function moveField(dir) {
+  return function (_ref) {
+    var state = _ref.state,
+      dispatch = _ref.dispatch;
+    var active = state.field(snippetState, false);
+    if (!active || dir < 0 && active.active === 0) {
+      return false;
+    }
+    var next = active.active + dir,
+      last = dir > 0 && !active.ranges.some(function (r) {
+        return r.field === next + dir;
+      });
+    dispatch(state.update({
+      selection: fieldSelection(active.ranges, next),
+      effects: setActive.of(last ? null : new ActiveSnippet(active.ranges, next))
+    }));
+    return true;
+  };
+}
+
+/// A command that clears the active snippet, if any.
+export var clearSnippet = function clearSnippet(_ref2) {
+  var state = _ref2.state,
+    dispatch = _ref2.dispatch;
+  var active = state.field(snippetState, false);
+  if (!active) {
+    return false;
+  }
+  dispatch(state.update({
+    effects: setActive.of(null)
+  }));
+  return true;
+};
+
+/// Move to the next snippet field, if available.
+export var nextSnippetField = moveField(1);
+
+/// Move to the previous snippet field, if available.
+export var prevSnippetField = moveField(-1);
+var defaultSnippetKeymap = [{
+  key: 'Tab',
+  run: nextSnippetField,
+  shift: prevSnippetField
+}, {
+  key: 'Escape',
+  run: clearSnippet
+}];
+
+/// A facet that can be used to configure the key bindings used by
+/// snippets. The default binds Tab to
+/// [`nextSnippetField`](#autocomplete.nextSnippetField), Shift-Tab to
+/// [`prevSnippetField`](#autocomplete.prevSnippetField), and Escape
+/// to [`clearSnippet`](#autocomplete.clearSnippet).
+export var snippetKeymap = Facet.define({
+  combine: function combine(maps) {
+    return maps.length ? maps[0] : defaultSnippetKeymap;
+  }
+});
+var addSnippetKeymap = Prec.highest(keymap.compute([snippetKeymap], function (state) {
+  return state.facet(snippetKeymap);
+}));
+
+/// Create a completion from a snippet. Returns an object with the
+/// properties from `completion`, plus an `apply` function that
+/// applies the snippet.
+export function snippetCompletion(template, completion) {
+  return _objectSpread(_objectSpread({}, completion), {}, {
+    apply: snippet(template)
+  });
+}
+var snippetPointerHandler = EditorView.domEventHandlers({
+  mousedown: function mousedown(event, view) {
+    var active = view.state.field(snippetState, false),
+      pos;
+    if (!active || (pos = view.posAtCoords({
+      x: event.clientX,
+      y: event.clientY
+    })) === null) {
+      return false;
+    }
+    var match = active.ranges.find(function (r) {
+      return r.from <= pos && r.to >= pos;
+    });
+    if (!match || match.field === active.active) {
+      return false;
+    }
+    view.dispatch({
+      selection: fieldSelection(active.ranges, match.field),
+      effects: setActive.of(active.ranges.some(function (r) {
+        return r.field > match.field;
+      }) ? new ActiveSnippet(active.ranges, match.field) : null)
+    });
+    return true;
+  }
+});

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

@@ -0,0 +1,63 @@
+import type { Transaction, EditorState, ChangeDesc } from '@codemirror/state';
+import { StateField } from '@codemirror/state';
+import type { Tooltip } from '@codemirror/view';
+import type { CompletionSource, CompletionResult } from './completion.js';
+import { Option } from './completion.js';
+import type { CompletionConfig } from './config.js';
+declare class CompletionDialog {
+    readonly options: readonly Option[];
+    readonly attrs: Record<string, string>;
+    readonly tooltip: Tooltip;
+    readonly timestamp: number;
+    readonly selected: number;
+    constructor(options: readonly Option[], attrs: Record<string, string>, tooltip: Tooltip, timestamp: number, selected: number);
+    setSelected(selected: number, id: string): CompletionDialog;
+    static build(active: readonly ActiveSource[], state: EditorState, id: string, prev: CompletionDialog | null, conf: Required<CompletionConfig>): CompletionDialog | null;
+    map(changes: ChangeDesc): CompletionDialog;
+}
+export declare class CompletionState {
+    readonly active: readonly ActiveSource[];
+    readonly id: string;
+    readonly open: CompletionDialog | null;
+    constructor(active: readonly ActiveSource[], id: string, open: CompletionDialog | null);
+    static start(): CompletionState;
+    update(tr: Transaction): CompletionState;
+    get tooltip(): Tooltip | null;
+    get attrs(): Record<string, string> | {
+        'aria-autocomplete': string;
+    };
+}
+export declare const enum State {
+    Inactive = 0,
+    Pending = 1,
+    Result = 2
+}
+export declare function getUserEvent(tr: Transaction): 'input' | 'delete' | null;
+export declare class ActiveSource {
+    readonly source: CompletionSource;
+    readonly state: State;
+    readonly explicitPos: number;
+    constructor(source: CompletionSource, state: State, explicitPos?: number);
+    hasResult(): this is ActiveResult;
+    update(tr: Transaction, conf: Required<CompletionConfig>): ActiveSource;
+    handleUserEvent(tr: Transaction, type: 'input' | 'delete', conf: Required<CompletionConfig>): ActiveSource;
+    handleChange(tr: Transaction): ActiveSource;
+    map(changes: ChangeDesc): ActiveSource;
+}
+export declare class ActiveResult extends ActiveSource {
+    readonly result: CompletionResult;
+    readonly from: number;
+    readonly to: number;
+    constructor(source: CompletionSource, explicitPos: number, result: CompletionResult, from: number, to: number);
+    hasResult(): this is ActiveResult;
+    handleUserEvent(tr: Transaction, type: 'input' | 'delete', conf: Required<CompletionConfig>): ActiveSource;
+    handleChange(tr: Transaction): ActiveSource;
+    map(mapping: ChangeDesc): ActiveResult;
+}
+export declare const startCompletionEffect: import("@codemirror/state").StateEffectType<boolean>;
+export declare const closeCompletionEffect: import("@codemirror/state").StateEffectType<null>;
+export declare const setActiveEffect: import("@codemirror/state").StateEffectType<readonly ActiveSource[]>;
+export declare const setSelectedEffect: import("@codemirror/state").StateEffectType<number>;
+export declare const completionState: StateField<CompletionState>;
+export {};
+//# sourceMappingURL=state.d.ts.map

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

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