@coldsmirk/inkstone-codemirror 0.9.0 → 0.10.1

package/dist/minijinja-D5ANOjtx.js

@@ -0,0 +1,700 @@
+import { i as resolveMembers, n as minijinjaContextField, o as typeAtPath, r as normalizeContext, t as elementType } from "./context-BJzyiP0A.js";
+import { LanguageSupport, syntaxTree } from "@codemirror/language";
+import { jinja, jinjaLanguage } from "@codemirror/lang-jinja";
+import { linter } from "@codemirror/lint";
+//#region src/minijinja-parser.ts
+var MinijinjaCompatibleInput = class {
+	value;
+	length;
+	lineChunks = false;
+	constructor(value) {
+		this.value = value;
+		this.length = value.length;
+	}
+	chunk(from) {
+		return this.value.slice(from);
+	}
+	read(from, to) {
+		return this.value.slice(from, to);
+	}
+};
+function withMinijinjaSyntax(language) {
+	const { parser } = language;
+	return language.configure({ wrap(inner, input, fragments, ranges) {
+		const source = input.read(0, input.length);
+		const compatible = normalizeSyntax(source);
+		return compatible === source ? inner : parser.startParse(new MinijinjaCompatibleInput(compatible), fragments, ranges);
+	} }, "minijinja");
+}
+function normalizeSyntax(source) {
+	let output = null;
+	let searchFrom = 0;
+	let raw = false;
+	while (searchFrom < source.length) {
+		const statementOpen = source.indexOf("{%", searchFrom);
+		if (!raw) {
+			const interpolationOpen = source.indexOf("{{", searchFrom);
+			const commentOpen = source.indexOf("{#", searchFrom);
+			const nextOpen = Math.min(statementOpen === -1 ? source.length : statementOpen, interpolationOpen === -1 ? source.length : interpolationOpen, commentOpen === -1 ? source.length : commentOpen);
+			if (nextOpen === source.length) break;
+			if (nextOpen === commentOpen) {
+				const commentClose = source.indexOf("#}", commentOpen + 2);
+				if (commentClose === -1) break;
+				searchFrom = commentClose + 2;
+				continue;
+			}
+			if (nextOpen === interpolationOpen) {
+				const interpolationClose = findInterpolationEnd(source, interpolationOpen + 2);
+				if (interpolationClose === -1) break;
+				if (source[interpolationOpen + 2] === "-" || source[interpolationOpen + 2] === "+") output = replaceAt(source, output, interpolationOpen + 2, " ");
+				if (source[interpolationClose - 1] === "-" || source[interpolationClose - 1] === "+") output = replaceAt(source, output, interpolationClose - 1, " ");
+				searchFrom = interpolationClose + 2;
+				continue;
+			}
+		}
+		if (statementOpen === -1) break;
+		if (raw) {
+			const end = rawEndTag(source, statementOpen);
+			if (end) {
+				if (end.openControl !== null) output = replaceAt(source, output, statementOpen + 2, " ");
+				for (const index of end.whitespace) if (source[index] !== " " && source[index] !== "\n") output = replaceAt(source, output, index, " ");
+				if (end.closeControl === "+") output = replaceAt(source, output, end.close - 1, " ");
+				raw = false;
+				searchFrom = end.close + 2;
+			} else {
+				const upstreamKeyword = upstreamRawEndKeyword(source, statementOpen);
+				if (upstreamKeyword !== null) output = replaceAt(source, output, upstreamKeyword, "_");
+				searchFrom = statementOpen + 2;
+			}
+			continue;
+		}
+		let keyword = statementOpen + 2;
+		const close = findTagEnd(source, keyword);
+		if (close === -1) break;
+		if (source[keyword] === "-" || source[keyword] === "+") keyword += 1;
+		while (/\s/u.test(source[keyword] ?? "")) keyword += 1;
+		if (source[statementOpen + 2] === "+") output = replaceAt(source, output, statementOpen + 2, " ");
+		if (source[close - 1] === "+") output = replaceAt(source, output, close - 1, " ");
+		if (hasKeywordAt(source, keyword, "raw")) raw = true;
+		else if (hasKeywordAt(source, keyword, "set")) {
+			const bodyEnd = source[close - 1] === "-" || source[close - 1] === "+" ? close - 1 : close;
+			output = normalizeSetBody(source, output, keyword + 3, bodyEnd);
+		}
+		searchFrom = close + 2;
+	}
+	return output ? output.join("") : source;
+}
+function replaceAt(source, output, index, replacement) {
+	const next = output ?? source.split("");
+	next[index] = replacement;
+	return next;
+}
+function hasKeywordAt(source, from, keyword) {
+	return source.startsWith(keyword, from) && !/[\p{L}\p{N}_]/u.test(source[from + keyword.length] ?? "");
+}
+function rawEndTag(source, statementOpen) {
+	let index = statementOpen + 2;
+	const open = source[index];
+	const openControl = open === "-" || open === "+" ? open : null;
+	const whitespace = [];
+	if (openControl !== null) index += 1;
+	while (isAsciiWhitespace(source[index])) {
+		whitespace.push(index);
+		index += 1;
+	}
+	if (!source.startsWith("endraw", index)) return null;
+	index += 6;
+	while (isAsciiWhitespace(source[index])) {
+		whitespace.push(index);
+		index += 1;
+	}
+	const close = source[index];
+	const closeControl = close === "-" || close === "+" ? close : null;
+	if (closeControl !== null) index += 1;
+	return source[index] === "%" && source[index + 1] === "}" ? {
+		close: index,
+		closeControl,
+		openControl,
+		whitespace
+	} : null;
+}
+function upstreamRawEndKeyword(source, statementOpen) {
+	let index = statementOpen + 2;
+	while (source[index] === " " || source[index] === "\n") index += 1;
+	return source.startsWith("endraw", index) && !/[A-Za-z]/u.test(source[index + 6] ?? "") ? index : null;
+}
+function isAsciiWhitespace(character) {
+	if (character === void 0) return false;
+	const code = character.codePointAt(0);
+	return code === 9 || code === 10 || code === 12 || code === 13 || code === 32;
+}
+function normalizeSetBody(source, output, from, to) {
+	const assignment = findTopLevelAssignment(source, from, to);
+	let next = replaceTargetDots(source, output, from, assignment === -1 ? findCaptureTargetEnd(source, from, to) : assignment);
+	if (assignment === -1) return next;
+	forEachTopLevel(source, assignment + 1, to, (index) => {
+		if (source[index] !== ",") return;
+		next ??= source.split("");
+		next[index] = hasNonWhitespace(source, index + 1, to) ? "+" : " ";
+	});
+	return next;
+}
+function replaceTargetDots(source, output, from, to) {
+	let next = output;
+	for (let index = from; index < to; index++) {
+		if (source[index] !== ".") continue;
+		next ??= source.split("");
+		next[index] = "_";
+	}
+	return next;
+}
+function findTopLevelAssignment(source, from, to) {
+	let found = -1;
+	forEachTopLevel(source, from, to, (index) => {
+		if (found !== -1 || source[index] !== "=") return;
+		const before = source[index - 1] ?? "";
+		const after = source[index + 1] ?? "";
+		if (before !== "=" && before !== "!" && before !== "<" && before !== ">" && after !== "=") found = index;
+	});
+	return found;
+}
+function findCaptureTargetEnd(source, from, to) {
+	let index = from;
+	while (/\s/u.test(source[index] ?? "")) index += 1;
+	while (index < to && !/\s|\|/u.test(source[index] ?? "")) index += 1;
+	return index;
+}
+function forEachTopLevel(source, from, to, visit) {
+	let quote = null;
+	let depth = 0;
+	for (let index = from; index < to; index++) {
+		const character = source[index];
+		if (quote) {
+			if (character === "\\") index += 1;
+			else if (character === quote) quote = null;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quote = character;
+			continue;
+		}
+		const depthChange = bracketDepthChange(character);
+		if (depthChange !== 0) {
+			depth = Math.max(0, depth + depthChange);
+			continue;
+		}
+		if (depth === 0) visit(index);
+	}
+}
+function bracketDepthChange(character) {
+	if (character === "(" || character === "[" || character === "{") return 1;
+	if (character === ")" || character === "]" || character === "}") return -1;
+	return 0;
+}
+function findTagEnd(source, from) {
+	let quote = null;
+	for (let index = from; index < source.length - 1; index++) {
+		const character = source[index];
+		if (quote) {
+			if (character === "\\") index += 1;
+			else if (character === quote) quote = null;
+		} else if (character === "\"" || character === "'") quote = character;
+		else if (character === "%" && source[index + 1] === "}") return index;
+	}
+	return -1;
+}
+function findInterpolationEnd(source, from) {
+	let quote = null;
+	let depth = 0;
+	for (let index = from; index < source.length - 1; index++) {
+		const character = source[index];
+		if (quote) {
+			if (character === "\\") index += 1;
+			else if (character === quote) quote = null;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quote = character;
+			continue;
+		}
+		if (character === "}" && source[index + 1] === "}" && depth === 0) return index;
+		depth = Math.max(0, depth + bracketDepthChange(character));
+	}
+	return -1;
+}
+function hasNonWhitespace(source, from, to) {
+	for (let index = from; index < to; index++) if (!/\s/u.test(source[index] ?? "")) return true;
+	return false;
+}
+//#endregion
+//#region src/minijinja.ts
+const MINIJINJA_TAGS = /* @__PURE__ */ new Set([
+	"autoescape",
+	"endautoescape",
+	"block",
+	"endblock",
+	"call",
+	"endcall",
+	"filter",
+	"endfilter",
+	"for",
+	"endfor",
+	"if",
+	"elif",
+	"else",
+	"endif",
+	"macro",
+	"endmacro",
+	"set",
+	"endset",
+	"with",
+	"endwith",
+	"raw",
+	"endraw",
+	"extends",
+	"include",
+	"import",
+	"from",
+	"do",
+	"break",
+	"continue"
+]);
+const MINIJINJA_FILTERS = [
+	"abs",
+	"attr",
+	"batch",
+	"bool",
+	"capitalize",
+	"chain",
+	"count",
+	"d",
+	"default",
+	"dictsort",
+	"e",
+	"escape",
+	"first",
+	"float",
+	"format",
+	"groupby",
+	"indent",
+	"int",
+	"items",
+	"join",
+	"last",
+	"length",
+	"lines",
+	"list",
+	"lower",
+	"map",
+	"max",
+	"min",
+	"pprint",
+	"reject",
+	"rejectattr",
+	"replace",
+	"reverse",
+	"round",
+	"safe",
+	"select",
+	"selectattr",
+	"slice",
+	"sort",
+	"split",
+	"string",
+	"sum",
+	"title",
+	"tojson",
+	"trim",
+	"unique",
+	"upper",
+	"urlencode",
+	"zip"
+];
+const MINIJINJA_TESTS = [
+	"boolean",
+	"defined",
+	"divisibleby",
+	"endingwith",
+	"eq",
+	"equalto",
+	"escaped",
+	"even",
+	"false",
+	"filter",
+	"float",
+	"ge",
+	"greaterthan",
+	"in",
+	"int",
+	"integer",
+	"iterable",
+	"le",
+	"lessthan",
+	"lower",
+	"lt",
+	"gt",
+	"mapping",
+	"ne",
+	"none",
+	"number",
+	"odd",
+	"safe",
+	"sameas",
+	"sequence",
+	"startingwith",
+	"string",
+	"test",
+	"true",
+	"undefined",
+	"upper"
+];
+const MINIJINJA_FUNCTIONS = [
+	"debug",
+	"dict",
+	"namespace",
+	"range"
+];
+function toCompletions(labels, type) {
+	return [...labels].toSorted().map((label) => {
+		return {
+			label,
+			type
+		};
+	});
+}
+const tagCompletions = toCompletions(MINIJINJA_TAGS, "keyword");
+const filterCompletions = toCompletions(MINIJINJA_FILTERS, "function");
+const testCompletions = toCompletions(MINIJINJA_TESTS, "function");
+const functionCompletions = toCompletions(MINIJINJA_FUNCTIONS, "function");
+function memberCompletions(members, type) {
+	return members.map((member) => {
+		return {
+			label: member.name,
+			type,
+			detail: `${irTypeToString(member.type)}${member.nullable ? "?" : ""}`,
+			info: member.doc
+		};
+	});
+}
+function irTypeToString(type) {
+	switch (type.kind) {
+		case "object": return "object";
+		case "array": return `${irTypeToString(type.element)}[]`;
+		case "enum": return type.values.map((value) => typeof value === "string" ? `"${value}"` : String(value)).join(" | ");
+		case "ref": return type.name;
+		default: return type.kind;
+	}
+}
+function walkBase(state, node) {
+	if (!node) return null;
+	if (node.name === "VariableName" || node.name === "loop") return [state.sliceDoc(node.from, node.to)];
+	if (node.name === "MemberExpression") {
+		const inner = walkBase(state, node.firstChild);
+		const property = node.lastChild;
+		if (inner === null || !property || property.name !== "PropertyName") return null;
+		return [...inner, state.sliceDoc(property.from, property.to)];
+	}
+	return null;
+}
+function contextTarget(state, pos) {
+	const node = syntaxTree(state).resolveInner(pos, -1);
+	if (node.name === "PropertyName" && node.parent?.name === "MemberExpression") {
+		const path = walkBase(state, node.parent.firstChild);
+		return path ? {
+			path,
+			from: node.from
+		} : null;
+	}
+	if (node.name === "." && node.parent?.name === "MemberExpression") {
+		const path = walkBase(state, node.parent.firstChild);
+		return path ? {
+			path,
+			from: pos
+		} : null;
+	}
+	if (node.name === "Definition") return null;
+	const word = state.wordAt(pos);
+	return {
+		path: [],
+		from: word ? word.from : pos
+	};
+}
+const LOOP_TYPE = {
+	kind: "object",
+	fields: {
+		index: loopField("number"),
+		index0: loopField("number"),
+		revindex: loopField("number"),
+		revindex0: loopField("number"),
+		first: loopField("boolean"),
+		last: loopField("boolean"),
+		length: loopField("number"),
+		depth: loopField("number"),
+		depth0: loopField("number"),
+		previtem: loopField("any"),
+		nextitem: loopField("any"),
+		cycle: loopField("any"),
+		changed: loopField("any")
+	}
+};
+function loopField(kind) {
+	return {
+		type: { kind },
+		required: true,
+		nullable: false
+	};
+}
+const ROOT_SCOPE = -1;
+function scopeBindings(state, pos, ir) {
+	const bindings = /* @__PURE__ */ new Map();
+	const enclosing = [];
+	for (let node = syntaxTree(state).resolveInner(pos, -1); node; node = node.parent) if (node.name === "ForStatement" || node.name === "MacroStatement" || node.name === "WithStatement" || node.name === "BlockStatement") enclosing.push(node);
+	const scopes = enclosing.toReversed();
+	const sets = collectSetBindings(state, pos, scopes);
+	const applySets = (scopeKey) => {
+		const definitions = sets.get(scopeKey) ?? [];
+		for (const definition of definitions) bindings.set(state.sliceDoc(definition.from, definition.to), { kind: "any" });
+	};
+	applySets(ROOT_SCOPE);
+	for (const node of scopes) {
+		collectScopeBindings(state, node, pos, ir, bindings);
+		applySets(node.from);
+	}
+	return bindings;
+}
+function collectScopeBindings(state, node, pos, ir, bindings) {
+	switch (node.name) {
+		case "ForStatement":
+			collectForBindings(state, node, pos, ir, bindings);
+			return;
+		case "MacroStatement":
+			collectMacroBindings(state, node, pos, bindings);
+			return;
+		case "WithStatement": collectWithBindings(state, node, pos, ir, bindings);
+	}
+}
+function collectForBindings(state, forNode, pos, ir, bindings) {
+	const tag = forNode.firstChild;
+	if (!tag || tag.name !== "Tag") return;
+	const definitions = [];
+	let iterable = null;
+	let filterKeyword = null;
+	let seenIn = false;
+	for (let child = tag.firstChild; child; child = child.nextSibling) if (child.name === "in") seenIn = true;
+	else if (!seenIn && child.name === "Definition") definitions.push(child);
+	else if (seenIn && !iterable && child.name !== "%}") iterable = child;
+	if (iterable?.name === "ConditionalExpression") {
+		for (let child = iterable.firstChild; child; child = child.nextSibling) if (child.name === "if") {
+			filterKeyword = child;
+			iterable = iterable.firstChild;
+			break;
+		}
+	}
+	let elseTag = null;
+	let endTag = null;
+	for (let child = tag.nextSibling; child; child = child.nextSibling) {
+		if (child.name === "EndTag") {
+			endTag = child;
+			break;
+		}
+		if (child.name === "Tag") {
+			const keyword = child.firstChild?.nextSibling;
+			if (keyword && state.sliceDoc(keyword.from, keyword.to) === "else") elseTag = child;
+		}
+	}
+	const inFilter = filterKeyword !== null && pos >= filterKeyword.to && pos <= tag.to;
+	const bodyEnd = elseTag?.from ?? endTag?.from ?? forNode.to;
+	const inUnclosedBodyAtEnd = elseTag === null && endTag === null && pos === bodyEnd;
+	const inBody = tagBodyStarted(tag, pos) && (pos < bodyEnd || inUnclosedBodyAtEnd);
+	if (!inFilter && !inBody) return;
+	let element = null;
+	if (definitions.length === 1 && iterable) {
+		const path = walkBase(state, iterable);
+		const iterableType = path ? typeAtPath(ir, path, bindings) : null;
+		element = iterableType ? elementType(ir, iterableType) : null;
+	}
+	if (inBody) bindings.set("loop", LOOP_TYPE);
+	for (const definition of definitions) bindings.set(state.sliceDoc(definition.from, definition.to), element ?? { kind: "any" });
+}
+function collectWithBindings(state, withNode, pos, ir, bindings) {
+	const tag = withNode.firstChild;
+	if (!tag || tag.name !== "Tag") return;
+	const inBody = tagBodyStarted(tag, pos);
+	let targets = [];
+	for (let child = tag.firstChild; child; child = child.nextSibling) {
+		if (child.name === "Definition") {
+			targets.push(child);
+			continue;
+		}
+		if (child.name !== "AssignOp" || targets.length === 0) continue;
+		const value = child.nextSibling;
+		const delimiter = value?.nextSibling;
+		if (inBody || delimiter?.name === "," && delimiter.to <= pos) {
+			const path = targets.length === 1 && value ? walkBase(state, value) : null;
+			const type = path ? typeAtPath(ir, path, bindings) : null;
+			for (const target of targets) bindings.set(state.sliceDoc(target.from, target.to), type ?? { kind: "any" });
+		}
+		targets = [];
+	}
+}
+function collectMacroBindings(state, macroNode, pos, bindings) {
+	const tag = macroNode.firstChild;
+	if (!tag || !tagBodyStarted(tag, pos)) return;
+	const paramList = tag.getChild("ParamList");
+	if (!paramList) return;
+	for (let child = paramList.firstChild; child; child = child.nextSibling) {
+		const definition = child.name === "Definition" ? child : child.name === "OptionalParameter" ? child.getChild("Definition") : null;
+		if (definition) bindings.set(state.sliceDoc(definition.from, definition.to), { kind: "any" });
+	}
+}
+function tagBodyStarted(tag, pos) {
+	return tag.name === "Tag" && tag.getChild("%}") !== null && pos >= tag.to;
+}
+function collectSetBindings(state, pos, scopes) {
+	const scopeStarts = new Set(scopes.map((scope) => scope.from));
+	const caretBranches = /* @__PURE__ */ new Map();
+	const sets = /* @__PURE__ */ new Map();
+	for (let node = syntaxTree(state).resolveInner(pos, -1); node; node = node.parent) if (node.name === "IfStatement" || node.name === "ForStatement") caretBranches.set(node.from, branchAt(state, node, pos));
+	syntaxTree(state).iterate({
+		to: pos,
+		enter: (node) => {
+			if (node.name !== "Tag" || node.to > pos) return;
+			const keyword = node.node.firstChild?.nextSibling;
+			if (!keyword || state.sliceDoc(keyword.from, keyword.to) !== "set") return;
+			const definitions = [];
+			let assignment = false;
+			for (let child = keyword.nextSibling; child; child = child.nextSibling) {
+				if (child.name === "AssignOp") {
+					assignment = true;
+					break;
+				}
+				if (child.name === "Definition" && !state.sliceDoc(child.from, child.to).includes(".")) definitions.push(child);
+			}
+			if (definitions.length === 0) return;
+			const statement = node.node.parent;
+			if (assignment) {
+				if (!node.node.getChild("%}")) return;
+			} else if (statement?.name !== "SetStatement" || statement.to > pos || !statement.getChild("EndTag")) return;
+			let scopeKey = ROOT_SCOPE;
+			for (let { parent } = node.node; parent; parent = parent.parent) {
+				if (parent.name !== "IfStatement" && parent.name !== "ForStatement") continue;
+				const caretBranch = caretBranches.get(parent.from);
+				if (caretBranch !== void 0 && branchAt(state, parent, node.from) !== caretBranch) return;
+			}
+			for (let { parent } = node.node; parent; parent = parent.parent) if (parent.name === "ForStatement" || parent.name === "MacroStatement" || parent.name === "WithStatement" || parent.name === "BlockStatement") {
+				if (!scopeStarts.has(parent.from)) return;
+				scopeKey = parent.from;
+				break;
+			}
+			const bucket = sets.get(scopeKey);
+			if (bucket) bucket.push(...definitions);
+			else sets.set(scopeKey, definitions);
+		}
+	});
+	return sets;
+}
+function branchAt(state, statement, pos) {
+	let branch = 0;
+	for (let child = statement.firstChild; child && child.from <= pos; child = child.nextSibling) {
+		if (child.name !== "Tag") continue;
+		const keyword = child.firstChild?.nextSibling;
+		if (!keyword) continue;
+		const name = state.sliceDoc(keyword.from, keyword.to);
+		if (name === "else" || statement.name === "IfStatement" && name === "elif") branch += 1;
+	}
+	return branch;
+}
+function jinjaContext(state, pos, side) {
+	for (let node = syntaxTree(state).resolveInner(pos, side); node; node = node.parent) {
+		const { name } = node;
+		if (name === "Comment") return "comment";
+		if (name === "StringLiteral" || name === "NumberLiteral") return null;
+		if (name === "Interpolation" || name === "Tag" || name === "EndTag") return "expr";
+	}
+	return null;
+}
+function minijinjaCompletion(context) {
+	const word = context.matchBefore(/\w*/);
+	if (!word) return null;
+	const { from } = word;
+	const before = context.state.sliceDoc(Math.max(0, from - 24), from);
+	let side = from === context.pos ? 1 : -1;
+	if (side === 1 && context.pos === context.state.doc.length) {
+		const left = syntaxTree(context.state).resolveInner(context.pos, -1);
+		if (left.name !== "}}" && left.name !== "%}" && left.name !== "#}") side = -1;
+	}
+	if (jinjaContext(context.state, context.pos, side) !== "expr") return null;
+	if (/\{%[-+]?\s*$/.test(before)) return {
+		from,
+		options: tagCompletions,
+		validFor: /^\w*$/
+	};
+	if (/\|\s*$/.test(before)) return {
+		from,
+		options: filterCompletions,
+		validFor: /^\w*$/
+	};
+	if (/\bis\s+(?:not\s+)?$/.test(before)) return {
+		from,
+		options: testCompletions,
+		validFor: /^\w*$/
+	};
+	const ir = context.state.field(minijinjaContextField, false);
+	if (ir) {
+		const target = contextTarget(context.state, context.pos);
+		if (!target) return null;
+		const scope = scopeBindings(context.state, context.pos, ir);
+		const members = resolveMembers(ir, target.path, scope);
+		if (target.path.length > 0) return members.length > 0 ? {
+			from: target.from,
+			options: memberCompletions(members, "property"),
+			validFor: /^\w*$/
+		} : null;
+		if (target.from === context.pos && !context.explicit) return null;
+		const memberOptions = memberCompletions(members, "variable");
+		const memberNames = new Set(memberOptions.map((option) => option.label));
+		return {
+			from: target.from,
+			options: [...memberOptions, ...functionCompletions.filter((option) => !memberNames.has(option.label))],
+			validFor: /^\w*$/
+		};
+	}
+	if (from === context.pos && !context.explicit) return null;
+	return {
+		from,
+		options: functionCompletions,
+		validFor: /^\w*$/
+	};
+}
+function minijinjaDiagnostics(state) {
+	const diagnostics = [];
+	const { doc } = state;
+	syntaxTree(state).iterate({ enter: (node) => {
+		if (node.name !== "Tag" && node.name !== "EndTag") return;
+		const keywordNode = node.node.firstChild?.nextSibling;
+		if (!keywordNode || keywordNode.type.isError) return;
+		const keyword = doc.sliceString(keywordNode.from, keywordNode.to);
+		if (!MINIJINJA_TAGS.has(keyword)) diagnostics.push({
+			from: keywordNode.from,
+			to: keywordNode.to,
+			severity: "error",
+			message: `"${keyword}" is not a MiniJinja tag.`
+		});
+	} });
+	return diagnostics;
+}
+const minijinjaLinter = linter((view) => minijinjaDiagnostics(view.state));
+function minijinja(config = {}) {
+	const { base, context } = config;
+	const language = withMinijinjaSyntax(base ? jinja({ base }).language : jinjaLanguage);
+	const contextField = context ? minijinjaContextField.init(() => normalizeContext(context)) : minijinjaContextField;
+	const support = [
+		language.data.of({ autocomplete: minijinjaCompletion }),
+		minijinjaLinter,
+		contextField
+	];
+	if (base) support.push(base.support);
+	return new LanguageSupport(language, support);
+}
+//#endregion
+export { minijinja, minijinjaCompletion, minijinjaDiagnostics };