@coldsmirk/inkstone-codemirror 0.9.0 → 0.10.1

package/README.md

@@ -1,16 +1,18 @@
 # @coldsmirk/inkstone-codemirror
 
-Framework-agnostic [CodeMirror 6](https://codemirror.net/) plumbing: a controlled editor host (create-once, external-value reconcile, in-place theme swap), the standard document extension bundle, lazy per-language grammar loading, and precise [MiniJinja](https://github.com/mitsuhiko/minijinja) template support with schema-driven context completion.
+Framework-agnostic [CodeMirror 6](https://codemirror.net/) plumbing: controlled editor and merge-view hosts (create-once, external-value reconcile, in-place theme swap), the standard document extension bundle, lazy per-language grammar loading, and precise [MiniJinja](https://github.com/mitsuhiko/minijinja) template support with schema-driven context completion.
 
 Part of [inkstone](https://github.com/coldsmirk/inkstone). For a drop-in React component use [`@coldsmirk/inkstone-react`](https://www.npmjs.com/package/@coldsmirk/inkstone-react)'s `<CodeMirrorEditor>`, which is built on this package; reach for this layer to wire the same plumbing into your own components (any framework).
 
 ## What you get
 
 - **`ControlledEditorHost`** — the controlled-editor lifecycle solved once: the view is created once, external value changes reconcile into the document without resetting cursor/undo, and theme/extension swaps happen in place.
+- **`ControlledMergeHost`** — the same discipline for [`@codemirror/merge`](https://github.com/codemirror/merge)'s side-by-side `MergeView`: both documents reconcile per side without caret resets or callback echo, dynamic extensions swap in place on both editors, and every merge-level option (`orientation`, `revertControls`, `collapseUnchanged`, …) passes straight through. Policy-free — pin either side read-only via `originalExtensions` / `modifiedExtensions` to match how your documents are controlled.
 - **`documentExtensions(options)`** — the standard document editing bundle (history, brackets, completion UI, optional line numbers / wrapping / search), so hosts start from working defaults instead of a bare `EditorState`.
 - **`codeMirrorLanguages` / `loadLanguage(language)`** — the supported `CodeMirrorLanguage` names and their lazy loaders: one dynamic `import()` per grammar, so only the selected language is fetched, never the whole catalog. Two tiers back the ids: the official `@codemirror/lang-*` (Lezer) parsers where upstream ships one, plus the full [`@codemirror/legacy-modes`](https://github.com/codemirror/legacy-modes) catalog (stream-mode highlighting) for everything upstream never wrote a Lezer grammar for — `shell`, `dockerfile`, `ini` / `env` / `properties`, `toml`, `nginx`, `powershell`, `lua`, and a hundred more.
-- **MiniJinja** — `language: "minijinja"` for standalone templates, or `minijinja-<host>` mixed variants (`minijinja-html`, `-xml`, `-json`, `-yaml`, `-css`, `-scss`, `-sass`, `-less`, `-markdown`; the SQL family — `-sql` plus every dialect id: `-mysql`, `-pgsql`, `-sqlite`, `-mssql`, `-mariadb`, `-plsql`, `-cassandra`, `-hive`, `-sparksql`, `-gql`, `-gpsql`, `-esper`; and the config/deploy hosts `-toml`, `-ini`, `-env`, `-shell`, `-dockerfile`, `-nginx`) that overlay MiniJinja tooling on the host grammar. A linter flags non-MiniJinja tags; autocomplete is restricted to MiniJinja's real tags / filters / tests / functions.
+- **MiniJinja** — `language: "minijinja"` for standalone templates, or `minijinja-<host>` mixed variants (`minijinja-html`, `-xml`, `-json`, `-yaml`, `-css`, `-scss`, `-sass`, `-less`, `-markdown`; the SQL family — `-sql` plus every dialect id: `-mysql`, `-pgsql`, `-sqlite`, `-mssql`, `-mariadb`, `-plsql`, `-cassandra`, `-hive`, `-sparksql`, `-gql`, `-gpsql`, `-esper`; and the config/deploy hosts `-toml`, `-ini`, `-env`, `-shell`, `-dockerfile`, `-nginx`) that overlay MiniJinja tooling on the host grammar. A parser adapter supports MiniJinja whitespace control, dotted namespace assignments, and comma-separated `set` assignments beyond the upstream Jinja grammar; a linter flags non-MiniJinja tags, and autocomplete is restricted to MiniJinja's real tags / filters / tests / functions.
 - **Context completion** — `normalizeContext({ schema })` (JSON Schema) or `normalizeContext({ sample })` (representative value) builds an `EditorContext`; dispatch it with `setMinijinjaContext` to make `{{ }}` / `{% if %}` / `{% for %}` complete the render context's variables and walk member access (`user.address.city`). `minijinjaContextField`, `resolveMembers`, and `typeAtPath` expose the underlying pieces.
+- **SQL schema completion** — dispatch `setSqlSchema.of({ tables })` for dialect-aware table and column completion in the Lezer-backed `sql`, `mysql`, `pgsql`, `sqlite`, `mssql`, `mariadb`, `plsql`, and `cassandra` languages plus their `minijinja-*` variants. Legacy stream-mode SQL languages do not consume schemas. Controlled hosts install the data channel eagerly, so the schema may arrive before the lazy grammar.
 - **`searchPhrasesZhCn`** — an opt-in `EditorState.phrases` table localizing the search panel to Simplified Chinese.
 
 ## Install
@@ -20,7 +22,7 @@ pnpm add @coldsmirk/inkstone-codemirror \
   @codemirror/state @codemirror/view @codemirror/language @codemirror/autocomplete @codemirror/commands @codemirror/search
 ```
 
-The `@codemirror/*` packages are **peer dependencies** on purpose: `@codemirror/state` breaks at runtime if two copies load, so your app owns the single copy and every extension is guaranteed to be built against it. Node.js >= 22 for build / SSR hosts.
+The `@codemirror/*` packages are **peer dependencies** on purpose: `@codemirror/state` breaks at runtime if two copies load, so your app owns the single copy and every extension is guaranteed to be built against it. Node.js >= 24 for build / SSR hosts.
 
 ## Quick start
 
@@ -38,6 +40,29 @@ const host = new ControlledEditorHost({
 host.setValue(remoteValue);
 ```
 
+For a side-by-side diff:
+
+```ts
+import { EditorState } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import { ControlledMergeHost, documentExtensions } from "@coldsmirk/inkstone-codemirror";
+
+const diff = new ControlledMergeHost({
+  parent: document.querySelector("#diff")!,
+  original: before,
+  modified: after,
+  extensions: [documentExtensions({ showLineNumbers: true })],
+  // The original side follows setOriginal only — no change channel, so lock it.
+  originalExtensions: [EditorState.readOnly.of(true), EditorView.editable.of(false)],
+  onModifiedChange: next => save(next),
+  revertControls: "a-to-b"
+});
+
+// Both sides reconcile externally, same rules as setValue.
+diff.setOriginal(nextBefore);
+diff.setModified(nextAfter);
+```
+
 For MiniJinja with context completion:
 
 ```ts
@@ -47,6 +72,11 @@ import { loadLanguage, normalizeContext, setMinijinjaContext } from "@coldsmirk/
 view.dispatch({ effects: setMinijinjaContext.of(normalizeContext({ schema })) });
 ```
 
+The controlled hosts install both context and SQL-schema fields before any grammar resolves, so
+applications may dispatch either effect immediately and load/reconfigure the grammar later.
+Hand-built `EditorState` instances should install `minijinjaContextField` / `sqlSchemaField`
+explicitly when they need the same ordering.
+
 The completion is **structural** — it walks the declared shape (member access along a literal path), not types produced by filters or arithmetic. For a Rust backend the schema is nearly free: derive it from the same `serde` struct you render with via [`schemars`](https://docs.rs/schemars), and the completion can't drift from the real context.
 
 ## License

package/dist/{context-D86o2jK3.js → context-BJzyiP0A.js}

@@ -32,7 +32,7 @@ function resolveMembers(ir, path, scope) {
 				required: true,
 				nullable: false
 			};
-		}), ...top];
+		}), ...top.filter((member) => !scope.has(member.name))];
 	}
 	const type = typeAtPath(ir, path, scope);
 	return type ? membersOf(ir, type) : [];
@@ -157,12 +157,13 @@ function defType(name, context) {
 function convert(node, context) {
 	if (typeof node === "boolean" || !isObject(node)) return ANY;
 	const ref = refName(node.$ref);
-	if (ref !== null) return {
+	const reference = ref === null ? null : {
 		kind: "ref",
 		name: ref
 	};
 	if (Array.isArray(node.allOf)) {
 		const branches = node.allOf.map((entry) => convert(entry, context));
+		if (reference) branches.unshift(reference);
 		return requireFields(mergeAll(isObject(node.properties) ? [...branches, objectType(node, context)] : branches, context, "all"), node.required, context);
 	}
 	const union = node.anyOf ?? node.oneOf;
@@ -172,7 +173,13 @@ function convert(node, context) {
 		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);
+		const withOwn = isObject(node.properties) ? mergeAll([merged, objectType(node, context)], context, "all") : merged;
+		return requireFields(reference ? mergeAll([reference, withOwn], context, "all") : withOwn, node.required, context);
+	}
+	if (reference) {
+		const hasProperties = isObject(node.properties);
+		if (!(hasProperties || Array.isArray(node.required) || primaryType(node) === "object")) return reference;
+		return requireFields(hasProperties ? mergeAll([reference, objectType(node, context)], context, "all") : reference, node.required, context);
 	}
 	if (Array.isArray(node.enum)) return {
 		kind: "enum",
@@ -186,7 +193,7 @@ function convert(node, context) {
 	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)
+		element: convert((Array.isArray(node.prefixItems) ? node.prefixItems[0] : void 0) ?? (Array.isArray(node.items) ? node.items[0] : node.items), context)
 	};
 	if (type === "string") return { kind: "string" };
 	if (type === "integer" || type === "number") return { kind: "number" };
@@ -320,7 +327,7 @@ function sampleObjectType(value, ancestors) {
 }
 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));
+	for (const prefix of REF_PREFIXES) if (ref.startsWith(prefix)) return decodeURIComponent(ref.slice(prefix.length)).replaceAll("~1", "/").replaceAll("~0", "~");
 	return null;
 }
 function primaryType(node) {

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { Extension, StateField } from "@codemirror/state";
 import { EditorView } from "@codemirror/view";
 import { LanguageSupport } from "@codemirror/language";
+import { DirectMergeConfig, MergeConfig, MergeConfig as MergeConfig$1, MergeView, MergeView as MergeView$1 } from "@codemirror/merge";
 
 //#region src/context.d.ts
 /**
@@ -61,8 +62,9 @@ type EditorContext = {
  * Reactively set (or clear) the render-context schema an editor completes against. Dispatch this
  * effect — `setMinijinjaContext.of(normalizeContext(...))`, or `.of(null)` to turn it off — to
  * update completion without recreating the editor, matching the create-once discipline used
- * throughout the toolkit. Defined here (not with the MiniJinja grammar) so it and the field stay
- * in the always-loaded chunk, leaving the grammar lazily code-split.
+ * throughout the toolkit. Controlled editor hosts install the field before any lazy grammar
+ * resolves; a hand-built EditorState should install {@link minijinjaContextField} itself when it
+ * needs to dispatch this effect before adding the MiniJinja support.
  */
 declare const setMinijinjaContext: import("@codemirror/state").StateEffectType<IrSchema | null>;
 /**
@@ -554,4 +556,130 @@ declare const codeMirrorLanguages: readonly CodeMirrorLanguage[];
  */
 declare function loadLanguage(language: CodeMirrorLanguage): Promise<Extension>;
 //#endregion
-export { type CodeMirrorLanguage, ControlledEditorHost, type ControlledEditorOptions, type DocumentExtensionsOptions, type EditorContext, type IrField, type IrSchema, type IrType, type Member, codeMirrorLanguages, documentExtensions, loadLanguage, minijinjaContextField, normalizeContext, resolveMembers, searchPhrasesZhCn, setMinijinjaContext, typeAtPath };
+//#region src/merge-host.d.ts
+interface ControlledMergeOptions extends MergeConfig$1 {
+  /**
+   * The element the merge view mounts into.
+   */
+  parent: HTMLElement;
+  /**
+   * Document or shadow root the merge view is mounted in. Required when `parent` lives outside
+   * the global document because the two editors are created before the merge DOM is attached.
+   */
+  root?: DirectMergeConfig["root"];
+  /**
+   * Initial text of the original document (editor A — the left side in the default
+   * orientation).
+   */
+  original: string;
+  /**
+   * Initial text of the modified document (editor B).
+   */
+  modified: string;
+  /**
+   * Called with the full original document after every edit made *in* editor A — user
+   * typing, or a `revertControls: "b-to-a"` copy. Not called for
+   * {@link ControlledMergeHost.setOriginal} reconciliations. Leave editor A read-only
+   * (via {@link ControlledMergeOptions.originalExtensions}) when nothing consumes this.
+   */
+  onOriginalChange?: (value: string) => void;
+  /**
+   * Called with the full modified document after every edit made *in* editor B — user
+   * typing, or a `revertControls: "a-to-b"` copy. Not called for
+   * {@link ControlledMergeHost.setModified} reconciliations.
+   */
+  onModifiedChange?: (value: string) => void;
+  /**
+   * Static extensions applied to both editors, fixed for the merge view's lifetime.
+   */
+  extensions?: Extension[];
+  /**
+   * Static extensions for editor A only — the place to make the original side read-only
+   * (`EditorState.readOnly.of(true)`, `EditorView.editable.of(false)`).
+   */
+  originalExtensions?: Extension[];
+  /**
+   * Static extensions for editor B only.
+   */
+  modifiedExtensions?: Extension[];
+  /**
+   * Extensions that change at runtime (theme, language config …), applied to both editors
+   * and swapped in place via {@link ControlledMergeHost.reconfigure}.
+   */
+  dynamicExtensions?: Extension[];
+}
+/**
+ * A controlled CodeMirror 6 merge view — {@link ControlledEditorHost}'s discipline applied to
+ * `@codemirror/merge`'s side-by-side {@link MergeView}:
+ *
+ * - **External value reconcile, per side.** {@link setOriginal} / {@link setModified} diff the
+ * incoming value against the live document and dispatch a minimal replace, so a store-driven
+ * update never resets the caret and never echoes back through the change callbacks.
+ * - **In-place reconfiguration.** `dynamicExtensions` live in one {@link Compartment} per
+ * editor; {@link reconfigure} swaps both (light/dark theme, language options) without
+ * rebuilding the view. Merge-level options (`orientation`, `revertControls`,
+ * `collapseUnchanged` …) reconfigure through {@link MergeView.reconfigure} on {@link view}.
+ *
+ * Policy-free plumbing: neither side is read-only by default — wire that through
+ * `originalExtensions` / `modifiedExtensions` to match how the documents are controlled.
+ * Framework-agnostic, same as `ControlledEditorHost`.
+ */
+declare class ControlledMergeHost {
+  private readonly originalCompartment;
+  private readonly modifiedCompartment;
+  private silent;
+  readonly view: MergeView$1;
+  constructor(options: ControlledMergeOptions);
+  private reconcile;
+  /**
+   * Reconcile an externally-changed original value into editor A without resetting its caret.
+   * No-op when the document already matches; the write never re-enters `onOriginalChange`.
+   */
+  setOriginal(value: string): void;
+  /**
+   * Reconcile an externally-changed modified value into editor B without resetting its caret.
+   * No-op when the document already matches; the write never re-enters `onModifiedChange`.
+   */
+  setModified(value: string): void;
+  /**
+   * Swap the dynamic extensions (theme, language configuration) in place, on both editors.
+   */
+  reconfigure(dynamicExtensions: Extension[]): void;
+  destroy(): void;
+}
+//#endregion
+//#region src/sql-schema.d.ts
+/**
+ * A database's completable surface. Table keys may be schema-qualified (`"analytics.events"`);
+ * unqualified keys complete against `defaultSchema` per `@codemirror/lang-sql` semantics.
+ */
+interface SqlSchema {
+  /**
+   * Table name (optionally schema-qualified) → column names, in declaration order.
+   */
+  readonly tables: Readonly<Record<string, readonly string[]>>;
+  /**
+   * Table whose columns complete unqualified (no `table.` prefix).
+   */
+  readonly defaultTable?: string;
+  /**
+   * Schema whose tables complete unqualified.
+   */
+  readonly defaultSchema?: string;
+}
+/**
+ * Reactively set (or clear) the database schema SQL completion reads. Dispatch
+ * `setSqlSchema.of(schema)` — or `.of(null)` to turn table/column completion off — to update a
+ * live editor without recreating it, matching the create-once discipline used throughout the
+ * toolkit.
+ */
+declare const setSqlSchema: import("@codemirror/state").StateEffectType<SqlSchema | null>;
+/**
+ * Holds the schema that SQL table/column completion reads. Controlled editor hosts install it
+ * eagerly; the `sql`-family language supports also include it for hand-built editors. `null`
+ * (the default) means no schema — keyword completion still works, table/column completion stays
+ * off.
+ */
+declare const sqlSchemaField: StateField<SqlSchema | null>;
+//#endregion
+export { type CodeMirrorLanguage, ControlledEditorHost, type ControlledEditorOptions, ControlledMergeHost, type ControlledMergeOptions, type DocumentExtensionsOptions, type EditorContext, type IrField, type IrSchema, type IrType, type Member, type MergeConfig, type MergeView, type SqlSchema, codeMirrorLanguages, documentExtensions, loadLanguage, minijinjaContextField, normalizeContext, resolveMembers, searchPhrasesZhCn, setMinijinjaContext, setSqlSchema, sqlSchemaField, typeAtPath };

package/dist/index.js

@@ -1,10 +1,77 @@
-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 { a as setMinijinjaContext, i as resolveMembers, n as minijinjaContextField, o as typeAtPath, r as normalizeContext } from "./context-BJzyiP0A.js";
+import { n as sqlSchemaField, t as setSqlSchema } from "./sql-schema-DiPx5-bu.js";
+import { Compartment, EditorState, Transaction } from "@codemirror/state";
 import { EditorView, drawSelection, highlightActiveLine, keymap, lineNumbers, placeholder } from "@codemirror/view";
 import { autocompletion, closeBrackets, closeBracketsKeymap, completionKeymap } from "@codemirror/autocomplete";
 import { defaultKeymap, history, historyKeymap, indentWithTab } from "@codemirror/commands";
 import { LanguageSupport, StreamLanguage, bracketMatching, codeFolding, foldGutter, foldKeymap, indentOnInput } from "@codemirror/language";
 import { highlightSelectionMatches, searchKeymap } from "@codemirror/search";
+import { MergeView } from "@codemirror/merge";
+//#region src/minimal-replace.ts
+function minimalReplace(state, externalValue) {
+	const current = state.doc;
+	const value = state.toText(externalValue);
+	if (value.eq(current)) return null;
+	const from = commonLength(current, value, 1, Math.min(current.length, value.length));
+	const suffix = commonLength(current, value, -1, Math.min(current.length - from, value.length - from));
+	const currentEnd = current.length - suffix;
+	const valueEnd = value.length - suffix;
+	return {
+		from,
+		to: currentEnd,
+		insert: value.slice(from, valueEnd)
+	};
+}
+function commonLength(a, b, direction, maximum) {
+	const aIterator = a.iter(direction);
+	const bIterator = b.iter(direction);
+	let length = 0;
+	aIterator.next();
+	bIterator.next();
+	while (length < maximum && !aIterator.done && !bIterator.done) {
+		if (aIterator.lineBreak || bIterator.lineBreak) {
+			if (aIterator.lineBreak !== bIterator.lineBreak) break;
+			length += 1;
+			aIterator.next();
+			bIterator.next();
+			continue;
+		}
+		const available = Math.min(aIterator.value.length, bIterator.value.length, maximum - length);
+		if (aIterator.value !== bIterator.value) {
+			length += commonStringLength(aIterator.value, bIterator.value, direction, available);
+			break;
+		}
+		if (available < aIterator.value.length) {
+			length += available;
+			break;
+		}
+		length += available;
+		aIterator.next();
+		bIterator.next();
+	}
+	return length;
+}
+function commonStringLength(a, b, direction, maximum) {
+	let length = 0;
+	let previous = -1;
+	while (length < maximum) {
+		const aCode = a.charCodeAt(direction === 1 ? length : a.length - length - 1);
+		if (aCode !== b.charCodeAt(direction === 1 ? length : b.length - length - 1)) {
+			if (direction === 1 && isHighSurrogate(previous) || direction === -1 && isLowSurrogate(previous)) length -= 1;
+			break;
+		}
+		previous = aCode;
+		length += 1;
+	}
+	return length;
+}
+function isHighSurrogate(codeUnit) {
+	return codeUnit >= 55296 && codeUnit <= 56319;
+}
+function isLowSurrogate(codeUnit) {
+	return codeUnit >= 56320 && codeUnit <= 57343;
+}
+//#endregion
 //#region src/controlled-host.ts
 var ControlledEditorHost = class {
 	compartment = new Compartment();
@@ -16,34 +83,26 @@ var ControlledEditorHost = class {
 			state: EditorState.create({
 				doc,
 				extensions: [
+					minijinjaContextField,
+					sqlSchemaField,
 					...extensions,
 					this.compartment.of(dynamicExtensions),
 					EditorView.updateListener.of((update) => {
-						if (update.docChanged && !this.silent) onChange(update.state.doc.toString());
+						if (update.docChanged && !this.silent) onChange(update.state.sliceDoc());
 					})
 				]
 			})
 		});
 	}
 	setValue(value) {
-		const current = this.view.state.doc.toString();
-		if (value === current) return;
-		const shorter = Math.min(current.length, value.length);
-		let from = 0;
-		while (from < shorter && current.codePointAt(from) === value.codePointAt(from)) from += 1;
-		let currentEnd = current.length;
-		let valueEnd = value.length;
-		while (currentEnd > from && valueEnd > from && current.codePointAt(currentEnd - 1) === value.codePointAt(valueEnd - 1)) {
-			currentEnd -= 1;
-			valueEnd -= 1;
-		}
+		const changes = minimalReplace(this.view.state, value);
+		if (!changes) return;
 		this.silent = true;
 		try {
-			this.view.dispatch({ changes: {
-				from,
-				to: currentEnd,
-				insert: value.slice(from, valueEnd)
-			} });
+			this.view.dispatch({
+				changes,
+				annotations: Transaction.addToHistory.of(false)
+			});
 		} finally {
 			this.silent = false;
 		}
@@ -98,7 +157,7 @@ function documentExtensions({ placeholder: placeholder$1, lineWrapping = false,
 			...completionKeymap,
 			indentWithTab
 		]),
-		placeholder(placeholder$1 ?? ""),
+		...placeholder$1 === void 0 ? [] : [placeholder(placeholder$1)],
 		...spellcheck ? [EditorView.contentAttributes.of({ spellcheck: "true" })] : []
 	];
 }
@@ -136,14 +195,14 @@ const loaders = {
 	liquid: () => import("@codemirror/lang-liquid").then((mod) => mod.liquid()),
 	wast: () => import("@codemirror/lang-wast").then((mod) => mod.wast()),
 	lezer: () => import("@codemirror/lang-lezer").then((mod) => mod.lezer()),
-	sql: () => import("@codemirror/lang-sql").then((mod) => mod.sql()),
-	mysql: () => import("@codemirror/lang-sql").then((mod) => mod.sql({ dialect: mod.MySQL })),
-	pgsql: () => import("@codemirror/lang-sql").then((mod) => mod.sql({ dialect: mod.PostgreSQL })),
-	sqlite: () => import("@codemirror/lang-sql").then((mod) => mod.sql({ dialect: mod.SQLite })),
-	mssql: () => import("@codemirror/lang-sql").then((mod) => mod.sql({ dialect: mod.MSSQL })),
-	mariadb: () => import("@codemirror/lang-sql").then((mod) => mod.sql({ dialect: mod.MariaSQL })),
-	plsql: () => import("@codemirror/lang-sql").then((mod) => mod.sql({ dialect: mod.PLSQL })),
-	cassandra: () => import("@codemirror/lang-sql").then((mod) => mod.sql({ dialect: mod.Cassandra })),
+	sql: () => Promise.all([import("./sql-support-Gk7Wv9Kj.js"), import("@codemirror/lang-sql")]).then(([schema, mod]) => schema.withSqlSchema(mod.sql(), mod.StandardSQL)),
+	mysql: () => Promise.all([import("./sql-support-Gk7Wv9Kj.js"), import("@codemirror/lang-sql")]).then(([schema, mod]) => schema.withSqlSchema(mod.sql({ dialect: mod.MySQL }), mod.MySQL)),
+	pgsql: () => Promise.all([import("./sql-support-Gk7Wv9Kj.js"), import("@codemirror/lang-sql")]).then(([schema, mod]) => schema.withSqlSchema(mod.sql({ dialect: mod.PostgreSQL }), mod.PostgreSQL)),
+	sqlite: () => Promise.all([import("./sql-support-Gk7Wv9Kj.js"), import("@codemirror/lang-sql")]).then(([schema, mod]) => schema.withSqlSchema(mod.sql({ dialect: mod.SQLite }), mod.SQLite)),
+	mssql: () => Promise.all([import("./sql-support-Gk7Wv9Kj.js"), import("@codemirror/lang-sql")]).then(([schema, mod]) => schema.withSqlSchema(mod.sql({ dialect: mod.MSSQL }), mod.MSSQL)),
+	mariadb: () => Promise.all([import("./sql-support-Gk7Wv9Kj.js"), import("@codemirror/lang-sql")]).then(([schema, mod]) => schema.withSqlSchema(mod.sql({ dialect: mod.MariaSQL }), mod.MariaSQL)),
+	plsql: () => Promise.all([import("./sql-support-Gk7Wv9Kj.js"), import("@codemirror/lang-sql")]).then(([schema, mod]) => schema.withSqlSchema(mod.sql({ dialect: mod.PLSQL }), mod.PLSQL)),
+	cassandra: () => Promise.all([import("./sql-support-Gk7Wv9Kj.js"), import("@codemirror/lang-sql")]).then(([schema, mod]) => schema.withSqlSchema(mod.sql({ dialect: mod.Cassandra }), mod.Cassandra)),
 	apl: legacy(() => import("@codemirror/legacy-modes/mode/apl").then((mod) => mod.apl)),
 	asciiarmor: legacy(() => import("@codemirror/legacy-modes/mode/asciiarmor").then((mod) => mod.asciiArmor)),
 	asn1: legacy(() => import("@codemirror/legacy-modes/mode/asn1").then((mod) => mod.asn1({}))),
@@ -264,39 +323,138 @@ 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-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)) }))
+	minijinja: () => import("./minijinja-D5ANOjtx.js").then((mod) => mod.minijinja()),
+	"minijinja-html": () => Promise.all([import("./minijinja-D5ANOjtx.js"), import("@codemirror/lang-html")]).then(([mj, mod]) => mj.minijinja({ base: mod.html() })),
+	"minijinja-xml": () => Promise.all([import("./minijinja-D5ANOjtx.js"), import("@codemirror/lang-xml")]).then(([mj, mod]) => mj.minijinja({ base: mod.xml() })),
+	"minijinja-json": () => Promise.all([import("./minijinja-D5ANOjtx.js"), import("@codemirror/lang-json")]).then(([mj, mod]) => mj.minijinja({ base: mod.json() })),
+	"minijinja-yaml": () => Promise.all([import("./minijinja-D5ANOjtx.js"), import("@codemirror/lang-yaml")]).then(([mj, mod]) => mj.minijinja({ base: mod.yaml() })),
+	"minijinja-css": () => Promise.all([import("./minijinja-D5ANOjtx.js"), import("@codemirror/lang-css")]).then(([mj, mod]) => mj.minijinja({ base: mod.css() })),
+	"minijinja-scss": () => Promise.all([import("./minijinja-D5ANOjtx.js"), import("@codemirror/lang-sass")]).then(([mj, mod]) => mj.minijinja({ base: mod.sass() })),
+	"minijinja-sass": () => Promise.all([import("./minijinja-D5ANOjtx.js"), import("@codemirror/lang-sass")]).then(([mj, mod]) => mj.minijinja({ base: mod.sass({ indented: true }) })),
+	"minijinja-less": () => Promise.all([import("./minijinja-D5ANOjtx.js"), import("@codemirror/lang-less")]).then(([mj, mod]) => mj.minijinja({ base: mod.less() })),
+	"minijinja-markdown": () => Promise.all([import("./minijinja-D5ANOjtx.js"), import("@codemirror/lang-markdown")]).then(([mj, mod]) => mj.minijinja({ base: mod.markdown() })),
+	"minijinja-sql": () => Promise.all([
+		import("./minijinja-D5ANOjtx.js"),
+		import("./sql-support-Gk7Wv9Kj.js"),
+		import("@codemirror/lang-sql")
+	]).then(([mj, schema, mod]) => mj.minijinja({ base: schema.withSqlSchema(mod.sql(), mod.StandardSQL) })),
+	"minijinja-mysql": () => Promise.all([
+		import("./minijinja-D5ANOjtx.js"),
+		import("./sql-support-Gk7Wv9Kj.js"),
+		import("@codemirror/lang-sql")
+	]).then(([mj, schema, mod]) => mj.minijinja({ base: schema.withSqlSchema(mod.sql({ dialect: mod.MySQL }), mod.MySQL) })),
+	"minijinja-pgsql": () => Promise.all([
+		import("./minijinja-D5ANOjtx.js"),
+		import("./sql-support-Gk7Wv9Kj.js"),
+		import("@codemirror/lang-sql")
+	]).then(([mj, schema, mod]) => mj.minijinja({ base: schema.withSqlSchema(mod.sql({ dialect: mod.PostgreSQL }), mod.PostgreSQL) })),
+	"minijinja-sqlite": () => Promise.all([
+		import("./minijinja-D5ANOjtx.js"),
+		import("./sql-support-Gk7Wv9Kj.js"),
+		import("@codemirror/lang-sql")
+	]).then(([mj, schema, mod]) => mj.minijinja({ base: schema.withSqlSchema(mod.sql({ dialect: mod.SQLite }), mod.SQLite) })),
+	"minijinja-mssql": () => Promise.all([
+		import("./minijinja-D5ANOjtx.js"),
+		import("./sql-support-Gk7Wv9Kj.js"),
+		import("@codemirror/lang-sql")
+	]).then(([mj, schema, mod]) => mj.minijinja({ base: schema.withSqlSchema(mod.sql({ dialect: mod.MSSQL }), mod.MSSQL) })),
+	"minijinja-mariadb": () => Promise.all([
+		import("./minijinja-D5ANOjtx.js"),
+		import("./sql-support-Gk7Wv9Kj.js"),
+		import("@codemirror/lang-sql")
+	]).then(([mj, schema, mod]) => mj.minijinja({ base: schema.withSqlSchema(mod.sql({ dialect: mod.MariaSQL }), mod.MariaSQL) })),
+	"minijinja-plsql": () => Promise.all([
+		import("./minijinja-D5ANOjtx.js"),
+		import("./sql-support-Gk7Wv9Kj.js"),
+		import("@codemirror/lang-sql")
+	]).then(([mj, schema, mod]) => mj.minijinja({ base: schema.withSqlSchema(mod.sql({ dialect: mod.PLSQL }), mod.PLSQL) })),
+	"minijinja-cassandra": () => Promise.all([
+		import("./minijinja-D5ANOjtx.js"),
+		import("./sql-support-Gk7Wv9Kj.js"),
+		import("@codemirror/lang-sql")
+	]).then(([mj, schema, mod]) => mj.minijinja({ base: schema.withSqlSchema(mod.sql({ dialect: mod.Cassandra }), mod.Cassandra) })),
+	"minijinja-hive": () => Promise.all([import("./minijinja-D5ANOjtx.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-D5ANOjtx.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-D5ANOjtx.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-D5ANOjtx.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-D5ANOjtx.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-D5ANOjtx.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-D5ANOjtx.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-D5ANOjtx.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-D5ANOjtx.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-D5ANOjtx.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-D5ANOjtx.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) {
 	return loaders[language]();
 }
 //#endregion
-export { ControlledEditorHost, codeMirrorLanguages, documentExtensions, loadLanguage, minijinjaContextField, normalizeContext, resolveMembers, searchPhrasesZhCn, setMinijinjaContext, typeAtPath };
+//#region src/merge-host.ts
+var ControlledMergeHost = class {
+	originalCompartment = new Compartment();
+	modifiedCompartment = new Compartment();
+	silent = false;
+	view;
+	constructor(options) {
+		const { parent, original, modified, onOriginalChange, onModifiedChange, extensions = [], originalExtensions = [], modifiedExtensions = [], dynamicExtensions = [], ...mergeConfig } = options;
+		this.view = new MergeView({
+			...mergeConfig,
+			parent,
+			a: {
+				doc: original,
+				extensions: [
+					...originalExtensions,
+					minijinjaContextField,
+					sqlSchemaField,
+					...extensions,
+					this.originalCompartment.of(dynamicExtensions),
+					EditorView.updateListener.of((update) => {
+						if (update.docChanged && !this.silent) onOriginalChange?.(update.state.sliceDoc());
+					})
+				]
+			},
+			b: {
+				doc: modified,
+				extensions: [
+					...modifiedExtensions,
+					minijinjaContextField,
+					sqlSchemaField,
+					...extensions,
+					this.modifiedCompartment.of(dynamicExtensions),
+					EditorView.updateListener.of((update) => {
+						if (update.docChanged && !this.silent) onModifiedChange?.(update.state.sliceDoc());
+					})
+				]
+			}
+		});
+	}
+	reconcile(editor, value) {
+		const changes = minimalReplace(editor.state, value);
+		if (!changes) return;
+		this.silent = true;
+		try {
+			editor.dispatch({
+				changes,
+				annotations: Transaction.addToHistory.of(false)
+			});
+		} finally {
+			this.silent = false;
+		}
+	}
+	setOriginal(value) {
+		this.reconcile(this.view.a, value);
+	}
+	setModified(value) {
+		this.reconcile(this.view.b, value);
+	}
+	reconfigure(dynamicExtensions) {
+		this.view.a.dispatch({ effects: this.originalCompartment.reconfigure(dynamicExtensions) });
+		this.view.b.dispatch({ effects: this.modifiedCompartment.reconfigure(dynamicExtensions) });
+	}
+	destroy() {
+		this.view.destroy();
+	}
+};
+//#endregion
+export { ControlledEditorHost, ControlledMergeHost, codeMirrorLanguages, documentExtensions, loadLanguage, minijinjaContextField, normalizeContext, resolveMembers, searchPhrasesZhCn, setMinijinjaContext, setSqlSchema, sqlSchemaField, typeAtPath };