@difizen/libro-codemirror 0.0.2-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present Difizen Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,12 @@
+import type { EditorState, Transaction, Extension, StateCommand } from '@codemirror/state';
+import type { KeyBinding } from '@codemirror/view';
+export interface CloseBracketConfig {
+    brackets?: string[];
+    before?: string;
+    stringPrefixes?: string[];
+}
+export declare function closeBrackets(): Extension;
+export declare const deleteBracketPair: StateCommand;
+export declare const closeBracketsKeymap: readonly KeyBinding[];
+export declare function insertBracket(state: EditorState, bracket: string): Transaction | null;
+//# sourceMappingURL=closebrackets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"closebrackets.d.ts","sourceRoot":"","sources":["../../src/auto-complete/closebrackets.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,WAAW,EACX,WAAW,EACX,SAAS,EACT,YAAY,EAEb,MAAM,mBAAmB,CAAC;AAa3B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAMnD,MAAM,WAAW,kBAAkB;IAIjC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IAIpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAGhB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B;AAyDD,wBAAgB,aAAa,IAAI,SAAS,CAEzC;AA0CD,eAAO,MAAM,iBAAiB,EAAE,YAiC/B,CAAC;AAIF,eAAO,MAAM,mBAAmB,EAAE,SAAS,UAAU,EAEpD,CAAC;AAWF,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAerF"}

package/es/auto-complete/closebrackets.js

