@scalar/use-codemirror 0.5.4 → 0.6.0

package/dist/components/CodeMirror/CodeMirror.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CodeMirror.vue.d.ts","sourceRoot":"","sources":["../../../src/components/CodeMirror/CodeMirror.vue.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAA;AA4DlD,KAAK,QAAQ,GACT,OAAO,GACP,GAAG,GACH,SAAS,GACT,QAAQ,GACR,IAAI,GACJ,MAAM,GACN,MAAM,GACN,YAAY,GACZ,MAAM,GACN,QAAQ,GACR,MAAM,GACN,MAAM,GACN,OAAO,GACP,YAAY,GACZ,QAAQ,GACR,GAAG,GACH,MAAM,GACN,OAAO,GACP,OAAO,GACP,KAAK,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0LT,wBAAkD"}
+{"version":3,"file":"CodeMirror.vue.d.ts","sourceRoot":"","sources":["../../../src/components/CodeMirror/CodeMirror.vue.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAA;AA6DlD,KAAK,QAAQ,GACT,OAAO,GACP,GAAG,GACH,SAAS,GACT,QAAQ,GACR,IAAI,GACJ,MAAM,GACN,MAAM,GACN,YAAY,GACZ,MAAM,GACN,QAAQ,GACR,MAAM,GACN,MAAM,GACN,OAAO,GACP,YAAY,GACZ,QAAQ,GACR,GAAG,GACH,MAAM,GACN,OAAO,GACP,OAAO,GACP,KAAK,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2LT,wBAAkD"}

package/dist/index.js

@@ -6311,7 +6311,9 @@ const swift = {
 const DefaultBufferLength = 1024;
 let nextPropID = 0;
 class NodeProp {
-  /// Create a new node prop type.
+  /**
+  Create a new node prop type.
+  */
   constructor(config = {}) {
     this.id = nextPropID++;
     this.perNode = !!config.perNode;
@@ -6319,13 +6321,15 @@ class NodeProp {
       throw new Error("This node type doesn't define a deserialize function");
     });
   }
-  /// This is meant to be used with
-  /// [`NodeSet.extend`](#common.NodeSet.extend) or
-  /// [`LRParser.configure`](#lr.ParserConfig.props) to compute
-  /// prop values for each node type in the set. Takes a [match
-  /// object](#common.NodeType^match) or function that returns undefined
-  /// if the node type doesn't get this prop, and the prop's value if
-  /// it does.
+  /**
+  This is meant to be used with
+  [`NodeSet.extend`](#common.NodeSet.extend) or
+  [`LRParser.configure`](#lr.ParserConfig.props) to compute
+  prop values for each node type in the set. Takes a [match
+  object](#common.NodeType^match) or function that returns undefined
+  if the node type doesn't get this prop, and the prop's value if
+  it does.
+  */
   add(match) {
     if (this.perNode)
       throw new RangeError("Can't add per-node props to node types");
@@ -6343,16 +6347,33 @@ NodeProp.group = new NodeProp({ deserialize: (str) => str.split(" ") });
 NodeProp.contextHash = new NodeProp({ perNode: true });
 NodeProp.lookAhead = new NodeProp({ perNode: true });
 NodeProp.mounted = new NodeProp({ perNode: true });
+class MountedTree {
+  constructor(tree, overlay, parser) {
+    this.tree = tree;
+    this.overlay = overlay;
+    this.parser = parser;
+  }
+  /**
+  @internal
+  */
+  static get(tree) {
+    return tree && tree.props && tree.props[NodeProp.mounted.id];
+  }
+}
 const noProps = /* @__PURE__ */ Object.create(null);
 class NodeType {
-  /// @internal
+  /**
+  @internal
+  */
   constructor(name2, props, id, flags = 0) {
     this.name = name2;
     this.props = props;
     this.id = id;
     this.flags = flags;
   }
-  /// Define a node type.
+  /**
+  Define a node type.
+  */
   static define(spec) {
     let props = spec.props && spec.props.length ? /* @__PURE__ */ Object.create(null) : noProps;
     let flags = (spec.top ? 1 : 0) | (spec.skipped ? 2 : 0) | (spec.error ? 4 : 0) | (spec.name == null ? 8 : 0);
@@ -6369,30 +6390,42 @@ class NodeType {
       }
     return type;
   }
-  /// Retrieves a node prop for this type. Will return `undefined` if
-  /// the prop isn't present on this node.
+  /**
+  Retrieves a node prop for this type. Will return `undefined` if
+  the prop isn't present on this node.
+  */
   prop(prop) {
     return this.props[prop.id];
   }
-  /// True when this is the top node of a grammar.
+  /**
+  True when this is the top node of a grammar.
+  */
   get isTop() {
     return (this.flags & 1) > 0;
   }
-  /// True when this node is produced by a skip rule.
+  /**
+  True when this node is produced by a skip rule.
+  */
   get isSkipped() {
     return (this.flags & 2) > 0;
   }
-  /// Indicates whether this is an error node.
+  /**
+  Indicates whether this is an error node.
+  */
   get isError() {
     return (this.flags & 4) > 0;
   }
-  /// When true, this node type doesn't correspond to a user-declared
-  /// named node, for example because it is used to cache repetition.
+  /**
+  When true, this node type doesn't correspond to a user-declared
+  named node, for example because it is used to cache repetition.
+  */
   get isAnonymous() {
     return (this.flags & 8) > 0;
   }
-  /// Returns true when this node's name or one of its
-  /// [groups](#common.NodeProp^group) matches the given string.
+  /**
+  Returns true when this node's name or one of its
+  [groups](#common.NodeProp^group) matches the given string.
+  */
   is(name2) {
     if (typeof name2 == "string") {
       if (this.name == name2)
@@ -6402,12 +6435,14 @@ class NodeType {
     }
     return this.id == name2;
   }
-  /// Create a function from node types to arbitrary values by
-  /// specifying an object whose property names are node or
-  /// [group](#common.NodeProp^group) names. Often useful with
-  /// [`NodeProp.add`](#common.NodeProp.add). You can put multiple
-  /// names, separated by spaces, in a single property name to map
-  /// multiple node names to a single value.
+  /**
+  Create a function from node types to arbitrary values by
+  specifying an object whose property names are node or
+  [group](#common.NodeProp^group) names. Often useful with
+  [`NodeProp.add`](#common.NodeProp.add). You can put multiple
+  names, separated by spaces, in a single property name to map
+  multiple node names to a single value.
+  */
   static match(map2) {
     let direct = /* @__PURE__ */ Object.create(null);
     for (let prop in map2)
@@ -6438,7 +6473,9 @@ var IterMode;
   IterMode2[IterMode2["IgnoreOverlays"] = 8] = "IgnoreOverlays";
 })(IterMode || (IterMode = {}));
 class Tree {
-  /// Construct a new tree. See also [`Tree.build`](#common.Tree^build).
+  /**
+  Construct a new tree. See also [`Tree.build`](#common.Tree^build).
+  */
   constructor(type, children, positions, length, props) {
     this.type = type;
     this.children = children;
@@ -6451,9 +6488,11 @@ class Tree {
         this.props[typeof prop == "number" ? prop : prop.id] = value;
     }
   }
-  /// @internal
+  /**
+  @internal
+  */
   toString() {
-    let mounted = this.prop(NodeProp.mounted);
+    let mounted = MountedTree.get(this);
     if (mounted && !mounted.overlay)
       return mounted.tree.toString();
     let children = "";
@@ -6467,15 +6506,19 @@ class Tree {
     }
     return !this.type.name ? children : (/\W/.test(this.type.name) && !this.type.isError ? JSON.stringify(this.type.name) : this.type.name) + (children.length ? "(" + children + ")" : "");
   }
-  /// Get a [tree cursor](#common.TreeCursor) positioned at the top of
-  /// the tree. Mode can be used to [control](#common.IterMode) which
-  /// nodes the cursor visits.
+  /**
+  Get a [tree cursor](#common.TreeCursor) positioned at the top of
+  the tree. Mode can be used to [control](#common.IterMode) which
+  nodes the cursor visits.
+  */
   cursor(mode = 0) {
     return new TreeCursor(this.topNode, mode);
   }
-  /// Get a [tree cursor](#common.TreeCursor) pointing into this tree
-  /// at the given position and side (see
-  /// [`moveTo`](#common.TreeCursor.moveTo).
+  /**
+  Get a [tree cursor](#common.TreeCursor) pointing into this tree
+  at the given position and side (see
+  [`moveTo`](#common.TreeCursor.moveTo).
+  */
   cursorAt(pos, side = 0, mode = 0) {
     let scope = CachedNode.get(this) || this.topNode;
     let cursor = new TreeCursor(scope);
@@ -6483,40 +6526,58 @@ class Tree {
     CachedNode.set(this, cursor._tree);
     return cursor;
   }
-  /// Get a [syntax node](#common.SyntaxNode) object for the top of the
-  /// tree.
+  /**
+  Get a [syntax node](#common.SyntaxNode) object for the top of the
+  tree.
+  */
   get topNode() {
     return new TreeNode(this, 0, 0, null);
   }
-  /// Get the [syntax node](#common.SyntaxNode) at the given position.
-  /// If `side` is -1, this will move into nodes that end at the
-  /// position. If 1, it'll move into nodes that start at the
-  /// position. With 0, it'll only enter nodes that cover the position
-  /// from both sides.
-  ///
-  /// Note that this will not enter
-  /// [overlays](#common.MountedTree.overlay), and you often want
-  /// [`resolveInner`](#common.Tree.resolveInner) instead.
+  /**
+  Get the [syntax node](#common.SyntaxNode) at the given position.
+  If `side` is -1, this will move into nodes that end at the
+  position. If 1, it'll move into nodes that start at the
+  position. With 0, it'll only enter nodes that cover the position
+  from both sides.
+  
+  Note that this will not enter
+  [overlays](#common.MountedTree.overlay), and you often want
+  [`resolveInner`](#common.Tree.resolveInner) instead.
+  */
   resolve(pos, side = 0) {
     let node = resolveNode(CachedNode.get(this) || this.topNode, pos, side, false);
     CachedNode.set(this, node);
     return node;
   }
-  /// Like [`resolve`](#common.Tree.resolve), but will enter
-  /// [overlaid](#common.MountedTree.overlay) nodes, producing a syntax node
-  /// pointing into the innermost overlaid tree at the given position
-  /// (with parent links going through all parent structure, including
-  /// the host trees).
+  /**
+  Like [`resolve`](#common.Tree.resolve), but will enter
+  [overlaid](#common.MountedTree.overlay) nodes, producing a syntax node
+  pointing into the innermost overlaid tree at the given position
+  (with parent links going through all parent structure, including
+  the host trees).
+  */
   resolveInner(pos, side = 0) {
     let node = resolveNode(CachedInnerNode.get(this) || this.topNode, pos, side, true);
     CachedInnerNode.set(this, node);
     return node;
   }
-  /// Iterate over the tree and its children, calling `enter` for any
-  /// node that touches the `from`/`to` region (if given) before
-  /// running over such a node's children, and `leave` (if given) when
-  /// leaving the node. When `enter` returns `false`, that node will
-  /// not have its children iterated over (or `leave` called).
+  /**
+  In some situations, it can be useful to iterate through all
+  nodes around a position, including those in overlays that don't
+  directly cover the position. This method gives you an iterator
+  that will produce all nodes, from small to big, around the given
+  position.
+  */
+  resolveStack(pos, side = 0) {
+    return stackIterator(this, pos, side);
+  }
+  /**
+  Iterate over the tree and its children, calling `enter` for any
+  node that touches the `from`/`to` region (if given) before
+  running over such a node's children, and `leave` (if given) when
+  leaving the node. When `enter` returns `false`, that node will
+  not have its children iterated over (or `leave` called).
+  */
   iterate(spec) {
     let { enter, leave, from = 0, to = this.length } = spec;
     let mode = spec.mode || 0, anon = (mode & IterMode.IncludeAnonymous) > 0;
@@ -6538,14 +6599,18 @@ class Tree {
       }
     }
   }
-  /// Get the value of the given [node prop](#common.NodeProp) for this
-  /// node. Works with both per-node and per-type props.
+  /**
+  Get the value of the given [node prop](#common.NodeProp) for this
+  node. Works with both per-node and per-type props.
+  */
   prop(prop) {
     return !prop.perNode ? this.type.prop(prop) : this.props ? this.props[prop.id] : void 0;
   }
-  /// Returns the node's [per-node props](#common.NodeProp.perNode) in a
-  /// format that can be passed to the [`Tree`](#common.Tree)
-  /// constructor.
+  /**
+  Returns the node's [per-node props](#common.NodeProp.perNode) in a
+  format that can be passed to the [`Tree`](#common.Tree)
+  constructor.
+  */
   get propValues() {
     let result = [];
     if (this.props)
@@ -6553,14 +6618,18 @@ class Tree {
         result.push([+id, this.props[id]]);
     return result;
   }
-  /// Balance the direct children of this tree, producing a copy of
-  /// which may have children grouped into subtrees with type
-  /// [`NodeType.none`](#common.NodeType^none).
+  /**
+  Balance the direct children of this tree, producing a copy of
+  which may have children grouped into subtrees with type
+  [`NodeType.none`](#common.NodeType^none).
+  */
   balance(config = {}) {
     return this.children.length <= 8 ? this : balanceRange(NodeType.none, this.children, this.positions, 0, this.children.length, 0, this.length, (children, positions, length) => new Tree(this.type, children, positions, length, this.propValues), config.makeTree || ((children, positions, length) => new Tree(NodeType.none, children, positions, length)));
   }
-  /// Build a tree from a postfix-ordered buffer of node information,
-  /// or a cursor over such a buffer.
+  /**
+  Build a tree from a postfix-ordered buffer of node information,
+  or a cursor over such a buffer.
+  */
   static build(data) {
     return buildTree(data);
   }
@@ -6594,17 +6663,23 @@ class FlatBufferCursor {
   }
 }
 class TreeBuffer {
-  /// Create a tree buffer.
+  /**
+  Create a tree buffer.
+  */
   constructor(buffer, length, set2) {
     this.buffer = buffer;
     this.length = length;
     this.set = set2;
   }
-  /// @internal
+  /**
+  @internal
+  */
   get type() {
     return NodeType.none;
   }
-  /// @internal
+  /**
+  @internal
+  */
   toString() {
     let result = [];
     for (let index = 0; index < this.buffer.length; ) {
@@ -6613,7 +6688,9 @@ class TreeBuffer {
     }
     return result.join(",");
   }
-  /// @internal
+  /**
+  @internal
+  */
   childString(index) {
     let id = this.buffer[index], endIndex = this.buffer[index + 3];
     let type = this.set.types[id], result = type.name;
@@ -6629,7 +6706,9 @@ class TreeBuffer {
     }
     return result + "(" + children.join(",") + ")";
   }
-  /// @internal
+  /**
+  @internal
+  */
   findChild(startIndex, endIndex, dir, pos, side) {
     let { buffer } = this, pick = -1;
     for (let i = startIndex; i != endIndex; i = buffer[i + 3]) {
@@ -6641,7 +6720,9 @@ class TreeBuffer {
     }
     return pick;
   }
-  /// @internal
+  /**
+  @internal
+  */
   slice(startI, endI, from) {
     let b = this.buffer;
     let copy = new Uint16Array(endI - startI), len = 0;
@@ -6671,21 +6752,6 @@ function checkSide(side, pos, from, to) {
       return true;
   }
 }
-function enterUnfinishedNodesBefore(node, pos) {
-  let scan = node.childBefore(pos);
-  while (scan) {
-    let last = scan.lastChild;
-    if (!last || last.to != scan.to)
-      break;
-    if (last.type.isError && last.from == last.to) {
-      node = scan;
-      scan = last.prevSibling;
-    } else {
-      scan = last;
-    }
-  }
-  return node;
-}
 function resolveNode(node, pos, side, overlays) {
   var _a;
   while (node.from == node.to || (side < 1 ? node.from >= pos : node.from > pos) || (side > -1 ? node.to <= pos : node.to < pos)) {
@@ -6707,8 +6773,51 @@ function resolveNode(node, pos, side, overlays) {
     node = inner;
   }
 }
-class TreeNode {
+class BaseNode {
+  cursor(mode = 0) {
+    return new TreeCursor(this, mode);
+  }
+  getChild(type, before = null, after = null) {
+    let r2 = getChildren(this, type, before, after);
+    return r2.length ? r2[0] : null;
+  }
+  getChildren(type, before = null, after = null) {
+    return getChildren(this, type, before, after);
+  }
+  resolve(pos, side = 0) {
+    return resolveNode(this, pos, side, false);
+  }
+  resolveInner(pos, side = 0) {
+    return resolveNode(this, pos, side, true);
+  }
+  matchContext(context) {
+    return matchNodeContext(this, context);
+  }
+  enterUnfinishedNodesBefore(pos) {
+    let scan = this.childBefore(pos), node = this;
+    while (scan) {
+      let last = scan.lastChild;
+      if (!last || last.to != scan.to)
+        break;
+      if (last.type.isError && last.from == last.to) {
+        node = scan;
+        scan = last.prevSibling;
+      } else {
+        scan = last;
+      }
+    }
+    return node;
+  }
+  get node() {
+    return this;
+  }
+  get next() {
+    return this.parent;
+  }
+}
+class TreeNode extends BaseNode {
   constructor(_tree, from, index, _parent) {
+    super();
     this._tree = _tree;
     this.from = from;
     this.index = index;
@@ -6737,7 +6846,7 @@ class TreeNode {
             return new BufferNode(new BufferContext(parent, next, i, start2), null, index);
         } else if (mode & IterMode.IncludeAnonymous || (!next.type.isAnonymous || hasChild(next))) {
           let mounted;
-          if (!(mode & IterMode.IgnoreMounts) && next.props && (mounted = next.prop(NodeProp.mounted)) && !mounted.overlay)
+          if (!(mode & IterMode.IgnoreMounts) && (mounted = MountedTree.get(next)) && !mounted.overlay)
             return new TreeNode(mounted.tree, start2, i, parent);
           let inner = new TreeNode(next, start2, i, parent);
           return mode & IterMode.IncludeAnonymous || !inner.type.isAnonymous ? inner : inner.nextChild(dir < 0 ? next.children.length - 1 : 0, dir, pos, side);
@@ -6792,7 +6901,7 @@ class TreeNode {
   }
   enter(pos, side, mode = 0) {
     let mounted;
-    if (!(mode & IterMode.IgnoreOverlays) && (mounted = this._tree.prop(NodeProp.mounted)) && mounted.overlay) {
+    if (!(mode & IterMode.IgnoreOverlays) && (mounted = MountedTree.get(this._tree)) && mounted.overlay) {
       let rPos = pos - this.from;
       for (let { from, to } of mounted.overlay) {
         if ((side > 0 ? from <= rPos : from < rPos) && (side < 0 ? to >= rPos : to > rPos))
@@ -6828,41 +6937,18 @@ class TreeNode {
       /* Side.DontCare */
     ) : null;
   }
-  cursor(mode = 0) {
-    return new TreeCursor(this, mode);
-  }
   get tree() {
     return this._tree;
   }
   toTree() {
     return this._tree;
   }
-  resolve(pos, side = 0) {
-    return resolveNode(this, pos, side, false);
-  }
-  resolveInner(pos, side = 0) {
-    return resolveNode(this, pos, side, true);
-  }
-  enterUnfinishedNodesBefore(pos) {
-    return enterUnfinishedNodesBefore(this, pos);
-  }
-  getChild(type, before = null, after = null) {
-    let r2 = getChildren(this, type, before, after);
-    return r2.length ? r2[0] : null;
-  }
-  getChildren(type, before = null, after = null) {
-    return getChildren(this, type, before, after);
-  }
-  /// @internal
+  /**
+  @internal
+  */
   toString() {
     return this._tree.toString();
   }
-  get node() {
-    return this;
-  }
-  matchContext(context) {
-    return matchNodeContext(this, context);
-  }
 }
 function getChildren(node, type, before, after) {
   let cur = node.cursor(), result = [];
@@ -6902,7 +6988,7 @@ class BufferContext {
     this.start = start2;
   }
 }
-class BufferNode {
+class BufferNode extends BaseNode {
   get name() {
     return this.type.name;
   }
@@ -6913,6 +6999,7 @@ class BufferNode {
     return this.context.start + this.context.buffer.buffer[this.index + 2];
   }
   constructor(context, _parent, index) {
+    super();
     this.context = context;
     this._parent = _parent;
     this.index = index;
@@ -6995,9 +7082,6 @@ class BufferNode {
       /* Side.DontCare */
     ));
   }
-  cursor(mode = 0) {
-    return new TreeCursor(this, mode);
-  }
   get tree() {
     return null;
   }
@@ -7012,39 +7096,70 @@ class BufferNode {
     }
     return new Tree(this.type, children, positions, this.to - this.from);
   }
-  resolve(pos, side = 0) {
-    return resolveNode(this, pos, side, false);
-  }
-  resolveInner(pos, side = 0) {
-    return resolveNode(this, pos, side, true);
-  }
-  enterUnfinishedNodesBefore(pos) {
-    return enterUnfinishedNodesBefore(this, pos);
-  }
-  /// @internal
+  /**
+  @internal
+  */
   toString() {
     return this.context.buffer.childString(this.index);
   }
-  getChild(type, before = null, after = null) {
-    let r2 = getChildren(this, type, before, after);
-    return r2.length ? r2[0] : null;
-  }
-  getChildren(type, before = null, after = null) {
-    return getChildren(this, type, before, after);
+}
+function iterStack(heads) {
+  if (!heads.length)
+    return null;
+  if (heads.length == 1)
+    return heads[0];
+  let pick = 0, picked = heads[0];
+  for (let i = 1; i < heads.length; i++) {
+    let node = heads[i];
+    if (node.from > picked.from || node.to < picked.to) {
+      picked = node;
+      pick = i;
+    }
+  }
+  let next = picked instanceof TreeNode && picked.index < 0 ? null : picked.parent;
+  let newHeads = heads.slice();
+  if (next)
+    newHeads[pick] = next;
+  else
+    newHeads.splice(pick, 1);
+  return new StackIterator(newHeads, picked);
+}
+class StackIterator {
+  constructor(heads, node) {
+    this.heads = heads;
+    this.node = node;
   }
-  get node() {
-    return this;
+  get next() {
+    return iterStack(this.heads);
   }
-  matchContext(context) {
-    return matchNodeContext(this, context);
+}
+function stackIterator(tree, pos, side) {
+  let inner = tree.resolveInner(pos, side), layers = null;
+  for (let scan = inner instanceof TreeNode ? inner : inner.context.parent; scan; scan = scan.parent) {
+    if (scan.index < 0) {
+      let parent = scan.parent;
+      (layers || (layers = [inner])).push(parent.resolve(pos, side));
+      scan = parent;
+    } else {
+      let mount = MountedTree.get(scan.tree);
+      if (mount && mount.overlay && mount.overlay[0].from <= pos && mount.overlay[mount.overlay.length - 1].to >= pos) {
+        let root = new TreeNode(mount.tree, mount.overlay[0].from + scan.from, 0, null);
+        (layers || (layers = [inner])).push(resolveNode(root, pos, side, false));
+      }
+    }
   }
+  return layers ? iterStack(layers) : inner;
 }
 class TreeCursor {
-  /// Shorthand for `.type.name`.
+  /**
+  Shorthand for `.type.name`.
+  */
   get name() {
     return this.type.name;
   }
-  /// @internal
+  /**
+  @internal
+  */
   constructor(node, mode = 0) {
     this.mode = mode;
     this.buffer = null;
@@ -7089,11 +7204,15 @@ class TreeCursor {
     this.buffer = node.context;
     return this.yieldBuf(node.index, node.type);
   }
-  /// @internal
+  /**
+  @internal
+  */
   toString() {
     return this.buffer ? this.buffer.buffer.childString(this.index) : this._tree.toString();
   }
-  /// @internal
+  /**
+  @internal
+  */
   enterChild(dir, pos, side) {
     if (!this.buffer)
       return this.yield(this._tree.nextChild(dir < 0 ? this._tree._tree.children.length - 1 : 0, dir, pos, side, this.mode));
@@ -7104,8 +7223,10 @@ class TreeCursor {
     this.stack.push(this.index);
     return this.yieldBuf(index);
   }
-  /// Move the cursor to this node's first child. When this returns
-  /// false, the node has no child, and the cursor has not been moved.
+  /**
+  Move the cursor to this node's first child. When this returns
+  false, the node has no child, and the cursor has not been moved.
+  */
   firstChild() {
     return this.enterChild(
       1,
@@ -7114,7 +7235,9 @@ class TreeCursor {
       /* Side.DontCare */
     );
   }
-  /// Move the cursor to this node's last child.
+  /**
+  Move the cursor to this node's last child.
+  */
   lastChild() {
     return this.enterChild(
       -1,
@@ -7123,7 +7246,9 @@ class TreeCursor {
       /* Side.DontCare */
     );
   }
-  /// Move the cursor to the first child that ends after `pos`.
+  /**
+  Move the cursor to the first child that ends after `pos`.
+  */
   childAfter(pos) {
     return this.enterChild(
       1,
@@ -7132,7 +7257,9 @@ class TreeCursor {
       /* Side.After */
     );
   }
-  /// Move to the last child that starts before `pos`.
+  /**
+  Move to the last child that starts before `pos`.
+  */
   childBefore(pos) {
     return this.enterChild(
       -1,
@@ -7141,17 +7268,21 @@ class TreeCursor {
       /* Side.Before */
     );
   }
-  /// Move the cursor to the child around `pos`. If side is -1 the
-  /// child may end at that position, when 1 it may start there. This
-  /// will also enter [overlaid](#common.MountedTree.overlay)
-  /// [mounted](#common.NodeProp^mounted) trees unless `overlays` is
-  /// set to false.
+  /**
+  Move the cursor to the child around `pos`. If side is -1 the
+  child may end at that position, when 1 it may start there. This
+  will also enter [overlaid](#common.MountedTree.overlay)
+  [mounted](#common.NodeProp^mounted) trees unless `overlays` is
+  set to false.
+  */
   enter(pos, side, mode = this.mode) {
     if (!this.buffer)
       return this.yield(this._tree.enter(pos, side, mode));
     return mode & IterMode.ExcludeBuffers ? false : this.enterChild(1, pos, side);
   }
-  /// Move to the node's parent node, if this isn't the top node.
+  /**
+  Move to the node's parent node, if this isn't the top node.
+  */
   parent() {
     if (!this.buffer)
       return this.yieldNode(this.mode & IterMode.IncludeAnonymous ? this._tree._parent : this._tree.parent);
@@ -7161,7 +7292,9 @@ class TreeCursor {
     this.buffer = null;
     return this.yieldNode(parent);
   }
-  /// @internal
+  /**
+  @internal
+  */
   sibling(dir) {
     if (!this.buffer)
       return !this._tree._parent ? false : this.yield(this._tree.index < 0 ? null : this._tree._parent.nextChild(this._tree.index + dir, dir, 0, 4, this.mode));
@@ -7184,11 +7317,15 @@ class TreeCursor {
     }
     return d < 0 ? this.yield(this.buffer.parent.nextChild(this.buffer.index + dir, dir, 0, 4, this.mode)) : false;
   }
-  /// Move to this node's next sibling, if any.
+  /**
+  Move to this node's next sibling, if any.
+  */
   nextSibling() {
     return this.sibling(1);
   }
-  /// Move to this node's previous sibling, if any.
+  /**
+  Move to this node's previous sibling, if any.
+  */
   prevSibling() {
     return this.sibling(-1);
   }
@@ -7232,24 +7369,30 @@ class TreeCursor {
         return false;
     }
   }
-  /// Move to the next node in a
-  /// [pre-order](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR)
-  /// traversal, going from a node to its first child or, if the
-  /// current node is empty or `enter` is false, its next sibling or
-  /// the next sibling of the first parent node that has one.
+  /**
+  Move to the next node in a
+  [pre-order](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR)
+  traversal, going from a node to its first child or, if the
+  current node is empty or `enter` is false, its next sibling or
+  the next sibling of the first parent node that has one.
+  */
   next(enter = true) {
     return this.move(1, enter);
   }
-  /// Move to the next node in a last-to-first pre-order traveral. A
-  /// node is followed by its last child or, if it has none, its
-  /// previous sibling or the previous sibling of the first parent
-  /// node that has one.
+  /**
+  Move to the next node in a last-to-first pre-order traveral. A
+  node is followed by its last child or, if it has none, its
+  previous sibling or the previous sibling of the first parent
+  node that has one.
+  */
   prev(enter = true) {
     return this.move(-1, enter);
   }
-  /// Move the cursor to the innermost node that covers `pos`. If
-  /// `side` is -1, it will enter nodes that end at `pos`. If it is 1,
-  /// it will enter nodes that start at `pos`.
+  /**
+  Move the cursor to the innermost node that covers `pos`. If
+  `side` is -1, it will enter nodes that end at `pos`. If it is 1,
+  it will enter nodes that start at `pos`.
+  */
   moveTo(pos, side = 0) {
     while (this.from == this.to || (side < 1 ? this.from >= pos : this.from > pos) || (side > -1 ? this.to <= pos : this.to < pos))
       if (!this.parent())
@@ -7258,8 +7401,10 @@ class TreeCursor {
     }
     return this;
   }
-  /// Get a [syntax node](#common.SyntaxNode) at the cursor's current
-  /// position.
+  /**
+  Get a [syntax node](#common.SyntaxNode) at the cursor's current
+  position.
+  */
   get node() {
     if (!this.buffer)
       return this._tree;
@@ -7282,16 +7427,20 @@ class TreeCursor {
       result = new BufferNode(this.buffer, result, this.stack[i]);
     return this.bufferNode = new BufferNode(this.buffer, result, this.index);
   }
-  /// Get the [tree](#common.Tree) that represents the current node, if
-  /// any. Will return null when the node is in a [tree
-  /// buffer](#common.TreeBuffer).
+  /**
+  Get the [tree](#common.Tree) that represents the current node, if
+  any. Will return null when the node is in a [tree
+  buffer](#common.TreeBuffer).
+  */
   get tree() {
     return this.buffer ? null : this._tree._tree;
   }
-  /// Iterate over the current node and all its descendants, calling
-  /// `enter` when entering a node and `leave`, if given, when leaving
-  /// one. When `enter` returns `false`, any children of that node are
-  /// skipped, and `leave` isn't called for it.
+  /**
+  Iterate over the current node and all its descendants, calling
+  `enter` when entering a node and `leave`, if given, when leaving
+  one. When `enter` returns `false`, any children of that node are
+  skipped, and `leave` isn't called for it.
+  */
   iterate(enter, leave) {
     for (let depth = 0; ; ) {
       let mustLeave = false;
@@ -7317,9 +7466,11 @@ class TreeCursor {
       }
     }
   }
-  /// Test whether the current node matches a given context—a sequence
-  /// of direct parent node names. Empty strings in the context array
-  /// are treated as wildcards.
+  /**
+  Test whether the current node matches a given context—a sequence
+  of direct parent node names. Empty strings in the context array
+  are treated as wildcards.
+  */
   matchContext(context) {
     if (!this.buffer)
       return matchNodeContext(this.node, context);

package/package.json

@@ -1,71 +1,69 @@
 {
   "name": "@scalar/use-codemirror",
   "description": "CodeMirror for Vue",
-  "keywords": [
-    "vue",
-    "vue3",
-    "composable",
-    "codemirror"
-  ],
-  "version": "0.5.4",
+  "version": "0.6.0",
   "author": "Scalar (https://github.com/scalar)",
-  "homepage": "https://github.com/scalar/scalar",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/scalar/scalar.git",
-    "directory": "packages/use-codemirror"
-  },
-  "bugs": {
-    "url": "https://github.com/scalar/scalar/issues/new"
-  },
-  "license": "MIT",
-  "engines": {
-    "node": ">=18"
-  },
-  "type": "module",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
-  "files": [
-    "dist"
-  ],
-  "exports": {
-    "import": "./dist/index.js"
-  },
+  "bugs": "https://github.com/scalar/scalar/issues/new",
   "dependencies": {
-    "@codemirror/lang-java": "^6.0.1",
+    "@codemirror/lang-java": "6.0.1",
     "@codemirror/lang-javascript": "6.2.1",
     "@codemirror/lang-json": "6.0.1",
     "@codemirror/lang-python": "6.1.3",
-    "@codemirror/language": "6.9.0",
+    "@codemirror/language": "6.9.1",
     "@codemirror/legacy-modes": "6.3.3",
     "@codemirror/state": "6.2.1",
-    "@codemirror/view": "6.18.0",
-    "@headlessui/vue": "1.7.14",
-    "@lezer/common": "1.0.3",
-    "@lezer/lr": "1.3.10",
+    "@codemirror/view": "6.20.0",
+    "@headlessui/vue": "1.7.16",
+    "@lezer/common": "1.1.0",
     "@lezer/highlight": "1.1.6",
-    "@uiw/codemirror-theme-duotone": "4.21.13",
-    "@uiw/codemirror-themes": "4.21.13",
-    "@vueuse/core": "10.1.2",
-    "axios": "1.4.0",
+    "@lezer/lr": "1.3.11",
+    "@uiw/codemirror-theme-duotone": "4.21.16",
+    "@uiw/codemirror-themes": "4.21.16",
+    "@vueuse/core": "10.4.1",
+    "axios": "1.5.0",
     "codemirror": "6.0.1",
     "javascript-time-ago": "2.5.9",
-    "nanoid": "4.0.2",
-    "pretty-bytes": "6.1.0",
+    "nanoid": "5.0.1",
+    "pretty-bytes": "6.1.1",
     "pretty-ms": "8.0.0",
     "tippy.js": "6.3.7"
   },
   "devDependencies": {
-    "@vitejs/plugin-vue": "4.2.3",
-    "tsc-alias": "1.8.6",
-    "vite": "4.4.8",
-    "vitest": "0.34.1",
-    "@vitest/coverage-v8": "^0.34.4",
-    "vue-tsc": "1.8.8"
+    "@vitejs/plugin-vue": "4.3.4",
+    "@vitest/coverage-v8": "0.34.4",
+    "tsc-alias": "1.8.8",
+    "vite": "4.4.9",
+    "vitest": "0.34.4",
+    "vue-tsc": "1.8.13"
   },
+  "engines": {
+    "node": ">=18"
+  },
+  "exports": {
+    "import": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "homepage": "https://github.com/scalar/scalar",
+  "keywords": [
+    "codemirror",
+    "composable",
+    "vue",
+    "vue3"
+  ],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
   "peerDependencies": {
     "vue": "3.3.4"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/scalar/scalar.git",
+    "directory": "packages/use-codemirror"
+  },
+  "type": "module",
   "scripts": {
     "build": "vite build && pnpm types:build && tsc-alias -p tsconfig.build.json",
     "dev": "vite",