@tablecraft-app/plugin-postgres 1.10.3 → 1.11.0

package/index.js

@@ -10937,7 +10937,12 @@ var connectionUrlSchema = strictObject({
 		string$1(),
 		number$1(),
 		boolean()
-	]))).optional()
+	]))).optional(),
+	/**
+	* The JDBC SQL Server form, `scheme://host[\instance][:port][;name=value…]` (plan 055): parameters
+	* follow `;`, a `{…}` value may hold one, and `\instance` is the parameter `instanceName`.
+	*/
+	semicolonParams: boolean().optional()
 });
 /**
 * Which fields hold the server's address (decision 070), so the host can open an SSH tunnel and
@@ -11215,7 +11220,13 @@ var SHOWN_ARROW = "→";
 var OPTIONAL_MARK = "?";
 var VARIADIC_MARK = "...";
 var COMPARATOR = /^(>=|<=|>|<|=)?(\d+(?:\.\d+)*)$/;
-function parameter$1(written) {
+var BARE_MARK = "=";
+var LEAD_WORD = /^[A-Z][A-Z_]*$/;
+var LEAD_CHOICE = "|";
+var PARAMETER_SEPARATOR = ",";
+var COMMA_SHOWN = ", ";
+var MEMBER_SEPARATOR$2 = ".";
+function parameter$1(written, lead) {
 	let name = written.trim();
 	const variadic = name.endsWith(VARIADIC_MARK);
 	if (variadic) name = name.slice(0, -3).trim();
@@ -11224,28 +11235,78 @@ function parameter$1(written) {
 	return {
 		name,
 		...optional ? { optional } : {},
-		...variadic ? { variadic } : {}
+		...variadic ? { variadic } : {},
+		...lead === null ? {} : { lead }
 	};
 }
-/** Reads `"str, len? -> string"`: `?` marks an optional parameter, `...` one that repeats. */
+function isLeadWord(word) {
+	return word.split(LEAD_CHOICE).every((choice) => LEAD_WORD.test(choice));
+}
+/** Whether `lead` is `word` or offers it among its `|` alternatives. */
+function leadMatches(lead, word) {
+	return lead.split(LEAD_CHOICE).includes(word);
+}
+/**
+* One comma-separated part: an upper-case word between names leads the next, as one before the
+* first parameter does; one standing alone is a keyword choice. After a comma the keyword is the
+* argument's own (`date, INTERVAL expr unit`), since the comma already separates it.
+*/
+function leadParameters(part, index) {
+	const words = part.trim().split(/\s+/);
+	const parameters = [];
+	let lead = null;
+	let name = [];
+	const flush = () => {
+		if (name.length > 0) parameters.push(parameter$1(name.join(" "), lead));
+		name = [];
+		lead = null;
+	};
+	words.forEach((word, at) => {
+		const next = words[at + 1];
+		if (!(at === 0 && index > 0) && isLeadWord(word) && next !== void 0 && !isLeadWord(next)) {
+			flush();
+			lead = word;
+		} else name.push(word);
+	});
+	flush();
+	return parameters;
+}
+function isBareSignature(written) {
+	return written.trim().startsWith(BARE_MARK);
+}
+/**
+* Reads `"str, len? -> string"`: `?` marks an optional parameter, `...` one that repeats, an
+* upper-case word between names the keyword before the next (`"unit FROM date -> integer"`).
+* `"= date"` is a bare function's and `"str ->"` a procedure's, which returns nothing.
+*/
 function parseSignature(written) {
+	if (isBareSignature(written)) return {
+		parameters: [],
+		returns: written.trim().slice(1).trim()
+	};
 	const arrow = written.lastIndexOf(RETURNS_ARROW);
 	if (arrow < 0) throw new Error(`Signature "${written}" has no "${RETURNS_ARROW} type"; add what it returns.`);
 	const list = written.slice(0, arrow).trim();
 	return {
-		parameters: list === "" ? [] : list.split(",").map(parameter$1),
+		parameters: list === "" ? [] : list.split(PARAMETER_SEPARATOR).flatMap(leadParameters),
 		returns: written.slice(arrow + 2).trim()
 	};
 }
 /** Specs for one category, from compact entries a plugin's data file lists. */
 function functionSpecs(category, entries) {
-	return entries.map(([name, signatures, summary, available]) => ({
-		name,
-		signatures: (typeof signatures === "string" ? [signatures] : signatures).map(parseSignature),
-		summary,
-		category,
-		...available === void 0 ? {} : { available }
-	}));
+	return entries.map(([name, signatures, summary, available]) => {
+		const written = typeof signatures === "string" ? [signatures] : signatures;
+		const bare = written.filter(isBareSignature).length;
+		if (bare > 0 && bare < written.length) throw new Error(`${name} mixes "${BARE_MARK} type" with called signatures; write the bare form as "-> type".`);
+		return {
+			name,
+			signatures: written.map(parseSignature),
+			summary,
+			category,
+			...available === void 0 ? {} : { available },
+			...bare > 0 ? { bare: true } : {}
+		};
+	});
 }
 function compareVersions(left, right) {
 	for (let at = 0; at < Math.max(left.length, right.length); at += 1) {
@@ -11274,20 +11335,48 @@ function isAvailable(spec, server) {
 	if (range === false) return false;
 	return range.split(/\s+/).filter((comparator) => comparator !== "").every((comparator) => satisfies(server.version, comparator));
 }
-function shownParameter(parameter) {
+function shownParameter(parameter, index) {
 	const name = parameter.variadic === true ? `${parameter.name}${VARIADIC_MARK}` : parameter.name;
-	return parameter.optional === true ? `[${name}]` : name;
+	const led = parameter.lead === void 0 ? name : `${parameter.lead} ${name}`;
+	return (index === 0 ? "" : parameter.lead === void 0 ? COMMA_SHOWN : " ") + (parameter.optional === true ? `[${led}]` : led);
+}
+function returnsLabel(returns) {
+	return returns === "" ? "" : `${SHOWN_ARROW} ${returns}`;
 }
-/** `(date, format) → string`, the popup's detail for one signature. */
+/** `(date, format) → string`, the popup's detail for one signature; a lead replaces the comma, a procedure has no `→`. */
 function signatureLabel(signature) {
-	return `(${signature.parameters.map(shownParameter).join(", ")}) ${SHOWN_ARROW} ${signature.returns}`;
+	const list = `(${signature.parameters.map(shownParameter).join("")})`;
+	const returns = returnsLabel(signature.returns);
+	return returns === "" ? list : `${list} ${returns}`;
+}
+function shownSignature(spec, signature) {
+	return spec.bare === true ? returnsLabel(signature.returns) : signatureLabel(signature);
 }
 /** Every signature on its own line, then the summary. */
 function functionInfo(spec) {
 	const label = spec.name.toLowerCase();
-	return `${spec.signatures.map((signature) => `${label}${signatureLabel(signature)}`).join("\n")}\n\n${spec.summary}`;
+	const gap = spec.bare === true ? " " : "";
+	return `${spec.signatures.map((signature) => `${label}${gap}${shownSignature(spec, signature)}`).join("\n")}\n\n${spec.summary}`;
 }
-/** A spec as an item: `name()` with the caret between the parentheses when it takes arguments. */
+/**
+* A spec as an item: `name()` with the caret between the parentheses when it takes arguments, or
+* the name alone for a bare one. `label` is what the popup offers, the member alone after `pkg.`.
+*/
+function specItem(spec, label, boost) {
+	const first = spec.signatures[0];
+	const takesArguments = spec.signatures.some((signature) => signature.parameters.length > 0);
+	const bare = spec.bare === true;
+	return {
+		label,
+		kind: "function",
+		detail: first === void 0 ? null : shownSignature(spec, first),
+		apply: bare ? label : `${label}()`,
+		boost,
+		info: functionInfo(spec),
+		caret: takesArguments && !bare ? label.length + 1 : null
+	};
+}
+/** A spec as an item: `name()` with the caret between the parentheses when it takes arguments, the name alone when bare. */
 function functionItem(spec, boost) {
 	if (typeof spec === "string") return {
 		label: spec,
@@ -11298,18 +11387,17 @@ function functionItem(spec, boost) {
 		info: null,
 		caret: null
 	};
-	const label = spec.name.toLowerCase();
-	const first = spec.signatures[0];
-	const takesArguments = spec.signatures.some((signature) => signature.parameters.length > 0);
-	return {
-		label,
-		kind: "function",
-		detail: first === void 0 ? null : signatureLabel(first),
-		apply: `${label}()`,
-		boost,
-		info: functionInfo(spec),
-		caret: takesArguments ? label.length + 1 : null
-	};
+	return specItem(spec, spec.name.toLowerCase(), boost);
+}
+/** The package a spec named `PKG.MEMBER` belongs to, upper case; null for a plain function. */
+function functionPackage(spec) {
+	const name = functionName(spec);
+	const dot = name.lastIndexOf(MEMBER_SEPARATOR$2);
+	return dot < 0 ? null : name.slice(0, dot).toUpperCase();
+}
+/** A package member as offered after `pkg.`: the member's name alone, the info naming it in full. */
+function memberItem(spec, boost) {
+	return specItem(spec, spec.name.slice(spec.name.lastIndexOf(MEMBER_SEPARATOR$2) + 1).toLowerCase(), boost);
 }
 /** The name a function entry is offered under, either form. */
 function functionName(spec) {
@@ -11420,6 +11508,7 @@ var Q_QUOTE_PAIRS = /* @__PURE__ */ new Map([
 var STRING_QUOTE$1 = "'";
 var BRACKET_OPEN$1 = "[";
 var BRACKET_CLOSE$1 = "]";
+var VARIABLE_CHARS = /* @__PURE__ */ new Set(["@", "#"]);
 function isSpace(char) {
 	return char === " " || char === "	" || char === "\n" || char === "\r" || char === "\f" || char === "\v";
 }
@@ -11461,7 +11550,7 @@ var Lexer = class {
 		else if (char === "`") token = this.#quoted(at, "`", "quoted", false);
 		else if (char === BRACKET_OPEN$1 && this.options.bracketIdentifiers === true) token = this.#bracketed(at);
 		else if (char === "$" && this.options.dollarQuotes === true && this.#dollarTag(at) !== null) token = this.#dollarQuoted(at, this.#dollarTag(at) ?? "");
-		else if (isWordChar(char)) token = this.#word(at, delimiter);
+		else if (this.#isWordChar(char)) token = this.#word(at, delimiter);
 		else token = {
 			kind: "symbol",
 			from: at,
@@ -11470,6 +11559,9 @@ var Lexer = class {
 		this.position = token.to;
 		return token;
 	}
+	#isWordChar(char) {
+		return isWordChar(char) || this.options.variables === true && VARIABLE_CHARS.has(char);
+	}
 	#lineComment(from) {
 		const end = this.text.indexOf(NEWLINE$2, from);
 		return {
@@ -11565,7 +11657,7 @@ var Lexer = class {
 		const text = this.text;
 		const customDelimiter = delimiter !== ";";
 		let at = from;
-		while (at < text.length && isWordChar(text.charAt(at))) {
+		while (at < text.length && this.#isWordChar(text.charAt(at))) {
 			if (customDelimiter && at > from && text.startsWith(delimiter, at)) break;
 			at += 1;
 		}
@@ -11637,7 +11729,7 @@ function wordOf(text, token) {
 var OPEN$6 = "(";
 var CLOSE$5 = ")";
 var DOT$3 = ".";
-var COMMA$7 = ",";
+var COMMA$9 = ",";
 var QUERY_STARTS$2 = /* @__PURE__ */ new Set(["SELECT", "WITH"]);
 var RELATION_INTRODUCERS$1 = /* @__PURE__ */ new Set([
 	"FROM",
@@ -11894,7 +11986,7 @@ var QueryReader = class {
 					flush();
 					selecting = false;
 					selected = true;
-				} else if (statement.isSymbol(index, COMMA$7)) {
+				} else if (statement.isSymbol(index, COMMA$9)) {
 					flush();
 					continue;
 				} else {
@@ -11926,7 +12018,7 @@ var QueryReader = class {
 				into = false;
 				continue;
 			}
-			if (fromList && statement.isSymbol(index, COMMA$7)) expectRelation = true;
+			if (fromList && statement.isSymbol(index, COMMA$9)) expectRelation = true;
 		}
 		if (selecting) flush();
 	}
@@ -11954,7 +12046,7 @@ var QueryReader = class {
 				query: statement.query(body)
 			});
 			this.#at += 1;
-			if (!statement.isSymbol(this.#index(), COMMA$7)) return;
+			if (!statement.isSymbol(this.#index(), COMMA$9)) return;
 			this.#at += 1;
 		}
 	}
@@ -12116,7 +12208,7 @@ function clauseOf(statement, queryOpen, group, anchor, query) {
 	}
 	const lastWord = statement.word(last ?? void 0);
 	if (lastWord !== null && (RELATION_INTRODUCERS$1.has(lastWord) || RELATION_MODIFIERS.has(lastWord))) return lastWord === "JOIN" || lastWord === "STRAIGHT_JOIN" ? "join" : "relation";
-	if (fromList && last !== null && statement.isSymbol(last, COMMA$7)) return "relation";
+	if (fromList && last !== null && statement.isSymbol(last, COMMA$9)) return "relation";
 	if (clause !== null && EXPRESSION_CLAUSES.has(clause)) return "columns";
 	return "keywords";
 }
@@ -12163,6 +12255,10 @@ function scopeAt(text, offset, dialect, mode = "complete") {
 	};
 }
 // ../plugin-api/src/sql/signature.ts
+var COMMA$8 = ",";
+var MEMBER_SEPARATOR$1 = ".";
+/** Calls a procedure by name, so it may come before a package member as it never may before a function. */
+var CALL_WORD = "CALL";
 /** Words a relation or routine name follows, so `TABLE upper (` defines rather than calls. */
 var NAME_INTRODUCERS = /* @__PURE__ */ new Set([
 	"CALL",
@@ -12189,7 +12285,8 @@ function upperWord(text, token) {
 }
 /**
 * Finds the innermost call around `offset` whose name `known` accepts, counting its top-level
-* commas; strings, comments and quoted names are tokens of their own, so their commas never count.
+* commas and listing its separators; strings, comments and quoted names are tokens of their own,
+* so their commas never count. `pkg.member (` asks `known` for `PKG.MEMBER`.
 * Grouping parentheses are looked through; a subquery, a non-function name before `(` or a caret
 * in a string or comment ends the search with null. `reserved` holds the dialect's keywords: a
 * function spelled like one (`VALUES`, `LEFT`) is a call only where an operand fits, not after a
@@ -12198,16 +12295,35 @@ function upperWord(text, token) {
 function callAt(text, offset, dialect, reserved, known) {
 	const { tokens, literal } = statementTokens(text, offset, dialect);
 	if (literal) return null;
+	/** `pkg.member` ending at `at`, when the package's spec knows the member. */
+	function member(at) {
+		const name = tokens[at];
+		const owner = tokens[at - 2];
+		const word = upperWord(text, name);
+		const ownerWord = upperWord(text, owner);
+		if (name === void 0 || owner === void 0 || word === null || ownerWord === null) return null;
+		if (!known(`${ownerWord}${MEMBER_SEPARATOR$1}${word}`)) return null;
+		const previous = upperWord(text, tokens[at - 3]);
+		if (previous !== null && previous !== CALL_WORD && NAME_INTRODUCERS.has(previous)) return null;
+		return {
+			written: `${text.slice(owner.from, owner.to)}${MEMBER_SEPARATOR$1}${text.slice(name.from, name.to)}`,
+			from: owner.from
+		};
+	}
 	function callable(at) {
 		const name = tokens[at];
+		const before = tokens[at - 1];
+		if (symbol(text, before, MEMBER_SEPARATOR$1)) return member(at);
 		const word = upperWord(text, name);
 		if (name === void 0 || word === null || !known(word)) return null;
-		const before = tokens[at - 1];
-		if (symbol(text, before, ".")) return null;
+		const found = {
+			written: text.slice(name.from, name.to),
+			from: name.from
+		};
 		const previous = upperWord(text, before);
 		if (previous !== null && NAME_INTRODUCERS.has(previous)) return null;
-		if (!reserved.has(word)) return name;
-		return before === void 0 || before.kind === "symbol" && !symbol(text, before, ")") || previous !== null && reserved.has(previous) ? name : null;
+		if (!reserved.has(word)) return found;
+		return before === void 0 || before.kind === "symbol" && !symbol(text, before, ")") || previous !== null && reserved.has(previous) ? found : null;
 	}
 	const frames = [];
 	let index = 0;
@@ -12220,12 +12336,19 @@ function callAt(text, offset, dialect, reserved, known) {
 				name,
 				named: name === null && !grouping(text, tokens[index - 1]),
 				open: index,
-				commas: 0
+				commas: 0,
+				separators: []
 			});
 		} else if (symbol(text, token, ")")) frames.pop();
-		else if (symbol(text, token, ",")) {
+		else if (symbol(text, token, COMMA$8)) {
 			const top = frames.at(-1);
-			if (top !== void 0) top.commas += 1;
+			if (top !== void 0) {
+				top.commas += 1;
+				top.separators.push(COMMA$8);
+			}
+		} else {
+			const word = upperWord(text, token);
+			if (word !== null) frames.at(-1)?.separators.push(word);
 		}
 	}
 	for (let depth = frames.length - 1; depth >= 0; depth -= 1) {
@@ -12236,8 +12359,9 @@ function callAt(text, offset, dialect, reserved, known) {
 			continue;
 		}
 		return {
-			name: text.slice(frame.name.from, frame.name.to),
+			name: frame.name.written,
 			argument: frame.commas,
+			separators: frame.separators,
 			from: frame.name.from,
 			to: closeOf(text, tokens, index, frames.length - depth) ?? offset
 		};
@@ -12304,7 +12428,7 @@ var FROM = "FROM";
 var AS$4 = "AS";
 var STAR$1 = "*";
 var DOT$2 = ".";
-var COMMA$6 = ",";
+var COMMA$7 = ",";
 var OPEN$5 = "(";
 var CLOSE$4 = ")";
 var OVER = "OVER";
@@ -12502,7 +12626,7 @@ function tailRefusal(reader, from, depth) {
 	const tokens = reader.tokens;
 	const first = reader.word(tokens[from]);
 	if (from < tokens.length && (first === null || !TAIL_CLAUSES.has(first))) {
-		if (reader.symbol(tokens[from]) === COMMA$6 || first !== null && JOINS.has(first)) return SELECT_READ_ONLY_REASONS.joins;
+		if (reader.symbol(tokens[from]) === COMMA$7 || first !== null && JOINS.has(first)) return SELECT_READ_ONLY_REASONS.joins;
 		if (first !== null && GROUPING.has(first)) return SELECT_READ_ONLY_REASONS.aggregates;
 		if (first !== null && SET_OPERATIONS.has(first)) return SELECT_READ_ONLY_REASONS.combines;
 		return SELECT_READ_ONLY_REASONS.notSelect;
@@ -12540,7 +12664,7 @@ function parseSimpleSelect(sql, dialect) {
 	if (refusal !== null) return { readOnly: refusal };
 	const items = [];
 	let itemFrom = at;
-	for (let index = at; index <= fromAt; index += 1) if (index === fromAt || depth[index] === 0 && reader.symbol(tokens[index]) === COMMA$6) {
+	for (let index = at; index <= fromAt; index += 1) if (index === fromAt || depth[index] === 0 && reader.symbol(tokens[index]) === COMMA$7) {
 		if (index === itemFrom) return { readOnly: SELECT_READ_ONLY_REASONS.notSelect };
 		items.push(selectItem(reader, itemFrom, index));
 		itemFrom = index + 1;
@@ -12666,6 +12790,25 @@ function searchPathTarget(text, tokens) {
 		candidates: names
 	};
 }
+var ALTER_SESSION_PREFIX = [
+	"ALTER",
+	"SESSION",
+	"SET",
+	"CURRENT_SCHEMA",
+	"="
+];
+function alterSessionPrefix(text, tokens) {
+	return ALTER_SESSION_PREFIX.every((word, at) => wordAt$1(text, tokens, at) === word);
+}
+function alterSessionTarget(text, tokens) {
+	if (tokens.length !== ALTER_SESSION_PREFIX.length + 1 || !alterSessionPrefix(text, tokens)) return null;
+	const token = tokens[ALTER_SESSION_PREFIX.length];
+	const name = identifier$1(text, token);
+	return name === null || token?.kind === "string" ? null : {
+		kind: "schema",
+		candidates: [name]
+	};
+}
 var NAME_TOKENS = /* @__PURE__ */ new Set([
 	"word",
 	"quoted",
@@ -12721,7 +12864,8 @@ function searchPathListStart(text, tokens) {
 }
 /**
 * Where the caret at `offset` names a namespace a session-namespace statement of the dialect moves
-* to: `USE |` or the elements of `SET search_path TO a, |` and `SET SCHEMA |`. Null anywhere else,
+* to: `USE |`, `ALTER SESSION SET CURRENT_SCHEMA = |` or the elements of `SET search_path TO a, |`
+* and `SET SCHEMA |`. Null anywhere else,
 * and after a name whose closing quote is typed.
 */
 function namespaceSlotAt(text, offset, dialect) {
@@ -12757,6 +12901,17 @@ function namespaceSlotAt(text, offset, dialect) {
 				listed: []
 			};
 		}
+		if (form === "alterSessionSchema") {
+			if (prefix?.kind === "string" || before.length !== ALTER_SESSION_PREFIX.length) continue;
+			if (!alterSessionPrefix(text, before)) continue;
+			return {
+				kind: "schema",
+				from,
+				to: offset,
+				quote,
+				listed: []
+			};
+		}
 		const start = searchPathListStart(text, before);
 		if (start === null) continue;
 		if (start.single && before.length !== start.at) continue;
@@ -12781,14 +12936,25 @@ function namespaceTarget(sql, dialect) {
 	if (forms.length === 0) return null;
 	const tokens = significantTokens(sql, dialect).filter((token) => token.kind !== "delimiter");
 	for (const form of forms) {
-		const target = form === "use" ? useTarget(sql, tokens) : searchPathTarget(sql, tokens);
+		const target = TARGET_READERS[form](sql, tokens);
 		if (target !== null) return target;
 	}
 	return null;
 }
+var TARGET_READERS = {
+	use: useTarget,
+	searchPath: searchPathTarget,
+	alterSessionSchema: alterSessionTarget
+};
 var SWITCH_TARGETS = {
 	use: "topLevel",
-	searchPath: "schema"
+	searchPath: "schema",
+	alterSessionSchema: "schema"
+};
+var SWITCH_STATEMENTS = {
+	use: (quoted) => `USE ${quoted}`,
+	searchPath: (quoted) => `SET search_path TO ${quoted}`,
+	alterSessionSchema: (quoted) => `ALTER SESSION SET CURRENT_SCHEMA = ${quoted}`
 };
 /**
 * The console's namespace switch for a dialect moving its namespace by `form` (decision 060):
@@ -12802,7 +12968,7 @@ function namespaceSwitcher(form, quoteIdentifier) {
 		statement(path) {
 			const name = path.at(-1);
 			if (name === void 0) throw new PluginError("statementFailed", "A namespace switch names no namespace; pick one from the list.");
-			return form === "use" ? `USE ${quoteIdentifier(name)}` : `SET search_path TO ${quoteIdentifier(name)}`;
+			return SWITCH_STATEMENTS[form](quoteIdentifier(name));
 		}
 	};
 }
@@ -13305,6 +13471,8 @@ var BOOST = {
 	keyword: -10
 };
 var UNQUOTED_WORD = "^[A-Za-z0-9_$]*$";
+/** Where `@` and `#` start a name (`variables`), the typed `@@` stays part of what is filtered. */
+var VARIABLE_WORD = "^[@#]*[A-Za-z0-9_$]*$";
 var ALIAS_WORD_BREAK = /[^A-Za-z0-9]+|(?<=[a-z0-9])(?=[A-Z])/;
 var FALLBACK_ALIAS = "t";
 var QUOTES = /* @__PURE__ */ new Set([
@@ -13315,12 +13483,54 @@ var QUOTES = /* @__PURE__ */ new Set([
 /** Below every other namespace: `USE mysql` is legitimate but rarely meant. */
 var SYSTEM_NAMESPACE_BOOST = -20;
 var CURRENT_DETAIL = "current";
+var COMMA$6 = ",";
+var MEMBER_SEPARATOR = ".";
+/**
+* Walks `separators` through `signature`: a comma moves to the next parameter without a lead, a
+* word to the next one it leads. A word nothing leads is an argument's own (`YEAR`, `DECIMAL`).
+* Past the last parameter a comma keeps counting, as the hint's variadic rule expects; a variadic
+* parameter keyword-led ones follow (`CHAR(code... USING charset)`) takes every comma.
+*/
+function argumentAt(signature, separators) {
+	const { parameters } = signature;
+	let at = 0;
+	let entered = false;
+	let led = 0;
+	for (const separator of separators) {
+		if (separator === COMMA$6) {
+			const next = parameters.findIndex((parameter, index) => index > at && parameter.lead === void 0);
+			if (next >= 0) at = next;
+			else if (!(parameters[at]?.variadic === true && at < parameters.length - 1)) at += 1;
+			entered = true;
+			continue;
+		}
+		const next = parameters.findIndex((parameter, index) => (index > at || index === at && !entered) && parameter.lead !== void 0 && leadMatches(parameter.lead, separator));
+		if (next < 0) continue;
+		at = next;
+		entered = true;
+		led += 1;
+	}
+	return {
+		argument: at,
+		led
+	};
+}
+/** The argument the caret is in, by the overload whose leads the call follows most; the first on a tie. */
+function argumentOf(spec, call) {
+	let best = null;
+	for (const signature of spec.signatures) {
+		const found = argumentAt(signature, call.separators ?? []);
+		if (best === null || found.led > best.led) best = found;
+	}
+	return best?.argument ?? call.argument;
+}
 function relationKind(relation) {
 	return relation.kind === "table" ? "table" : "view";
 }
 /** The shared completion and navigation every built-in plugin spreads into its `SqlLanguage` (decision 028). */
 function sqlCompleter(options) {
 	const reserved = new Set(options.keywords.map((keyword) => keyword.toUpperCase()));
+	const unquotedWord = options.dialect.variables === true ? VARIABLE_WORD : UNQUOTED_WORD;
 	const { denotes, sameIdentifier, cteNamed, sourceNamed, serverOf, Lookup } = nameRules(options);
 	const specs = /* @__PURE__ */ new Map();
 	for (const spec of options.functions) {
@@ -13331,6 +13541,11 @@ function sqlCompleter(options) {
 	function specNamed(name, server) {
 		return specs.get(name.toUpperCase())?.find((spec) => isAvailable(spec, server));
 	}
+	/** The members of the package `qualifier` names, as offered after its dot. */
+	function memberItems(qualifier, server) {
+		const name = qualifier.map((part) => part.name.toUpperCase()).join(MEMBER_SEPARATOR);
+		return availableFunctions(server, true).filter((spec) => typeof spec !== "string" && functionPackage(spec) === name).map((spec) => memberItem(spec, BOOST.function));
+	}
 	function quoted(name) {
 		return options.plainIdentifier.test(name) && !reserved.has(name.toUpperCase()) ? name : options.quoteIdentifier(name);
 	}
@@ -13355,10 +13570,12 @@ function sqlCompleter(options) {
 	function keywordItems(except = /* @__PURE__ */ new Set()) {
 		return options.keywords.filter((keyword) => !except.has(keyword.toUpperCase())).map((keyword) => item("keyword", keyword, keyword, null));
 	}
-	function availableFunctions(server) {
+	/** Plain functions, or with `members` the package members only: a bare name never offers `pkg.member`. */
+	function availableFunctions(server, members = false) {
 		const offered = /* @__PURE__ */ new Set();
 		return options.functions.filter((spec) => {
 			const name = functionName(spec).toUpperCase();
+			if (functionPackage(spec) !== null !== members) return false;
 			if (offered.has(name) || typeof spec !== "string" && !isAvailable(spec, server)) return false;
 			offered.add(name);
 			return true;
@@ -13369,17 +13586,18 @@ function sqlCompleter(options) {
 		const last = qualifier.at(-1);
 		if (last === void 0) return [];
 		const relational = clause === "relation" || clause === "join";
+		const members = relational ? [] : memberItems(qualifier, lookup.server);
 		if (qualifier.length === 1 && !relational) {
 			const source = sourceNamed(query, last);
-			if (source !== void 0) return columnItems(await lookup.columnsOf(source, query));
+			if (source !== void 0) return [...columnItems(await lookup.columnsOf(source, query)), ...members];
 			const cte = cteNamed(query, last);
-			if (cte !== void 0) return columnItems(await lookup.cteColumns(cte, 1));
+			if (cte !== void 0) return [...columnItems(await lookup.cteColumns(cte, 1)), ...members];
 		}
 		const namespace = await lookup.namespace(qualifier);
-		if (namespace !== void 0) return relationItems(await lookup.relations(namespace.path), null);
+		if (namespace !== void 0) return [...members, ...relationItems(await lookup.relations(namespace.path), null)];
 		if (relational) return [];
 		const found = await lookup.relation(qualifier.slice(0, -1), last);
-		return found === null ? [] : columnItems(found.relation.columns);
+		return found === null ? members : [...columnItems(found.relation.columns), ...members];
 	}
 	async function relationContextItems(scope, lookup) {
 		const current = lookup.current;
@@ -13396,7 +13614,8 @@ function sqlCompleter(options) {
 	}
 	function aliasFor(name, taken) {
 		const initials = name.split(ALIAS_WORD_BREAK).filter((word) => word !== "").map((word) => word.charAt(0).toLowerCase()).join("");
-		const base = initials === "" || !options.plainIdentifier.test(initials) ? FALLBACK_ALIAS : initials;
+		const folded = options.identifierFolding === "upper" ? initials.toUpperCase() : initials;
+		const base = initials === "" || !options.plainIdentifier.test(folded) ? FALLBACK_ALIAS : initials;
 		let alias = base;
 		for (let suffix = 1; taken.has(alias) || reserved.has(alias.toUpperCase()); suffix += 1) alias = `${base}${String(suffix)}`;
 		taken.add(alias);
@@ -13421,7 +13640,7 @@ function sqlCompleter(options) {
 			if (source.qualifier.length === 0 && cteNamed(scope.query, source.name) !== void 0) continue;
 			const found = await lookup.relation(source.qualifier, source.name);
 			if (found === null) continue;
-			const near = source.alias === null ? relationReference(found.path, found.relation.name, lookup.current) : quoted(source.alias.name);
+			const near = source.alias === null ? relationReference(found.path, found.relation.name, lookup.current) : source.alias.quoted ? options.quoteIdentifier(source.alias.name) : source.alias.name;
 			for (const key of found.relation.foreignKeys) {
 				const alias = aliasFor(key.target.relation, new Set(taken));
 				const on = key.columns.map((column, at) => `${alias}.${quoted(key.target.columns[at] ?? column)} = ${near}.${quoted(column)}`).join(" AND ");
@@ -13531,7 +13750,7 @@ function sqlCompleter(options) {
 					from: slot.from,
 					to: slot.to,
 					items,
-					validFor: slot.quote === null ? UNQUOTED_WORD : null
+					validFor: slot.quote === null ? unquotedWord : null
 				};
 			}
 		}
@@ -13545,7 +13764,7 @@ function sqlCompleter(options) {
 			from: scope.prefixFrom - shift,
 			to: offset - shift,
 			items: typedQuote ? quotedLabels(items) : items,
-			validFor: typedQuote ? null : UNQUOTED_WORD
+			validFor: typedQuote ? null : unquotedWord
 		};
 	}
 	function sourceDeclaring(query, word) {
@@ -13688,14 +13907,18 @@ function sqlCompleter(options) {
 	function signatureAt(request, catalog) {
 		const { text, offset, shift } = wrap(request);
 		const server = serverOf(catalog);
-		const call = callAt(text, offset, options.dialect, reserved, (name) => specNamed(name, server) !== void 0);
+		const callable = (name) => {
+			const spec = specNamed(name, server);
+			return spec !== void 0 && spec.bare !== true;
+		};
+		const call = callAt(text, offset, options.dialect, reserved, callable);
 		const spec = call === null ? void 0 : specNamed(call.name, server);
 		if (call === null || spec === void 0) return Promise.resolve(null);
 		return Promise.resolve({
 			name: spec.name.toLowerCase(),
 			summary: spec.summary,
 			signatures: spec.signatures,
-			argument: call.argument,
+			argument: argumentOf(spec, call),
 			from: call.from - shift,
 			to: call.to - shift
 		});
@@ -14113,6 +14336,7 @@ var PARAMETER_MARKS = /* @__PURE__ */ new Set([
 	"?"
 ]);
 var PARAMETER_START = /^[$@:]/;
+var PARAMETER_OR_TEMPORARY = /^[@#]/;
 /** Rows a statement may name without declaring them: PostgreSQL's `EXCLUDED`, a trigger's `NEW` and `OLD`. */
 var PSEUDO_RELATIONS = /* @__PURE__ */ new Set([
 	"EXCLUDED",
@@ -14231,6 +14455,7 @@ async function unresolvedRelation(view, query, source) {
 	if (view.verb === "SELECT" && view.roleOf(source) === "target") return [];
 	if (source.qualifier.length === 0 && view.rules.cteNamed(query, source.name) !== void 0) return [];
 	if (!source.name.quoted && NOT_RELATION_NAMES.has(source.name.name.toUpperCase())) return [];
+	if (!source.name.quoted && PARAMETER_OR_TEMPORARY.test(source.name.name)) return [];
 	const { lookup } = view;
 	let path = lookup.current;
 	if (source.qualifier.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablecraft-app/plugin-postgres",
-  "version": "1.10.3",
+  "version": "1.11.0",
   "description": "The PostgreSQL datasource plugin for TableCraft, downloaded by the app when a data source needs it.",
   "license": "MIT",
   "type": "module",
@@ -24,6 +24,6 @@
   },
   "tableCraft": {
     "id": "postgres",
-    "apiVersion": "1.3.0"
+    "apiVersion": "1.5.0"
   }
 }

package/table-craft-plugin.json

@@ -1,8 +1,8 @@
 {
   "id": "postgres",
   "name": "PostgreSQL",
-  "version": "1.10.3",
-  "apiVersion": "1.3.0",
+  "version": "1.11.0",
+  "apiVersion": "1.5.0",
   "entry": "index.js",
   "capabilities": [
     "sql",