@coldsmirk/inkstone-sql 0.13.0

package/dist/index.js

@@ -0,0 +1,1531 @@
+//#region src/dialect.ts
+function fn(name, signature, summary) {
+	return {
+		name,
+		signature,
+		summary
+	};
+}
+const CORE_KEYWORDS = [
+	"select",
+	"from",
+	"where",
+	"join",
+	"inner",
+	"left",
+	"right",
+	"full",
+	"outer",
+	"cross",
+	"on",
+	"as",
+	"and",
+	"or",
+	"not",
+	"in",
+	"exists",
+	"between",
+	"like",
+	"is",
+	"null",
+	"distinct",
+	"group",
+	"by",
+	"having",
+	"order",
+	"asc",
+	"desc",
+	"union",
+	"all",
+	"insert",
+	"into",
+	"values",
+	"update",
+	"set",
+	"delete",
+	"case",
+	"when",
+	"then",
+	"else",
+	"end",
+	"cast",
+	"with",
+	"using"
+];
+const CORE_FUNCTIONS = [
+	fn("count", "count(expr)", "Rows in the group; `count(*)` counts every row, `count(column)` skips NULLs."),
+	fn("sum", "sum(expr)", "Adds the values, ignoring NULLs."),
+	fn("avg", "avg(expr)", "Mean of the values, ignoring NULLs."),
+	fn("min", "min(expr)", "Smallest value in the group."),
+	fn("max", "max(expr)", "Largest value in the group."),
+	fn("coalesce", "coalesce(value, fallback, …)", "The first argument that is not NULL."),
+	fn("nullif", "nullif(value, equal_to)", "NULL when the two are equal, otherwise the first argument."),
+	fn("abs", "abs(number)", "Absolute value."),
+	fn("round", "round(number, digits)", "Rounds to the given number of decimal places."),
+	fn("upper", "upper(text)", "Upper case."),
+	fn("lower", "lower(text)", "Lower case."),
+	fn("trim", "trim(text)", "Strips leading and trailing whitespace."),
+	fn("row_number", "row_number()", "Window: a running number over `over (partition by … order by …)`."),
+	fn("rank", "rank()", "Window: ties share a rank, and the next rank skips."),
+	fn("dense_rank", "dense_rank()", "Window: ties share a rank, and the next rank does not skip.")
+];
+const GREATEST = fn("greatest", "greatest(value, …)", "The largest of the arguments.");
+const LEAST = fn("least", "least(value, …)", "The smallest of the arguments.");
+const SUBSTRING = fn("substring", "substring(text, start, count)", "`count` characters from position `start`, counting from 1.");
+const TO_CHAR = fn("to_char", "to_char(value, format)", "Formats a timestamp or a number through a format string.");
+const TO_DATE = fn("to_date", "to_date(text, format)", "Parses text into a date through a format string.");
+const EXTRACT = fn("extract", "extract(field from source)", "One field out of a temporal value, as in `extract(year from created_at)`.");
+function dialect(keywords, functions) {
+	return {
+		keywords: [...CORE_KEYWORDS, ...keywords],
+		functions: [...CORE_FUNCTIONS, ...functions]
+	};
+}
+const ORACLE$1 = dialect([
+	"dual",
+	"rownum",
+	"minus",
+	"connect",
+	"start",
+	"prior",
+	"fetch",
+	"first",
+	"next",
+	"rows",
+	"only",
+	"merge",
+	"matched",
+	"returning",
+	"sysdate",
+	"systimestamp"
+], [
+	fn("nvl", "nvl(value, fallback)", "The second argument when the first is NULL."),
+	fn("nvl2", "nvl2(value, if_not_null, if_null)", "Chooses by whether the first argument is NULL."),
+	fn("decode", "decode(expr, search, result, …, default)", "Compares pair by pair — a `case` in shorthand."),
+	TO_CHAR,
+	TO_DATE,
+	fn("to_number", "to_number(text, format)", "Parses text into a number through a format string."),
+	fn("trunc", "trunc(value, unit)", "Truncates: a date to a precision, a number to decimal places."),
+	EXTRACT,
+	fn("substr", "substr(text, start, count)", "`count` characters from position `start`; a negative `start` counts from the end."),
+	fn("instr", "instr(text, search)", "Position of a substring, or 0 when it is absent."),
+	fn("length", "length(text)", "Characters in the string."),
+	fn("concat", "concat(text, text)", "Joins two strings; use `||` for more."),
+	GREATEST,
+	LEAST,
+	fn("listagg", "listagg(expr, delimiter)", "Aggregate: joins with a delimiter; needs `within group (order by …)`.")
+]);
+const SQL_DIALECTS = {
+	postgres: dialect([
+		"limit",
+		"offset",
+		"returning",
+		"ilike",
+		"lateral",
+		"conflict",
+		"do",
+		"nothing",
+		"recursive",
+		"fetch",
+		"first",
+		"next",
+		"rows",
+		"only",
+		"true",
+		"false",
+		"current_date",
+		"current_timestamp"
+	], [
+		fn("now", "now()", "Current date and time."),
+		TO_CHAR,
+		TO_DATE,
+		fn("to_timestamp", "to_timestamp(text, format)", "Parses text into a timestamp through a format string."),
+		EXTRACT,
+		fn("date_trunc", "date_trunc(field, source)", "Truncates a timestamp to a precision, as in `date_trunc('day', created_at)`."),
+		fn("concat", "concat(value, …)", "Joins the arguments as text, treating NULL as an empty string."),
+		SUBSTRING,
+		fn("length", "length(text)", "Characters in the string."),
+		GREATEST,
+		LEAST,
+		fn("string_agg", "string_agg(expr, delimiter)", "Aggregate: joins each row's value with a delimiter."),
+		fn("array_agg", "array_agg(expr)", "Aggregate: collects each row's value into an array."),
+		fn("jsonb_agg", "jsonb_agg(expr)", "Aggregate: collects each row's value into a JSON array."),
+		fn("jsonb_build_object", "jsonb_build_object(key, value, …)", "Builds a JSON object from alternating key and value arguments.")
+	]),
+	mysql: dialect([
+		"limit",
+		"offset",
+		"ignore",
+		"replace",
+		"duplicate",
+		"key",
+		"interval",
+		"straight_join",
+		"true",
+		"false"
+	], [
+		fn("now", "now()", "Current date and time."),
+		fn("curdate", "curdate()", "Current date."),
+		fn("curtime", "curtime()", "Current time."),
+		fn("ifnull", "ifnull(value, fallback)", "The second argument when the first is NULL."),
+		fn("if", "if(condition, then, else)", "Ternary choice."),
+		fn("date_format", "date_format(date, format)", "Formats a date through a format string."),
+		fn("str_to_date", "str_to_date(text, format)", "Parses text into a date through a format string."),
+		fn("date_add", "date_add(date, interval n unit)", "Adds an interval, as in `date_add(d, interval 7 day)`."),
+		fn("date_sub", "date_sub(date, interval n unit)", "Subtracts an interval."),
+		fn("concat", "concat(value, …)", "Joins the arguments as text; NULL in any of them makes the whole result NULL."),
+		fn("concat_ws", "concat_ws(separator, value, …)", "Joins with a separator, skipping NULLs."),
+		SUBSTRING,
+		fn("length", "length(text)", "Bytes in the string; `char_length` counts characters."),
+		GREATEST,
+		LEAST,
+		fn("group_concat", "group_concat(expr)", "Aggregate: joins each row's value into one string; takes `separator '…'`."),
+		fn("json_extract", "json_extract(json, path)", "Reads a JSON path, as in `'$.id'`.")
+	]),
+	oracle: ORACLE$1,
+	sqlserver: dialect([
+		"top",
+		"offset",
+		"fetch",
+		"next",
+		"rows",
+		"only",
+		"apply",
+		"output",
+		"inserted",
+		"deleted",
+		"merge",
+		"matched",
+		"pivot",
+		"unpivot"
+	], [
+		fn("isnull", "isnull(value, fallback)", "The second argument when the first is NULL."),
+		fn("iif", "iif(condition, then, else)", "Ternary choice."),
+		fn("getdate", "getdate()", "Current date and time."),
+		fn("sysdatetime", "sysdatetime()", "Current date and time, at higher precision."),
+		fn("dateadd", "dateadd(datepart, number, date)", "Adds to a date part, as in `dateadd(day, 7, d)`."),
+		fn("datediff", "datediff(datepart, start, end)", "Whole date parts between two times."),
+		fn("datepart", "datepart(datepart, date)", "One part of a date, as an integer."),
+		fn("datename", "datename(datepart, date)", "One part of a date, as text."),
+		fn("convert", "convert(type, value, style)", "Converts a type through a style number."),
+		fn("try_convert", "try_convert(type, value, style)", "Like `convert`, but NULL instead of an error."),
+		fn("format", "format(value, format, culture)", "Formats through a .NET format string."),
+		fn("concat", "concat(value, …)", "Joins the arguments as text, treating NULL as an empty string."),
+		SUBSTRING,
+		fn("charindex", "charindex(search, text, start)", "Position of a substring, or 0 when it is absent."),
+		fn("len", "len(text)", "Characters in the string, trailing spaces excluded."),
+		fn("ltrim", "ltrim(text)", "Strips leading whitespace."),
+		fn("rtrim", "rtrim(text)", "Strips trailing whitespace."),
+		fn("string_agg", "string_agg(expr, delimiter)", "Aggregate: joins each row's value with a delimiter.")
+	]),
+	dm: ORACLE$1
+};
+function signatureParameters(signature) {
+	const open = signature.indexOf("(");
+	const close = signature.lastIndexOf(")");
+	if (open === -1 || close < open) return [];
+	const spans = [];
+	let depth = 0;
+	let start = open + 1;
+	const push = (end) => {
+		const text = signature.slice(start, end);
+		const lead = text.length - text.trimStart().length;
+		const tail = text.length - text.trimEnd().length;
+		if (text.trim() !== "") spans.push([start + lead, end - tail]);
+	};
+	for (let at = open + 1; at < close; at += 1) {
+		const ch = signature[at];
+		if (ch === "(") depth += 1;
+		else if (ch === ")") depth -= 1;
+		else if (ch === "," && depth === 0) {
+			push(at);
+			start = at + 1;
+		}
+	}
+	push(close);
+	return spans;
+}
+//#endregion
+//#region src/spelling.ts
+function reservedWords(list) {
+	return new Set(list.trim().split(/\s+/u));
+}
+const POSTGRES_RESERVED = reservedWords(`
+  all analyse analyze and any array as asc asymmetric authorization between bigint binary bit
+  boolean both case cast char character check coalesce collate collation column concurrently
+  constraint create cross current_catalog current_date current_role current_schema current_time
+  current_timestamp current_user dec decimal default deferrable desc distinct do else end except
+  exists extract false fetch float for foreign freeze from full grant greatest group grouping
+  having ilike in initially inner inout int integer intersect interval into is isnull join
+  lateral leading least left like limit localtime localtimestamp national natural nchar none
+  normalize not notnull null nullif numeric offset on only or order out outer overlaps overlay
+  placing position precision primary real references returning right row select session_user
+  setof similar smallint some substring symmetric system_user table tablesample then time
+  timestamp to trailing treat trim true union unique user using values varchar variadic verbose
+  when where window with xmlattributes xmlconcat xmlelement xmlexists xmlforest xmlnamespaces
+  xmlparse xmlpi xmlroot xmlserialize xmltable
+`);
+const MYSQL_RESERVED = reservedWords(`
+  accessible add all alter analyze and as asc asensitive before between bigint binary blob both
+  by call cascade case change char character check collate column condition constraint continue
+  convert create cross cube cume_dist current_date current_time current_timestamp current_user
+  cursor database databases day_hour day_microsecond day_minute day_second dec decimal declare
+  default delayed delete dense_rank desc describe deterministic distinct distinctrow div double
+  drop dual each else elseif empty enclosed escaped except exists exit explain false fetch
+  first_value float float4 float8 for force foreign from fulltext function generated get grant
+  group grouping groups having high_priority hour_microsecond hour_minute hour_second if ignore
+  in index infile inner inout insensitive insert int int1 int2 int3 int4 int8 integer intersect
+  interval into io_after_gtids io_before_gtids is iterate join json_table key keys kill lag
+  last_value lateral lead leading leave left like limit linear lines load localtime
+  localtimestamp lock long longblob longtext loop low_priority master_bind match maxvalue
+  mediumblob mediumint mediumtext middleint minute_microsecond minute_second mod modifies
+  natural no_write_to_binlog not nth_value ntile null numeric of on optimize optimizer_costs
+  option optionally or order out outer outfile over partition percent_rank precision primary
+  procedure purge qualify range rank read read_write reads real recursive references regexp
+  release rename repeat
+  replace require resignal restrict return revoke right rlike row row_number rows schema
+  schemas second_microsecond select sensitive separator set show signal smallint spatial
+  specific sql sql_big_result sql_calc_found_rows sql_small_result sqlexception sqlstate
+  sqlwarning ssl starting stored straight_join system table tablesample terminated then tinyblob tinyint
+  tinytext to trailing trigger true undo union unique unlock unsigned update usage use using
+  utc_date utc_time utc_timestamp values varbinary varchar varcharacter varying virtual when
+  where while window with write xor year_month zerofill
+`);
+const ORACLE_RESERVED = reservedWords(`
+  access add all alter and any as asc audit between by char check cluster column comment
+  compress connect create current date decimal default delete desc distinct drop else exclusive
+  exists file float for from grant group having identified immediate in increment index initial
+  insert integer intersect into is level like lock long maxextents minus mlslabel mode modify
+  noaudit nocompress not nowait null number of offline on online option or order pctfree prior
+  privileges public raw rename resource revoke row rowid rownum rows select session set share
+  size smallint start successful synonym sysdate table then to trigger uid union unique update
+  user validate values varchar varchar2 view whenever where with
+`);
+const TSQL_RESERVED = reservedWords(`
+  add all alter and any as asc authorization backup begin between break browse bulk by cascade
+  case check checkpoint close clustered coalesce collate column commit compute constraint
+  contains containstable continue convert create cross current current_date current_time
+  current_timestamp current_user cursor database dbcc deallocate declare default delete deny
+  desc disk distinct distributed double drop dump else end errlvl escape except exec execute
+  exists exit external fetch file fillfactor for foreign freetext freetexttable from full
+  function goto grant group having holdlock identity identity_insert identitycol if image in
+  index inner insert intersect into is join key kill left like lineno load merge national
+  nocheck nonclustered not ntext null nullif of off offsets on open opendatasource openquery
+  openrowset openxml option or order outer over percent pivot plan precision primary print proc
+  procedure public raiserror read readtext reconfigure references replication restore restrict
+  return revert revoke right rollback rowcount rowguidcol rule save schema securityaudit select
+  semantickeyphrasetable semanticsimilaritydetailstable semanticsimilaritytable session_user
+  set setuser shutdown some statistics system_user table tablesample text textsize then to top
+  tran transaction trigger truncate try_convert tsequal union unique unpivot update updatetext
+  use user values varying view waitfor when where while with within writetext
+`);
+const ORACLE = {
+	open: "\"",
+	close: "\"",
+	regular: /^[A-Z][A-Z0-9_$#]*$/,
+	reserved: ORACLE_RESERVED
+};
+const SPELLINGS = {
+	postgres: {
+		open: "\"",
+		close: "\"",
+		regular: /^[a-z_][a-z0-9_$]*$/,
+		reserved: POSTGRES_RESERVED
+	},
+	mysql: {
+		open: "`",
+		close: "`",
+		regular: /^(?!\d+$)[\w$\u{0080}-\u{FFFF}]+$/u,
+		reserved: MYSQL_RESERVED
+	},
+	oracle: ORACLE,
+	sqlserver: {
+		open: "[",
+		close: "]",
+		regular: /^[a-z_@#][\w@#$]*$/i,
+		reserved: TSQL_RESERVED
+	},
+	dm: ORACLE
+};
+function delimited(spelling, name) {
+	return `${spelling.open}${name.replaceAll(spelling.close, () => spelling.close + spelling.close)}${spelling.close}`;
+}
+function spellIdentifier(kind, name) {
+	const spelling = SPELLINGS[kind];
+	if (spelling.regular.test(name) && !spelling.reserved.has(name.toLowerCase())) return name;
+	return delimited(spelling, name);
+}
+function spellCallable(kind, name) {
+	const spelling = SPELLINGS[kind];
+	return spelling.regular.test(name) ? name : delimited(spelling, name);
+}
+function spellQualifier(kind, source) {
+	return source.aliasWritten === "" ? spellIdentifier(kind, source.table.name) : source.aliasWritten;
+}
+function spellQualifiedName(kind, table) {
+	const name = spellIdentifier(kind, table.name);
+	return table.schema === "" ? name : `${spellIdentifier(kind, table.schema)}.${name}`;
+}
+//#endregion
+//#region src/joins.ts
+const BY_NAMED_KEY = "named-foreign-key";
+const BY_SHARED_KEY = "shared-key";
+function singular(name) {
+	if (name.endsWith("ies")) return `${name.slice(0, -3)}y`;
+	return name.endsWith("s") && !name.endsWith("ss") ? name.slice(0, -1) : name;
+}
+function pointsAt(from, to) {
+	const base = to.table.name.toLowerCase();
+	const prefixes = [.../* @__PURE__ */ new Set([`${singular(base)}_`, `${base}_`])];
+	return from.columns.flatMap((column) => {
+		const name = column.name.toLowerCase();
+		const prefix = prefixes.find((one) => name.startsWith(one));
+		if (prefix === void 0) return [];
+		const rest = name.slice(prefix.length);
+		const key = to.columns.find((entry) => entry.name.toLowerCase() === rest && (entry.primaryKey || entry.unique));
+		return key === void 0 ? [] : [[column, key]];
+	});
+}
+function sharedKey(here, there) {
+	return (here.primaryKey || here.unique) && !there.primaryKey || (there.primaryKey || there.unique) && !here.primaryKey || here.name.toLowerCase().endsWith("_id");
+}
+function joinGuesses(kind, target, others) {
+	const found = /* @__PURE__ */ new Map();
+	const add = (left, leftColumn, right, rightColumn, why) => {
+		const text = `${spellQualifier(kind, left)}.${spellIdentifier(kind, leftColumn)} = ${spellQualifier(kind, right)}.${spellIdentifier(kind, rightColumn)}`;
+		if (!found.has(text)) found.set(text, {
+			text,
+			why
+		});
+	};
+	for (const other of others) {
+		for (const [column, key] of pointsAt(target, other)) add(target, column.name, other, key.name, BY_NAMED_KEY);
+		for (const [column, key] of pointsAt(other, target)) add(other, column.name, target, key.name, BY_NAMED_KEY);
+	}
+	for (const other of others) for (const column of target.columns) {
+		const twin = other.columns.find((entry) => entry.name.toLowerCase() === column.name.toLowerCase());
+		if (twin !== void 0 && sharedKey(column, twin)) add(target, column.name, other, twin.name, BY_SHARED_KEY);
+	}
+	return [...found.values()];
+}
+//#endregion
+//#region src/noise.ts
+const BASE = {
+	backslashEscapes: false,
+	doubleQuotedStrings: false,
+	hashLineComments: false,
+	lineCommentNeedsSpace: false,
+	backtickIdentifiers: false,
+	bracketIdentifiers: false,
+	dollarQuoting: false,
+	escapeStrings: false,
+	nestedBlockComments: false,
+	alternativeQuoting: false
+};
+const NOISE_PROFILES = {
+	postgres: {
+		...BASE,
+		escapeStrings: true,
+		nestedBlockComments: true,
+		dollarQuoting: true
+	},
+	mysql: {
+		...BASE,
+		backslashEscapes: true,
+		doubleQuotedStrings: true,
+		hashLineComments: true,
+		lineCommentNeedsSpace: true,
+		backtickIdentifiers: true
+	},
+	oracle: {
+		...BASE,
+		alternativeQuoting: true
+	},
+	sqlserver: {
+		...BASE,
+		bracketIdentifiers: true
+	},
+	dm: BASE
+};
+const WORD_START = /[a-z_\u{0080}-\u{FFFF}]/iu;
+const WORD_BYTE = /[\w$\u{0080}-\u{FFFF}]/u;
+const NAME_BYTE = /\w/;
+const ALTERNATIVE_QUOTE_CLOSE = {
+	"[": "]",
+	"{": "}",
+	"(": ")",
+	"<": ">"
+};
+function closeDelimited(text, from, delimiter, backslash) {
+	let at = from;
+	while (at < text.length) if (backslash && text[at] === "\\" && at + 1 < text.length) at += 2;
+	else if (text[at] === delimiter) if (text[at + 1] === delimiter) at += 2;
+	else return {
+		end: at + 1,
+		sealed: true
+	};
+	else at += 1;
+	return {
+		end: text.length,
+		sealed: false
+	};
+}
+function closeBracket(text, from) {
+	let at = from;
+	while (at < text.length) if (text[at] === "]") if (text[at + 1] === "]") at += 2;
+	else return {
+		end: at + 1,
+		sealed: true
+	};
+	else at += 1;
+	return {
+		end: text.length,
+		sealed: false
+	};
+}
+function closeLine(text, from) {
+	const newline = text.indexOf("\n", from);
+	return {
+		end: newline === -1 ? text.length : newline,
+		sealed: false
+	};
+}
+function closeBlock(text, from, nested) {
+	let depth = 1;
+	let at = from;
+	while (at + 1 < text.length) if (text[at] === "*" && text[at + 1] === "/") {
+		depth -= 1;
+		at += 2;
+		if (depth === 0) return {
+			end: at,
+			sealed: true
+		};
+	} else if (nested && text[at] === "/" && text[at + 1] === "*") {
+		depth += 1;
+		at += 2;
+	} else at += 1;
+	return {
+		end: text.length,
+		sealed: false
+	};
+}
+function closeDollarQuoted(text, from) {
+	let tagEnd = from + 1;
+	if (tagEnd < text.length && WORD_START.test(text[tagEnd])) {
+		tagEnd += 1;
+		while (tagEnd < text.length && NAME_BYTE.test(text[tagEnd])) tagEnd += 1;
+	}
+	if (text[tagEnd] !== "$") return null;
+	const tag = text.slice(from, tagEnd + 1);
+	const close = text.indexOf(tag, tagEnd + 1);
+	return close === -1 ? {
+		end: text.length,
+		sealed: false
+	} : {
+		end: close + tag.length,
+		sealed: true
+	};
+}
+function closeAlternativeQuoted(text, quote) {
+	const open = text[quote + 1];
+	if (open === void 0) return {
+		end: text.length,
+		sealed: false
+	};
+	const close = text.indexOf(`${ALTERNATIVE_QUOTE_CLOSE[open] ?? open}'`, quote + 2);
+	return close === -1 ? {
+		end: text.length,
+		sealed: false
+	} : {
+		end: close + 2,
+		sealed: true
+	};
+}
+function opensLineComment(text, from, profile) {
+	if (text[from] === "#") return profile.hashLineComments;
+	if (text[from] !== "-" || text[from + 1] !== "-") return false;
+	const after = text[from + 2];
+	return !profile.lineCommentNeedsSpace || after === void 0 || after <= " ";
+}
+let lastBlanked = null;
+function blankNoise(text, kind) {
+	if (lastBlanked !== null && lastBlanked.text === text && lastBlanked.kind === kind) return lastBlanked.result;
+	const profile = NOISE_PROFILES[kind];
+	const withNames = text.split("");
+	const blanked = text.split("");
+	const spans = [];
+	let at = 0;
+	const skip = (run, name) => {
+		for (let index = at; index < run.end; index += 1) {
+			blanked[index] = " ";
+			if (!name) withNames[index] = " ";
+		}
+		spans.push({
+			start: at,
+			end: run.end,
+			sealed: run.sealed,
+			name
+		});
+		at = run.end;
+	};
+	while (at < text.length) {
+		const ch = text[at];
+		if (ch === "'") skip(closeDelimited(text, at + 1, "'", profile.backslashEscapes), false);
+		else if (ch === "\"") skip(closeDelimited(text, at + 1, "\"", profile.backslashEscapes), !profile.doubleQuotedStrings);
+		else if (ch === "`" && profile.backtickIdentifiers) skip(closeDelimited(text, at + 1, "`", false), true);
+		else if (ch === "[" && profile.bracketIdentifiers) skip(closeBracket(text, at + 1), true);
+		else if (opensLineComment(text, at, profile)) skip(closeLine(text, at), false);
+		else if (ch === "/" && text[at + 1] === "*") skip(closeBlock(text, at + 2, profile.nestedBlockComments), false);
+		else if (ch === "$" && profile.dollarQuoting) {
+			const quoted = closeDollarQuoted(text, at);
+			if (quoted === null) at += 1;
+			else skip(quoted, false);
+		} else if (WORD_START.test(ch)) {
+			let end = at + 1;
+			while (end < text.length && WORD_BYTE.test(text[end])) end += 1;
+			const word = text.slice(at, end).toLowerCase();
+			if (text[end] === "'" && profile.escapeStrings && word === "e") skip(closeDelimited(text, end + 1, "'", true), false);
+			else if (text[end] === "'" && profile.alternativeQuoting && (word === "q" || word === "nq")) skip(closeAlternativeQuoted(text, end), false);
+			else at = end;
+		} else at += 1;
+	}
+	const result = {
+		withNames: withNames.join(""),
+		blanked: blanked.join(""),
+		spans
+	};
+	lastBlanked = {
+		text,
+		kind,
+		result
+	};
+	return result;
+}
+function insideNoise(spans, cursor) {
+	return spans.some((span) => !span.name && cursor > span.start && (span.sealed ? cursor < span.end : cursor <= span.end));
+}
+//#endregion
+//#region src/reader.ts
+const TOKENS = /[\w$\u{0080}-\u{FFFF}]+|"(?:[^"]|"")*"|`(?:[^`]|``)*`|\[(?:[^\]]|\]\])*\]|\S/gu;
+const TOKENS_TSQL = /[\w$#\u{0080}-\u{FFFF}]+|"(?:[^"]|"")*"|`(?:[^`]|``)*`|\[(?:[^\]]|\]\])*\]|\S/gu;
+function statementBounds(blanked, cursor) {
+	const start = cursor === 0 ? 0 : blanked.lastIndexOf(";", cursor - 1) + 1;
+	const close = blanked.indexOf(";", cursor);
+	return {
+		start,
+		end: close === -1 ? blanked.length : close
+	};
+}
+function tokenize(blanked, bounds, kind) {
+	const tokens = [];
+	const tokensFor = kind === "sqlserver" ? TOKENS_TSQL : TOKENS;
+	for (const match of blanked.slice(bounds.start, bounds.end).matchAll(tokensFor)) {
+		const value = match[0];
+		tokens.push({
+			value,
+			kind: /^[\w$#"`[\u{0080}-\u{FFFF}]/u.test(value) ? "word" : "punct",
+			start: bounds.start + match.index,
+			end: bounds.start + match.index + value.length
+		});
+	}
+	return tokens;
+}
+function unquote(value) {
+	const quoted = /^"(?<d>.*)"$|^`(?<b>.*)`$|^\[(?<s>.*)\]$/s.exec(value);
+	if (quoted?.groups?.d !== void 0) return quoted.groups.d.replaceAll("\"\"", "\"");
+	if (quoted?.groups?.b !== void 0) return quoted.groups.b.replaceAll("``", "`");
+	if (quoted?.groups?.s !== void 0) return quoted.groups.s.replaceAll("]]", "]");
+	return value;
+}
+function word(token) {
+	return token !== void 0 && token.kind === "word" ? token.value.toLowerCase() : "";
+}
+function scan(text, cursor, kind) {
+	const noise = blankNoise(text, kind);
+	if (insideNoise(noise.spans, cursor)) return null;
+	return tokenize(noise.withNames, statementBounds(noise.blanked, cursor), kind);
+}
+const TABLE_ANCHORS = /* @__PURE__ */ new Set([
+	"from",
+	"join",
+	"update",
+	"into",
+	"table"
+]);
+const NOT_AN_ALIAS = /* @__PURE__ */ new Set([
+	"as",
+	"where",
+	"on",
+	"join",
+	"inner",
+	"left",
+	"right",
+	"full",
+	"cross",
+	"outer",
+	"natural",
+	"group",
+	"order",
+	"having",
+	"limit",
+	"offset",
+	"fetch",
+	"union",
+	"intersect",
+	"except",
+	"minus",
+	"set",
+	"values",
+	"returning",
+	"when",
+	"then",
+	"using",
+	"and",
+	"or",
+	"not",
+	"for",
+	"into",
+	"from",
+	"select",
+	"with",
+	"start",
+	"connect",
+	"straight_join",
+	"output"
+]);
+function readName(tokens, at) {
+	const parts = [];
+	let dangling = false;
+	let i = at;
+	for (;;) {
+		const part = tokens[i];
+		if (part === void 0 || part.kind !== "word") break;
+		parts.push(unquote(part.value));
+		dangling = false;
+		if (tokens[i + 1]?.value === ".") {
+			i += 2;
+			dangling = true;
+		} else {
+			i += 1;
+			break;
+		}
+	}
+	return {
+		parts,
+		dangling,
+		next: i
+	};
+}
+function readAnchored(tokens, start, anchor) {
+	const refs = [];
+	let i = start;
+	for (;;) {
+		const first = tokens[i];
+		const name = readName(tokens, i);
+		i = name.next;
+		if (first === void 0 || name.parts.length === 0 || name.dangling) break;
+		let alias = "";
+		let aliasWritten = "";
+		const next = tokens[i];
+		if (next !== void 0 && next.kind === "word") {
+			if (word(next) === "as") {
+				i += 1;
+				const named = tokens[i];
+				if (named !== void 0 && named.kind === "word") {
+					alias = unquote(named.value);
+					aliasWritten = named.value;
+					i += 1;
+				}
+			} else if (!NOT_AN_ALIAS.has(word(next))) {
+				alias = unquote(next.value);
+				aliasWritten = next.value;
+				i += 1;
+			}
+		}
+		refs.push({
+			schema: name.parts.length > 1 ? name.parts.at(-2) : "",
+			table: name.parts.at(-1),
+			alias,
+			aliasWritten,
+			anchor,
+			from: first.start,
+			to: tokens[i - 1]?.end ?? first.end
+		});
+		if (anchor === "from" && tokens[i]?.value === ",") {
+			i += 1;
+			continue;
+		}
+		break;
+	}
+	return {
+		refs,
+		next: i
+	};
+}
+function tableRefs(tokens) {
+	const refs = [];
+	let i = 0;
+	while (i < tokens.length) {
+		const head = tokens[i];
+		i += 1;
+		if (!TABLE_ANCHORS.has(word(head))) continue;
+		const anchored = readAnchored(tokens, i, word(head));
+		refs.push(...anchored.refs);
+		i = anchored.next;
+	}
+	return refs;
+}
+const CLAUSE_HEADS = /* @__PURE__ */ new Set([
+	"on",
+	"where",
+	"having",
+	"set",
+	"values",
+	"select",
+	"from",
+	"join",
+	"group",
+	"order",
+	"when",
+	"then",
+	"using",
+	"update",
+	"insert",
+	"delete",
+	"returning"
+]);
+function joinContext(clauseHead, refs) {
+	if (clauseHead === void 0 || word(clauseHead) !== "on") return null;
+	const joined = refs.findLast((ref) => ref.anchor === "join" && ref.from < clauseHead.start);
+	if (joined === void 0) return null;
+	return {
+		kind: "joinCondition",
+		joined,
+		earlier: refs.filter((ref) => ref.from < joined.from)
+	};
+}
+function insertContext(verb, prior, refs) {
+	if (verb !== "insert") return null;
+	const into = refs.find((ref) => ref.anchor === "into");
+	if (into === void 0 || (prior.at(-1)?.end ?? 0) < into.to) return null;
+	return prior.some((token) => token.start >= into.to && (token.value === "(" || word(token) === "values" || word(token) === "select")) ? null : {
+		kind: "insertColumns",
+		into
+	};
+}
+function memberParts(prior) {
+	const parts = [];
+	let at = prior.length - 1;
+	while (at >= 1) {
+		const dot = prior[at];
+		const name = prior[at - 1];
+		if (dot.value !== "." || name.kind !== "word") break;
+		parts.unshift(unquote(name.value));
+		at -= 2;
+	}
+	return parts;
+}
+function readStatement(text, cursor, kind) {
+	const tokens = scan(text, cursor, kind);
+	if (tokens === null) return null;
+	const refs = tableRefs(tokens);
+	let prior = tokens.filter((token) => token.end <= cursor);
+	const typing = prior.at(-1);
+	const typed = typing !== void 0 && typing.kind === "word" && typing.end === cursor ? typing.value : "";
+	if (typed !== "") prior = prior.slice(0, -1);
+	const clauseHead = prior.findLast((token) => CLAUSE_HEADS.has(word(token)));
+	const previous = prior.at(-1);
+	const read = (context) => {
+		return {
+			context,
+			refs,
+			typed,
+			previous: previous?.value ?? "",
+			onStar: previous?.value === "*" && previous.end === cursor,
+			clause: word(clauseHead)
+		};
+	};
+	if (previous === void 0) return read({ kind: "expression" });
+	if (previous.value === ":") return read({ kind: "none" });
+	if (previous.value === ".") {
+		const parts = memberParts(prior);
+		return read(parts.length === 0 ? { kind: "none" } : {
+			kind: "member",
+			parts
+		});
+	}
+	if (TABLE_ANCHORS.has(word(previous))) return read({ kind: "table" });
+	return read(joinContext(clauseHead, refs) ?? insertContext(word(tokens[0]), prior, refs) ?? { kind: "expression" });
+}
+function trimmedSpan(text, blanked, from, to) {
+	let start = from;
+	let end = to;
+	while (start < end && /\s/.test(text[start])) start += 1;
+	while (end > start && /\s/.test(text[end - 1])) end -= 1;
+	return start === end || blanked.slice(start, end).trim() === "" ? null : {
+		from: start,
+		to: end
+	};
+}
+function statementSpans(text, blanked, from, to) {
+	const spans = [];
+	let start = from;
+	for (let at = from; at <= to; at += 1) {
+		if (!(at === to || blanked[at] === ";")) continue;
+		const span = trimmedSpan(text, blanked, start, at);
+		if (span !== null) spans.push(span);
+		start = at + 1;
+	}
+	return spans;
+}
+function runnableStatement(text, from, to, kind) {
+	const { blanked } = blankNoise(text, kind);
+	const selected = from < to;
+	const around = statementBounds(blanked, from);
+	const spans = selected ? statementSpans(text, blanked, from, to) : statementSpans(text, blanked, around.start, around.end);
+	if (spans.length === 0) return { kind: "none" };
+	if (selected && spans.length > 1) return { kind: "several" };
+	const span = spans[0];
+	return {
+		kind: "one",
+		text: text.slice(span.from, span.to),
+		blanked: blanked.slice(span.from, span.to),
+		from: span.from,
+		to: span.to,
+		alone: statementSpans(text, blanked, 0, text.length).length <= 1
+	};
+}
+function readIdentifier(text, offset, kind) {
+	const tokens = scan(text, offset, kind);
+	if (tokens === null) return null;
+	const under = tokens.findIndex((token) => token.start <= offset && offset < token.end);
+	const index = under !== -1 && tokens[under].kind === "word" ? under : tokens.findIndex((token) => token.end === offset);
+	const hovered = tokens[index];
+	if (hovered === void 0 || hovered.kind !== "word") return null;
+	const parts = [unquote(hovered.value)];
+	let at = index;
+	while (at >= 2 && tokens[at - 1].value === "." && tokens[at - 2].kind === "word") {
+		parts.unshift(unquote(tokens[at - 2].value));
+		at -= 2;
+	}
+	return {
+		parts,
+		from: tokens[at].start,
+		to: hovered.end,
+		refs: tableRefs(tokens)
+	};
+}
+function readCall(text, cursor, kind) {
+	const scanned = scan(text, cursor, kind);
+	if (scanned === null) return null;
+	const tokens = scanned.filter((token) => token.end <= cursor);
+	const open = [];
+	for (const [index, token] of tokens.entries()) if (token.value === "(") open.push({
+		name: word(tokens[index - 1]),
+		argument: 0
+	});
+	else if (token.value === ")") open.pop();
+	else if (token.value === "," && open.length > 0) open.at(-1).argument += 1;
+	const call = open.at(-1);
+	return call === void 0 || call.name === "" ? null : call;
+}
+//#endregion
+//#region src/completion.ts
+const RANK_ACTION = 0;
+const RANK_PRIMARY = 1;
+const RANK_KEYWORD = 2;
+const RANK_FUNCTION = 3;
+const RANK_TABLE = 4;
+const RANK_VENDOR = 5;
+const EXPANSION_PREVIEW = 200;
+function columnCandidate(kind, column, origin) {
+	const tag = `${column.dataType}${column.nullable ? "?" : ""}`;
+	const qualifier = origin?.qualifier ?? "";
+	const label = origin?.label ?? "";
+	const spelled = spellIdentifier(kind, column.name);
+	return {
+		label: column.name,
+		kind: "column",
+		insertText: qualifier === "" ? spelled : `${qualifier}.${spelled}`,
+		detail: label === "" ? tag : `${label} · ${tag}`,
+		documentation: column.comment === "" ? void 0 : column.comment,
+		sortGroup: RANK_PRIMARY
+	};
+}
+function tableCandidate(table, insertText, sortGroup) {
+	return {
+		label: table.name,
+		kind: table.kind === "view" ? "view" : "table",
+		insertText,
+		detail: table.schema === "" ? void 0 : table.schema,
+		documentation: table.comment === "" ? void 0 : table.comment,
+		sortGroup
+	};
+}
+function ambiguousNames(sources) {
+	const seen = /* @__PURE__ */ new Set();
+	const twice = /* @__PURE__ */ new Set();
+	for (const source of sources) for (const column of source.columns) {
+		const name = column.name.toLowerCase();
+		if (seen.has(name)) twice.add(name);
+		seen.add(name);
+	}
+	return twice;
+}
+function expansionCandidate(kind, sources, replacesStar) {
+	const many = sources.length > 1;
+	const names = sources.flatMap((source) => source.columns.map((column) => {
+		const spelled = spellIdentifier(kind, column.name);
+		return many ? `${spellQualifier(kind, source)}.${spelled}` : spelled;
+	}));
+	if (names.length === 0) return null;
+	const list = names.join(", ");
+	return {
+		label: "*",
+		kind: "snippet",
+		insertText: list,
+		replace: replacesStar ? 1 : void 0,
+		detail: `expand to ${names.length} columns`,
+		documentation: list.length > EXPANSION_PREVIEW ? `${list.slice(0, EXPANSION_PREVIEW)}…` : list,
+		sortGroup: RANK_ACTION
+	};
+}
+function createSqlCompletion(kind, schema, functions) {
+	const { keywords } = SQL_DIALECTS[kind];
+	const spelled = /* @__PURE__ */ new Map();
+	async function wordCandidates(typed) {
+		const upper = typed !== "" && typed === typed.toUpperCase() && typed !== typed.toLowerCase();
+		const known = await functions.all();
+		const built = spelled.get(upper);
+		if (built?.of === known) return built.candidates;
+		const spell = (word) => upper ? word.toUpperCase() : word;
+		const candidates = [...keywords.map((word) => {
+			return {
+				label: spell(word),
+				kind: "keyword",
+				insertText: spell(word),
+				sortGroup: RANK_KEYWORD
+			};
+		}), ...known.map((entry) => {
+			const name = entry.origin === "curated" ? spell(entry.name) : entry.name;
+			const written = entry.origin === "curated" ? name : spellCallable(kind, name);
+			return {
+				label: name,
+				kind: "function",
+				insertText: `${entry.qualifier === "" ? written : `${spellIdentifier(kind, entry.qualifier)}.${written}`}($0)`,
+				snippet: true,
+				detail: entry.signature,
+				documentation: entry.summary === "" ? void 0 : entry.summary,
+				sortGroup: entry.origin === "builtin" ? RANK_VENDOR : RANK_FUNCTION
+			};
+		})];
+		spelled.set(upper, {
+			of: known,
+			candidates
+		});
+		return candidates;
+	}
+	async function memberCandidates(parts, refs) {
+		if (parts.length === 1) {
+			const name = parts[0];
+			const table = await schema.resolve(name, refs);
+			if (table !== null) return (await schema.columns(table)).map((column) => columnCandidate(kind, column));
+			return (await schema.tables()).filter((entry) => entry.schema.toLowerCase() === name.toLowerCase()).map((entry) => tableCandidate(entry, spellIdentifier(kind, entry.name), RANK_PRIMARY));
+		}
+		if (parts.length === 2) {
+			const table = await schema.find({
+				schema: parts[0],
+				table: parts[1]
+			});
+			if (table !== null) return (await schema.columns(table)).map((column) => columnCandidate(kind, column));
+		}
+		return [];
+	}
+	async function tableCandidates() {
+		return (await schema.tables()).map((table) => tableCandidate(table, spellQualifiedName(kind, table), RANK_PRIMARY));
+	}
+	async function insertCandidates(into, typed) {
+		const words = await wordCandidates(typed);
+		const table = await schema.find(into);
+		if (table === null) return words;
+		const columns = await schema.columns(table);
+		if (columns.length === 0) return words;
+		const names = columns.map((column) => spellIdentifier(kind, column.name)).join(", ");
+		const marks = columns.map(() => "?").join(", ");
+		return [{
+			label: "(…) values (…)",
+			kind: "snippet",
+			insertText: `(${names}) values (${marks})`,
+			detail: `${columns.length} columns of ${table.name}`,
+			documentation: `(${names})\nvalues (${marks})`,
+			sortGroup: RANK_ACTION
+		}, ...words];
+	}
+	async function expressionCandidates(read) {
+		const words = await wordCandidates(read.typed);
+		try {
+			const tables = await schema.tables();
+			const sources = await schema.sources(read.refs);
+			const twice = ambiguousNames(sources);
+			const columns = sources.flatMap((source) => source.columns.map((column) => columnCandidate(kind, column, {
+				label: sources.length > 1 ? source.table.name : "",
+				qualifier: twice.has(column.name.toLowerCase()) ? spellQualifier(kind, source) : ""
+			})));
+			const opens = read.previous.toLowerCase() === "select" || read.previous === "," || read.onStar;
+			const expansion = read.clause === "select" && opens ? expansionCandidate(kind, sources, read.onStar) : null;
+			return [
+				...expansion === null ? [] : [expansion],
+				...columns,
+				...words,
+				...tables.map((table) => tableCandidate(table, spellQualifiedName(kind, table), RANK_TABLE))
+			];
+		} catch {
+			return words;
+		}
+	}
+	async function joinCandidates(joined, earlier, read) {
+		const rest = await expressionCandidates(read);
+		try {
+			const [target] = await schema.sources([joined]);
+			const others = await schema.sources(earlier);
+			if (target === void 0 || others.length === 0) return rest;
+			return [...joinGuesses(kind, target, others).map((guess) => {
+				return {
+					label: guess.text,
+					kind: "snippet",
+					insertText: guess.text,
+					detail: guess.why === "named-foreign-key" ? "named foreign key" : "shared key column",
+					sortGroup: RANK_ACTION
+				};
+			}), ...rest];
+		} catch {
+			return rest;
+		}
+	}
+	return async (text, cursor) => {
+		const read = readStatement(text, cursor, kind);
+		if (read === null) return [];
+		try {
+			switch (read.context.kind) {
+				case "none": return [];
+				case "member": return await memberCandidates(read.context.parts, read.refs);
+				case "table": return await tableCandidates();
+				case "insertColumns": return await insertCandidates(read.context.into, read.typed);
+				case "joinCondition": return await joinCandidates(read.context.joined, read.context.earlier, read);
+				case "expression": return await expressionCandidates(read);
+			}
+		} catch {
+			return [];
+		}
+	};
+}
+//#endregion
+//#region src/format.ts
+const DIALECTS = {
+	postgres: "postgresql",
+	mysql: "mysql",
+	oracle: "plsql",
+	dm: "plsql",
+	sqlserver: "transactsql"
+};
+const PLACEHOLDERS = String.raw`\?|:[A-Za-z_]\w*`;
+function sentinelFor(text) {
+	let sentinel = ":inkqq";
+	while (text.includes(sentinel)) sentinel += "q";
+	return sentinel;
+}
+function createSqlFormat(kind) {
+	return async (text) => {
+		const sentinel = sentinelFor(text);
+		const formatter = await import("sql-formatter");
+		try {
+			return formatter.formatDialect(text.replaceAll("??", () => sentinel), {
+				dialect: formatter[DIALECTS[kind]],
+				tabWidth: 2,
+				keywordCase: "preserve",
+				paramTypes: { custom: [{ regex: PLACEHOLDERS }] }
+			}).replaceAll(sentinel, "??");
+		} catch {
+			return null;
+		}
+	};
+}
+//#endregion
+//#region src/functions.ts
+function createSqlFunctions(kind, schema) {
+	const curated = SQL_DIALECTS[kind].functions.map((entry) => {
+		return {
+			name: entry.name,
+			signature: entry.signature,
+			summary: entry.summary,
+			returns: "",
+			qualifier: "",
+			origin: "curated"
+		};
+	});
+	let merged = null;
+	function merge(reported) {
+		const byName = /* @__PURE__ */ new Map();
+		const routines = reported.filter((entry) => !entry.builtin);
+		const builtins = reported.filter((entry) => entry.builtin);
+		for (const entry of routines) byName.set(entry.name.toLowerCase(), {
+			name: entry.name,
+			signature: entry.signature,
+			summary: entry.comment,
+			returns: entry.returns,
+			qualifier: entry.schema,
+			origin: "routine"
+		});
+		for (const entry of curated) if (!byName.has(entry.name.toLowerCase())) byName.set(entry.name.toLowerCase(), entry);
+		for (const entry of builtins) if (!byName.has(entry.name.toLowerCase())) byName.set(entry.name.toLowerCase(), {
+			name: entry.name,
+			signature: entry.signature,
+			summary: entry.comment,
+			returns: entry.returns,
+			qualifier: "",
+			origin: "builtin"
+		});
+		return [...byName.values()];
+	}
+	async function all() {
+		const reported = await schema.functions().catch(() => null);
+		if (reported === null) return curated;
+		if (merged?.of !== reported) merged = {
+			of: reported,
+			known: merge(reported)
+		};
+		return merged.known;
+	}
+	return {
+		all,
+		async find(name) {
+			const wanted = name.toLowerCase();
+			return (await all()).find((entry) => entry.name.toLowerCase() === wanted) ?? null;
+		}
+	};
+}
+//#endregion
+//#region src/schema.ts
+function qualifiedName(table) {
+	return table.schema === "" ? table.name : `${table.schema}.${table.name}`;
+}
+function identity(table) {
+	return `${table.schema}\u{0}${table.name}`;
+}
+function matches(table, ref) {
+	return table.name.toLowerCase() === ref.table.toLowerCase() && (ref.schema === "" || table.schema.toLowerCase() === ref.schema.toLowerCase());
+}
+function createSqlSchema(catalog) {
+	function tables() {
+		return catalog.tables();
+	}
+	function functions() {
+		return catalog.functions();
+	}
+	function columns(table) {
+		return catalog.columns(table.schema, table.name);
+	}
+	async function find(ref) {
+		return (await tables()).find((table) => matches(table, ref)) ?? null;
+	}
+	function resolve(name, refs) {
+		const wanted = name.toLowerCase();
+		return find(refs.find((entry) => entry.alias.toLowerCase() === wanted) ?? refs.find((entry) => entry.table.toLowerCase() === wanted) ?? {
+			schema: "",
+			table: name
+		});
+	}
+	async function sources(refs) {
+		const known = await tables();
+		const wanted = /* @__PURE__ */ new Map();
+		for (const ref of refs) {
+			const table = known.find((entry) => matches(entry, ref));
+			if (table === void 0) continue;
+			const as = ref.alias === "" ? ref.table : ref.alias;
+			wanted.set(`${identity(table)}\u{0}${as.toLowerCase()}`, {
+				table,
+				as,
+				aliasWritten: ref.aliasWritten
+			});
+		}
+		return (await Promise.allSettled(Array.from(wanted.values(), async (entry) => {
+			return {
+				...entry,
+				columns: await columns(entry.table)
+			};
+		}))).filter((one) => one.status === "fulfilled").map((one) => one.value);
+	}
+	return {
+		tables,
+		columns,
+		functions,
+		find,
+		resolve,
+		sources
+	};
+}
+//#endregion
+//#region src/hover.ts
+const COLUMN_PREVIEW = 12;
+function typeTag(column) {
+	return `${column.dataType}${column.nullable ? "?" : ""}`;
+}
+function plain(text) {
+	return text.replaceAll(/[\\`*_[\]<>]/g, (one) => `\\${one}`);
+}
+function keyMarks(column) {
+	const marks = [];
+	if (column.primaryKey) marks.push("primary key");
+	if (column.foreignKey) marks.push("foreign key");
+	if (column.unique) marks.push("unique");
+	if (column.indexed) marks.push("indexed");
+	return marks.join(" · ");
+}
+function tableCard(table, columns) {
+	const blocks = [`**${plain(qualifiedName(table))}** · ${table.kind}`];
+	if (table.comment !== "") blocks.push(plain(table.comment));
+	if (columns.length > 0) {
+		const shown = columns.slice(0, COLUMN_PREVIEW);
+		const width = Math.max(...shown.map((column) => column.name.length));
+		const lines = shown.map((column) => {
+			const marks = keyMarks(column);
+			return `${column.name.padEnd(width)}  ${typeTag(column)}${marks === "" ? "" : `  ${marks}`}`;
+		});
+		if (columns.length > shown.length) lines.push(`… ${columns.length - shown.length} more columns`);
+		blocks.push([
+			"```",
+			...lines,
+			"```"
+		].join("\n"));
+	}
+	return blocks;
+}
+function columnCard(column, table) {
+	const blocks = [`**${plain(column.name)}** · ${plain(typeTag(column))}`];
+	const marks = keyMarks(column);
+	if (marks !== "") blocks.push(marks);
+	if (column.comment !== "") blocks.push(plain(column.comment));
+	blocks.push(`in ${plain(qualifiedName(table))}`);
+	return blocks;
+}
+function functionCard(entry) {
+	const call = entry.qualifier === "" ? entry.signature : `${entry.qualifier}.${entry.signature}`;
+	const blocks = [[
+		"```sql",
+		entry.returns === "" ? call : `${call} → ${entry.returns}`,
+		"```"
+	].join("\n")];
+	if (entry.origin === "routine") blocks.push("Defined by this schema.");
+	if (entry.summary !== "") blocks.push(plain(entry.summary));
+	return blocks;
+}
+function createSqlHover(kind, schema, functions) {
+	return async (text, offset) => {
+		const read = readIdentifier(text, offset, kind);
+		if (read === null) return null;
+		const name = read.parts.at(-1).toLowerCase();
+		const card = (markdown) => {
+			return {
+				from: read.from,
+				to: read.to,
+				markdown
+			};
+		};
+		try {
+			if (read.parts.length >= 2) {
+				const owner = read.parts.at(-2);
+				const table = read.parts.length >= 3 ? await schema.find({
+					schema: read.parts.at(-3),
+					table: owner
+				}) : await schema.resolve(owner, read.refs);
+				const column = (table === null ? [] : await schema.columns(table)).find((entry) => entry.name.toLowerCase() === name);
+				if (table !== null && column !== void 0) return card(columnCard(column, table));
+				const qualified = read.parts.length === 2 ? await schema.find({
+					schema: owner,
+					table: read.parts.at(-1)
+				}) : null;
+				return qualified === null ? null : card(tableCard(qualified, await schema.columns(qualified)));
+			}
+			const sources = await schema.sources(read.refs);
+			for (const source of sources) {
+				const column = source.columns.find((entry) => entry.name.toLowerCase() === name);
+				if (column !== void 0) return card(columnCard(column, source.table));
+			}
+			const table = await schema.resolve(name, read.refs);
+			if (table !== null) return card(tableCard(table, await schema.columns(table)));
+			const entry = await functions.find(name);
+			return entry === null ? null : card(functionCard(entry));
+		} catch {
+			return null;
+		}
+	};
+}
+//#endregion
+//#region src/signature.ts
+function createSqlSignature(kind, functions) {
+	return async (text, cursor) => {
+		const call = readCall(text, cursor, kind);
+		if (call === null) return null;
+		const entry = await functions.find(call.name);
+		if (entry === null) return null;
+		const parameters = signatureParameters(entry.signature);
+		return {
+			label: entry.signature,
+			parameters,
+			active: Math.min(call.argument, Math.max(0, parameters.length - 1)),
+			documentation: entry.summary === "" ? void 0 : entry.summary
+		};
+	};
+}
+//#endregion
+//#region src/assist.ts
+function createSqlAssist(kind, catalog) {
+	const schema = createSqlSchema(catalog);
+	const functions = createSqlFunctions(kind, schema);
+	return {
+		complete: createSqlCompletion(kind, schema, functions),
+		hover: createSqlHover(kind, schema, functions),
+		signature: createSqlSignature(kind, functions),
+		format: createSqlFormat(kind)
+	};
+}
+//#endregion
+//#region src/markers.ts
+const SCAN = /[A-Z_\u0080-\uFFFF][\w$\u0080-\uFFFF]*|(?<qq>\?\?)|::|(?<q>\?)|:(?<name>[A-Z_]\w*)|(?<colonDigits>:\d+)|(?<dollarDigits>\$\d+)|(?<atDigits>@P\d+)/gi;
+const QUESTION_IS_NATIVE = /* @__PURE__ */ new Set(["mysql", "dm"]);
+const NATIVE_GROUP = {
+	postgres: "dollarDigits",
+	mysql: null,
+	oracle: "colonDigits",
+	sqlserver: "atDigits",
+	dm: null
+};
+function statementMarkers(statement, kind) {
+	const names = [];
+	const nativeGroup = NATIVE_GROUP[kind];
+	let count = 0;
+	let native = false;
+	let refusal = null;
+	const refuse = (fault) => {
+		refusal ??= fault;
+	};
+	for (const match of statement.matchAll(SCAN)) {
+		const groups = match.groups;
+		if (groups.qq !== void 0 && QUESTION_IS_NATIVE.has(kind)) refuse("question-escape-unsupported");
+		else if (groups.q !== void 0) {
+			if (names.length > 0) refuse("mixed-forms");
+			count += 1;
+		} else if (groups.name !== void 0) {
+			if (count > 0) refuse("mixed-forms");
+			if (!names.includes(groups.name)) names.push(groups.name);
+		} else if (nativeGroup !== null && groups[nativeGroup] !== void 0) native = true;
+	}
+	if (refusal === null && native && (count > 0 || names.length > 0)) refusal = "native-marker-collision";
+	return {
+		form: names.length > 0 ? "named" : count > 0 ? "positional" : "none",
+		names,
+		count,
+		refusal
+	};
+}
+//#endregion
+//#region src/origin.ts
+const SINGLE_TABLE = /^\s*select\s+\*\s+from\s+(?<qualified>[^\s;,()]+)(?:[\s;]*$|\s+(?:where|order|group|having|limit|offset|fetch|for)\b)/i;
+function statementOrigin(statement) {
+	const qualified = SINGLE_TABLE.exec(statement)?.groups?.qualified;
+	if (qualified === void 0) return null;
+	const segments = qualified.split(".").map((segment) => segment.replace(/^"(?<inner>.*)"$/s, "$<inner>"));
+	if (segments.length > 3 || segments.some((segment) => segment === "" || segment.includes("\""))) return null;
+	const table = segments.at(-1);
+	const schema = segments.length > 1 ? segments.at(-2) : "";
+	if (table === void 0 || schema === void 0) return null;
+	return {
+		schema,
+		table
+	};
+}
+//#endregion
+//#region src/params.ts
+const TEXT_PARAM = Object.freeze({
+	type: "text",
+	text: ""
+});
+function untouched(rows) {
+	const all = Object.values(rows);
+	return all.length > 0 && all.every((row) => row.type === TEXT_PARAM.type && row.text === TEXT_PARAM.text);
+}
+const SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
+const DECIMAL = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
+const INTEGER = /^[+-]?\d+$/;
+function boundValue(param) {
+	switch (param.type) {
+		case "text": return {
+			ok: true,
+			value: param.text
+		};
+		case "null": return {
+			ok: true,
+			value: null
+		};
+		case "boolean":
+			if (param.text === "true" || param.text === "false") return {
+				ok: true,
+				value: param.text === "true"
+			};
+			return {
+				ok: false,
+				refusal: "not-a-boolean"
+			};
+		case "number": {
+			const text = param.text.trim();
+			if (text === "") return {
+				ok: false,
+				refusal: "empty"
+			};
+			if (!DECIMAL.test(text)) return {
+				ok: false,
+				refusal: "not-a-number"
+			};
+			const value = Number(text);
+			if (!Number.isFinite(value)) return {
+				ok: false,
+				refusal: "not-finite"
+			};
+			if (INTEGER.test(text)) {
+				const exact = BigInt(text);
+				if (exact > SAFE_INTEGER || exact < -SAFE_INTEGER) return {
+					ok: false,
+					refusal: "unsafe-integer"
+				};
+			}
+			return {
+				ok: true,
+				value
+			};
+		}
+	}
+}
+function boundParams(markers, rows) {
+	if (markers.form === "none") return {
+		ok: true,
+		params: void 0
+	};
+	const bound = {};
+	const keys = markers.form === "positional" ? Array.from({ length: markers.count }, (_, index) => String(index + 1)) : markers.names;
+	for (const key of keys) {
+		const one = boundValue(rows[key] ?? TEXT_PARAM);
+		if (!one.ok) return {
+			ok: false,
+			form: markers.form,
+			key,
+			refusal: one.refusal
+		};
+		bound[key] = one.value;
+	}
+	return {
+		ok: true,
+		params: markers.form === "positional" ? keys.map((key) => bound[key]) : bound
+	};
+}
+//#endregion
+export { SQL_DIALECTS, TEXT_PARAM, blankNoise, boundParams, boundValue, createSqlAssist, createSqlCompletion, createSqlFormat, createSqlFunctions, createSqlHover, createSqlSchema, createSqlSignature, insideNoise, joinGuesses, qualifiedName, readCall, readIdentifier, readStatement, runnableStatement, signatureParameters, spellCallable, spellIdentifier, spellQualifiedName, spellQualifier, statementMarkers, statementOrigin, untouched };