@coldsmirk/inkstone-codemirror 0.8.3 → 0.9.0

package/dist/context-D86o2jK3.js

@@ -0,0 +1,382 @@
+import { StateEffect, StateField } from "@codemirror/state";
+//#region src/context.ts
+const ANY = { kind: "any" };
+const NULL = { kind: "null" };
+const MAX_DEREF = 100;
+const setMinijinjaContext = StateEffect.define();
+const minijinjaContextField = StateField.define({
+	create() {
+		return null;
+	},
+	update(value, transaction) {
+		let next = value;
+		for (const effect of transaction.effects) if (effect.is(setMinijinjaContext)) next = effect.value;
+		return next;
+	}
+});
+function normalizeContext(input) {
+	if ("schema" in input) return fromJsonSchema(input.schema);
+	return {
+		root: fromSample(input.sample),
+		defs: {}
+	};
+}
+function resolveMembers(ir, path, scope) {
+	if (path.length === 0) {
+		const top = membersOf(ir, ir.root);
+		if (!scope || scope.size === 0) return top;
+		return [...[...scope].map(([name, type]) => {
+			return {
+				name,
+				type,
+				required: true,
+				nullable: false
+			};
+		}), ...top];
+	}
+	const type = typeAtPath(ir, path, scope);
+	return type ? membersOf(ir, type) : [];
+}
+function typeAtPath(ir, path, scope) {
+	const [first, ...rest] = path;
+	if (first === void 0) return deref(ir, ir.root);
+	let type = scope?.get(first) ?? stepInto(ir, ir.root, first);
+	for (const key of rest) {
+		if (type === null) return null;
+		type = stepInto(ir, type, key);
+	}
+	return type === null ? null : deref(ir, type);
+}
+function elementType(ir, type) {
+	const resolved = deref(ir, type);
+	return resolved.kind === "array" ? deref(ir, resolved.element) : null;
+}
+function followRefs(type, lookup) {
+	let current = type;
+	for (let i = 0; i < MAX_DEREF && current.kind === "ref"; i++) {
+		const next = lookup(current.name);
+		if (!next) return null;
+		current = next;
+	}
+	return current.kind === "ref" ? null : current;
+}
+function deref(ir, type) {
+	return followRefs(type, (name) => ir.defs[name] ?? null) ?? ANY;
+}
+function stepInto(ir, type, key) {
+	const resolved = deref(ir, type);
+	if (resolved.kind !== "object") return null;
+	const field = resolved.fields[key];
+	return field ? field.type : null;
+}
+function membersOf(ir, type) {
+	const resolved = deref(ir, type);
+	if (resolved.kind !== "object") return [];
+	return Object.entries(resolved.fields).map(([name, field]) => {
+		return {
+			name,
+			type: field.type,
+			required: field.required,
+			nullable: field.nullable,
+			doc: field.doc
+		};
+	});
+}
+const REF_PREFIXES = ["#/$defs/", "#/definitions/"];
+function fromJsonSchema(schema) {
+	if (!isObject(schema)) return {
+		root: ANY,
+		defs: {}
+	};
+	const context = {
+		raw: {
+			...asObject(schema.definitions),
+			...asObject(schema.$defs)
+		},
+		defs: Object.create(null),
+		resolving: /* @__PURE__ */ new Set(),
+		tainted: /* @__PURE__ */ new Set(),
+		cyclic: /* @__PURE__ */ new Set(),
+		dependents: /* @__PURE__ */ new Map(),
+		converting: []
+	};
+	for (const name of Object.keys(context.raw)) defType(name, context);
+	if (context.tainted.size > 0) {
+		const queue = [...context.tainted];
+		const pending = new Set(queue);
+		let head = 0;
+		let budget = (Object.keys(context.raw).length + 1) ** 2;
+		while (head < queue.length && budget > 0) {
+			budget -= 1;
+			const name = queue[head];
+			head += 1;
+			if (name === void 0) break;
+			pending.delete(name);
+			context.converting.push(name);
+			const next = convert(context.raw[name], context);
+			context.converting.pop();
+			if (JSON.stringify(next) !== JSON.stringify(context.defs[name])) {
+				context.defs[name] = next;
+				const stale = [...context.dependents.get(name) ?? []].filter((reader) => !pending.has(reader));
+				for (const dependent of stale) {
+					pending.add(dependent);
+					queue.push(dependent);
+				}
+			}
+		}
+	}
+	return {
+		root: convert(schema, context),
+		defs: context.defs
+	};
+}
+function defType(name, context) {
+	const reader = context.converting.at(-1);
+	if (reader !== void 0 && reader !== name) {
+		const readers = context.dependents.get(name);
+		if (readers) readers.add(reader);
+		else context.dependents.set(name, /* @__PURE__ */ new Set([reader]));
+	}
+	if (Object.hasOwn(context.defs, name)) return context.defs[name] ?? null;
+	if (context.resolving.has(name)) {
+		for (const pending of context.converting) context.tainted.add(pending);
+		const cycleStart = context.converting.lastIndexOf(name);
+		if (cycleStart === -1) context.cyclic.add(name);
+		else for (const member of context.converting.slice(cycleStart)) context.cyclic.add(member);
+		return null;
+	}
+	if (!Object.hasOwn(context.raw, name)) return null;
+	context.resolving.add(name);
+	context.converting.push(name);
+	const type = convert(context.raw[name], context);
+	context.converting.pop();
+	context.resolving.delete(name);
+	context.defs[name] = type;
+	return type;
+}
+function convert(node, context) {
+	if (typeof node === "boolean" || !isObject(node)) return ANY;
+	const ref = refName(node.$ref);
+	if (ref !== null) return {
+		kind: "ref",
+		name: ref
+	};
+	if (Array.isArray(node.allOf)) {
+		const branches = node.allOf.map((entry) => convert(entry, context));
+		return requireFields(mergeAll(isObject(node.properties) ? [...branches, objectType(node, context)] : branches, context, "all"), node.required, context);
+	}
+	const union = node.anyOf ?? node.oneOf;
+	if (Array.isArray(union)) {
+		const viable = union.filter((branch) => unionBranchKind(branch, context) !== "impossible");
+		const nonNull = viable.filter((branch) => unionBranchKind(branch, context) !== "null");
+		if (viable.length === 0) return ANY;
+		if (nonNull.length === 0) return NULL;
+		const merged = nonNull.length === 1 ? convert(nonNull[0], context) : mergeAll(nonNull.map((entry) => convert(entry, context)), context, "any");
+		return requireFields(isObject(node.properties) ? mergeAll([merged, objectType(node, context)], context, "all") : merged, node.required, context);
+	}
+	if (Array.isArray(node.enum)) return {
+		kind: "enum",
+		values: node.enum.filter(isLiteral)
+	};
+	if ("const" in node && isLiteral(node.const)) return {
+		kind: "enum",
+		values: [node.const]
+	};
+	const type = primaryType(node);
+	if (isObjectShape(node)) return objectType(node, context);
+	if (type === "array") return {
+		kind: "array",
+		element: convert(Array.isArray(node.items) ? node.items[0] : node.items, context)
+	};
+	if (type === "string") return { kind: "string" };
+	if (type === "integer" || type === "number") return { kind: "number" };
+	if (type === "boolean") return { kind: "boolean" };
+	if (type === "null") return NULL;
+	return ANY;
+}
+function isObjectShape(node) {
+	return primaryType(node) === "object" || isObject(node.properties);
+}
+function objectType(node, context) {
+	const properties = asObject(node.properties);
+	const required = new Set(Array.isArray(node.required) ? node.required.filter((name) => typeof name === "string") : []);
+	const fields = Object.create(null);
+	for (const [name, sub] of Object.entries(properties)) fields[name] = {
+		type: convert(sub, context),
+		required: required.has(name),
+		nullable: isNullable(sub, context),
+		doc: description(sub)
+	};
+	return {
+		kind: "object",
+		fields
+	};
+}
+function mergeAll(types, context, mode) {
+	const [only] = types;
+	if (only && types.length === 1) return only;
+	const fields = Object.create(null);
+	const appearances = /* @__PURE__ */ new Map();
+	let branches = 0;
+	for (const type of types) {
+		const resolved = derefFully(type, context);
+		if (resolved?.kind === "object") {
+			branches += 1;
+			for (const [name, field] of Object.entries(resolved.fields)) {
+				const existing = fields[name];
+				fields[name] = existing ? mergeField(existing, field, mode) : field;
+				appearances.set(name, (appearances.get(name) ?? 0) + 1);
+			}
+		}
+	}
+	if (branches > 0) {
+		if (mode === "any") {
+			for (const [name, field] of Object.entries(fields)) if (field.required && appearances.get(name) !== types.length) fields[name] = {
+				...field,
+				required: false
+			};
+		}
+		return {
+			kind: "object",
+			fields
+		};
+	}
+	return types.find((type) => type.kind !== "any") ?? ANY;
+}
+function requireFields(type, required, context) {
+	const names = Array.isArray(required) ? required.filter((name) => typeof name === "string") : [];
+	if (names.length === 0) return type;
+	const resolved = type.kind === "ref" ? derefNonCyclic(type, context) : type;
+	if (resolved === null || resolved.kind !== "object") return type;
+	const fields = Object.assign(Object.create(null), resolved.fields);
+	let changed = false;
+	for (const name of names) {
+		const field = fields[name];
+		if (field && !field.required) {
+			fields[name] = {
+				...field,
+				required: true
+			};
+			changed = true;
+		}
+	}
+	return changed ? {
+		kind: "object",
+		fields
+	} : type;
+}
+function mergeField(existing, incoming, mode) {
+	return {
+		type: incoming.type,
+		required: mode === "all" ? existing.required || incoming.required : existing.required && incoming.required,
+		nullable: mode === "all" ? existing.nullable && incoming.nullable : existing.nullable || incoming.nullable,
+		doc: incoming.doc ?? existing.doc
+	};
+}
+function derefFully(type, context) {
+	return followRefs(type, (name) => defType(name, context));
+}
+function derefNonCyclic(type, context) {
+	let current = type;
+	for (let i = 0; i < MAX_DEREF && current.kind === "ref"; i++) {
+		if (context.cyclic.has(current.name)) return null;
+		const next = defType(current.name, context);
+		if (!next) return null;
+		current = next;
+	}
+	return current.kind === "ref" ? null : current;
+}
+function fromSample(value, ancestors = /* @__PURE__ */ new WeakSet()) {
+	if (value === null || value === void 0) return ANY;
+	if (typeof value === "object") {
+		if (ancestors.has(value)) return ANY;
+		ancestors.add(value);
+		const type = Array.isArray(value) ? sampleArrayType(value, ancestors) : sampleObjectType(value, ancestors);
+		ancestors.delete(value);
+		return type;
+	}
+	if (typeof value === "string") return { kind: "string" };
+	if (typeof value === "number") return { kind: "number" };
+	if (typeof value === "boolean") return { kind: "boolean" };
+	return ANY;
+}
+function sampleArrayType(value, ancestors) {
+	return {
+		kind: "array",
+		element: value.length > 0 ? fromSample(value[0], ancestors) : ANY
+	};
+}
+function sampleObjectType(value, ancestors) {
+	const fields = Object.create(null);
+	for (const [name, member] of Object.entries(value)) fields[name] = {
+		type: fromSample(member, ancestors),
+		required: true,
+		nullable: member === null
+	};
+	return {
+		kind: "object",
+		fields
+	};
+}
+function refName(ref) {
+	if (typeof ref !== "string") return null;
+	for (const prefix of REF_PREFIXES) if (ref.startsWith(prefix)) return decodeURIComponent(ref.slice(prefix.length));
+	return null;
+}
+function primaryType(node) {
+	const { type } = node;
+	if (typeof type === "string") return type;
+	if (Array.isArray(type)) {
+		const nonNull = type.find((entry) => typeof entry === "string" && entry !== "null");
+		if (typeof nonNull === "string") return nonNull;
+		return type.includes("null") ? "null" : null;
+	}
+	return null;
+}
+function isNullable(node, context) {
+	const pending = [node];
+	const seenRefs = /* @__PURE__ */ new Set();
+	while (pending.length > 0) {
+		const current = pending.pop();
+		if (!isObject(current)) continue;
+		const { type } = current;
+		if (type === "null" || Array.isArray(type) && type.includes("null")) return true;
+		const ref = refName(current.$ref);
+		if (ref !== null && !seenRefs.has(ref) && Object.hasOwn(context.raw, ref)) {
+			seenRefs.add(ref);
+			pending.push(context.raw[ref]);
+			continue;
+		}
+		const union = current.anyOf ?? current.oneOf;
+		if (Array.isArray(union)) pending.push(...union);
+	}
+	return false;
+}
+function unionBranchKind(branch, context) {
+	const seenRefs = /* @__PURE__ */ new Set();
+	let current = branch;
+	for (let i = 0; i < MAX_DEREF; i++) {
+		if (current === false) return "impossible";
+		if (!isObject(current)) return "other";
+		if (current.type === "null" || Array.isArray(current.type) && current.type.length === 1 && current.type[0] === "null") return "null";
+		const ref = refName(current.$ref);
+		if (ref === null || seenRefs.has(ref) || !Object.hasOwn(context.raw, ref)) return "other";
+		seenRefs.add(ref);
+		current = context.raw[ref];
+	}
+	return "other";
+}
+function description(node) {
+	return isObject(node) && typeof node.description === "string" ? node.description : void 0;
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asObject(value) {
+	return isObject(value) ? value : {};
+}
+function isLiteral(value) {
+	return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+//#endregion
+export { setMinijinjaContext as a, resolveMembers as i, minijinjaContextField as n, typeAtPath as o, normalizeContext as r, elementType as t };

package/dist/index.d.ts

@@ -84,9 +84,12 @@ declare function normalizeContext(input: EditorContext): IrSchema;
  */
 declare function resolveMembers(ir: IrSchema, path: readonly string[], scope?: ReadonlyMap<string, IrType>): Member[];
 /**
- * The type at a declared property path, or null if the path leaves the walkable shape.
+ * The type at a declared property path, or null if the path leaves the walkable shape. As in
+ * {@link resolveMembers}, the first segment may resolve against a `scope` binding before falling
+ * back to the root — so a nested `{% for child in parent.children %}` can walk the `parent` its
+ * enclosing loop bound.
  */
-declare function typeAtPath(ir: IrSchema, path: readonly string[]): IrType | null;
+declare function typeAtPath(ir: IrSchema, path: readonly string[], scope?: ReadonlyMap<string, IrType>): IrType | null;
 //#endregion
 //#region src/controlled-host.d.ts
 interface ControlledEditorOptions {

package/dist/index.js

@@ -1,4 +1,4 @@
-import { a as setMinijinjaContext, i as resolveMembers, n as minijinjaContextField, o as typeAtPath, r as normalizeContext } from "./context-Dx6bPnKq.js";
+import { a as setMinijinjaContext, i as resolveMembers, n as minijinjaContextField, o as typeAtPath, r as normalizeContext } from "./context-D86o2jK3.js";
 import { Compartment, EditorState } from "@codemirror/state";
 import { EditorView, drawSelection, highlightActiveLine, keymap, lineNumbers, placeholder } from "@codemirror/view";
 import { autocompletion, closeBrackets, closeBracketsKeymap, completionKeymap } from "@codemirror/autocomplete";
@@ -69,6 +69,8 @@ const searchPhrasesZhCn = EditorState.phrases.of({
 	close: "关闭",
 	"current match": "当前匹配",
 	"on line": "所在行",
+	"replaced $ matches": "已替换 $ 处匹配",
+	"replaced match on line $": "已替换第 $ 行的匹配",
 	"Go to line": "跳转到行",
 	go: "跳转"
 });
@@ -262,35 +264,35 @@ const loaders = {
 	xu: legacy(() => import("@codemirror/legacy-modes/mode/mscgen").then((mod) => mod.xu)),
 	yacas: legacy(() => import("@codemirror/legacy-modes/mode/yacas").then((mod) => mod.yacas)),
 	z80: legacy(() => import("@codemirror/legacy-modes/mode/z80").then((mod) => mod.z80)),
-	minijinja: () => import("./minijinja-HpehSBbW.js").then((mod) => mod.minijinja()),
-	"minijinja-html": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/lang-html")]).then(([mj, mod]) => mj.minijinja({ base: mod.html() })),
-	"minijinja-xml": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/lang-xml")]).then(([mj, mod]) => mj.minijinja({ base: mod.xml() })),
-	"minijinja-json": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/lang-json")]).then(([mj, mod]) => mj.minijinja({ base: mod.json() })),
-	"minijinja-yaml": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/lang-yaml")]).then(([mj, mod]) => mj.minijinja({ base: mod.yaml() })),
-	"minijinja-css": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/lang-css")]).then(([mj, mod]) => mj.minijinja({ base: mod.css() })),
-	"minijinja-scss": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/lang-sass")]).then(([mj, mod]) => mj.minijinja({ base: mod.sass() })),
-	"minijinja-sass": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/lang-sass")]).then(([mj, mod]) => mj.minijinja({ base: mod.sass({ indented: true }) })),
-	"minijinja-less": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/lang-less")]).then(([mj, mod]) => mj.minijinja({ base: mod.less() })),
-	"minijinja-markdown": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/lang-markdown")]).then(([mj, mod]) => mj.minijinja({ base: mod.markdown() })),
-	"minijinja-sql": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/lang-sql")]).then(([mj, mod]) => mj.minijinja({ base: mod.sql() })),
-	"minijinja-mysql": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/lang-sql")]).then(([mj, mod]) => mj.minijinja({ base: mod.sql({ dialect: mod.MySQL }) })),
-	"minijinja-pgsql": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/lang-sql")]).then(([mj, mod]) => mj.minijinja({ base: mod.sql({ dialect: mod.PostgreSQL }) })),
-	"minijinja-sqlite": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/lang-sql")]).then(([mj, mod]) => mj.minijinja({ base: mod.sql({ dialect: mod.SQLite }) })),
-	"minijinja-mssql": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/lang-sql")]).then(([mj, mod]) => mj.minijinja({ base: mod.sql({ dialect: mod.MSSQL }) })),
-	"minijinja-mariadb": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/lang-sql")]).then(([mj, mod]) => mj.minijinja({ base: mod.sql({ dialect: mod.MariaSQL }) })),
-	"minijinja-plsql": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/lang-sql")]).then(([mj, mod]) => mj.minijinja({ base: mod.sql({ dialect: mod.PLSQL }) })),
-	"minijinja-cassandra": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/lang-sql")]).then(([mj, mod]) => mj.minijinja({ base: mod.sql({ dialect: mod.Cassandra }) })),
-	"minijinja-hive": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/legacy-modes/mode/sql")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.hive)) })),
-	"minijinja-sparksql": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/legacy-modes/mode/sql")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.sparkSQL)) })),
-	"minijinja-gql": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/legacy-modes/mode/sql")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.gql)) })),
-	"minijinja-gpsql": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/legacy-modes/mode/sql")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.gpSQL)) })),
-	"minijinja-esper": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/legacy-modes/mode/sql")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.esper)) })),
-	"minijinja-toml": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/legacy-modes/mode/toml")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.toml)) })),
-	"minijinja-ini": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/legacy-modes/mode/properties")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.properties)) })),
-	"minijinja-env": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/legacy-modes/mode/properties")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.properties)) })),
-	"minijinja-shell": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/legacy-modes/mode/shell")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.shell)) })),
-	"minijinja-dockerfile": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/legacy-modes/mode/dockerfile")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.dockerFile)) })),
-	"minijinja-nginx": () => Promise.all([import("./minijinja-HpehSBbW.js"), import("@codemirror/legacy-modes/mode/nginx")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.nginx)) }))
+	minijinja: () => import("./minijinja-D_5erBa7.js").then((mod) => mod.minijinja()),
+	"minijinja-html": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/lang-html")]).then(([mj, mod]) => mj.minijinja({ base: mod.html() })),
+	"minijinja-xml": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/lang-xml")]).then(([mj, mod]) => mj.minijinja({ base: mod.xml() })),
+	"minijinja-json": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/lang-json")]).then(([mj, mod]) => mj.minijinja({ base: mod.json() })),
+	"minijinja-yaml": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/lang-yaml")]).then(([mj, mod]) => mj.minijinja({ base: mod.yaml() })),
+	"minijinja-css": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/lang-css")]).then(([mj, mod]) => mj.minijinja({ base: mod.css() })),
+	"minijinja-scss": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/lang-sass")]).then(([mj, mod]) => mj.minijinja({ base: mod.sass() })),
+	"minijinja-sass": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/lang-sass")]).then(([mj, mod]) => mj.minijinja({ base: mod.sass({ indented: true }) })),
+	"minijinja-less": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/lang-less")]).then(([mj, mod]) => mj.minijinja({ base: mod.less() })),
+	"minijinja-markdown": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/lang-markdown")]).then(([mj, mod]) => mj.minijinja({ base: mod.markdown() })),
+	"minijinja-sql": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/lang-sql")]).then(([mj, mod]) => mj.minijinja({ base: mod.sql() })),
+	"minijinja-mysql": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/lang-sql")]).then(([mj, mod]) => mj.minijinja({ base: mod.sql({ dialect: mod.MySQL }) })),
+	"minijinja-pgsql": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/lang-sql")]).then(([mj, mod]) => mj.minijinja({ base: mod.sql({ dialect: mod.PostgreSQL }) })),
+	"minijinja-sqlite": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/lang-sql")]).then(([mj, mod]) => mj.minijinja({ base: mod.sql({ dialect: mod.SQLite }) })),
+	"minijinja-mssql": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/lang-sql")]).then(([mj, mod]) => mj.minijinja({ base: mod.sql({ dialect: mod.MSSQL }) })),
+	"minijinja-mariadb": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/lang-sql")]).then(([mj, mod]) => mj.minijinja({ base: mod.sql({ dialect: mod.MariaSQL }) })),
+	"minijinja-plsql": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/lang-sql")]).then(([mj, mod]) => mj.minijinja({ base: mod.sql({ dialect: mod.PLSQL }) })),
+	"minijinja-cassandra": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/lang-sql")]).then(([mj, mod]) => mj.minijinja({ base: mod.sql({ dialect: mod.Cassandra }) })),
+	"minijinja-hive": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/legacy-modes/mode/sql")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.hive)) })),
+	"minijinja-sparksql": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/legacy-modes/mode/sql")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.sparkSQL)) })),
+	"minijinja-gql": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/legacy-modes/mode/sql")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.gql)) })),
+	"minijinja-gpsql": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/legacy-modes/mode/sql")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.gpSQL)) })),
+	"minijinja-esper": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/legacy-modes/mode/sql")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.esper)) })),
+	"minijinja-toml": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/legacy-modes/mode/toml")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.toml)) })),
+	"minijinja-ini": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/legacy-modes/mode/properties")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.properties)) })),
+	"minijinja-env": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/legacy-modes/mode/properties")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.properties)) })),
+	"minijinja-shell": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/legacy-modes/mode/shell")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.shell)) })),
+	"minijinja-dockerfile": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/legacy-modes/mode/dockerfile")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.dockerFile)) })),
+	"minijinja-nginx": () => Promise.all([import("./minijinja-D_5erBa7.js"), import("@codemirror/legacy-modes/mode/nginx")]).then(([mj, mod]) => mj.minijinja({ base: new LanguageSupport(StreamLanguage.define(mod.nginx)) }))
 };
 const codeMirrorLanguages = Object.keys(loaders).toSorted();
 function loadLanguage(language) {

package/dist/{minijinja-HpehSBbW.js → minijinja-D_5erBa7.js}

@@ -1,4 +1,4 @@
-import { i as resolveMembers, n as minijinjaContextField, o as typeAtPath, r as normalizeContext, t as elementType } from "./context-Dx6bPnKq.js";
+import { i as resolveMembers, n as minijinjaContextField, o as typeAtPath, r as normalizeContext, t as elementType } from "./context-D86o2jK3.js";
 import { LanguageSupport, syntaxTree } from "@codemirror/language";
 import { jinja, jinjaLanguage } from "@codemirror/lang-jinja";
 import { linter } from "@codemirror/lint";
@@ -219,51 +219,110 @@ function loopField(kind) {
 		nullable: false
 	};
 }