@@ -0,0 +1,408 @@
+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(_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"); } }
+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); }
+import { syntaxTree } from '@codemirror/language';
+import { EditorSelection, StateField, StateEffect, MapMode, CharCategory, codePointAt, fromCodePoint, codePointSize, RangeSet, RangeValue } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+
+/// Configures bracket closing behavior for a syntax (via
+/// [language data](#state.EditorState.languageDataAt)) using the `"closeBrackets"`
+/// identifier.
+var defaults = {
+  brackets: ['(', '[', '{', "'", '"'],
+  before: ')]}:;>',
+  stringPrefixes: []
+};
+var closeBracketEffect = StateEffect.define({
+  map: function map(value, mapping) {
+    var mapped = mapping.mapPos(value, -1, MapMode.TrackAfter);
+    return mapped === null ? undefined : mapped;
+  }
+});
+var skipBracketEffect = StateEffect.define({
+  map: function map(value, mapping) {
+    return mapping.mapPos(value);
+  }
+});
+var closedBracket = new ( /*#__PURE__*/function (_RangeValue) {
+  _inherits(_class, _RangeValue);
+  var _super = _createSuper(_class);
+  function _class() {
+    _classCallCheck(this, _class);
+    return _super.apply(this, arguments);
+  }
+  return _createClass(_class);
+}(RangeValue))();
+closedBracket.startSide = 1;
+closedBracket.endSide = -1;
+var bracketState = StateField.define({
+  create: function create() {
+    return RangeSet.empty;
+  },
+  update: function update(value, tr) {
+    if (tr.selection) {
+      var lineStart = tr.state.doc.lineAt(tr.selection.main.head).from;
+      var prevLineStart = tr.startState.doc.lineAt(tr.startState.selection.main.head).from;
+      if (lineStart !== tr.changes.mapPos(prevLineStart, -1)) {
+        value = RangeSet.empty;
+      }
+    }
+    value = value.map(tr.changes);
+    var _iterator = _createForOfIteratorHelper(tr.effects),
+      _step;
+    try {
+      var _loop = function _loop() {
+        var effect = _step.value;
+        if (effect.is(closeBracketEffect)) {
+          value = value.update({
+            add: [closedBracket.range(effect.value, effect.value + 1)]
+          });
+        } else if (effect.is(skipBracketEffect)) {
+          value = value.update({
+            filter: function filter(from) {
+              return from !== effect.value;
+            }
+          });
+        }
+      };
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        _loop();
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return value;
+  }
+});
+
+/// Extension to enable bracket-closing behavior. When a closeable
+/// bracket is typed, its closing bracket is immediately inserted
+/// after the cursor. When closing a bracket directly in front of a
+/// closing bracket inserted by the extension, the cursor moves over
+/// that bracket.
+export function closeBrackets() {
+  return [inputHandler, bracketState];
+}
+var definedClosing = '()[]{}<>';
+function closing(ch) {
+  for (var i = 0; i < definedClosing.length; i += 2) {
+    if (definedClosing.charCodeAt(i) === ch) {
+      return definedClosing.charAt(i + 1);
+    }
+  }
+  return fromCodePoint(ch < 128 ? ch : ch + 1);
+}
+function config(state, pos) {
+  return state.languageDataAt('closeBrackets', pos)[0] || defaults;
+}
+var android = (typeof navigator === "undefined" ? "undefined" : _typeof(navigator)) === 'object' && /Android\b/.test(navigator.userAgent);
+var inputHandler = EditorView.inputHandler.of(function (view, from, to, insert) {
+  if ((android ? view.composing : view.compositionStarted) || view.state.readOnly) {
+    return false;
+  }
+  var sel = view.state.selection.main;
+  if (insert.length > 2 || insert.length === 2 && codePointSize(codePointAt(insert, 0)) === 1 || from !== sel.from || to !== sel.to) {
+    return false;
+  }
+  var tr = insertBracket(view.state, insert);
+  if (!tr) {
+    return false;
+  }
+  view.dispatch(tr);
+  return true;
+});
+
+/// Command that implements deleting a pair of matching brackets when
+/// the cursor is between them.
+export var deleteBracketPair = function deleteBracketPair(_ref) {
+  var state = _ref.state,
+    dispatch = _ref.dispatch;
+  if (state.readOnly) {
+    return false;
+  }
+  var conf = config(state, state.selection.main.head);
+  var tokens = conf.brackets || defaults.brackets;
+  var dont = null;
+  var changes = state.changeByRange(function (range) {
+    if (range.empty) {
+      var before = prevChar(state.doc, range.head);
+      var _iterator2 = _createForOfIteratorHelper(tokens),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var token = _step2.value;
+          if (token === before && nextChar(state.doc, range.head) === closing(codePointAt(token, 0))) {
+            return {
+              changes: {
+                from: range.head - token.length,
+                to: range.head + token.length
+              },
+              range: EditorSelection.cursor(range.head - token.length)
+            };
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+    return {
+      range: dont = range
+    };
+  });
+  if (!dont) {
+    dispatch(state.update(changes, {
+      scrollIntoView: true,
+      userEvent: 'delete.backward'
+    }));
+  }
+  return !dont;
+};
+
+/// Close-brackets related key bindings. Binds Backspace to
+/// [`deleteBracketPair`](#autocomplete.deleteBracketPair).
+export var closeBracketsKeymap = [{
+  key: 'Backspace',
+  run: deleteBracketPair
+}];
+
+/// Implements the extension's behavior on text insertion. If the
+/// given string counts as a bracket in the language around the
+/// selection, and replacing the selection with it requires custom
+/// behavior (inserting a closing version or skipping past a
+/// previously-closed bracket), this function returns a transaction
+/// representing that custom behavior. (You only need this if you want
+/// to programmatically insert brackets—the
+/// [`closeBrackets`](#autocomplete.closeBrackets) extension will
+/// take care of running this for user input.)
+export function insertBracket(state, bracket) {
+  var conf = config(state, state.selection.main.head);
+  var tokens = conf.brackets || defaults.brackets;
+  var _iterator3 = _createForOfIteratorHelper(tokens),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var tok = _step3.value;
+      var closed = closing(codePointAt(tok, 0));
+      if (bracket === tok) {
+        return closed === tok ? handleSame(state, tok, tokens.indexOf(tok + tok + tok) > -1, conf) : handleOpen(state, tok, closed, conf.before || defaults.before);
+      }
+      if (bracket === closed && closedBracketAt(state, state.selection.main.from)) {
+        return handleClose(state, tok, closed);
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return null;
+}
+function closedBracketAt(state, pos) {
+  var found = false;
+  state.field(bracketState).between(0, state.doc.length, function (from) {
+    if (from === pos) {
+      found = true;
+    }
+  });
+  return found;
+}
+function nextChar(doc, pos) {
+  var next = doc.sliceString(pos, pos + 2);
+  return next.slice(0, codePointSize(codePointAt(next, 0)));
+}
+function prevChar(doc, pos) {
+  var prev = doc.sliceString(pos - 2, pos);
+  return codePointSize(codePointAt(prev, 0)) === prev.length ? prev : prev.slice(1);
+}
+function handleOpen(state, open, close, closeBefore) {
+  var dont = null;
+  var changes = state.changeByRange(function (range) {
+    if (!range.empty) {
+      return {
+        changes: [{
+          insert: open,
+          from: range.from
+        }, {
+          insert: close,
+          from: range.to
+        }],
+        effects: closeBracketEffect.of(range.to + open.length),
+        range: EditorSelection.range(range.anchor + open.length, range.head + open.length)
+      };
+    }
+    var next = nextChar(state.doc, range.head);
+    if (!next || /\s/.test(next) || closeBefore.indexOf(next) > -1) {
+      return {
+        changes: {
+          insert: open + close,
+          from: range.head
+        },
+        effects: closeBracketEffect.of(range.head + open.length),
+        range: EditorSelection.cursor(range.head + open.length)
+      };
+    }
+    return {
+      range: dont = range
+    };
+  });
+  return dont ? null : state.update(changes, {
+    scrollIntoView: true,
+    userEvent: 'input.type'
+  });
+}
+function handleClose(state, _open, close) {
+  var dont = null;
+  var moved = state.selection.ranges.map(function (range) {
+    if (range.empty && nextChar(state.doc, range.head) === close) {
+      return EditorSelection.cursor(range.head + close.length);
+    }
+    return dont = range;
+  });
+  return dont ? null : state.update({
+    selection: EditorSelection.create(moved, state.selection.mainIndex),
+    scrollIntoView: true,
+    effects: state.selection.ranges.map(function (_ref2) {
+      var from = _ref2.from;
+      return skipBracketEffect.of(from);
+    })
+  });
+}
+
+// Handles cases where the open and close token are the same, and
+// possibly triple quotes (as in `"""abc"""`-style quoting).
+function handleSame(state, token, allowTriple, config) {
+  var stringPrefixes = config.stringPrefixes || defaults.stringPrefixes;
+  var dont = null;
+  var changes = state.changeByRange(function (range) {
+    if (!range.empty) {
+      return {
+        changes: [{
+          insert: token,
+          from: range.from
+        }, {
+          insert: token,
+          from: range.to
+        }],
+        effects: closeBracketEffect.of(range.to + token.length),
+        range: EditorSelection.range(range.anchor + token.length, range.head + token.length)
+      };
+    }
+    var pos = range.head;
+    var start;
+    var next = nextChar(state.doc, pos);
+    if (next === token) {
+      if (nodeStart(state, pos)) {
+        return {
+          changes: {
+            insert: token + token,
+            from: pos
+          },
+          effects: closeBracketEffect.of(pos + token.length),
+          range: EditorSelection.cursor(pos + token.length)
+        };
+      } else if (closedBracketAt(state, pos)) {
+        var isTriple = allowTriple && state.sliceDoc(pos, pos + token.length * 3) === token + token + token;
+        return {
+          range: EditorSelection.cursor(pos + token.length * (isTriple ? 3 : 1)),
+          effects: skipBracketEffect.of(pos)
+        };
+      }
+    } else if (allowTriple && state.sliceDoc(pos - 2 * token.length, pos) === token + token && (start = canStartStringAt(state, pos - 2 * token.length, stringPrefixes)) > -1 && nodeStart(state, start)) {
+      return {
+        changes: {
+          insert: token + token + token + token,
+          from: pos
+        },
+        effects: closeBracketEffect.of(pos + token.length),
+        range: EditorSelection.cursor(pos + token.length)
+      };
+    } else if (state.charCategorizer(pos)(next) !== CharCategory.Word) {
+      if (canStartStringAt(state, pos, stringPrefixes) > -1 && !probablyInString(state, pos, token, stringPrefixes)) {
+        return {
+          changes: {
+            insert: token + token,
+            from: pos
+          },
+          effects: closeBracketEffect.of(pos + token.length),
+          range: EditorSelection.cursor(pos + token.length)
+        };
+      }
+    }
+    return {
+      range: dont = range
+    };
+  });
+  return dont ? null : state.update(changes, {
+    scrollIntoView: true,
+    userEvent: 'input.type'
+  });
+}
+function nodeStart(state, pos) {
+  var tree = syntaxTree(state).resolveInner(pos + 1);
+  return tree.parent && tree.from === pos;
+}
+function probablyInString(state, pos, quoteToken, prefixes) {
+  var node = syntaxTree(state).resolveInner(pos, -1);
+  var maxPrefix = prefixes.reduce(function (m, p) {
+    return Math.max(m, p.length);
+  }, 0);
+  for (var i = 0; i < 5; i++) {
+    var start = state.sliceDoc(node.from, Math.min(node.to, node.from + quoteToken.length + maxPrefix));
+    var quotePos = start.indexOf(quoteToken);
+    if (!quotePos || quotePos > -1 && prefixes.indexOf(start.slice(0, quotePos)) > -1) {
+      var first = node.firstChild;
+      while (first && first.from === node.from && first.to - first.from > quoteToken.length + quotePos) {
+        if (state.sliceDoc(first.to - quoteToken.length, first.to) === quoteToken) {
+          return false;
+        }
+        first = first.firstChild;
+      }
+      return true;
+    }
+    var parent = node.to === pos && node.parent;
+    if (!parent) {
+      break;
+    }
+    node = parent;
+  }
+  return false;
+}
+function canStartStringAt(state, pos, prefixes) {
+  var charCat = state.charCategorizer(pos);
+  if (charCat(state.sliceDoc(pos - 1, pos)) !== CharCategory.Word) {
+    return pos;
+  }
+  var _iterator4 = _createForOfIteratorHelper(prefixes),
+    _step4;
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var prefix = _step4.value;
+      var start = pos - prefix.length;
+      if (state.sliceDoc(start, pos) === prefix && charCat(state.sliceDoc(start - 1, start)) !== CharCategory.Word) {
+        return start;
+      }
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+  return -1;
+}

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

@@ -0,0 +1,57 @@
+import type { EditorState, TransactionSpec } from '@codemirror/state';
+import type { EditorView } from '@codemirror/view';
+import type { ActiveResult } from './state.js';
+export interface Completion {
+    label: string;
+    detail?: string;
+    info?: string | ((completion: Completion) => Node | null | Promise<Node | null>);
+    apply?: string | ((view: EditorView, completion: Completion, from: number, to: number) => void);
+    type?: string;
+    boost?: number;
+}
+export declare class CompletionContext {
+    readonly state: EditorState;
+    readonly pos: number;
+    readonly explicit: boolean;
+    abortListeners: (() => void)[] | null;
+    constructor(state: EditorState, pos: number, explicit: boolean);
+    tokenBefore(types: readonly string[]): {
+        from: number;
+        to: number;
+        text: string;
+        type: import("@lezer/common").NodeType;
+    } | null;
+    matchBefore(expr: RegExp): {
+        from: number;
+        to: number;
+        text: string;
+    } | null;
+    get aborted(): boolean;
+    addEventListener(type: 'abort', listener: () => void): void;
+}
+export declare function completeFromList(list: readonly (string | Completion)[]): CompletionSource;
+export declare function ifIn(nodes: readonly string[], source: CompletionSource): CompletionSource;
+export declare function ifNotIn(nodes: readonly string[], source: CompletionSource): CompletionSource;
+export type CompletionSource = (context: CompletionContext) => CompletionResult | null | Promise<CompletionResult | null>;
+export interface CompletionResult {
+    from: number;
+    to?: number;
+    options: readonly Completion[];
+    validFor?: RegExp | ((text: string, from: number, to: number, state: EditorState) => boolean);
+    filter?: boolean;
+    getMatch?: (completion: Completion) => readonly number[];
+    update?: (current: CompletionResult, from: number, to: number, context: CompletionContext) => CompletionResult | null;
+}
+export declare class Option {
+    readonly completion: Completion;
+    readonly source: ActiveResult;
+    readonly match: readonly number[];
+    constructor(completion: Completion, source: ActiveResult, match: readonly number[]);
+}
+export declare function cur(state: EditorState): number;
+export declare function ensureAnchor(expr: RegExp, start: boolean): RegExp;
+export declare const pickedCompletion: import("@codemirror/state").AnnotationType<Completion>;
+export declare function insertCompletionText(state: EditorState, text: string, from: number, to: number): TransactionSpec;
+export declare function applyCompletion(view: EditorView, option: Option): void;
+export declare function asSource(source: CompletionSource | readonly (string | Completion)[]): CompletionSource;
+//# sourceMappingURL=completion.d.ts.map

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

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