@kky42/pievo-server 1.0.0

package/.output/server/_libs/codemirror__lint.mjs

@@ -0,0 +1,565 @@
+import { $ as getPanel, Dt as combineConfig, J as WidgetType, K as EditorView, St as StateField, W as Decoration, Y as activateHover, bt as RangeSetBuilder, dt as crelt, rt as hoverTooltip, ut as showPanel, vt as Facet, xt as StateEffect } from "./@codemirror/autocomplete+[...].mjs";
+//#region ../../node_modules/.pnpm/@codemirror+lint@6.9.7/node_modules/@codemirror/lint/dist/index.js
+var SelectedDiagnostic = class {
+	constructor(from, to, diagnostic) {
+		this.from = from;
+		this.to = to;
+		this.diagnostic = diagnostic;
+	}
+};
+var LintState = class LintState {
+	constructor(diagnostics, panel, selected) {
+		this.diagnostics = diagnostics;
+		this.panel = panel;
+		this.selected = selected;
+	}
+	static init(diagnostics, panel, state) {
+		let diagnosticFilter = state.facet(lintConfig).markerFilter;
+		if (diagnosticFilter) diagnostics = diagnosticFilter(diagnostics, state);
+		let sorted = diagnostics.slice().sort((a, b) => a.from - b.from || a.to - b.to);
+		let deco = new RangeSetBuilder(), active = [], pos = 0;
+		let scan = state.doc.iter(), scanPos = 0, docLen = state.doc.length;
+		for (let i = 0;;) {
+			let next = i == sorted.length ? null : sorted[i];
+			if (!next && !active.length) break;
+			let from, to;
+			if (active.length) {
+				from = pos;
+				to = active.reduce((p, d) => Math.min(p, d.to), next && next.from > from ? next.from : 1e8);
+			} else {
+				from = next.from;
+				if (from > docLen) break;
+				to = next.to;
+				active.push(next);
+				i++;
+			}
+			while (i < sorted.length) {
+				let next = sorted[i];
+				if (next.from == from && (next.to > next.from || next.to == from)) {
+					active.push(next);
+					i++;
+					to = Math.min(next.to, to);
+				} else {
+					to = Math.min(next.from, to);
+					break;
+				}
+			}
+			to = Math.min(to, docLen);
+			let widget = false;
+			if (active.some((d) => d.from == from && (d.to == to || to == docLen))) {
+				widget = from == to;
+				if (!widget && to - from < 10) {
+					let behind = from - (scanPos + scan.value.length);
+					if (behind > 0) {
+						scan.next(behind);
+						scanPos = from;
+					}
+					for (let check = from;;) {
+						if (check >= to) {
+							widget = true;
+							break;
+						}
+						if (!scan.lineBreak && scanPos + scan.value.length > check) break;
+						check = scanPos + scan.value.length;
+						scanPos += scan.value.length;
+						scan.next();
+					}
+				}
+			}
+			let sev = maxSeverity(active);
+			if (widget) deco.add(from, from, Decoration.widget({
+				widget: new DiagnosticWidget(sev),
+				diagnostics: active.slice()
+			}));
+			else {
+				let markClass = active.reduce((c, d) => d.markClass ? c + " " + d.markClass : c, "");
+				deco.add(from, to, Decoration.mark({
+					class: "cm-lintRange cm-lintRange-" + sev + markClass,
+					diagnostics: active.slice(),
+					inclusiveEnd: active.some((a) => a.to > to)
+				}));
+			}
+			pos = to;
+			if (pos == docLen) break;
+			for (let i = 0; i < active.length; i++) if (active[i].to <= pos) active.splice(i--, 1);
+		}
+		let set = deco.finish();
+		return new LintState(set, panel, findDiagnostic(set));
+	}
+};
+function findDiagnostic(diagnostics, diagnostic = null, after = 0) {
+	let found = null;
+	diagnostics.between(after, 1e9, (from, to, { spec }) => {
+		if (diagnostic && spec.diagnostics.indexOf(diagnostic) < 0) return;
+		if (!found) found = new SelectedDiagnostic(from, to, diagnostic || spec.diagnostics[0]);
+		else if (spec.diagnostics.indexOf(found.diagnostic) < 0) return false;
+		else found = new SelectedDiagnostic(found.from, to, found.diagnostic);
+	});
+	return found;
+}
+function hideTooltip(tr, tooltip) {
+	let from = tooltip.pos, to = tooltip.end || from;
+	let result = tr.state.facet(lintConfig).hideOn(tr, from, to);
+	if (result != null) return result;
+	let line = tr.startState.doc.lineAt(tooltip.pos);
+	return !!(tr.effects.some((e) => e.is(setDiagnosticsEffect)) || tr.changes.touchesRange(line.from, Math.max(line.to, to)));
+}
+function maybeEnableLint(state, effects) {
+	return state.field(lintState, false) ? effects : effects.concat(StateEffect.appendConfig.of(lintExtensions));
+}
+/**
+The state effect that updates the set of active diagnostics. Can
+be useful when writing an extension that needs to track these.
+*/
+var setDiagnosticsEffect = /*@__PURE__*/ StateEffect.define();
+var togglePanel = /*@__PURE__*/ StateEffect.define();
+var movePanelSelection = /*@__PURE__*/ StateEffect.define();
+var lintState = /*@__PURE__*/ StateField.define({
+	create() {
+		return new LintState(Decoration.none, null, null);
+	},
+	update(value, tr) {
+		if (tr.docChanged && value.diagnostics.size) {
+			let mapped = value.diagnostics.map(tr.changes), selected = null, panel = value.panel;
+			if (value.selected) {
+				let selPos = tr.changes.mapPos(value.selected.from, 1);
+				selected = findDiagnostic(mapped, value.selected.diagnostic, selPos) || findDiagnostic(mapped, null, selPos);
+			}
+			if (!mapped.size && panel && tr.state.facet(lintConfig).autoPanel) panel = null;
+			value = new LintState(mapped, panel, selected);
+		}
+		for (let effect of tr.effects) if (effect.is(setDiagnosticsEffect)) {
+			let panel = !tr.state.facet(lintConfig).autoPanel ? value.panel : effect.value.length ? LintPanel.open : null;
+			value = LintState.init(effect.value, panel, tr.state);
+		} else if (effect.is(togglePanel)) value = new LintState(value.diagnostics, effect.value ? LintPanel.open : null, value.selected);
+		else if (effect.is(movePanelSelection)) value = new LintState(value.diagnostics, value.panel, effect.value);
+		return value;
+	},
+	provide: (f) => [showPanel.from(f, (val) => val.panel), EditorView.decorations.from(f, (s) => s.diagnostics)]
+});
+var activeMark = /*@__PURE__*/ Decoration.mark({ class: "cm-lintRange cm-lintRange-active" });
+function lintTooltip(view, pos, side) {
+	let { diagnostics } = view.state.field(lintState);
+	let found, start = -1, end = -1;
+	diagnostics.between(pos - (side < 0 ? 1 : 0), pos + (side > 0 ? 1 : 0), (from, to, { spec }) => {
+		if (pos >= from && pos <= to && (from == to || (pos > from || side > 0) && (pos < to || side < 0))) {
+			found = spec.diagnostics;
+			start = from;
+			end = to;
+			return false;
+		}
+	});
+	let diagnosticFilter = view.state.facet(lintConfig).tooltipFilter;
+	if (found && diagnosticFilter) found = diagnosticFilter(found, view.state);
+	if (!found) return null;
+	return {
+		pos: start,
+		end,
+		above: true,
+		create() {
+			return { dom: diagnosticsTooltip(view, found) };
+		}
+	};
+}
+function diagnosticsTooltip(view, diagnostics) {
+	return crelt("ul", { class: "cm-tooltip-lint" }, diagnostics.map((d) => renderDiagnostic(view, d, false)));
+}
+/**
+Command to open and focus the lint panel.
+*/
+var openLintPanel = (view) => {
+	let field = view.state.field(lintState, false);
+	if (!field || !field.panel) view.dispatch({ effects: maybeEnableLint(view.state, [togglePanel.of(true)]) });
+	let panel = getPanel(view, LintPanel.open);
+	if (panel) panel.dom.querySelector(".cm-panel-lint ul").focus();
+	return true;
+};
+/**
+Command to close the lint panel, when open.
+*/
+var closeLintPanel = (view) => {
+	let field = view.state.field(lintState, false);
+	if (!field || !field.panel) return false;
+	view.dispatch({ effects: togglePanel.of(false) });
+	return true;
+};
+/**
+Move the selection to the next diagnostic.
+*/
+var nextDiagnostic = (view) => {
+	let field = view.state.field(lintState, false);
+	if (!field) return false;
+	let sel = view.state.selection.main, next = findDiagnostic(field.diagnostics, null, sel.to + 1);
+	if (!next) {
+		next = findDiagnostic(field.diagnostics, null, 0);
+		if (!next || next.from == sel.from && next.to == sel.to) return false;
+	}
+	view.dispatch({
+		selection: {
+			anchor: next.from,
+			head: next.to
+		},
+		scrollIntoView: true
+	});
+	activateHover(view, next.from, 1, {
+		tooltip: lintHover,
+		until: (tr) => tr.docChanged || tr.newSelection.main.head < next.from || tr.newSelection.main.head > next.to
+	});
+	return true;
+};
+/**
+A set of default key bindings for the lint functionality.
+
+- Ctrl-Shift-m (Cmd-Shift-m on macOS): [`openLintPanel`](https://codemirror.net/6/docs/ref/#lint.openLintPanel)
+- F8: [`nextDiagnostic`](https://codemirror.net/6/docs/ref/#lint.nextDiagnostic)
+*/
+var lintKeymap = [{
+	key: "Mod-Shift-m",
+	run: openLintPanel,
+	preventDefault: true
+}, {
+	key: "F8",
+	run: nextDiagnostic
+}];
+var lintConfig = /*@__PURE__*/ Facet.define({ combine(input) {
+	return {
+		sources: input.map((i) => i.source).filter((x) => x != null),
+		...combineConfig(input.map((i) => i.config), {
+			delay: 750,
+			markerFilter: null,
+			tooltipFilter: null,
+			needsRefresh: null,
+			hideOn: () => null
+		}, {
+			delay: Math.max,
+			markerFilter: combineFilter,
+			tooltipFilter: combineFilter,
+			needsRefresh: (a, b) => !a ? b : !b ? a : (u) => a(u) || b(u),
+			hideOn: (a, b) => !a ? b : !b ? a : (t, x, y) => a(t, x, y) || b(t, x, y),
+			autoPanel: (a, b) => a || b
+		})
+	};
+} });
+function combineFilter(a, b) {
+	return !a ? b : !b ? a : (d, s) => b(a(d, s), s);
+}
+function assignKeys(actions) {
+	let assigned = [];
+	if (actions) actions: for (let { name } of actions) {
+		for (let i = 0; i < name.length; i++) {
+			let ch = name[i];
+			if (/[a-zA-Z]/.test(ch) && !assigned.some((c) => c.toLowerCase() == ch.toLowerCase())) {
+				assigned.push(ch);
+				continue actions;
+			}
+		}
+		assigned.push("");
+	}
+	return assigned;
+}
+function renderDiagnostic(view, diagnostic, inPanel) {
+	var _a;
+	let keys = inPanel ? assignKeys(diagnostic.actions) : [];
+	return crelt("li", { class: "cm-diagnostic cm-diagnostic-" + diagnostic.severity }, crelt("span", { class: "cm-diagnosticText" }, diagnostic.renderMessage ? diagnostic.renderMessage(view) : diagnostic.message), (_a = diagnostic.actions) === null || _a === void 0 ? void 0 : _a.map((action, i) => {
+		let fired = false, click = (e) => {
+			e.preventDefault();
+			if (fired) return;
+			fired = true;
+			let found = findDiagnostic(view.state.field(lintState).diagnostics, diagnostic);
+			if (found) action.apply(view, found.from, found.to);
+		};
+		let { name } = action, keyIndex = keys[i] ? name.indexOf(keys[i]) : -1;
+		let nameElt = keyIndex < 0 ? name : [
+			name.slice(0, keyIndex),
+			crelt("u", name.slice(keyIndex, keyIndex + 1)),
+			name.slice(keyIndex + 1)
+		];
+		return crelt("button", {
+			type: "button",
+			class: "cm-diagnosticAction" + (action.markClass ? " " + action.markClass : ""),
+			onclick: click,
+			onmousedown: click,
+			"aria-label": ` Action: ${name}${keyIndex < 0 ? "" : ` (access key "${keys[i]})"`}.`
+		}, nameElt);
+	}), diagnostic.source && crelt("div", { class: "cm-diagnosticSource" }, diagnostic.source));
+}
+var DiagnosticWidget = class extends WidgetType {
+	constructor(sev) {
+		super();
+		this.sev = sev;
+	}
+	eq(other) {
+		return other.sev == this.sev;
+	}
+	toDOM() {
+		return crelt("span", { class: "cm-lintPoint cm-lintPoint-" + this.sev });
+	}
+};
+var PanelItem = class {
+	constructor(view, diagnostic) {
+		this.diagnostic = diagnostic;
+		this.id = "item_" + Math.floor(Math.random() * 4294967295).toString(16);
+		this.dom = renderDiagnostic(view, diagnostic, true);
+		this.dom.id = this.id;
+		this.dom.setAttribute("role", "option");
+	}
+};
+var LintPanel = class LintPanel {
+	constructor(view) {
+		this.view = view;
+		this.items = [];
+		let onkeydown = (event) => {
+			if (event.ctrlKey || event.altKey || event.metaKey) return;
+			if (event.keyCode == 27) {
+				closeLintPanel(this.view);
+				this.view.focus();
+			} else if (event.keyCode == 38 || event.keyCode == 33) this.moveSelection((this.selectedIndex - 1 + this.items.length) % this.items.length);
+			else if (event.keyCode == 40 || event.keyCode == 34) this.moveSelection((this.selectedIndex + 1) % this.items.length);
+			else if (event.keyCode == 36) this.moveSelection(0);
+			else if (event.keyCode == 35) this.moveSelection(this.items.length - 1);
+			else if (event.keyCode == 13) this.view.focus();
+			else if (event.keyCode >= 65 && event.keyCode <= 90 && this.selectedIndex >= 0) {
+				let { diagnostic } = this.items[this.selectedIndex], keys = assignKeys(diagnostic.actions);
+				for (let i = 0; i < keys.length; i++) if (keys[i].toUpperCase().charCodeAt(0) == event.keyCode) {
+					let found = findDiagnostic(this.view.state.field(lintState).diagnostics, diagnostic);
+					if (found) diagnostic.actions[i].apply(view, found.from, found.to);
+				}
+			} else return;
+			event.preventDefault();
+		};
+		let onclick = (event) => {
+			for (let i = 0; i < this.items.length; i++) if (this.items[i].dom.contains(event.target)) this.moveSelection(i);
+		};
+		this.list = crelt("ul", {
+			tabIndex: 0,
+			role: "listbox",
+			"aria-label": this.view.state.phrase("Diagnostics"),
+			onkeydown,
+			onclick
+		});
+		this.dom = crelt("div", { class: "cm-panel-lint" }, this.list, crelt("button", {
+			type: "button",
+			name: "close",
+			"aria-label": this.view.state.phrase("close"),
+			onclick: () => closeLintPanel(this.view)
+		}, "×"));
+		this.update();
+	}
+	get selectedIndex() {
+		let selected = this.view.state.field(lintState).selected;
+		if (!selected) return -1;
+		for (let i = 0; i < this.items.length; i++) if (this.items[i].diagnostic == selected.diagnostic) return i;
+		return -1;
+	}
+	update() {
+		let { diagnostics, selected } = this.view.state.field(lintState);
+		let i = 0, needsSync = false, newSelectedItem = null;
+		let seen = /* @__PURE__ */ new Set();
+		diagnostics.between(0, this.view.state.doc.length, (_start, _end, { spec }) => {
+			for (let diagnostic of spec.diagnostics) {
+				if (seen.has(diagnostic)) continue;
+				seen.add(diagnostic);
+				let found = -1, item;
+				for (let j = i; j < this.items.length; j++) if (this.items[j].diagnostic == diagnostic) {
+					found = j;
+					break;
+				}
+				if (found < 0) {
+					item = new PanelItem(this.view, diagnostic);
+					this.items.splice(i, 0, item);
+					needsSync = true;
+				} else {
+					item = this.items[found];
+					if (found > i) {
+						this.items.splice(i, found - i);
+						needsSync = true;
+					}
+				}
+				if (selected && item.diagnostic == selected.diagnostic) {
+					if (!item.dom.hasAttribute("aria-selected")) {
+						item.dom.setAttribute("aria-selected", "true");
+						newSelectedItem = item;
+					}
+				} else if (item.dom.hasAttribute("aria-selected")) item.dom.removeAttribute("aria-selected");
+				i++;
+			}
+		});
+		while (i < this.items.length && !(this.items.length == 1 && this.items[0].diagnostic.from < 0)) {
+			needsSync = true;
+			this.items.pop();
+		}
+		if (this.items.length == 0) {
+			this.items.push(new PanelItem(this.view, {
+				from: -1,
+				to: -1,
+				severity: "info",
+				message: this.view.state.phrase("No diagnostics")
+			}));
+			needsSync = true;
+		}
+		if (newSelectedItem) {
+			this.list.setAttribute("aria-activedescendant", newSelectedItem.id);
+			this.view.requestMeasure({
+				key: this,
+				read: () => ({
+					sel: newSelectedItem.dom.getBoundingClientRect(),
+					panel: this.list.getBoundingClientRect()
+				}),
+				write: ({ sel, panel }) => {
+					let scaleY = panel.height / this.list.offsetHeight;
+					if (sel.top < panel.top) this.list.scrollTop -= (panel.top - sel.top) / scaleY;
+					else if (sel.bottom > panel.bottom) this.list.scrollTop += (sel.bottom - panel.bottom) / scaleY;
+				}
+			});
+		} else if (this.selectedIndex < 0) this.list.removeAttribute("aria-activedescendant");
+		if (needsSync) this.sync();
+	}
+	sync() {
+		let domPos = this.list.firstChild;
+		function rm() {
+			let prev = domPos;
+			domPos = prev.nextSibling;
+			prev.remove();
+		}
+		for (let item of this.items) if (item.dom.parentNode == this.list) {
+			while (domPos != item.dom) rm();
+			domPos = item.dom.nextSibling;
+		} else this.list.insertBefore(item.dom, domPos);
+		while (domPos) rm();
+	}
+	moveSelection(selectedIndex) {
+		if (this.selectedIndex < 0) return;
+		let selection = findDiagnostic(this.view.state.field(lintState).diagnostics, this.items[selectedIndex].diagnostic);
+		if (!selection) return;
+		this.view.dispatch({
+			selection: {
+				anchor: selection.from,
+				head: selection.to
+			},
+			scrollIntoView: true,
+			effects: movePanelSelection.of(selection)
+		});
+	}
+	static open(view) {
+		return new LintPanel(view);
+	}
+};
+function svg(content, attrs = `viewBox="0 0 40 40"`) {
+	return `url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" ${attrs}>${encodeURIComponent(content)}</svg>')`;
+}
+function underline(color) {
+	return svg(`<path d="m0 2.5 l2 -1.5 l1 0 l2 1.5 l1 0" stroke="${color}" fill="none" stroke-width=".7"/>`, `width="6" height="3"`);
+}
+var baseTheme = /*@__PURE__*/ EditorView.baseTheme({
+	".cm-diagnostic": {
+		padding: "3px 6px 3px 8px",
+		marginLeft: "-1px",
+		display: "block",
+		whiteSpace: "pre-wrap"
+	},
+	".cm-diagnostic-error": { borderLeft: "5px solid #d11" },
+	".cm-diagnostic-warning": { borderLeft: "5px solid orange" },
+	".cm-diagnostic-info": { borderLeft: "5px solid #999" },
+	".cm-diagnostic-hint": { borderLeft: "5px solid #66d" },
+	".cm-diagnosticAction": {
+		font: "inherit",
+		border: "none",
+		padding: "2px 4px",
+		backgroundColor: "#444",
+		color: "white",
+		borderRadius: "3px",
+		marginLeft: "8px",
+		cursor: "pointer"
+	},
+	".cm-diagnosticSource": {
+		fontSize: "70%",
+		opacity: .7
+	},
+	".cm-lintRange": {
+		backgroundPosition: "left bottom",
+		backgroundRepeat: "repeat-x",
+		paddingBottom: "0.7px"
+	},
+	".cm-lintRange-error": { backgroundImage: /*@__PURE__*/ underline("#f11") },
+	".cm-lintRange-warning": { backgroundImage: /*@__PURE__*/ underline("orange") },
+	".cm-lintRange-info": { backgroundImage: /*@__PURE__*/ underline("#999") },
+	".cm-lintRange-hint": { backgroundImage: /*@__PURE__*/ underline("#66d") },
+	".cm-lintRange-active": { backgroundColor: "#ffdd9980" },
+	".cm-tooltip-lint": {
+		padding: 0,
+		margin: 0
+	},
+	".cm-lintPoint": {
+		position: "relative",
+		"&:after": {
+			content: "\"\"",
+			position: "absolute",
+			bottom: 0,
+			left: "-2px",
+			borderLeft: "3px solid transparent",
+			borderRight: "3px solid transparent",
+			borderBottom: "4px solid #d11"
+		}
+	},
+	".cm-lintPoint-warning": { "&:after": { borderBottomColor: "orange" } },
+	".cm-lintPoint-info": { "&:after": { borderBottomColor: "#999" } },
+	".cm-lintPoint-hint": { "&:after": { borderBottomColor: "#66d" } },
+	".cm-panel.cm-panel-lint": {
+		position: "relative",
+		"& ul": {
+			maxHeight: "100px",
+			overflowY: "auto",
+			"& [aria-selected]": {
+				backgroundColor: "#ddd",
+				"& u": { textDecoration: "underline" }
+			},
+			"&:focus [aria-selected]": {
+				background_fallback: "#bdf",
+				backgroundColor: "Highlight",
+				color_fallback: "white",
+				color: "HighlightText"
+			},
+			"& u": { textDecoration: "none" },
+			padding: 0,
+			margin: 0
+		},
+		"& [name=close]": {
+			position: "absolute",
+			top: "0",
+			right: "2px",
+			background: "inherit",
+			border: "none",
+			font: "inherit",
+			padding: 0,
+			margin: 0
+		}
+	},
+	"&dark .cm-lintRange-active": { backgroundColor: "#86714a80" },
+	"&dark .cm-panel.cm-panel-lint ul": { "& [aria-selected]": { backgroundColor: "#2e343e" } }
+});
+function severityWeight(sev) {
+	return sev == "error" ? 4 : sev == "warning" ? 3 : sev == "info" ? 2 : 1;
+}
+function maxSeverity(diagnostics) {
+	let sev = "hint", weight = 1;
+	for (let d of diagnostics) {
+		let w = severityWeight(d.severity);
+		if (w > weight) {
+			weight = w;
+			sev = d.severity;
+		}
+	}
+	return sev;
+}
+var lintHover = /*@__PURE__*/ hoverTooltip(lintTooltip, { hideOn: hideTooltip });
+var lintExtensions = [
+	lintState,
+	/*@__PURE__*/ EditorView.decorations.compute([lintState], (state) => {
+		let { selected, panel } = state.field(lintState);
+		return !selected || !panel || selected.from == selected.to ? Decoration.none : Decoration.set([activeMark.range(selected.from, selected.to)]);
+	}),
+	lintHover,
+	baseTheme
+];
+//#endregion
+export { lintKeymap as t };