@veltra/desktop 1.2.17 → 1.2.19

package/dist/node_modules/.bun/@codemirror_view@6.43.4/node_modules/@codemirror/view/dist/index.js

@@ -1,6 +1,7 @@
 import { Annotation, ChangeSet, CharCategory, EditorSelection, EditorState, Facet, MapMode, Prec, RangeSet, RangeSetBuilder, RangeValue, StateEffect, StateField, Text, Transaction, codePointAt, codePointSize, combineConfig, countColumn, findClusterBreak, findColumn } from "../../../../../@codemirror_state@6.7.0/node_modules/@codemirror/state/dist/index.js";
 import { StyleModule } from "../../../../../style-mod@4.1.3/node_modules/style-mod/src/style-mod.js";
 import { base, keyName, shift } from "../../../../../w3c-keyname@2.2.8/node_modules/w3c-keyname/index.js";
+import crelt from "../../../../../crelt@1.0.6/node_modules/crelt/index.js";
 //#region ../../node_modules/.bun/@codemirror+view@6.43.4/node_modules/@codemirror/view/dist/index.js
 let nav = typeof navigator != "undefined" ? navigator : {
 	userAgent: "",
@@ -7491,6 +7492,14 @@ function getKeymap(state) {
 	if (!map) Keymaps.set(bindings, map = buildKeymap(bindings.reduce((a, b) => a.concat(b), [])));
 	return map;
 }
+/**
+Run the key handlers registered for a given scope. The event
+object should be a `"keydown"` event. Returns true if any of the
+handlers handled it.
+*/
+function runScopeHandlers(view, event, scope) {
+	return runHandlers(getKeymap(view.state), event, view, scope);
+}
 let storedPrefix = null;
 const PrefixTimeout = 4e3;
 function buildKeymap(bindings, platform = currentPlatform) {
@@ -8398,6 +8407,56 @@ function crosshairCursor(options = {}) {
 		return ((_a = view.plugin(plugin)) === null || _a === void 0 ? void 0 : _a.isDown) ? showCrosshair : null;
 	})];
 }
+const Outside = "-10000px";
+var TooltipViewManager = class {
+	constructor(view, facet, createTooltipView, removeTooltipView) {
+		this.facet = facet;
+		this.createTooltipView = createTooltipView;
+		this.removeTooltipView = removeTooltipView;
+		this.input = view.state.facet(facet);
+		this.tooltips = this.input.filter((t) => t);
+		let prev = null;
+		this.tooltipViews = this.tooltips.map((t) => prev = createTooltipView(t, prev));
+	}
+	update(update, above) {
+		var _a;
+		let input = update.state.facet(this.facet);
+		let tooltips = input.filter((x) => x);
+		if (input === this.input) {
+			for (let t of this.tooltipViews) if (t.update) t.update(update);
+			return false;
+		}
+		let tooltipViews = [], newAbove = above ? [] : null;
+		for (let i = 0; i < tooltips.length; i++) {
+			let tip = tooltips[i], known = -1;
+			if (!tip) continue;
+			for (let i = 0; i < this.tooltips.length; i++) {
+				let other = this.tooltips[i];
+				if (other && other.create == tip.create) known = i;
+			}
+			if (known < 0) {
+				tooltipViews[i] = this.createTooltipView(tip, i ? tooltipViews[i - 1] : null);
+				if (newAbove) newAbove[i] = !!tip.above;
+			} else {
+				let tooltipView = tooltipViews[i] = this.tooltipViews[known];
+				if (newAbove) newAbove[i] = above[known];
+				if (tooltipView.update) tooltipView.update(update);
+			}
+		}
+		for (let t of this.tooltipViews) if (tooltipViews.indexOf(t) < 0) {
+			this.removeTooltipView(t);
+			(_a = t.destroy) === null || _a === void 0 || _a.call(t);
+		}
+		if (above) {
+			newAbove.forEach((val, i) => above[i] = val);
+			above.length = newAbove.length;
+		}
+		this.input = input;
+		this.tooltips = tooltips;
+		this.tooltipViews = tooltipViews;
+		return true;
+	}
+};
 /**
 Creates an extension that configures tooltip behavior.
 */
@@ -8421,6 +8480,838 @@ const tooltipConfig = /*@__PURE__*/ Facet.define({ combine: (values) => {
 		tooltipSpace: ((_c = values.find((conf) => conf.tooltipSpace)) === null || _c === void 0 ? void 0 : _c.tooltipSpace) || windowSpace
 	};
 } });