+const ROOT_SCOPE = -1;
 function scopeBindings(state, pos, ir) {
 	const bindings = /* @__PURE__ */ new Map();
-	for (let node = syntaxTree(state).resolveInner(pos, -1); node; node = node.parent) if (node.name === "ForStatement") collectForBindings(state, node, pos, ir, bindings);
-	else if (node.name === "MacroStatement") collectMacroBindings(state, node, pos, bindings);
-	collectSetBindings(state, pos, bindings);
+	const enclosing = [];
+	for (let node = syntaxTree(state).resolveInner(pos, -1); node; node = node.parent) if (node.name === "ForStatement" || node.name === "MacroStatement" || node.name === "WithStatement") 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) {
+		if (node.name === "ForStatement") collectForBindings(state, node, pos, ir, bindings);
+		else if (node.name === "MacroStatement") collectMacroBindings(state, node, pos, bindings);
+		else collectWithBindings(state, node, pos, ir, bindings);
+		applySets(node.from);
+	}
 	return bindings;
 }
 function collectForBindings(state, forNode, pos, ir, bindings) {
 	const tag = forNode.firstChild;
-	if (!tag || tag.name !== "Tag" || pos < tag.to) return;
+	if (!tag || !tagBodyStarted(tag, pos)) return;
 	const definitions = [];
 	let iterable = 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 (!bindings.has("loop")) bindings.set("loop", LOOP_TYPE);
-	const [only] = definitions;
-	if (only && definitions.length === 1 && iterable) {
+	let element = null;
+	if (definitions.length === 1 && iterable) {
 		const path = walkBase(state, iterable);
-		const iterableType = path ? typeAtPath(ir, path) : null;
-		const element = iterableType ? elementType(ir, iterableType) : null;
-		bindings.set(state.sliceDoc(only.from, only.to), element ?? { kind: "any" });
-		return;
+		const iterableType = path ? typeAtPath(ir, path, bindings) : null;
+		element = iterableType ? elementType(ir, iterableType) : null;
+	}
+	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 = [];
 	}
-	for (const definition of definitions) bindings.set(state.sliceDoc(definition.from, definition.to), { kind: "any" });
 }
 function collectMacroBindings(state, macroNode, pos, bindings) {
 	const tag = macroNode.firstChild;
-	if (!tag || tag.name !== "Tag" || pos < tag.to) return;
+	if (!tag || !tagBodyStarted(tag, pos)) return;
 	const paramList = tag.getChild("ParamList");
 	if (!paramList) return;
 	for (let child = paramList.firstChild; child; child = child.nextSibling) if (child.name === "Definition") bindings.set(state.sliceDoc(child.from, child.to), { kind: "any" });
 }
-function collectSetBindings(state, pos, bindings) {
+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 sets = /* @__PURE__ */ new Map();
 	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 definition = keyword.nextSibling;
-			if (definition && definition.name === "Definition") bindings.set(state.sliceDoc(definition.from, definition.to), { kind: "any" });
+			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") 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 === "ForStatement" || parent.name === "MacroStatement" || parent.name === "WithStatement") {
+				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 jinjaContext(state, pos, side) {
 	for (let node = syntaxTree(state).resolveInner(pos, side); node; node = node.parent) {
@@ -279,7 +338,11 @@ function minijinjaCompletion(context) {
 	if (!word) return null;
 	const { from } = word;
 	const before = context.state.sliceDoc(Math.max(0, from - 24), from);
-	const side = from === context.pos ? 1 : -1;
+	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,