@pyreon/code 0.5.0 → 0.7.0

package/lib/types/dist.d.ts

@@ -1,798 +0,0 @@
-function checkSide(side, pos, from, to) {
-  switch (side) {
-    case -2:
-      return from < pos;
-    case -1:
-      return to >= pos && from < pos;
-    case 0:
-      return from < pos && to > pos;
-    case 1:
-      return from <= pos && to > pos;
-    case 2:
-      return to > pos;
-    case 4:
-      return true;
-  }
-}
-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)) {
-    let parent = !overlays && node instanceof TreeNode && node.index < 0 ? null : node.parent;
-    if (!parent) return node;
-    node = parent;
-  }
-  let mode = overlays ? 0 : IterMode.IgnoreOverlays;
-  if (overlays) {
-    for (let scan = node, parent = scan.parent; parent; scan = parent, parent = scan.parent) if (scan instanceof TreeNode && scan.index < 0 && ((_a = parent.enter(pos, side, mode)) === null || _a === void 0 ? void 0 : _a.from) != scan.from) node = parent;
-  }
-  for (;;) {
-    let inner = node.enter(pos, side, mode);
-    if (!inner) return node;
-    node = inner;
-  }
-}
-function getChildren(node, type, before, after) {
-  let cur = node.cursor(),
-    result = [];
-  if (!cur.firstChild()) return result;
-  if (before != null) for (let found = false; !found;) {
-    found = cur.type.is(before);
-    if (!cur.nextSibling()) return result;
-  }
-  for (;;) {
-    if (after != null && cur.type.is(after)) return result;
-    if (cur.type.is(type)) result.push(cur.node);
-    if (!cur.nextSibling()) return after == null ? result : [];
-  }
-}
-function matchNodeContext(node, context, i = context.length - 1) {
-  for (let p = node; i >= 0; p = p.parent) {
-    if (!p) return false;
-    if (!p.type.isAnonymous) {
-      if (context[i] && context[i] != p.name) return false;
-      i--;
-    }
-  }
-  return true;
-}
-function iterStack(heads) {
-  if (!heads.length) return null;
-  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);
-}
-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, -1, scan);
-      (layers || (layers = [inner])).push(resolveNode(root, pos, side, false));
-    }
-  }
-  return layers ? iterStack(layers) : inner;
-}
-/**
-A tree cursor object focuses on a given node in a syntax tree, and
-allows you to move to adjacent nodes.
-*/
-
-function hasChild(tree) {
-  return tree.children.some(ch => ch instanceof TreeBuffer || !ch.type.isAnonymous || hasChild(ch));
-}
-function buildTree(data) {
-  var _a;
-  let {
-    buffer,
-    nodeSet,
-    maxBufferLength = DefaultBufferLength,
-    reused = [],
-    minRepeatType = nodeSet.types.length
-  } = data;
-  let cursor = Array.isArray(buffer) ? new FlatBufferCursor(buffer, buffer.length) : buffer;
-  let types = nodeSet.types;
-  let contextHash = 0,
-    lookAhead = 0;
-  function takeNode(parentStart, minPos, children, positions, inRepeat, depth) {
-    let {
-      id,
-      start,
-      end,
-      size
-    } = cursor;
-    let lookAheadAtStart = lookAhead,
-      contextAtStart = contextHash;
-    if (size < 0) {
-      cursor.next();
-      if (size == -1) {
-        let node = reused[id];
-        children.push(node);
-        positions.push(start - parentStart);
-        return;
-      } else if (size == -3) {
-        contextHash = id;
-        return;
-      } else if (size == -4) {
-        lookAhead = id;
-        return;
-      } else throw new RangeError(`Unrecognized record size: ${size}`);
-    }
-    let type = types[id],
-      node,
-      buffer;
-    let startPos = start - parentStart;
-    if (end - start <= maxBufferLength && (buffer = findBufferSize(cursor.pos - minPos, inRepeat))) {
-      let data = new Uint16Array(buffer.size - buffer.skip);
-      let endPos = cursor.pos - buffer.size,
-        index = data.length;
-      while (cursor.pos > endPos) index = copyToBuffer(buffer.start, data, index);
-      node = new TreeBuffer(data, end - buffer.start, nodeSet);
-      startPos = buffer.start - parentStart;
-    } else {
-      let endPos = cursor.pos - size;
-      cursor.next();
-      let localChildren = [],
-        localPositions = [];
-      let localInRepeat = id >= minRepeatType ? id : -1;
-      let lastGroup = 0,
-        lastEnd = end;
-      while (cursor.pos > endPos) if (localInRepeat >= 0 && cursor.id == localInRepeat && cursor.size >= 0) {
-        if (cursor.end <= lastEnd - maxBufferLength) {
-          makeRepeatLeaf(localChildren, localPositions, start, lastGroup, cursor.end, lastEnd, localInRepeat, lookAheadAtStart, contextAtStart);
-          lastGroup = localChildren.length;
-          lastEnd = cursor.end;
-        }
-        cursor.next();
-      } else if (depth > 2500) takeFlatNode(start, endPos, localChildren, localPositions);else takeNode(start, endPos, localChildren, localPositions, localInRepeat, depth + 1);
-      if (localInRepeat >= 0 && lastGroup > 0 && lastGroup < localChildren.length) makeRepeatLeaf(localChildren, localPositions, start, lastGroup, start, lastEnd, localInRepeat, lookAheadAtStart, contextAtStart);
-      localChildren.reverse();
-      localPositions.reverse();
-      if (localInRepeat > -1 && lastGroup > 0) {
-        let make = makeBalanced(type, contextAtStart);
-        node = balanceRange(type, localChildren, localPositions, 0, localChildren.length, 0, end - start, make, make);
-      } else node = makeTree(type, localChildren, localPositions, end - start, lookAheadAtStart - end, contextAtStart);
-    }
-    children.push(node);
-    positions.push(startPos);
-  }
-  function takeFlatNode(parentStart, minPos, children, positions) {
-    let nodes = [];
-    let nodeCount = 0,
-      stopAt = -1;
-    while (cursor.pos > minPos) {
-      let {
-        id,
-        start,
-        end,
-        size
-      } = cursor;
-      if (size > 4) cursor.next();else if (stopAt > -1 && start < stopAt) break;else {
-        if (stopAt < 0) stopAt = end - maxBufferLength;
-        nodes.push(id, start, end);
-        nodeCount++;
-        cursor.next();
-      }
-    }
-    if (nodeCount) {
-      let buffer = new Uint16Array(nodeCount * 4);
-      let start = nodes[nodes.length - 2];
-      for (let i = nodes.length - 3, j = 0; i >= 0; i -= 3) {
-        buffer[j++] = nodes[i];
-        buffer[j++] = nodes[i + 1] - start;
-        buffer[j++] = nodes[i + 2] - start;
-        buffer[j++] = j;
-      }
-      children.push(new TreeBuffer(buffer, nodes[2] - start, nodeSet));
-      positions.push(start - parentStart);
-    }
-  }
-  function makeBalanced(type, contextHash) {
-    return (children, positions, length) => {
-      let lookAhead = 0,
-        lastI = children.length - 1,
-        last,
-        lookAheadProp;
-      if (lastI >= 0 && (last = children[lastI]) instanceof Tree) {
-        if (!lastI && last.type == type && last.length == length) return last;
-        if (lookAheadProp = last.prop(NodeProp.lookAhead)) lookAhead = positions[lastI] + last.length + lookAheadProp;
-      }
-      return makeTree(type, children, positions, length, lookAhead, contextHash);
-    };
-  }
-  function makeRepeatLeaf(children, positions, base, i, from, to, type, lookAhead, contextHash) {
-    let localChildren = [],
-      localPositions = [];
-    while (children.length > i) {
-      localChildren.push(children.pop());
-      localPositions.push(positions.pop() + base - from);
-    }
-    children.push(makeTree(nodeSet.types[type], localChildren, localPositions, to - from, lookAhead - to, contextHash));
-    positions.push(from - base);
-  }
-  function makeTree(type, children, positions, length, lookAhead, contextHash, props) {
-    if (contextHash) {
-      let pair = [NodeProp.contextHash, contextHash];
-      props = props ? [pair].concat(props) : [pair];
-    }
-    if (lookAhead > 25) {
-      let pair = [NodeProp.lookAhead, lookAhead];
-      props = props ? [pair].concat(props) : [pair];
-    }
-    return new Tree(type, children, positions, length, props);
-  }
-  function findBufferSize(maxSize, inRepeat) {
-    let fork = cursor.fork();
-    let size = 0,
-      start = 0,
-      skip = 0,
-      minStart = fork.end - maxBufferLength;
-    let result = {
-      size: 0,
-      start: 0,
-      skip: 0
-    };
-    scan: for (let minPos = fork.pos - maxSize; fork.pos > minPos;) {
-      let nodeSize = fork.size;
-      if (fork.id == inRepeat && nodeSize >= 0) {
-        result.size = size;
-        result.start = start;
-        result.skip = skip;
-        skip += 4;
-        size += 4;
-        fork.next();
-        continue;
-      }
-      let startPos = fork.pos - nodeSize;
-      if (nodeSize < 0 || startPos < minPos || fork.start < minStart) break;
-      let localSkipped = fork.id >= minRepeatType ? 4 : 0;
-      let nodeStart = fork.start;
-      fork.next();
-      while (fork.pos > startPos) {
-        if (fork.size < 0) {
-          if (fork.size == -3 || fork.size == -4) localSkipped += 4;else break scan;
-        } else if (fork.id >= minRepeatType) localSkipped += 4;
-        fork.next();
-      }
-      start = nodeStart;
-      size += nodeSize;
-      skip += localSkipped;
-    }
-    if (inRepeat < 0 || size == maxSize) {
-      result.size = size;
-      result.start = start;
-      result.skip = skip;
-    }
-    return result.size > 4 ? result : void 0;
-  }
-  function copyToBuffer(bufferStart, buffer, index) {
-    let {
-      id,
-      start,
-      end,
-      size
-    } = cursor;
-    cursor.next();
-    if (size >= 0 && id < minRepeatType) {
-      let startIndex = index;
-      if (size > 4) {
-        let endPos = cursor.pos - (size - 4);
-        while (cursor.pos > endPos) index = copyToBuffer(bufferStart, buffer, index);
-      }
-      buffer[--index] = startIndex;
-      buffer[--index] = end - bufferStart;
-      buffer[--index] = start - bufferStart;
-      buffer[--index] = id;
-    } else if (size == -3) contextHash = id;else if (size == -4) lookAhead = id;
-    return index;
-  }
-  let children = [],
-    positions = [];
-  while (cursor.pos > 0) takeNode(data.start || 0, data.bufferStart || 0, children, positions, -1, 0);
-  let length = (_a = data.length) !== null && _a !== void 0 ? _a : children.length ? positions[0] + children[0].length : 0;
-  return new Tree(types[data.topID], children.reverse(), positions.reverse(), length);
-}
-function nodeSize(balanceType, node) {
-  if (!balanceType.isAnonymous || node instanceof TreeBuffer || node.type != balanceType) return 1;
-  let size = nodeSizeCache.get(node);
-  if (size == null) {
-    size = 1;
-    for (let child of node.children) {
-      if (child.type != balanceType || !(child instanceof Tree)) {
-        size = 1;
-        break;
-      }
-      size += nodeSize(balanceType, child);
-    }
-    nodeSizeCache.set(node, size);
-  }
-  return size;
-}
-function balanceRange(balanceType, children, positions, from, to, start, length, mkTop, mkTree) {
-  let total = 0;
-  for (let i = from; i < to; i++) total += nodeSize(balanceType, children[i]);
-  let maxChild = Math.ceil(total * 1.5 / 8);
-  let localChildren = [],
-    localPositions = [];
-  function divide(children, positions, from, to, offset) {
-    for (let i = from; i < to;) {
-      let groupFrom = i,
-        groupStart = positions[i],
-        groupSize = nodeSize(balanceType, children[i]);
-      i++;
-      for (; i < to; i++) {
-        let nextSize = nodeSize(balanceType, children[i]);
-        if (groupSize + nextSize >= maxChild) break;
-        groupSize += nextSize;
-      }
-      if (i == groupFrom + 1) {
-        if (groupSize > maxChild) {
-          let only = children[groupFrom];
-          divide(only.children, only.positions, 0, only.children.length, positions[groupFrom] + offset);
-          continue;
-        }
-        localChildren.push(children[groupFrom]);
-      } else {
-        let length = positions[i - 1] + children[i - 1].length - groupStart;
-        localChildren.push(balanceRange(balanceType, children, positions, groupFrom, i, groupStart, length, null, mkTree));
-      }
-      localPositions.push(groupStart + offset - start);
-    }
-  }
-  divide(children, positions, from, to, 0);
-  return (mkTop || mkTree)(localChildren, localPositions, length);
-}
-/**
-Provides a way to associate values with pieces of trees. As long
-as that part of the tree is reused, the associated values can be
-retrieved from an updated tree.
-*/
-
-/**
-Create a parse wrapper that, after the inner parse completes,
-scans its tree for mixed language regions with the `nest`
-function, runs the resulting [inner parses](#common.NestedParse),
-and then [mounts](#common.NodeProp^mounted) their results onto the
-tree.
-*/
-function parseMixed(nest) {
-  return (parse, input, fragments, ranges) => new MixedParse(parse, nest, input, fragments, ranges);
-}
-function checkRanges(ranges) {
-  if (!ranges.length || ranges.some(r => r.from >= r.to)) throw new RangeError("Invalid inner parse ranges given: " + JSON.stringify(ranges));
-}
-function checkCover(covered, from, to) {
-  for (let range of covered) {
-    if (range.from >= to) break;
-    if (range.to > from) return range.from <= from && range.to >= to ? 2 : 1;
-  }
-  return 0;
-}
-function sliceBuf(buf, startI, endI, nodes, positions, off) {
-  if (startI < endI) {
-    let from = buf.buffer[startI + 1];
-    nodes.push(buf.slice(startI, endI, from));
-    positions.push(from - off);
-  }
-}
-function materialize(cursor) {
-  let {
-      node
-    } = cursor,
-    stack = [];
-  let buffer = node.context.buffer;
-  do {
-    stack.push(cursor.index);
-    cursor.parent();
-  } while (!cursor.tree);
-  let base = cursor.tree,
-    i = base.children.indexOf(buffer);
-  let buf = base.children[i],
-    b = buf.buffer,
-    newStack = [i];
-  function split(startI, endI, type, innerOffset, length, stackPos) {
-    let targetI = stack[stackPos];
-    let children = [],
-      positions = [];
-    sliceBuf(buf, startI, targetI, children, positions, innerOffset);
-    let from = b[targetI + 1],
-      to = b[targetI + 2];
-    newStack.push(children.length);
-    let child = stackPos ? split(targetI + 4, b[targetI + 3], buf.set.types[b[targetI]], from, to - from, stackPos - 1) : node.toTree();
-    children.push(child);
-    positions.push(from - innerOffset);
-    sliceBuf(buf, b[targetI + 3], endI, children, positions, innerOffset);
-    return new Tree(type, children, positions, length);
-  }
-  base.children[i] = split(0, b.length, NodeType.none, 0, buf.length, stack.length - 1);
-  for (let index of newStack) {
-    let tree = cursor.tree.children[index],
-      pos = cursor.tree.positions[index];
-    cursor.yield(new TreeNode(tree, pos + cursor.from, index, cursor._tree));
-  }
-}
-function punchRanges(outer, ranges) {
-  let copy = null,
-    current = ranges;
-  for (let i = 1, j = 0; i < outer.length; i++) {
-    let gapFrom = outer[i - 1].to,
-      gapTo = outer[i].from;
-    for (; j < current.length; j++) {
-      let r = current[j];
-      if (r.from >= gapTo) break;
-      if (r.to <= gapFrom) continue;
-      if (!copy) current = copy = ranges.slice();
-      if (r.from < gapFrom) {
-        copy[j] = new Range(r.from, gapFrom);
-        if (r.to > gapTo) copy.splice(j + 1, 0, new Range(gapTo, r.to));
-      } else if (r.to > gapTo) copy[j--] = new Range(gapTo, r.to);else copy.splice(j--, 1);
-    }
-  }
-  return current;
-}
-function findCoverChanges(a, b, from, to) {
-  let iA = 0,
-    iB = 0,
-    inA = false,
-    inB = false,
-    pos = -1e9;
-  let result = [];
-  for (;;) {
-    let nextA = iA == a.length ? 1e9 : inA ? a[iA].to : a[iA].from;
-    let nextB = iB == b.length ? 1e9 : inB ? b[iB].to : b[iB].from;
-    if (inA != inB) {
-      let start = Math.max(pos, from),
-        end = Math.min(nextA, nextB, to);
-      if (start < end) result.push(new Range(start, end));
-    }
-    pos = Math.min(nextA, nextB);
-    if (pos == 1e9) break;
-    if (nextA == pos) if (!inA) inA = true;else {
-      inA = false;
-      iA++;
-    }
-    if (nextB == pos) if (!inB) inB = true;else {
-      inB = false;
-      iB++;
-    }
-  }
-  return result;
-}
-function enterFragments(mounts, ranges) {
-  let result = [];
-  for (let {
-    pos,
-    mount,
-    frag
-  } of mounts) {
-    let startPos = pos + (mount.overlay ? mount.overlay[0].from : 0),
-      endPos = startPos + mount.tree.length;
-    let from = Math.max(frag.from, startPos),
-      to = Math.min(frag.to, endPos);
-    if (mount.overlay) {
-      let changes = findCoverChanges(ranges, mount.overlay.map(r => new Range(r.from + pos, r.to + pos)), from, to);
-      for (let i = 0, pos = from;; i++) {
-        let last = i == changes.length,
-          end = last ? to : changes[i].from;
-        if (end > pos) result.push(new TreeFragment(pos, end, mount.tree, -startPos, frag.from >= pos || frag.openStart, frag.to <= end || frag.openEnd));
-        if (last) break;
-        pos = changes[i].to;
-      }
-    } else result.push(new TreeFragment(from, to, mount.tree, -startPos, frag.from >= startPos || frag.openStart, frag.to <= endPos || frag.openEnd));
-  }
-  return result;
-}
-
-//#endregion
-//#region ../../node_modules/.bun/@lezer+lr@1.4.8/node_modules/@lezer/lr/dist/index.js
-/**
-A parse stack. These are used internally by the parser to track
-parsing progress. They also provide some properties and methods
-that external code such as a tokenizer can use to get information
-about the parse state.
-*/
-
-function decodeArray(input, Type = Uint16Array) {
-  if (typeof input != "string") return input;
-  let array = null;
-  for (let pos = 0, out = 0; pos < input.length;) {
-    let value = 0;
-    for (;;) {
-      let next = input.charCodeAt(pos++),
-        stop = false;
-      if (next == 126) {
-        value = 65535;
-        break;
-      }
-      if (next >= 92) next--;
-      if (next >= 34) next--;
-      let digit = next - 32;
-      if (digit >= 46) {
-        digit -= 46;
-        stop = true;
-      }
-      value += digit;
-      if (stop) break;
-      value *= 46;
-    }
-    if (array) array[out++] = value;else array = new Type(value);
-  }
-  return array;
-}
-function readToken(data, input, stack, group, precTable, precOffset) {
-  let state = 0,
-    groupMask = 1 << group,
-    {
-      dialect
-    } = stack.p.parser;
-  scan: for (;;) {
-    if ((groupMask & data[state]) == 0) break;
-    let accEnd = data[state + 1];
-    for (let i = state + 3; i < accEnd; i += 2) if ((data[i + 1] & groupMask) > 0) {
-      let term = data[i];
-      if (dialect.allows(term) && (input.token.value == -1 || input.token.value == term || overrides(term, input.token.value, precTable, precOffset))) {
-        input.acceptToken(term);
-        break;
-      }
-    }
-    let next = input.next,
-      low = 0,
-      high = data[state + 2];
-    if (input.next < 0 && high > low && data[accEnd + high * 3 - 3] == 65535) {
-      state = data[accEnd + high * 3 - 1];
-      continue scan;
-    }
-    for (; low < high;) {
-      let mid = low + high >> 1;
-      let index = accEnd + mid + (mid << 1);
-      let from = data[index],
-        to = data[index + 1] || 65536;
-      if (next < from) high = mid;else if (next >= to) low = mid + 1;else {
-        state = data[index + 2];
-        input.advance();
-        continue scan;
-      }
-    }
-    break;
-  }
-}
-function findOffset(data, start, term) {
-  for (let i = start, next; (next = data[i]) != 65535; i++) if (next == term) return i - start;
-  return -1;
-}
-function overrides(token, prev, tableData, tableOffset) {
-  let iPrev = findOffset(tableData, tableOffset, prev);
-  return iPrev < 0 || findOffset(tableData, tableOffset, token) < iPrev;
-}
-function cutAt(tree, pos, side) {
-  let cursor = tree.cursor(IterMode.IncludeAnonymous);
-  cursor.moveTo(pos);
-  for (;;) if (!(side < 0 ? cursor.childBefore(pos) : cursor.childAfter(pos))) for (;;) {
-    if ((side < 0 ? cursor.to < pos : cursor.from > pos) && !cursor.type.isError) return side < 0 ? Math.max(0, Math.min(cursor.to - 1, pos - 25)) : Math.min(tree.length, Math.max(cursor.from + 1, pos + 25));
-    if (side < 0 ? cursor.prevSibling() : cursor.nextSibling()) break;
-    if (!cursor.parent()) return side < 0 ? 0 : tree.length;
-  }
-}
-function pushStackDedup(stack, newStacks) {
-  for (let i = 0; i < newStacks.length; i++) {
-    let other = newStacks[i];
-    if (other.pos == stack.pos && other.sameState(stack)) {
-      if (newStacks[i].score < stack.score) newStacks[i] = stack;
-      return;
-    }
-  }
-  newStacks.push(stack);
-}
-function pair(data, off) {
-  return data[off] | data[off + 1] << 16;
-}
-function findFinished(stacks) {
-  let best = null;
-  for (let stack of stacks) {
-    let stopped = stack.p.stoppedAt;
-    if ((stack.pos == stack.p.stream.end || stopped != null && stack.pos > stopped) && stack.p.parser.stateFlag(stack.state, 2) && (!best || best.score < stack.score)) best = stack;
-  }
-  return best;
-}
-function getSpecializer(spec) {
-  if (spec.external) {
-    let mask = spec.extend ? 1 : 0;
-    return (value, stack) => spec.external(value, stack) << 1 | mask;
-  }
-  return spec.get;
-}
-
-//#endregion
-//#region ../../node_modules/.bun/@lezer+highlight@1.2.3/node_modules/@lezer/highlight/dist/index.js
-
-function sameArray(a, b) {
-  return a.length == b.length && a.every((x, i) => x == b[i]);
-}
-function powerSet(array) {
-  let sets = [[]];
-  for (let i = 0; i < array.length; i++) for (let j = 0, e = sets.length; j < e; j++) sets.push(sets[j].concat(array[i]));
-  return sets.sort((a, b) => b.length - a.length);
-}
-/**
-This function is used to add a set of tags to a language syntax
-via [`NodeSet.extend`](#common.NodeSet.extend) or
-[`LRParser.configure`](#lr.LRParser.configure).
-
-The argument object maps node selectors to [highlighting
-tags](#highlight.Tag) or arrays of tags.
-
-Node selectors may hold one or more (space-separated) node paths.
-Such a path can be a [node name](#common.NodeType.name), or
-multiple node names (or `*` wildcards) separated by slash
-characters, as in `"Block/Declaration/VariableName"`. Such a path
-matches the final node but only if its direct parent nodes are the
-other nodes mentioned. A `*` in such a path matches any parent,
-but only a single level—wildcards that match multiple parents
-aren't supported, both for efficiency reasons and because Lezer
-trees make it rather hard to reason about what they would match.)
-
-A path can be ended with `/...` to indicate that the tag assigned
-to the node should also apply to all child nodes, even if they
-match their own style (by default, only the innermost style is
-used).
-
-When a path ends in `!`, as in `Attribute!`, no further matching
-happens for the node's child nodes, and the entire node gets the
-given style.
-
-In this notation, node names that contain `/`, `!`, `*`, or `...`
-must be quoted as JSON strings.
-
-For example:
-
-```javascript
-parser.configure({props: [
-styleTags({
-// Style Number and BigNumber nodes
-"Number BigNumber": tags.number,
-// Style Escape nodes whose parent is String
-"String/Escape": tags.escape,
-// Style anything inside Attributes nodes
-"Attributes!": tags.meta,
-// Add a style to all content inside Italic nodes
-"Italic/...": tags.emphasis,
-// Style InvalidString nodes as both `string` and `invalid`
-"InvalidString": [tags.string, tags.invalid],
-// Style the node named "/" as punctuation
-'"/"': tags.punctuation
-})
-]})
-```
-*/
-function styleTags(spec) {
-  let byName = Object.create(null);
-  for (let prop in spec) {
-    let tags = spec[prop];
-    if (!Array.isArray(tags)) tags = [tags];
-    for (let part of prop.split(" ")) if (part) {
-      let pieces = [],
-        mode = 2,
-        rest = part;
-      for (let pos = 0;;) {
-        if (rest == "..." && pos > 0 && pos + 3 == part.length) {
-          mode = 1;
-          break;
-        }
-        let m = /^"(?:[^"\\]|\\.)*?"|[^\/!]+/.exec(rest);
-        if (!m) throw new RangeError("Invalid path: " + part);
-        pieces.push(m[0] == "*" ? "" : m[0][0] == "\"" ? JSON.parse(m[0]) : m[0]);
-        pos += m[0].length;
-        if (pos == part.length) break;
-        let next = part[pos++];
-        if (pos == part.length && next == "!") {
-          mode = 0;
-          break;
-        }
-        if (next != "/") throw new RangeError("Invalid path: " + part);
-        rest = part.slice(pos);
-      }
-      let last = pieces.length - 1,
-        inner = pieces[last];
-      if (!inner) throw new RangeError("Invalid path: " + part);
-      byName[inner] = new Rule(tags, mode, last > 0 ? pieces.slice(0, last) : null).sort(byName[inner]);
-    }
-  }
-  return ruleNodeProp.add(byName);
-}
-/**
-Define a [highlighter](#highlight.Highlighter) from an array of
-tag/class pairs. Classes associated with more specific tags will
-take precedence.
-*/
-function tagHighlighter(tags, options) {
-  let map = Object.create(null);
-  for (let style of tags) if (!Array.isArray(style.tag)) map[style.tag.id] = style.class;else for (let tag of style.tag) map[tag.id] = style.class;
-  let {
-    scope,
-    all = null
-  } = options || {};
-  return {
-    style: tags => {
-      let cls = all;
-      for (let tag of tags) for (let sub of tag.set) {
-        let tagClass = map[sub.id];
-        if (tagClass) {
-          cls = cls ? cls + " " + tagClass : tagClass;
-          break;
-        }
-      }
-      return cls;
-    },
-    scope
-  };
-}
-for (let name in tags) {
-  let val = tags[name];
-  if (val instanceof Tag) val.name = name;
-}
-/**
-This is a highlighter that adds stable, predictable classes to
-tokens, for styling with external CSS.
-
-The following tags are mapped to their name prefixed with `"tok-"`
-(for example `"tok-comment"`):
-
-* [`link`](#highlight.tags.link)
-* [`heading`](#highlight.tags.heading)
-* [`emphasis`](#highlight.tags.emphasis)
-* [`strong`](#highlight.tags.strong)
-* [`keyword`](#highlight.tags.keyword)
-* [`atom`](#highlight.tags.atom)
-* [`bool`](#highlight.tags.bool)
-* [`url`](#highlight.tags.url)
-* [`labelName`](#highlight.tags.labelName)
-* [`inserted`](#highlight.tags.inserted)
-* [`deleted`](#highlight.tags.deleted)
-* [`literal`](#highlight.tags.literal)
-* [`string`](#highlight.tags.string)
-* [`number`](#highlight.tags.number)
-* [`variableName`](#highlight.tags.variableName)
-* [`typeName`](#highlight.tags.typeName)
-* [`namespace`](#highlight.tags.namespace)
-* [`className`](#highlight.tags.className)
-* [`macroName`](#highlight.tags.macroName)
-* [`propertyName`](#highlight.tags.propertyName)
-* [`operator`](#highlight.tags.operator)
-* [`comment`](#highlight.tags.comment)
-* [`meta`](#highlight.tags.meta)
-* [`punctuation`](#highlight.tags.punctuation)
-* [`invalid`](#highlight.tags.invalid)
-
-In addition, these mappings are provided:
-
-* [`regexp`](#highlight.tags.regexp),
-[`escape`](#highlight.tags.escape), and
-[`special`](#highlight.tags.special)[`(string)`](#highlight.tags.string)
-are mapped to `"tok-string2"`
-* [`special`](#highlight.tags.special)[`(variableName)`](#highlight.tags.variableName)
-to `"tok-variableName2"`
-* [`local`](#highlight.tags.local)[`(variableName)`](#highlight.tags.variableName)
-to `"tok-variableName tok-local"`
-* [`definition`](#highlight.tags.definition)[`(variableName)`](#highlight.tags.variableName)
-to `"tok-variableName tok-definition"`
-* [`definition`](#highlight.tags.definition)[`(propertyName)`](#highlight.tags.propertyName)
-to `"tok-propertyName tok-definition"`
-*/
-
-//#endregion
-export { ExternalTokenizer as a, IterMode as c, NodeType as d, NodeWeakMap as f, parseMixed as h, ContextTracker as i, NodeProp as l, Tree as m, styleTags as n, LRParser as o, Parser as p, tags as r, LocalTokenGroup as s, Tag as t, NodeSet as u };
-//# sourceMappingURL=dist.d.ts.map