+const knownHeight = /*@__PURE__*/ new WeakMap();
+const tooltipPlugin = /*@__PURE__*/ ViewPlugin.fromClass(class {
+	constructor(view) {
+		this.view = view;
+		this.above = [];
+		this.inView = true;
+		this.madeAbsolute = false;
+		this.lastTransaction = 0;
+		this.measureTimeout = -1;
+		let config = view.state.facet(tooltipConfig);
+		this.position = config.position;
+		this.parent = config.parent;
+		this.classes = view.themeClasses;
+		this.createContainer();
+		this.measureReq = {
+			read: this.readMeasure.bind(this),
+			write: this.writeMeasure.bind(this),
+			key: this
+		};
+		this.resizeObserver = typeof ResizeObserver == "function" ? new ResizeObserver(() => this.measureSoon()) : null;
+		this.manager = new TooltipViewManager(view, showTooltip, (t, p) => this.createTooltip(t, p), (t) => {
+			if (this.resizeObserver) this.resizeObserver.unobserve(t.dom);
+			t.dom.remove();
+		});
+		this.above = this.manager.tooltips.map((t) => !!t.above);
+		this.intersectionObserver = typeof IntersectionObserver == "function" ? new IntersectionObserver((entries) => {
+			if (Date.now() > this.lastTransaction - 50 && entries.length > 0 && entries[entries.length - 1].intersectionRatio < 1) this.measureSoon();
+		}, { threshold: [1] }) : null;
+		this.observeIntersection();
+		view.win.addEventListener("resize", this.measureSoon = this.measureSoon.bind(this));
+		this.maybeMeasure();
+	}
+	createContainer() {
+		if (this.parent) {
+			this.container = document.createElement("div");
+			this.container.style.position = "relative";
+			this.container.className = this.view.themeClasses;
+			this.parent.appendChild(this.container);
+		} else this.container = this.view.dom;
+	}
+	observeIntersection() {
+		if (this.intersectionObserver) {
+			this.intersectionObserver.disconnect();
+			for (let tooltip of this.manager.tooltipViews) this.intersectionObserver.observe(tooltip.dom);
+		}
+	}
+	measureSoon() {
+		if (this.measureTimeout < 0) this.measureTimeout = setTimeout(() => {
+			this.measureTimeout = -1;
+			this.maybeMeasure();
+		}, 50);
+	}
+	update(update) {
+		if (update.transactions.length) this.lastTransaction = Date.now();
+		let updated = this.manager.update(update, this.above);
+		if (updated) this.observeIntersection();
+		let shouldMeasure = updated || update.geometryChanged;
+		let newConfig = update.state.facet(tooltipConfig);
+		if (newConfig.position != this.position && !this.madeAbsolute) {
+			this.position = newConfig.position;
+			for (let t of this.manager.tooltipViews) t.dom.style.position = this.position;
+			shouldMeasure = true;
+		}
+		if (newConfig.parent != this.parent) {
+			if (this.parent) this.container.remove();
+			this.parent = newConfig.parent;
+			this.createContainer();
+			for (let t of this.manager.tooltipViews) this.container.appendChild(t.dom);
+			shouldMeasure = true;
+		} else if (this.parent && this.view.themeClasses != this.classes) this.classes = this.container.className = this.view.themeClasses;
+		if (shouldMeasure) this.maybeMeasure();
+	}
+	createTooltip(tooltip, prev) {
+		let tooltipView = tooltip.create(this.view);
+		let before = prev ? prev.dom : null;
+		tooltipView.dom.classList.add("cm-tooltip");
+		if (tooltip.arrow && !tooltipView.dom.querySelector(".cm-tooltip > .cm-tooltip-arrow")) {
+			let arrow = document.createElement("div");
+			arrow.className = "cm-tooltip-arrow";
+			tooltipView.dom.appendChild(arrow);
+		}
+		tooltipView.dom.style.position = this.position;
+		tooltipView.dom.style.top = Outside;
+		tooltipView.dom.style.left = "0px";
+		this.container.insertBefore(tooltipView.dom, before);
+		if (tooltipView.mount) tooltipView.mount(this.view);
+		if (this.resizeObserver) this.resizeObserver.observe(tooltipView.dom);
+		return tooltipView;
+	}
+	destroy() {
+		var _a, _b, _c;
+		this.view.win.removeEventListener("resize", this.measureSoon);
+		for (let tooltipView of this.manager.tooltipViews) {
+			tooltipView.dom.remove();
+			(_a = tooltipView.destroy) === null || _a === void 0 || _a.call(tooltipView);
+		}
+		if (this.parent) this.container.remove();
+		(_b = this.resizeObserver) === null || _b === void 0 || _b.disconnect();
+		(_c = this.intersectionObserver) === null || _c === void 0 || _c.disconnect();
+		clearTimeout(this.measureTimeout);
+	}
+	readMeasure() {
+		let scaleX = 1, scaleY = 1, makeAbsolute = false;
+		if (this.position == "fixed" && this.manager.tooltipViews.length) {
+			let { dom } = this.manager.tooltipViews[0];
+			if (browser.safari) {
+				let rect = dom.getBoundingClientRect();
+				makeAbsolute = Math.abs(rect.top + 1e4) > 1 || Math.abs(rect.left) > 1;
+			} else makeAbsolute = !!dom.offsetParent && dom.offsetParent != this.container.ownerDocument.body;
+		}
+		if (makeAbsolute || this.position == "absolute") if (this.parent) {
+			let rect = this.parent.getBoundingClientRect();
+			if (rect.width && rect.height) {
+				scaleX = rect.width / this.parent.offsetWidth;
+				scaleY = rect.height / this.parent.offsetHeight;
+			}
+		} else ({scaleX, scaleY} = this.view.viewState);
+		let visible = this.view.scrollDOM.getBoundingClientRect(), margins = getScrollMargins(this.view);
+		return {
+			visible: {
+				left: visible.left + margins.left,
+				top: visible.top + margins.top,
+				right: visible.right - margins.right,
+				bottom: visible.bottom - margins.bottom
+			},
+			parent: this.parent ? this.container.getBoundingClientRect() : this.view.dom.getBoundingClientRect(),
+			pos: this.manager.tooltips.map((t, i) => {
+				let tv = this.manager.tooltipViews[i];
+				return tv.getCoords ? tv.getCoords(t.pos) : this.view.coordsAtPos(t.pos);
+			}),
+			size: this.manager.tooltipViews.map(({ dom }) => dom.getBoundingClientRect()),
+			space: this.view.state.facet(tooltipConfig).tooltipSpace(this.view),
+			scaleX,
+			scaleY,
+			makeAbsolute
+		};
+	}
+	writeMeasure(measured) {
+		var _a;
+		if (measured.makeAbsolute) {
+			this.madeAbsolute = true;
+			this.position = "absolute";
+			for (let t of this.manager.tooltipViews) t.dom.style.position = "absolute";
+		}
+		let { visible, space, scaleX, scaleY } = measured;
+		let others = [];
+		for (let i = 0; i < this.manager.tooltips.length; i++) {
+			let tooltip = this.manager.tooltips[i], tView = this.manager.tooltipViews[i], { dom } = tView;
+			let pos = measured.pos[i], size = measured.size[i];
+			if (!pos || tooltip.clip !== false && (pos.bottom <= Math.max(visible.top, space.top) || pos.top >= Math.min(visible.bottom, space.bottom) || pos.right < Math.max(visible.left, space.left) - .1 || pos.left > Math.min(visible.right, space.right) + .1)) {
+				dom.style.top = Outside;
+				continue;
+			}
+			let arrow = tooltip.arrow ? tView.dom.querySelector(".cm-tooltip-arrow") : null;
+			let arrowHeight = arrow ? 7 : 0;
+			let width = size.right - size.left, height = (_a = knownHeight.get(tView)) !== null && _a !== void 0 ? _a : size.bottom - size.top;
+			let offset = tView.offset || noOffset, ltr = this.view.textDirection == Direction.LTR;
+			let left = size.width > space.right - space.left ? ltr ? space.left : space.right - size.width : ltr ? Math.max(space.left, Math.min(pos.left - (arrow ? 14 : 0) + offset.x, space.right - width)) : Math.min(Math.max(space.left, pos.left - width + (arrow ? 14 : 0) - offset.x), space.right - width);
+			let above = this.above[i];
+			if (!tooltip.strictSide && (above ? pos.top - height - arrowHeight - offset.y < space.top : pos.bottom + height + arrowHeight + offset.y > space.bottom) && above == space.bottom - pos.bottom > pos.top - space.top) above = this.above[i] = !above;
+			let spaceVert = (above ? pos.top - space.top : space.bottom - pos.bottom) - arrowHeight;
+			if (spaceVert < height && tView.resize !== false) {
+				if (spaceVert < this.view.defaultLineHeight) {
+					dom.style.top = Outside;
+					continue;
+				}
+				knownHeight.set(tView, height);
+				dom.style.height = (height = spaceVert) / scaleY + "px";
+			} else if (dom.style.height) dom.style.height = "";
+			let top = above ? pos.top - height - arrowHeight - offset.y : pos.bottom + arrowHeight + offset.y;
+			let right = left + width;
+			if (tView.overlap !== true) {
+				for (let r of others) if (r.left < right && r.right > left && r.top < top + height && r.bottom > top) top = above ? r.top - height - 2 - arrowHeight : r.bottom + arrowHeight + 2;
+			}
+			if (this.position == "absolute") {
+				dom.style.top = (top - measured.parent.top) / scaleY + "px";
+				setLeftStyle(dom, (left - measured.parent.left) / scaleX);
+			} else {
+				dom.style.top = top / scaleY + "px";
+				setLeftStyle(dom, left / scaleX);
+			}
+			if (arrow) {
+				let arrowLeft = pos.left + (ltr ? offset.x : -offset.x) - (left + 14 - 7);
+				arrow.style.left = arrowLeft / scaleX + "px";
+			}
+			if (tView.overlap !== true) others.push({
+				left,
+				top,
+				right,
+				bottom: top + height
+			});
+			dom.classList.toggle("cm-tooltip-above", above);
+			dom.classList.toggle("cm-tooltip-below", !above);
+			if (tView.positioned) tView.positioned(measured.space);
+		}
+	}
+	maybeMeasure() {
+		if (this.manager.tooltips.length) {
+			if (this.view.inView) this.view.requestMeasure(this.measureReq);
+			if (this.inView != this.view.inView) {
+				this.inView = this.view.inView;
+				if (!this.inView) for (let tv of this.manager.tooltipViews) tv.dom.style.top = Outside;
+			}
+		}
+	}
+}, { eventObservers: { scroll() {
+	this.maybeMeasure();
+} } });
+function setLeftStyle(elt, value) {
+	let current = parseInt(elt.style.left, 10);
+	if (isNaN(current) || Math.abs(value - current) > 1) elt.style.left = value + "px";
+}
+const baseTheme = /*@__PURE__*/ EditorView.baseTheme({
+	".cm-tooltip": {
+		zIndex: 500,
+		boxSizing: "border-box"
+	},
+	"&light .cm-tooltip": {
+		border: "1px solid #bbb",
+		backgroundColor: "#f5f5f5"
+	},
+	"&light .cm-tooltip-section:not(:first-child)": { borderTop: "1px solid #bbb" },
+	"&dark .cm-tooltip": {
+		backgroundColor: "#333338",
+		color: "white"
+	},
+	".cm-tooltip-arrow": {
+		height: `7px`,
+		width: `14px`,
+		position: "absolute",
+		zIndex: -1,
+		overflow: "hidden",
+		"&:before, &:after": {
+			content: "''",
+			position: "absolute",
+			width: 0,
+			height: 0,
+			borderLeft: `7px solid transparent`,
+			borderRight: `7px solid transparent`
+		},
+		".cm-tooltip-above &": {
+			bottom: `-7px`,
+			"&:before": { borderTop: `7px solid #bbb` },
+			"&:after": {
+				borderTop: `7px solid #f5f5f5`,
+				bottom: "1px"
+			}
+		},
+		".cm-tooltip-below &": {
+			top: `-7px`,
+			"&:before": { borderBottom: `7px solid #bbb` },
+			"&:after": {
+				borderBottom: `7px solid #f5f5f5`,
+				top: "1px"
+			}
+		}
+	},
+	"&dark .cm-tooltip .cm-tooltip-arrow": {
+		"&:before": {
+			borderTopColor: "#333338",
+			borderBottomColor: "#333338"
+		},
+		"&:after": {
+			borderTopColor: "transparent",
+			borderBottomColor: "transparent"
+		}
+	}
+});
+const noOffset = {
+	x: 0,
+	y: 0
+};
+/**
+Facet to which an extension can add a value to show a tooltip.
+*/
+const showTooltip = /*@__PURE__*/ Facet.define({ enables: [tooltipPlugin, baseTheme] });
+const showHoverTooltip = /*@__PURE__*/ Facet.define({ combine: (inputs) => inputs.reduce((a, i) => a.concat(i), []) });
+var HoverTooltipHost = class HoverTooltipHost {
+	static create(view) {
+		return new HoverTooltipHost(view);
+	}
+	constructor(view) {
+		this.view = view;
+		this.mounted = false;
+		this.dom = document.createElement("div");
+		this.dom.classList.add("cm-tooltip-hover");
+		this.manager = new TooltipViewManager(view, showHoverTooltip, (t, p) => this.createHostedView(t, p), (t) => t.dom.remove());
+	}
+	createHostedView(tooltip, prev) {
+		let hostedView = tooltip.create(this.view);
+		hostedView.dom.classList.add("cm-tooltip-section");
+		this.dom.insertBefore(hostedView.dom, prev ? prev.dom.nextSibling : this.dom.firstChild);
+		if (this.mounted && hostedView.mount) hostedView.mount(this.view);
+		return hostedView;
+	}
+	mount(view) {
+		for (let hostedView of this.manager.tooltipViews) if (hostedView.mount) hostedView.mount(view);
+		this.mounted = true;
+	}
+	positioned(space) {
+		for (let hostedView of this.manager.tooltipViews) if (hostedView.positioned) hostedView.positioned(space);
+	}
+	update(update) {
+		this.manager.update(update);
+	}
+	destroy() {
+		var _a;
+		for (let t of this.manager.tooltipViews) (_a = t.destroy) === null || _a === void 0 || _a.call(t);
+	}
+	passProp(name) {
+		let value = void 0;
+		for (let view of this.manager.tooltipViews) {
+			let given = view[name];
+			if (given !== void 0) {
+				if (value === void 0) value = given;
+				else if (value !== given) return void 0;
+			}
+		}
+		return value;
+	}
+	get offset() {
+		return this.passProp("offset");
+	}
+	get getCoords() {
+		return this.passProp("getCoords");
+	}
+	get overlap() {
+		return this.passProp("overlap");
+	}
+	get resize() {
+		return this.passProp("resize");
+	}
+};
+const showHoverTooltipHost = /*@__PURE__*/ showTooltip.compute([showHoverTooltip], (state) => {
+	let tooltips = state.facet(showHoverTooltip);
+	if (tooltips.length === 0) return null;
+	return {
+		pos: Math.min(...tooltips.map((t) => t.pos)),
+		end: Math.max(...tooltips.map((t) => {
+			var _a;
+			return (_a = t.end) !== null && _a !== void 0 ? _a : t.pos;
+		})),
+		create: HoverTooltipHost.create,
+		above: tooltips[0].above,
+		arrow: tooltips.some((t) => t.arrow)
+	};
+});
+const hoverPlugin = /*@__PURE__*/ Facet.define();
+var HoverPlugin = class {
+	constructor(view, source, field, locked, setHover, hoverTime) {
+		this.view = view;
+		this.source = source;
+		this.field = field;
+		this.locked = locked;
+		this.setHover = setHover;
+		this.hoverTime = hoverTime;
+		this.hoverTimeout = -1;
+		this.restartTimeout = -1;
+		this.pending = null;
+		this.lastMove = {
+			x: 0,
+			y: 0,
+			target: view.dom,
+			time: 0
+		};
+		this.checkHover = this.checkHover.bind(this);
+		view.dom.addEventListener("mouseleave", this.mouseleave = this.mouseleave.bind(this));
+		view.dom.addEventListener("mousemove", this.mousemove = this.mousemove.bind(this));
+	}
+	update(update) {
+		if (this.pending) {
+			this.pending = null;
+			clearTimeout(this.restartTimeout);
+			this.restartTimeout = setTimeout(() => this.startHover(), 20);
+		}
+	}
+	get active() {
+		return this.view.state.field(this.field);
+	}
+	checkHover() {
+		this.hoverTimeout = -1;
+		if (this.active.length) return;
+		let hovered = Date.now() - this.lastMove.time;
+		if (hovered < this.hoverTime) this.hoverTimeout = setTimeout(this.checkHover, this.hoverTime - hovered);
+		else this.startHover();
+	}
+	startHover() {
+		clearTimeout(this.restartTimeout);
+		let { view, lastMove } = this;
+		let tile = view.docView.tile.nearest(lastMove.target);
+		if (!tile) return;
+		let pos, side = 1;
+		if (tile.isWidget()) pos = tile.posAtStart;
+		else {
+			pos = view.posAtCoords(lastMove);
+			if (pos == null) return;
+			let posCoords = view.coordsAtPos(pos);
+			if (!posCoords || lastMove.y < posCoords.top || lastMove.y > posCoords.bottom || lastMove.x < posCoords.left - view.defaultCharacterWidth || lastMove.x > posCoords.right + view.defaultCharacterWidth) return;
+			let bidi = view.bidiSpans(view.state.doc.lineAt(pos)).find((s) => s.from <= pos && s.to >= pos);
+			let rtl = bidi && bidi.dir == Direction.RTL ? -1 : 1;
+			side = lastMove.x < posCoords.left ? -rtl : rtl;
+		}
+		this.activateHover(view, pos, side);
+	}
+	activateHover(view, pos, side, locked) {
+		let open = this.source(view, pos, side);
+		let done = (value) => {
+			if (value && !(Array.isArray(value) && !value.length)) {
+				let tooltips = Array.isArray(value) ? value : [value];
+				if (locked) this.locked.set(tooltips, locked);
+				view.dispatch({ effects: this.setHover.of(tooltips) });
+			}
+		};
+		if (open && "then" in open) {
+			let pending = this.pending = { pos };
+			open.then((result) => {
+				if (this.pending == pending) {
+					this.pending = null;
+					done(result);
+				}
+			}, (e) => logException(view.state, e, "hover tooltip"));
+		} else done(open);
+	}
+	get tooltip() {
+		let plugin = this.view.plugin(tooltipPlugin);
+		let index = plugin ? plugin.manager.tooltips.findIndex((t) => t.create == HoverTooltipHost.create) : -1;
+		return index > -1 ? plugin.manager.tooltipViews[index] : null;
+	}
+	mousemove(event) {
+		var _a, _b;
+		this.lastMove = {
+			x: event.clientX,
+			y: event.clientY,
+			target: event.target,
+			time: Date.now()
+		};
+		if (this.hoverTimeout < 0) this.hoverTimeout = setTimeout(this.checkHover, this.hoverTime);
+		let { active, tooltip } = this;
+		if (active.length && !this.locked.has(active) && tooltip && !isInTooltip(tooltip.dom, event) || this.pending) {
+			let { pos } = active[0] || this.pending, end = (_b = (_a = active[0]) === null || _a === void 0 ? void 0 : _a.end) !== null && _b !== void 0 ? _b : pos;
+			if (pos == end ? this.view.posAtCoords(this.lastMove) != pos : !isOverRange(this.view, pos, end, event.clientX, event.clientY)) {
+				this.view.dispatch({ effects: this.setHover.of([]) });
+				this.pending = null;
+			}
+		}
+	}
+	mouseleave(event) {
+		clearTimeout(this.hoverTimeout);
+		this.hoverTimeout = -1;
+		let { active } = this;
+		if (active.length && !this.locked.has(active)) {
+			let { tooltip } = this;
+			if (!(tooltip && tooltip.dom.contains(event.relatedTarget))) this.view.dispatch({ effects: this.setHover.of([]) });
+			else this.watchTooltipLeave(tooltip.dom);
+		}
+	}
+	watchTooltipLeave(tooltip) {
+		let watch = (event) => {
+			tooltip.removeEventListener("mouseleave", watch);
+			let { active } = this;
+			if (active.length && !this.locked.has(active) && !this.view.dom.contains(event.relatedTarget)) this.view.dispatch({ effects: this.setHover.of([]) });
+		};
+		tooltip.addEventListener("mouseleave", watch);
+	}
+	destroy() {
+		clearTimeout(this.hoverTimeout);
+		clearTimeout(this.restartTimeout);
+		this.view.dom.removeEventListener("mouseleave", this.mouseleave);
+		this.view.dom.removeEventListener("mousemove", this.mousemove);
+	}
+};
+const tooltipMargin = 4;
+function isInTooltip(tooltip, event) {
+	let { left, right, top, bottom } = tooltip.getBoundingClientRect(), arrow;
+	if (arrow = tooltip.querySelector(".cm-tooltip-arrow")) {
+		let arrowRect = arrow.getBoundingClientRect();
+		top = Math.min(arrowRect.top, top);
+		bottom = Math.max(arrowRect.bottom, bottom);
+	}
+	return event.clientX >= left - tooltipMargin && event.clientX <= right + tooltipMargin && event.clientY >= top - tooltipMargin && event.clientY <= bottom + tooltipMargin;
+}
+function isOverRange(view, from, to, x, y, margin) {
+	let rect = view.scrollDOM.getBoundingClientRect();
+	let docBottom = view.documentTop + view.documentPadding.top + view.contentHeight;
+	if (rect.left > x || rect.right < x || rect.top > y || Math.min(rect.bottom, docBottom) < y) return false;
+	let pos = view.posAtCoords({
+		x,
+		y
+	}, false);
+	return pos >= from && pos <= to;
+}
+/**
+Set up a hover tooltip, which shows up when the pointer hovers
+over ranges of text. The callback is called when the mouse hovers
+over the document text. It should, if there is a tooltip
+associated with position `pos`, return the tooltip description
+(either directly or in a promise). The `side` argument indicates
+on which side of the position the pointer is—it will be -1 if the
+pointer is before the position, 1 if after the position.
+
+Note that all hover tooltips are hosted within a single tooltip
+container element. This allows multiple tooltips over the same
+range to be "merged" together without overlapping.
+
+The return value is a valid [editor extension](https://codemirror.net/6/docs/ref/#state.Extension)
+but also provides an `active` property holding a state field that
+can be used to read the currently active tooltips produced by this
+extension.
+*/
+function hoverTooltip(source, options = {}) {
+	let setHover = StateEffect.define();
+	let locked = /* @__PURE__ */ new WeakMap();
+	let hoverState = StateField.define({
+		create() {
+			return [];
+		},
+		update(value, tr) {
+			let lock = locked.get(value);
+			if (value.length) {
+				if (options.hideOnChange && (tr.docChanged || tr.selection)) value = [];
+				else if (lock && lock(tr)) value = [];
+				else if (options.hideOn) value = value.filter((v) => !options.hideOn(tr, v));
+			}
+			if (tr.docChanged && value.length) {
+				let mapped = [];
+				for (let tooltip of value) {
+					let newPos = tr.changes.mapPos(tooltip.pos, -1, MapMode.TrackDel);
+					if (newPos != null) {
+						let copy = Object.assign(Object.create(null), tooltip);
+						copy.pos = newPos;
+						if (copy.end != null) copy.end = tr.changes.mapPos(copy.end);
+						mapped.push(copy);
+					}
+				}
+				value = mapped;
+			}
+			for (let effect of tr.effects) {
+				if (effect.is(setHover)) {
+					value = effect.value;
+					lock = void 0;
+				}
+				if (effect.is(closeHoverTooltipEffect) && !effect.value || effect.value == hoverState) value = [];
+			}
+			if (value.length && lock) locked.set(value, lock);
+			return value;
+		},
+		provide: (f) => showHoverTooltip.from(f)
+	});
+	const plugin = ViewPlugin.define((view) => new HoverPlugin(view, source, hoverState, locked, setHover, options.hoverTime || 300));
+	return {
+		active: hoverState,
+		extension: [
+			hoverState,
+			plugin,
+			hoverPlugin.of(plugin),
+			showHoverTooltipHost
+		]
+	};
+}
+/**
+Activate hover tooltips for the given position and side. If you
+provide a specific hover tooltip (the value returned from
+[`hoverTooltip`](https://codemirror.net/6/docs/ref/#view.hoverTooltip)), only that one will be
+activated. If not given, all hover tooltips at the given position
+are triggered.
+
+Note that tooltips opened this way don't close automatically, and
+you'll want to pass an `until` callback or use
+[`closeHoverTooltip`](https://codemirror.net/6/docs/ref/#view.closeHoverTooltip)/[`closeHoverTooltips`](https://codemirror.net/6/docs/ref/#view.closeHoverTooltips)
+to deactivate them.
+*/
+function activateHover(view, pos, side, options = {}) {
+	var _a;
+	let plugins = view.state.facet(hoverPlugin).map((p) => view.plugin(p)).filter((p) => !!p);
+	if (options.tooltip && options.tooltip.active) {
+		let found = plugins.find((p) => p.field == options.tooltip.active);
+		if (found) plugins = [found];
+	}
+	for (let plugin of plugins) plugin.activateHover(view, pos, side, (_a = options.until) !== null && _a !== void 0 ? _a : (() => false));
+}
+/**
+Get the active tooltip view for a given tooltip, if available.
+*/
+function getTooltip(view, tooltip) {
+	let plugin = view.plugin(tooltipPlugin);
+	if (!plugin) return null;
+	let found = plugin.manager.tooltips.indexOf(tooltip);
+	return found < 0 ? null : plugin.manager.tooltipViews[found];
+}
+const closeHoverTooltipEffect = /*@__PURE__*/ StateEffect.define();
+const panelConfig = /*@__PURE__*/ Facet.define({ combine(configs) {
+	let topContainer, bottomContainer;
+	for (let c of configs) {
+		topContainer = topContainer || c.topContainer;
+		bottomContainer = bottomContainer || c.bottomContainer;
+	}
+	return {
+		topContainer,
+		bottomContainer
+	};
+} });
+/**
+Get the active panel created by the given constructor, if any.
+This can be useful when you need access to your panels' DOM
+structure.
+*/
+function getPanel(view, panel) {
+	let plugin = view.plugin(panelPlugin);
+	let index = plugin ? plugin.specs.indexOf(panel) : -1;
+	return index > -1 ? plugin.panels[index] : null;
+}
+const panelPlugin = /*@__PURE__*/ ViewPlugin.fromClass(class {
+	constructor(view) {
+		this.input = view.state.facet(showPanel);
+		this.specs = this.input.filter((s) => s);
+		this.panels = this.specs.map((spec) => spec(view));
+		let conf = view.state.facet(panelConfig);
+		this.top = new PanelGroup(view, true, conf.topContainer);
+		this.bottom = new PanelGroup(view, false, conf.bottomContainer);
+		this.top.sync(this.panels.filter((p) => p.top));
+		this.bottom.sync(this.panels.filter((p) => !p.top));
+		for (let p of this.panels) {
+			p.dom.classList.add("cm-panel");
+			if (p.mount) p.mount();
+		}
+	}
+	update(update) {
+		let conf = update.state.facet(panelConfig);
+		if (this.top.container != conf.topContainer) {
+			this.top.sync([]);
+			this.top = new PanelGroup(update.view, true, conf.topContainer);
+		}
+		if (this.bottom.container != conf.bottomContainer) {
+			this.bottom.sync([]);
+			this.bottom = new PanelGroup(update.view, false, conf.bottomContainer);
+		}
+		this.top.syncClasses();
+		this.bottom.syncClasses();
+		let input = update.state.facet(showPanel);
+		if (input != this.input) {
+			let specs = input.filter((x) => x);
+			let panels = [], top = [], bottom = [], mount = [];
+			for (let spec of specs) {
+				let known = this.specs.indexOf(spec), panel;
+				if (known < 0) {
+					panel = spec(update.view);
+					mount.push(panel);
+				} else {
+					panel = this.panels[known];
+					if (panel.update) panel.update(update);
+				}
+				panels.push(panel);
+				(panel.top ? top : bottom).push(panel);
+			}
+			this.specs = specs;
+			this.panels = panels;
+			this.top.sync(top);
+			this.bottom.sync(bottom);
+			for (let p of mount) {
+				p.dom.classList.add("cm-panel");
+				if (p.mount) p.mount();
+			}
+		} else for (let p of this.panels) if (p.update) p.update(update);
+	}
+	destroy() {
+		this.top.sync([]);
+		this.bottom.sync([]);
+	}
+}, { provide: (plugin) => EditorView.scrollMargins.of((view) => {
+	let value = view.plugin(plugin);
+	return value && {
+		top: value.top.scrollMargin(),
+		bottom: value.bottom.scrollMargin()
+	};
+}) });
+var PanelGroup = class {
+	constructor(view, top, container) {
+		this.view = view;
+		this.top = top;
+		this.container = container;
+		this.dom = void 0;
+		this.classes = "";
+		this.panels = [];
+		this.syncClasses();
+	}
+	sync(panels) {
+		for (let p of this.panels) if (p.destroy && panels.indexOf(p) < 0) p.destroy();
+		this.panels = panels;
+		this.syncDOM();
+	}
+	syncDOM() {
+		if (this.panels.length == 0) {
+			if (this.dom) {
+				this.dom.remove();
+				this.dom = void 0;
+			}
+			return;
+		}
+		if (!this.dom) {
+			this.dom = document.createElement("div");
+			this.dom.className = this.top ? "cm-panels cm-panels-top" : "cm-panels cm-panels-bottom";
+			this.dom.style[this.top ? "top" : "bottom"] = "0";
+			let parent = this.container || this.view.dom;
+			parent.insertBefore(this.dom, this.top ? parent.firstChild : null);
+		}
+		let curDOM = this.dom.firstChild;
+		for (let panel of this.panels) if (panel.dom.parentNode == this.dom) {
+			while (curDOM != panel.dom) curDOM = rm(curDOM);
+			curDOM = curDOM.nextSibling;
+		} else this.dom.insertBefore(panel.dom, curDOM);
+		while (curDOM) curDOM = rm(curDOM);
+	}
+	scrollMargin() {
+		return !this.dom || this.container ? 0 : Math.max(0, this.top ? this.dom.getBoundingClientRect().bottom - Math.max(0, this.view.scrollDOM.getBoundingClientRect().top) : Math.min(innerHeight, this.view.scrollDOM.getBoundingClientRect().bottom) - this.dom.getBoundingClientRect().top);
+	}
+	syncClasses() {
+		if (!this.container || this.classes == this.view.themeClasses) return;
+		for (let cls of this.classes.split(" ")) if (cls) this.container.classList.remove(cls);
+		for (let cls of (this.classes = this.view.themeClasses).split(" ")) if (cls) this.container.classList.add(cls);
+	}
+};
+function rm(node) {
+	let next = node.nextSibling;
+	node.remove();
+	return next;
+}
+/**
+Opening a panel is done by providing a constructor function for
+the panel through this facet. (The panel is closed again when its
+constructor is no longer provided.) Values of `null` are ignored.
+*/
+const showPanel = /*@__PURE__*/ Facet.define({ enables: panelPlugin });
+/**
+Show a panel above or below the editor to show the user a message
+or prompt them for input. Returns an effect that can be dispatched
+to close the dialog, and a promise that resolves when the dialog
+is closed or a form inside of it is submitted.
+
+You are encouraged, if your handling of the result of the promise
+dispatches a transaction, to include the `close` effect in it. If
+you don't, this function will automatically dispatch a separate
+transaction right after.
+*/
+function showDialog(view, config) {
+	let resolve;
+	let promise = new Promise((r) => resolve = r);
+	let panelCtor = (view) => createDialog(view, config, resolve);
+	if (view.state.field(dialogField, false)) view.dispatch({ effects: openDialogEffect.of(panelCtor) });
+	else view.dispatch({ effects: StateEffect.appendConfig.of(dialogField.init(() => [panelCtor])) });
+	let close = closeDialogEffect.of(panelCtor);
+	return {
+		close,
+		result: promise.then((form) => {
+			(view.win.queueMicrotask || ((f) => view.win.setTimeout(f, 10)))(() => {
+				if (view.state.field(dialogField).indexOf(panelCtor) > -1) view.dispatch({ effects: close });
+			});
+			return form;
+		})
+	};
+}
+const dialogField = /*@__PURE__*/ StateField.define({
+	create() {
+		return [];
+	},
+	update(dialogs, tr) {
+		for (let e of tr.effects) if (e.is(openDialogEffect)) dialogs = [e.value].concat(dialogs);
+		else if (e.is(closeDialogEffect)) dialogs = dialogs.filter((d) => d != e.value);
+		return dialogs;
+	},
+	provide: (f) => showPanel.computeN([f], (state) => state.field(f))
+});
+const openDialogEffect = /*@__PURE__*/ StateEffect.define();
+const closeDialogEffect = /*@__PURE__*/ StateEffect.define();
+function createDialog(view, config, result) {
+	let content = config.content ? config.content(view, () => done(null)) : null;
+	if (!content) {
+		content = crelt("form");
+		if (config.input) {
+			let input = crelt("input", config.input);
+			if (/^(text|password|number|email|tel|url)$/.test(input.type)) input.classList.add("cm-textfield");
+			if (!input.name) input.name = "input";
+			content.appendChild(crelt("label", (config.label || "") + ": ", input));
+		} else content.appendChild(document.createTextNode(config.label || ""));
+		content.appendChild(document.createTextNode(" "));
+		content.appendChild(crelt("button", {
+			class: "cm-button",
+			type: "submit"
+		}, config.submitLabel || "OK"));
+	}
+	let forms = content.nodeName == "FORM" ? [content] : content.querySelectorAll("form");
+	for (let i = 0; i < forms.length; i++) {
+		let form = forms[i];
+		form.addEventListener("keydown", (event) => {
+			if (event.keyCode == 27) {
+				event.preventDefault();
+				done(null);
+			} else if (event.keyCode == 13) {
+				event.preventDefault();
+				done(form);
+			}
+		});
+		form.addEventListener("submit", (event) => {
+			event.preventDefault();
+			done(form);
+		});
+	}
+	let panel = crelt("div", content, crelt("button", {
+		onclick: () => done(null),
+		"aria-label": view.state.phrase("close"),
+		class: "cm-dialog-close",
+		type: "button"
+	}, ["×"]));
+	if (config.class) panel.className = config.class;
+	panel.classList.add("cm-dialog");
+	function done(form) {
+		if (panel.contains(panel.ownerDocument.activeElement)) view.focus();
+		result(form);
+	}
+	return {
+		dom: panel,
+		top: config.top,
+		mount: () => {
+			if (config.focus) {
+				let focus;
+				if (typeof config.focus == "string") focus = content.querySelector(config.focus);
+				else focus = content.querySelector("input") || content.querySelector("button");
+				if (focus && "select" in focus) focus.select();
+				else if (focus && "focus" in focus) focus.focus();
+			}
+		}
+	};
+}
 /**
 A gutter marker represents a bit of information attached to a line
 in a specific gutter. Your own custom markers have to extend this
@@ -8463,7 +9354,30 @@ Facet used to add a class to all gutter elements next to a widget.
 Should not provide widgets with a `toDOM` method.
 */
 const gutterWidgetClass = /*@__PURE__*/ Facet.define();
