@veltra/desktop 1.3.0 → 1.3.2

package/dist/node_modules/.bun/@lezer_common@1.5.2/node_modules/@lezer/common/dist/index.js

@@ -1560,8 +1560,332 @@ var StringInput = class {
 		return this.string.slice(from, to);
 	}
 };
-new NodeProp({ perNode: true });
+/**
+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);
+}
+var InnerParse = class {
+	constructor(parser, parse, overlay, bracketed, target, from) {
+		this.parser = parser;
+		this.parse = parse;
+		this.overlay = overlay;
+		this.bracketed = bracketed;
+		this.target = target;
+		this.from = from;
+	}
+};
+function checkRanges(ranges) {
+	if (!ranges.length || ranges.some((r) => r.from >= r.to)) throw new RangeError("Invalid inner parse ranges given: " + JSON.stringify(ranges));
+}
+var ActiveOverlay = class {
+	constructor(parser, predicate, mounts, index, start, bracketed, target, prev) {
+		this.parser = parser;
+		this.predicate = predicate;
+		this.mounts = mounts;
+		this.index = index;
+		this.start = start;
+		this.bracketed = bracketed;
+		this.target = target;
+		this.prev = prev;
+		this.depth = 0;
+		this.ranges = [];
+	}
+};
+const stoppedInner = new NodeProp({ perNode: true });
+var MixedParse = class {
+	constructor(base, nest, input, fragments, ranges) {
+		this.nest = nest;
+		this.input = input;
+		this.fragments = fragments;
+		this.ranges = ranges;
+		this.inner = [];
+		this.innerDone = 0;
+		this.baseTree = null;
+		this.stoppedAt = null;
+		this.baseParse = base;
+	}
+	advance() {
+		if (this.baseParse) {
+			let done = this.baseParse.advance();
+			if (!done) return null;
+			this.baseParse = null;
+			this.baseTree = done;
+			this.startInner();
+			if (this.stoppedAt != null) for (let inner of this.inner) inner.parse.stopAt(this.stoppedAt);
+		}
+		if (this.innerDone == this.inner.length) {
+			let result = this.baseTree;
+			if (this.stoppedAt != null) result = new Tree(result.type, result.children, result.positions, result.length, result.propValues.concat([[stoppedInner, this.stoppedAt]]));
+			return result;
+		}
+		let inner = this.inner[this.innerDone], done = inner.parse.advance();
+		if (done) {
+			this.innerDone++;
+			let props = Object.assign(Object.create(null), inner.target.props);
+			props[NodeProp.mounted.id] = new MountedTree(done, inner.overlay, inner.parser, inner.bracketed);
+			inner.target.props = props;
+		}
+		return null;
+	}
+	get parsedPos() {
+		if (this.baseParse) return 0;
+		let pos = this.input.length;
+		for (let i = this.innerDone; i < this.inner.length; i++) if (this.inner[i].from < pos) pos = Math.min(pos, this.inner[i].parse.parsedPos);
+		return pos;
+	}
+	stopAt(pos) {
+		this.stoppedAt = pos;
+		if (this.baseParse) this.baseParse.stopAt(pos);
+		else for (let i = this.innerDone; i < this.inner.length; i++) this.inner[i].parse.stopAt(pos);
+	}
+	startInner() {
+		let fragmentCursor = new FragmentCursor(this.fragments);
+		let overlay = null;
+		let covered = null;
+		let cursor = new TreeCursor(new TreeNode(this.baseTree, this.ranges[0].from, 0, null), IterMode.IncludeAnonymous | IterMode.IgnoreMounts);
+		scan: for (let nest, isCovered;;) {
+			let enter = true, range;
+			if (this.stoppedAt != null && cursor.from >= this.stoppedAt) enter = false;
+			else if (fragmentCursor.hasNode(cursor)) {
+				if (overlay) {
+					let match = overlay.mounts.find((m) => m.frag.from <= cursor.from && m.frag.to >= cursor.to && m.mount.overlay);
+					if (match) for (let r of match.mount.overlay) {
+						let from = r.from + match.pos, to = r.to + match.pos;
+						if (from >= cursor.from && to <= cursor.to && !overlay.ranges.some((r) => r.from < to && r.to > from)) overlay.ranges.push({
+							from,
+							to
+						});
+					}
+				}
+				enter = false;
+			} else if (covered && (isCovered = checkCover(covered.ranges, cursor.from, cursor.to))) enter = isCovered != 2;
+			else if (!cursor.type.isAnonymous && (nest = this.nest(cursor, this.input)) && (cursor.from < cursor.to || !nest.overlay)) {
+				if (!cursor.tree) {
+					materialize(cursor);
+					if (overlay) overlay.depth++;
+					if (covered) covered.depth++;
+				}
+				let oldMounts = fragmentCursor.findMounts(cursor.from, nest.parser);
+				if (typeof nest.overlay == "function") overlay = new ActiveOverlay(nest.parser, nest.overlay, oldMounts, this.inner.length, cursor.from, !!nest.bracketed, cursor.tree, overlay);
+				else {
+					let ranges = punchRanges(this.ranges, nest.overlay || (cursor.from < cursor.to ? [new Range(cursor.from, cursor.to)] : []));
+					if (ranges.length) checkRanges(ranges);
+					if (ranges.length || !nest.overlay) this.inner.push(new InnerParse(nest.parser, ranges.length ? nest.parser.startParse(this.input, enterFragments(oldMounts, ranges), ranges) : nest.parser.startParse(""), nest.overlay ? nest.overlay.map((r) => new Range(r.from - cursor.from, r.to - cursor.from)) : null, !!nest.bracketed, cursor.tree, ranges.length ? ranges[0].from : cursor.from));
+					if (!nest.overlay) enter = false;
+					else if (ranges.length) covered = {
+						ranges,
+						depth: 0,
+						prev: covered
+					};
+				}
+			} else if (overlay && (range = overlay.predicate(cursor))) {
+				if (range === true) range = new Range(cursor.from, cursor.to);
+				if (range.from < range.to) {
+					let last = overlay.ranges.length - 1;
+					if (last >= 0 && overlay.ranges[last].to == range.from) overlay.ranges[last] = {
+						from: overlay.ranges[last].from,
+						to: range.to
+					};
+					else overlay.ranges.push(range);
+				}
+			}
+			if (enter && cursor.firstChild()) {
+				if (overlay) overlay.depth++;
+				if (covered) covered.depth++;
+			} else for (;;) {
+				if (cursor.nextSibling()) break;
+				if (!cursor.parent()) break scan;
+				if (overlay && !--overlay.depth) {
+					let ranges = punchRanges(this.ranges, overlay.ranges);
+					if (ranges.length) {
+						checkRanges(ranges);
+						this.inner.splice(overlay.index, 0, new InnerParse(overlay.parser, overlay.parser.startParse(this.input, enterFragments(overlay.mounts, ranges), ranges), overlay.ranges.map((r) => new Range(r.from - overlay.start, r.to - overlay.start)), overlay.bracketed, overlay.target, ranges[0].from));
+					}
+					overlay = overlay.prev;
+				}
+				if (covered && !--covered.depth) covered = covered.prev;
+			}
+		}
+	}
+};
+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));
+	}
+}
+var StructureCursor = class {
+	constructor(root, offset) {
+		this.offset = offset;
+		this.done = false;
+		this.cursor = root.cursor(IterMode.IncludeAnonymous | IterMode.IgnoreMounts);
+	}
+	moveTo(pos) {
+		let { cursor } = this, p = pos - this.offset;
+		while (!this.done && cursor.from < p) if (cursor.to >= pos && cursor.enter(p, 1, IterMode.IgnoreOverlays | IterMode.ExcludeBuffers));
+		else if (cursor.to <= pos) {
+			if (!cursor.next(false)) this.done = true;
+		} else break;
+	}
+	hasNode(cursor) {
+		this.moveTo(cursor.from);
+		if (!this.done && this.cursor.from + this.offset == cursor.from && this.cursor.tree) for (let tree = this.cursor.tree;;) {
+			if (tree == cursor.tree) return true;
+			if (tree.children.length && tree.positions[0] == 0 && tree.children[0] instanceof Tree) tree = tree.children[0];
+			else break;
+		}
+		return false;
+	}
+};
+var FragmentCursor = class {
+	constructor(fragments) {
+		var _a;
+		this.fragments = fragments;
+		this.curTo = 0;
+		this.fragI = 0;
+		if (fragments.length) {
+			let first = this.curFrag = fragments[0];
+			this.curTo = (_a = first.tree.prop(stoppedInner)) !== null && _a !== void 0 ? _a : first.to;
+			this.inner = new StructureCursor(first.tree, -first.offset);
+		} else this.curFrag = this.inner = null;
+	}
+	hasNode(node) {
+		while (this.curFrag && node.from >= this.curTo) this.nextFrag();
+		return this.curFrag && this.curFrag.from <= node.from && this.curTo >= node.to && this.inner.hasNode(node);
+	}
+	nextFrag() {
+		var _a;
+		this.fragI++;
+		if (this.fragI == this.fragments.length) this.curFrag = this.inner = null;
+		else {
+			let frag = this.curFrag = this.fragments[this.fragI];
+			this.curTo = (_a = frag.tree.prop(stoppedInner)) !== null && _a !== void 0 ? _a : frag.to;
+			this.inner = new StructureCursor(frag.tree, -frag.offset);
+		}
+	}
+	findMounts(pos, parser) {
+		var _a;
+		let result = [];
+		if (this.inner) {
+			this.inner.cursor.moveTo(pos, 1);
+			for (let pos = this.inner.cursor.node; pos; pos = pos.parent) {
+				let mount = (_a = pos.tree) === null || _a === void 0 ? void 0 : _a.prop(NodeProp.mounted);
+				if (mount && mount.parser == parser) for (let i = this.fragI; i < this.fragments.length; i++) {
+					let frag = this.fragments[i];
+					if (frag.from >= pos.to) break;
+					if (frag.tree == this.curFrag.tree) result.push({
+						frag,
+						pos: pos.from - frag.offset,
+						mount
+					});
+				}
+			}
+		}
+		return result;
+	}
+};
+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
-export { DefaultBufferLength, IterMode, NodeProp, NodeSet, NodeType, NodeWeakMap, Parser, Tree, TreeFragment };
+export { DefaultBufferLength, IterMode, NodeProp, NodeSet, NodeType, NodeWeakMap, Parser, Tree, TreeFragment, parseMixed };
 
 //# sourceMappingURL=index.js.map