@difizen/libro-codemirror 0.0.2-alpha.0

package/es/auto-complete/completion.js

@@ -0,0 +1,265 @@
+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 _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 _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 _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 _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 _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); }
+/* eslint-disable @typescript-eslint/no-parameter-properties */
+/* eslint-disable @typescript-eslint/parameter-properties */
+import { syntaxTree } from '@codemirror/language';
+import { Annotation, EditorSelection } from '@codemirror/state';
+
+/// Objects type used to represent individual completions.
+
+/// An instance of this is passed to completion source functions.
+export var CompletionContext = /*#__PURE__*/function () {
+  /// Create a new completion context. (Mostly useful for testing
+  /// completion sources—in the editor, the extension will create
+  /// these for you.)
+  function CompletionContext(
+  /// The editor state that the completion happens in.
+  state,
+  /// The position at which the completion is happening.
+  pos,
+  /// Indicates whether completion was activated explicitly, or
+  /// implicitly by typing. The usual way to respond to this is to
+  /// only return completions when either there is part of a
+  /// completable entity before the cursor, or `explicit` is true.
+  explicit) {
+    _classCallCheck(this, CompletionContext);
+    this.state = state;
+    this.pos = pos;
+    this.explicit = explicit;
+    /// @internal
+    this.abortListeners = [];
+  }
+
+  /// Get the extent, content, and (if there is a token) type of the
+  /// token before `this.pos`.
+  _createClass(CompletionContext, [{
+    key: "tokenBefore",
+    value: function tokenBefore(types) {
+      var token = syntaxTree(this.state).resolveInner(this.pos, -1);
+      while (token && types.indexOf(token.name) < 0) {
+        token = token.parent;
+      }
+      return token ? {
+        from: token.from,
+        to: this.pos,
+        text: this.state.sliceDoc(token.from, this.pos),
+        type: token.type
+      } : null;
+    }
+
+    /// Get the match of the given expression directly before the
+    /// cursor.
+  }, {
+    key: "matchBefore",
+    value: function matchBefore(expr) {
+      var line = this.state.doc.lineAt(this.pos);
+      var start = Math.max(line.from, this.pos - 250);
+      var str = line.text.slice(start - line.from, this.pos - line.from);
+      var found = str.search(ensureAnchor(expr, false));
+      return found < 0 ? null : {
+        from: start + found,
+        to: this.pos,
+        text: str.slice(found)
+      };
+    }
+
+    /// Yields true when the query has been aborted. Can be useful in
+    /// asynchronous queries to avoid doing work that will be ignored.
+  }, {
+    key: "aborted",
+    get: function get() {
+      return this.abortListeners === null;
+    }
+
+    /// Allows you to register abort handlers, which will be called when
+    /// the query is
+    /// [aborted](#autocomplete.CompletionContext.aborted).
+  }, {
+    key: "addEventListener",
+    value: function addEventListener(type, listener) {
+      if (type === 'abort' && this.abortListeners) {
+        this.abortListeners.push(listener);
+      }
+    }
+  }]);
+  return CompletionContext;
+}();
+function toSet(chars) {
+  var flat = Object.keys(chars).join('');
+  var words = /\w/.test(flat);
+  if (words) {
+    flat = flat.replace(/\w/g, '');
+  }
+  return "[".concat(words ? '\\w' : '').concat(flat.replace(/[^\w\s]/g, '\\$&'), "]");
+}
+function prefixMatch(options) {
+  var first = Object.create(null),
+    rest = Object.create(null);
+  var _iterator = _createForOfIteratorHelper(options),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var label = _step.value.label;
+      first[label[0]] = true;
+      for (var i = 1; i < label.length; i++) {
+        rest[label[i]] = true;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var source = toSet(first) + toSet(rest) + '*$';
+  return [new RegExp('^' + source), new RegExp(source)];
+}
+
+/// Given a a fixed array of options, return an autocompleter that
+/// completes them.
+export function completeFromList(list) {
+  var options = list.map(function (o) {
+    return typeof o === 'string' ? {
+      label: o
+    } : o;
+  });
+  var _ref = options.every(function (o) {
+      return /^\w+$/.test(o.label);
+    }) ? [/\w*$/, /\w+$/] : prefixMatch(options),
+    _ref2 = _slicedToArray(_ref, 2),
+    validFor = _ref2[0],
+    match = _ref2[1];
+  return function (context) {
+    var token = context.matchBefore(match);
+    return token || context.explicit ? {
+      from: token ? token.from : context.pos,
+      options: options,
+      validFor: validFor
+    } : null;
+  };
+}
+
+/// Wrap the given completion source so that it will only fire when the
+/// cursor is in a syntax node with one of the given names.
+export function ifIn(nodes, source) {
+  return function (context) {
+    for (var _pos = syntaxTree(context.state).resolveInner(context.pos, -1); _pos; _pos = _pos.parent) {
+      if (nodes.indexOf(_pos.name) > -1) {
+        return source(context);
+      }
+    }
+    return null;
+  };
+}
+
+/// Wrap the given completion source so that it will not fire when the
+/// cursor is in a syntax node with one of the given names.
+export function ifNotIn(nodes, source) {
+  return function (context) {
+    for (var _pos2 = syntaxTree(context.state).resolveInner(context.pos, -1); _pos2; _pos2 = _pos2.parent) {
+      if (nodes.indexOf(_pos2.name) > -1) {
+        return null;
+      }
+    }
+    return source(context);
+  };
+}
+
+/// The function signature for a completion source. Such a function
+/// may return its [result](#autocomplete.CompletionResult)
+/// synchronously or as a promise. Returning null indicates no
+/// completions are available.
+/// Interface for objects returned by completion sources.
+export var Option = /*#__PURE__*/_createClass(function Option(completion, source, match) {
+  _classCallCheck(this, Option);
+  this.completion = completion;
+  this.source = source;
+  this.match = match;
+});
+export function cur(state) {
+  return state.selection.main.head;
+}
+
+// Make sure the given regexp has a $ at its end and, if `start` is
+// true, a ^ at its start.
+export function ensureAnchor(expr, start) {
+  var _expr$flags;
+  var source = expr.source;
+  var addStart = start && source[0] !== '^',
+    addEnd = source[source.length - 1] !== '$';
+  if (!addStart && !addEnd) {
+    return expr;
+  }
+  return new RegExp("".concat(addStart ? '^' : '', "(?:").concat(source, ")").concat(addEnd ? '$' : ''), (_expr$flags = expr.flags) !== null && _expr$flags !== void 0 ? _expr$flags : expr.ignoreCase ? 'i' : '');
+}
+
+/// This annotation is added to transactions that are produced by
+/// picking a completion.
+export var pickedCompletion = Annotation.define();
+
+/// Helper function that returns a transaction spec which inserts a
+/// completion's text in the main selection range, and any other
+/// selection range that has the same text in front of it.
+export function insertCompletionText(state, text, from, to) {
+  return _objectSpread(_objectSpread({}, state.changeByRange(function (range) {
+    if (range === state.selection.main) {
+      return {
+        changes: {
+          from: from,
+          to: to,
+          insert: text
+        },
+        range: EditorSelection.cursor(from + text.length)
+      };
+    }
+    var len = to - from;
+    if (!range.empty || len && state.sliceDoc(range.from - len, range.from) !== state.sliceDoc(from, to)) {
+      return {
+        range: range
+      };
+    }
+    return {
+      changes: {
+        from: range.from - len,
+        to: range.from,
+        insert: text
+      },
+      range: EditorSelection.cursor(range.from - len + text.length)
+    };
+  })), {}, {
+    userEvent: 'input.complete'
+  });
+}
+export function applyCompletion(view, option) {
+  var apply = option.completion.apply || option.completion.label;
+  var result = option.source;
+  if (typeof apply === 'string') {
+    view.dispatch(insertCompletionText(view.state, apply, result.from, result.to));
+  } else {
+    apply(view, option.completion, result.from, result.to);
+  }
+}
+var SourceCache = new WeakMap();
+export function asSource(source) {
+  if (!Array.isArray(source)) {
+    return source;
+  }
+  var known = SourceCache.get(source);
+  if (!known) {
+    SourceCache.set(source, known = completeFromList(source));
+  }
+  return known;
+}

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

@@ -0,0 +1,22 @@
+import type { EditorState } from '@codemirror/state';
+import { Facet } from '@codemirror/state';
+import type { Completion, CompletionSource } from './completion.js';
+export interface CompletionConfig {
+    activateOnTyping?: boolean;
+    selectOnOpen?: boolean;
+    override?: readonly CompletionSource[] | null;
+    closeOnBlur?: boolean;
+    maxRenderedOptions?: number;
+    defaultKeymap?: boolean;
+    aboveCursor?: boolean;
+    optionClass?: (completion: Completion) => string;
+    icons?: boolean;
+    addToOptions?: {
+        render: (completion: Completion, state: EditorState) => Node | null;
+        position: number;
+    }[];
+    compareCompletions?: (a: Completion, b: Completion) => number;
+    interactionDelay?: number;
+}
+export declare const completionConfig: Facet<CompletionConfig, Required<CompletionConfig>>;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/auto-complete/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,KAAK,EAAiB,MAAM,mBAAmB,CAAC;AAEzD,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,MAAM,WAAW,gBAAgB;IAG/B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAO3B,YAAY,CAAC,EAAE,OAAO,CAAC;IAMvB,QAAQ,CAAC,EAAE,SAAS,gBAAgB,EAAE,GAAG,IAAI,CAAC;IAG9C,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAM5B,aAAa,CAAC,EAAE,OAAO,CAAC;IAIxB,WAAW,CAAC,EAAE,OAAO,CAAC;IAGtB,WAAW,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,MAAM,CAAC;IAIjD,KAAK,CAAC,EAAE,OAAO,CAAC;IAQhB,YAAY,CAAC,EAAE;QACb,MAAM,EAAE,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,KAAK,IAAI,GAAG,IAAI,CAAC;QACpE,QAAQ,EAAE,MAAM,CAAC;KAClB,EAAE,CAAC;IAIJ,kBAAkB,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,KAAK,MAAM,CAAC;IAK9D,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,eAAO,MAAM,gBAAgB,qDA8B3B,CAAC"}

package/es/auto-complete/config.js

@@ -0,0 +1,44 @@
+import { Facet, combineConfig } from '@codemirror/state';
+export var completionConfig = Facet.define({
+  combine: function combine(configs) {
+    return combineConfig(configs, {
+      activateOnTyping: true,
+      selectOnOpen: true,
+      override: null,
+      closeOnBlur: true,
+      maxRenderedOptions: 100,
+      defaultKeymap: true,
+      optionClass: function optionClass() {
+        return '';
+      },
+      aboveCursor: false,
+      icons: true,
+      addToOptions: [],
+      compareCompletions: function compareCompletions(a, b) {
+        return a.label.localeCompare(b.label);
+      },
+      interactionDelay: 75
+    }, {
+      defaultKeymap: function defaultKeymap(a, b) {
+        return a && b;
+      },
+      closeOnBlur: function closeOnBlur(a, b) {
+        return a && b;
+      },
+      icons: function icons(a, b) {
+        return a && b;
+      },
+      optionClass: function optionClass(a, b) {
+        return function (c) {
+          return joinClass(a(c), b(c));
+        };
+      },
+      addToOptions: function addToOptions(a, b) {
+        return a.concat(b);
+      }
+    });
+  }
+});
+function joinClass(a, b) {
+  return a ? b ? a + ' ' + b : a : b;
+}

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

@@ -0,0 +1,13 @@
+export declare class FuzzyMatcher {
+    readonly pattern: string;
+    chars: number[];
+    folded: number[];
+    astral: boolean;
+    any: number[];
+    precise: number[];
+    byWord: number[];
+    constructor(pattern: string);
+    match(word: string): number[] | null;
+    result(score: number, positions: number[], word: string): number[];
+}
+//# sourceMappingURL=filter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/auto-complete/filter.ts"],"names":[],"mappings":"AAuBA,qBAAa,YAAY;IAWX,QAAQ,CAAC,OAAO,EAAE,MAAM;IAVpC,KAAK,EAAE,MAAM,EAAE,CAAM;IACrB,MAAM,EAAE,MAAM,EAAE,CAAM;IACtB,MAAM,EAAE,OAAO,CAAC;IAIhB,GAAG,EAAE,MAAM,EAAE,CAAM;IACnB,OAAO,EAAE,MAAM,EAAE,CAAM;IACvB,MAAM,EAAE,MAAM,EAAE,CAAM;gBAED,OAAO,EAAE,MAAM;IAoBpC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI;IAkJpC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM;CAcxD"}

package/es/auto-complete/filter.js

@@ -0,0 +1,191 @@
+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 _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 _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 _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); }
+/* eslint-disable prefer-const */
+/* eslint-disable @typescript-eslint/no-parameter-properties */
+/* eslint-disable @typescript-eslint/parameter-properties */
+import { codePointAt, codePointSize, fromCodePoint } from '@codemirror/state';
+
+// Scores are counted from 0 (great match) down to negative numbers,
+// assigning specific penalty values for specific shortcomings.
+var Penalty = /*#__PURE__*/function (Penalty) {
+  Penalty[Penalty["Gap"] = -1100] = "Gap";
+  Penalty[Penalty["NotStart"] = -700] = "NotStart";
+  Penalty[Penalty["CaseFold"] = -200] = "CaseFold";
+  Penalty[Penalty["ByWord"] = -100] = "ByWord";
+  return Penalty;
+}(Penalty || {}); // The match is by-word, meaning each char in the pattern matches the start of a word in the string
+var Tp = /*#__PURE__*/function (Tp) {
+  Tp[Tp["NonWord"] = 0] = "NonWord";
+  Tp[Tp["Upper"] = 1] = "Upper";
+  Tp[Tp["Lower"] = 2] = "Lower";
+  return Tp;
+}(Tp || {}); // A pattern matcher for fuzzy completion matching. Create an instance
+// once for a pattern, and then use that to match any number of
+// completions.
+export var FuzzyMatcher = /*#__PURE__*/function () {
+  function FuzzyMatcher(pattern) {
+    _classCallCheck(this, FuzzyMatcher);
+    this.pattern = pattern;
+    this.chars = [];
+    this.folded = [];
+    // Buffers reused by calls to `match` to track matched character
+    // positions.
+    this.any = [];
+    this.precise = [];
+    this.byWord = [];
+    for (var p = 0; p < pattern.length;) {
+      var char = codePointAt(pattern, p),
+        size = codePointSize(char);
+      this.chars.push(char);
+      var part = pattern.slice(p, p + size),
+        upper = part.toUpperCase();
+      this.folded.push(codePointAt(upper === part ? part.toLowerCase() : upper, 0));
+      p += size;
+    }
+    this.astral = pattern.length !== this.chars.length;
+  }
+
+  // Matches a given word (completion) against the pattern (input).
+  // Will return null for no match, and otherwise an array that starts
+  // with the match score, followed by any number of `from, to` pairs
+  // indicating the matched parts of `word`.
+  //
+  // The score is a number that is more negative the worse the match
+  // is. See `Penalty` above.
+  _createClass(FuzzyMatcher, [{
+    key: "match",
+    value: function match(word) {
+      if (this.pattern.length === 0) {
+        return [0];
+      }
+      if (word.length < this.pattern.length) {
+        return null;
+      }
+      var chars = this.chars,
+        folded = this.folded,
+        any = this.any,
+        precise = this.precise,
+        byWord = this.byWord;
+      // For single-character queries, only match when they occur right
+      // at the start
+      if (chars.length === 1) {
+        var first = codePointAt(word, 0);
+        return first === chars[0] ? [0, 0, codePointSize(first)] : first === folded[0] ? [Penalty.CaseFold, 0, codePointSize(first)] : null;
+      }
+      var direct = word.indexOf(this.pattern);
+      if (direct === 0) {
+        return [0, 0, this.pattern.length];
+      }
+      var len = chars.length,
+        anyTo = 0;
+      if (direct < 0) {
+        for (var i = 0, e = Math.min(word.length, 200); i < e && anyTo < len;) {
+          var next = codePointAt(word, i);
+          if (next === chars[anyTo] || next === folded[anyTo]) {
+            any[anyTo++] = i;
+          }
+          i += codePointSize(next);
+        }
+        // No match, exit immediately
+        if (anyTo < len) {
+          return null;
+        }
+      }
+
+      // This tracks the extent of the precise (non-folded, not
+      // necessarily adjacent) match
+      var preciseTo = 0;
+      // Tracks whether there is a match that hits only characters that
+      // appear to be starting words. `byWordFolded` is set to true when
+      // a case folded character is encountered in such a match
+      var byWordTo = 0,
+        byWordFolded = false;
+      // If we've found a partial adjacent match, these track its state
+      var adjacentTo = 0,
+        adjacentStart = -1,
+        adjacentEnd = -1;
+      var hasLower = /[a-z]/.test(word),
+        wordAdjacent = true;
+      // Go over the option's text, scanning for the various kinds of matches
+      for (var _i = 0, _e = Math.min(word.length, 200), prevType = Tp.NonWord; _i < _e && byWordTo < len;) {
+        var _next = codePointAt(word, _i);
+        if (direct < 0) {
+          if (preciseTo < len && _next === chars[preciseTo]) {
+            precise[preciseTo++] = _i;
+          }
+          if (adjacentTo < len) {
+            if (_next === chars[adjacentTo] || _next === folded[adjacentTo]) {
+              if (adjacentTo === 0) {
+                adjacentStart = _i;
+              }
+              adjacentEnd = _i + 1;
+              adjacentTo++;
+            } else {
+              adjacentTo = 0;
+            }
+          }
+        }
+        var ch = void 0,
+          type = _next < 0xff ? _next >= 48 && _next <= 57 || _next >= 97 && _next <= 122 ? Tp.Lower : _next >= 65 && _next <= 90 ? Tp.Upper : Tp.NonWord : (ch = fromCodePoint(_next)) !== ch.toLowerCase() ? Tp.Upper : ch !== ch.toUpperCase() ? Tp.Lower : Tp.NonWord;
+        if (!_i || type === Tp.Upper && hasLower || prevType === Tp.NonWord && type !== Tp.NonWord) {
+          if (chars[byWordTo] === _next || folded[byWordTo] === _next && (byWordFolded = true)) {
+            byWord[byWordTo++] = _i;
+          } else if (byWord.length) {
+            wordAdjacent = false;
+          }
+        }
+        prevType = type;
+        _i += codePointSize(_next);
+      }
+      if (byWordTo === len && byWord[0] === 0 && wordAdjacent) {
+        return this.result(Penalty.ByWord + (byWordFolded ? Penalty.CaseFold : 0), byWord, word);
+      }
+      if (adjacentTo === len && adjacentStart === 0) {
+        return [Penalty.CaseFold - word.length, 0, adjacentEnd];
+      }
+      if (direct > -1) {
+        return [Penalty.NotStart - word.length, direct, direct + this.pattern.length];
+      }
+      if (adjacentTo === len) {
+        return [Penalty.CaseFold + Penalty.NotStart - word.length, adjacentStart, adjacentEnd];
+      }
+      if (byWordTo === len) {
+        return this.result(Penalty.ByWord + (byWordFolded ? Penalty.CaseFold : 0) + Penalty.NotStart + (wordAdjacent ? 0 : Penalty.Gap), byWord, word);
+      }
+      return chars.length === 2 ? null : this.result((any[0] ? Penalty.NotStart : 0) + Penalty.CaseFold + Penalty.Gap, any, word);
+    }
+  }, {
+    key: "result",
+    value: function result(score, positions, word) {
+      var result = [score - word.length],
+        i = 1;
+      var _iterator = _createForOfIteratorHelper(positions),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var pos = _step.value;
+          var to = pos + (this.astral ? codePointSize(codePointAt(word, pos)) : 1);
+          if (i > 1 && result[i - 1] === pos) {
+            result[i - 1] = to;
+          } else {
+            result[i++] = pos;
+            result[i++] = to;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return result;
+    }
+  }]);
+  return FuzzyMatcher;
+}();

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

@@ -0,0 +1,17 @@
+import type { Extension, EditorState, StateEffect } from '@codemirror/state';
+import type { KeyBinding } from '@codemirror/view';
+import type { Completion } from './completion.js';
+import type { CompletionConfig } from './config.js';
+export * from './snippet.js';
+export * from './completion.js';
+export * from './view.js';
+export * from './word.js';
+export * from './closebrackets.js';
+export declare function autocompletion(config?: CompletionConfig): Extension;
+export declare const completionKeymap: readonly KeyBinding[];
+export declare function completionStatus(state: EditorState): null | 'active' | 'pending';
+export declare function currentCompletions(state: EditorState): readonly Completion[];
+export declare function selectedCompletion(state: EditorState): Completion | null;
+export declare function selectedCompletionIndex(state: EditorState): number | null;
+export declare function setSelectedCompletion(index: number): StateEffect<unknown>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/auto-complete/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE7E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAKnD,OAAO,KAAK,EAAE,UAAU,EAAU,MAAM,iBAAiB,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAWpD,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AAGnC,wBAAgB,cAAc,CAAC,MAAM,GAAE,gBAAqB,GAAG,SAAS,CAQvE;AAWD,eAAO,MAAM,gBAAgB,EAAE,SAAS,UAAU,EAQjD,CAAC;AAYF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,GAAG,QAAQ,GAAG,SAAS,CAOhF;AAMD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,UAAU,EAAE,CAa5E;AAGD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,GAAG,UAAU,GAAG,IAAI,CAGxE;AAID,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI,CAGzE;AAID,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAAC,OAAO,CAAC,CAEzE"}