+const defaults = {
+	class: "",
+	renderEmptyElements: false,
+	elementStyle: "",
+	markers: () => RangeSet.empty,
+	lineMarker: () => null,
+	widgetMarker: () => null,
+	lineMarkerChange: null,
+	initialSpacer: null,
+	updateSpacer: null,
+	domEventHandlers: {},
+	side: "before"
+};
 const activeGutters = /*@__PURE__*/ Facet.define();
+/**
+Define an editor gutter. The order in which the gutters appear is
+determined by their extension priority.
+*/
+function gutter(config) {
+	return [gutters(), activeGutters.of({
+		...defaults,
+		...config
+	})];
+}
 const unfixGutters = /*@__PURE__*/ Facet.define({ combine: (values) => values.some((x) => x) });
 /**
 The gutter-drawing plugin is automatically enabled when you add a
@@ -8851,6 +9765,6 @@ function highlightActiveLineGutter() {
 	return activeLineGutterHighlighter;
 }
 //#endregion
-export { EditorView, ViewPlugin, crosshairCursor, drawSelection, dropCursor, highlightActiveLine, highlightActiveLineGutter, highlightSpecialChars, keymap, lineNumbers, rectangularSelection, tooltips };
+export { Decoration, Direction, EditorView, GutterMarker, ViewPlugin, WidgetType, activateHover, crosshairCursor, drawSelection, dropCursor, getPanel, getTooltip, gutter, highlightActiveLine, highlightActiveLineGutter, highlightSpecialChars, hoverTooltip, keymap, lineNumbers, logException, rectangularSelection, runScopeHandlers, showDialog, showPanel, showTooltip, tooltips };
 
 //# sourceMappingURL=index.js.map