neonctl 2.27.1 → 2.29.0

package/dist/psql/complete/rules.js

@@ -96,653 +96,653 @@
  * The shape mirrors the C source closely enough that adding new rules is
  * mechanical: drop a new `if (TailMatches(...))` arm in the right region.
  */
-import { completeFilenames, isCopyFromOrTo } from './filenames.js';
-import { HeadMatches, MatchAny, TailMatches, tokenize } from './matcher.js';
-import { Query_for_constraint_of_table, Query_for_constraint_of_table_in_schema, Query_for_list_of_casts, Query_for_list_of_databases, Query_for_list_of_datatypes, Query_for_list_of_enum_values_quoted, Query_for_list_of_extensions, Query_for_list_of_functions, Query_for_list_of_index_access_methods, Query_for_list_of_indexes, Query_for_list_of_languages, Query_for_list_of_matviews, Query_for_list_of_operators, Query_for_list_of_publications, Query_for_list_of_relations_in_schema, Query_for_list_of_roles, Query_for_list_of_schemas, Query_for_list_of_sequences, Query_for_list_of_set_vars, Query_for_list_of_subscriptions, Query_for_list_of_tables, Query_for_list_of_tables_for_constraint, Query_for_list_of_tables_for_constraint_in_schema, Query_for_list_of_tables_views, Query_for_list_of_tablespaces, Query_for_list_of_timezone_names_quoted_in, Query_for_list_of_timezone_names_quoted_out, Query_for_list_of_types, Query_for_list_of_views, Query_for_values_of_enum_GUC, runCatalogQuery, } from './queries.js';
-import { ENCODINGS, PSET_OPTIONS, SPECIAL_VARIABLES, psetValuesFor, variableValuesFor, } from './psqlVars.js';
+import { completeFilenames, isCopyFromOrTo } from "./filenames.js";
+import { HeadMatches, MatchAny, TailMatches, tokenize } from "./matcher.js";
+import { ENCODINGS, PSET_OPTIONS, psetValuesFor, SPECIAL_VARIABLES, variableValuesFor, } from "./psqlVars.js";
+import { Query_for_constraint_of_table, Query_for_constraint_of_table_in_schema, Query_for_list_of_casts, Query_for_list_of_databases, Query_for_list_of_datatypes, Query_for_list_of_enum_values_quoted, Query_for_list_of_extensions, Query_for_list_of_functions, Query_for_list_of_index_access_methods, Query_for_list_of_indexes, Query_for_list_of_languages, Query_for_list_of_matviews, Query_for_list_of_operators, Query_for_list_of_publications, Query_for_list_of_relations_in_schema, Query_for_list_of_roles, Query_for_list_of_schemas, Query_for_list_of_sequences, Query_for_list_of_set_vars, Query_for_list_of_subscriptions, Query_for_list_of_tables, Query_for_list_of_tables_for_constraint, Query_for_list_of_tables_for_constraint_in_schema, Query_for_list_of_tables_views, Query_for_list_of_tablespaces, Query_for_list_of_timezone_names_quoted_in, Query_for_list_of_timezone_names_quoted_out, Query_for_list_of_types, Query_for_list_of_views, Query_for_values_of_enum_GUC, runCatalogQuery, } from "./queries.js";
 /** Backslash command names psql tab-completes (mirrors backslash_commands[]). */
 export const BACKSLASH_COMMANDS = [
-    '\\a',
-    '\\bind',
-    '\\bind_named',
-    '\\c',
-    '\\C',
-    '\\cd',
-    '\\close_prepared',
-    '\\conninfo',
-    '\\connect',
-    '\\copy',
-    '\\copyright',
-    '\\crosstabview',
-    '\\d',
-    '\\dA',
-    '\\dAc',
-    '\\dAf',
-    '\\dAo',
-    '\\dAp',
-    '\\da',
-    '\\db',
-    '\\dC',
-    '\\dc',
-    '\\dconfig',
-    '\\dD',
-    '\\dd',
-    '\\ddp',
-    '\\dE',
-    '\\des',
-    '\\det',
-    '\\deu',
-    '\\dew',
-    '\\df',
-    '\\dF',
-    '\\dFd',
-    '\\dFp',
-    '\\dFt',
-    '\\dg',
-    '\\di',
-    '\\dl',
-    '\\dL',
-    '\\dm',
-    '\\dn',
-    '\\do',
-    '\\dO',
-    '\\dp',
-    '\\dP',
-    '\\dPi',
-    '\\dPt',
-    '\\drds',
-    '\\drg',
-    '\\dRs',
-    '\\dRp',
-    '\\ds',
-    '\\dt',
-    '\\dT',
-    '\\dv',
-    '\\du',
-    '\\dx',
-    '\\dX',
-    '\\dy',
-    '\\echo',
-    '\\edit',
-    '\\ef',
-    '\\elif',
-    '\\else',
-    '\\encoding',
-    '\\endif',
-    '\\endpipeline',
-    '\\errverbose',
-    '\\ev',
-    '\\f',
-    '\\flush',
-    '\\flushrequest',
-    '\\g',
-    '\\gdesc',
-    '\\getenv',
-    '\\getresults',
-    '\\gexec',
-    '\\gset',
-    '\\gx',
-    '\\help',
-    '\\html',
-    '\\if',
-    '\\include',
-    '\\include_relative',
-    '\\ir',
-    '\\l',
-    '\\list',
-    '\\lo_export',
-    '\\lo_import',
-    '\\lo_list',
-    '\\lo_unlink',
-    '\\o',
-    '\\out',
-    '\\parse',
-    '\\password',
-    '\\print',
-    '\\prompt',
-    '\\pset',
-    '\\q',
-    '\\qecho',
-    '\\quit',
-    '\\reset',
-    '\\restrict',
-    '\\s',
-    '\\sendpipeline',
-    '\\set',
-    '\\setenv',
-    '\\sf',
-    '\\startpipeline',
-    '\\sv',
-    '\\syncpipeline',
-    '\\t',
-    '\\T',
-    '\\timing',
-    '\\unrestrict',
-    '\\unset',
-    '\\w',
-    '\\warn',
-    '\\watch',
-    '\\write',
-    '\\x',
-    '\\z',
-    '\\!',
-    '\\?',
+    "\\a",
+    "\\bind",
+    "\\bind_named",
+    "\\c",
+    "\\C",
+    "\\cd",
+    "\\close_prepared",
+    "\\conninfo",
+    "\\connect",
+    "\\copy",
+    "\\copyright",
+    "\\crosstabview",
+    "\\d",
+    "\\dA",
+    "\\dAc",
+    "\\dAf",
+    "\\dAo",
+    "\\dAp",
+    "\\da",
+    "\\db",
+    "\\dC",
+    "\\dc",
+    "\\dconfig",
+    "\\dD",
+    "\\dd",
+    "\\ddp",
+    "\\dE",
+    "\\des",
+    "\\det",
+    "\\deu",
+    "\\dew",
+    "\\df",
+    "\\dF",
+    "\\dFd",
+    "\\dFp",
+    "\\dFt",
+    "\\dg",
+    "\\di",
+    "\\dl",
+    "\\dL",
+    "\\dm",
+    "\\dn",
+    "\\do",
+    "\\dO",
+    "\\dp",
+    "\\dP",
+    "\\dPi",
+    "\\dPt",
+    "\\drds",
+    "\\drg",
+    "\\dRs",
+    "\\dRp",
+    "\\ds",
+    "\\dt",
+    "\\dT",
+    "\\dv",
+    "\\du",
+    "\\dx",
+    "\\dX",
+    "\\dy",
+    "\\echo",
+    "\\edit",
+    "\\ef",
+    "\\elif",
+    "\\else",
+    "\\encoding",
+    "\\endif",
+    "\\endpipeline",
+    "\\errverbose",
+    "\\ev",
+    "\\f",
+    "\\flush",
+    "\\flushrequest",
+    "\\g",
+    "\\gdesc",
+    "\\getenv",
+    "\\getresults",
+    "\\gexec",
+    "\\gset",
+    "\\gx",
+    "\\help",
+    "\\html",
+    "\\if",
+    "\\include",
+    "\\include_relative",
+    "\\ir",
+    "\\l",
+    "\\list",
+    "\\lo_export",
+    "\\lo_import",
+    "\\lo_list",
+    "\\lo_unlink",
+    "\\o",
+    "\\out",
+    "\\parse",
+    "\\password",
+    "\\print",
+    "\\prompt",
+    "\\pset",
+    "\\q",
+    "\\qecho",
+    "\\quit",
+    "\\reset",
+    "\\restrict",
+    "\\s",
+    "\\sendpipeline",
+    "\\set",
+    "\\setenv",
+    "\\sf",
+    "\\startpipeline",
+    "\\sv",
+    "\\syncpipeline",
+    "\\t",
+    "\\T",
+    "\\timing",
+    "\\unrestrict",
+    "\\unset",
+    "\\w",
+    "\\warn",
+    "\\watch",
+    "\\write",
+    "\\x",
+    "\\z",
+    "\\!",
+    "\\?",
 ];
 /** Top-level SQL statement keywords. */
 export const SQL_TOP_KEYWORDS = [
-    'ABORT',
-    'ALTER',
-    'ANALYZE',
-    'BEGIN',
-    'CALL',
-    'CHECKPOINT',
-    'CLOSE',
-    'CLUSTER',
-    'COMMENT',
-    'COMMIT',
-    'COPY',
-    'CREATE',
-    'DEALLOCATE',
-    'DECLARE',
-    'DELETE FROM',
-    'DISCARD',
-    'DO',
-    'DROP',
-    'END',
-    'EXECUTE',
-    'EXPLAIN',
-    'FETCH',
-    'GRANT',
-    'IMPORT',
-    'INSERT INTO',
-    'LISTEN',
-    'LOAD',
-    'LOCK',
-    'MERGE',
-    'MOVE',
-    'NOTIFY',
-    'PREPARE',
-    'REASSIGN',
-    'REFRESH MATERIALIZED VIEW',
-    'REINDEX',
-    'RELEASE',
-    'RESET',
-    'REVOKE',
-    'ROLLBACK',
-    'SAVEPOINT',
-    'SECURITY LABEL',
-    'SELECT',
-    'SET',
-    'SHOW',
-    'START TRANSACTION',
-    'TABLE',
-    'TRUNCATE',
-    'UNLISTEN',
-    'UPDATE',
-    'VACUUM',
-    'VALUES',
-    'WITH',
+    "ABORT",
+    "ALTER",
+    "ANALYZE",
+    "BEGIN",
+    "CALL",
+    "CHECKPOINT",
+    "CLOSE",
+    "CLUSTER",
+    "COMMENT",
+    "COMMIT",
+    "COPY",
+    "CREATE",
+    "DEALLOCATE",
+    "DECLARE",
+    "DELETE FROM",
+    "DISCARD",
+    "DO",
+    "DROP",
+    "END",
+    "EXECUTE",
+    "EXPLAIN",
+    "FETCH",
+    "GRANT",
+    "IMPORT",
+    "INSERT INTO",
+    "LISTEN",
+    "LOAD",
+    "LOCK",
+    "MERGE",
+    "MOVE",
+    "NOTIFY",
+    "PREPARE",
+    "REASSIGN",
+    "REFRESH MATERIALIZED VIEW",
+    "REINDEX",
+    "RELEASE",
+    "RESET",
+    "REVOKE",
+    "ROLLBACK",
+    "SAVEPOINT",
+    "SECURITY LABEL",
+    "SELECT",
+    "SET",
+    "SHOW",
+    "START TRANSACTION",
+    "TABLE",
+    "TRUNCATE",
+    "UNLISTEN",
+    "UPDATE",
+    "VACUUM",
+    "VALUES",
+    "WITH",
 ];
 /** Keywords accepted after CREATE. */
 export const CREATE_OBJECTS = [
-    'ACCESS METHOD',
-    'AGGREGATE',
-    'CAST',
-    'COLLATION',
-    'CONVERSION',
-    'DATABASE',
-    'DEFAULT PRIVILEGES',
-    'DOMAIN',
-    'EVENT TRIGGER',
-    'EXTENSION',
-    'FOREIGN DATA WRAPPER',
-    'FOREIGN TABLE',
-    'FUNCTION',
-    'GLOBAL',
-    'GROUP',
-    'INDEX',
-    'LANGUAGE',
-    'LOCAL',
-    'MATERIALIZED VIEW',
-    'OPERATOR',
-    'OR REPLACE',
-    'POLICY',
-    'PROCEDURE',
-    'PUBLICATION',
-    'ROLE',
-    'RULE',
-    'SCHEMA',
-    'SEQUENCE',
-    'SERVER',
-    'STATISTICS',
-    'SUBSCRIPTION',
-    'TABLE',
-    'TABLESPACE',
-    'TEMP',
-    'TEMPORARY',
-    'TEXT SEARCH',
-    'TRANSFORM',
-    'TRIGGER',
-    'TYPE',
-    'UNIQUE',
-    'UNLOGGED',
-    'USER',
-    'VIEW',
+    "ACCESS METHOD",
+    "AGGREGATE",
+    "CAST",
+    "COLLATION",
+    "CONVERSION",
+    "DATABASE",
+    "DEFAULT PRIVILEGES",
+    "DOMAIN",
+    "EVENT TRIGGER",
+    "EXTENSION",
+    "FOREIGN DATA WRAPPER",
+    "FOREIGN TABLE",
+    "FUNCTION",
+    "GLOBAL",
+    "GROUP",
+    "INDEX",
+    "LANGUAGE",
+    "LOCAL",
+    "MATERIALIZED VIEW",
+    "OPERATOR",
+    "OR REPLACE",
+    "POLICY",
+    "PROCEDURE",
+    "PUBLICATION",
+    "ROLE",
+    "RULE",
+    "SCHEMA",
+    "SEQUENCE",
+    "SERVER",
+    "STATISTICS",
+    "SUBSCRIPTION",
+    "TABLE",
+    "TABLESPACE",
+    "TEMP",
+    "TEMPORARY",
+    "TEXT SEARCH",
+    "TRANSFORM",
+    "TRIGGER",
+    "TYPE",
+    "UNIQUE",
+    "UNLOGGED",
+    "USER",
+    "VIEW",
 ];
 /** Keywords accepted after DROP. */
 export const DROP_OBJECTS = [
-    'ACCESS METHOD',
-    'AGGREGATE',
-    'CAST',
-    'COLLATION',
-    'CONVERSION',
-    'DATABASE',
-    'DOMAIN',
-    'EVENT TRIGGER',
-    'EXTENSION',
-    'FOREIGN DATA WRAPPER',
-    'FOREIGN TABLE',
-    'FUNCTION',
-    'GROUP',
-    'INDEX',
-    'LANGUAGE',
-    'MATERIALIZED VIEW',
-    'OPERATOR',
-    'OWNED',
-    'POLICY',
-    'PROCEDURE',
-    'PUBLICATION',
-    'ROLE',
-    'RULE',
-    'SCHEMA',
-    'SEQUENCE',
-    'SERVER',
-    'STATISTICS',
-    'SUBSCRIPTION',
-    'TABLE',
-    'TABLESPACE',
-    'TEXT SEARCH',
-    'TRANSFORM',
-    'TRIGGER',
-    'TYPE',
-    'USER',
-    'VIEW',
+    "ACCESS METHOD",
+    "AGGREGATE",
+    "CAST",
+    "COLLATION",
+    "CONVERSION",
+    "DATABASE",
+    "DOMAIN",
+    "EVENT TRIGGER",
+    "EXTENSION",
+    "FOREIGN DATA WRAPPER",
+    "FOREIGN TABLE",
+    "FUNCTION",
+    "GROUP",
+    "INDEX",
+    "LANGUAGE",
+    "MATERIALIZED VIEW",
+    "OPERATOR",
+    "OWNED",
+    "POLICY",
+    "PROCEDURE",
+    "PUBLICATION",
+    "ROLE",
+    "RULE",
+    "SCHEMA",
+    "SEQUENCE",
+    "SERVER",
+    "STATISTICS",
+    "SUBSCRIPTION",
+    "TABLE",
+    "TABLESPACE",
+    "TEXT SEARCH",
+    "TRANSFORM",
+    "TRIGGER",
+    "TYPE",
+    "USER",
+    "VIEW",
 ];
 /** Keywords accepted after ALTER. */
 export const ALTER_OBJECTS = [
-    'AGGREGATE',
-    'COLLATION',
-    'CONVERSION',
-    'DATABASE',
-    'DEFAULT PRIVILEGES',
-    'DOMAIN',
-    'EVENT TRIGGER',
-    'EXTENSION',
-    'FOREIGN DATA WRAPPER',
-    'FOREIGN TABLE',
-    'FUNCTION',
-    'GROUP',
-    'INDEX',
-    'LANGUAGE',
-    'LARGE OBJECT',
-    'MATERIALIZED VIEW',
-    'OPERATOR',
-    'POLICY',
-    'PROCEDURE',
-    'PUBLICATION',
-    'ROLE',
-    'RULE',
-    'SCHEMA',
-    'SEQUENCE',
-    'SERVER',
-    'STATISTICS',
-    'SUBSCRIPTION',
-    'SYSTEM',
-    'TABLE',
-    'TABLESPACE',
-    'TEXT SEARCH',
-    'TRIGGER',
-    'TYPE',
-    'USER',
-    'VIEW',
+    "AGGREGATE",
+    "COLLATION",
+    "CONVERSION",
+    "DATABASE",
+    "DEFAULT PRIVILEGES",
+    "DOMAIN",
+    "EVENT TRIGGER",
+    "EXTENSION",
+    "FOREIGN DATA WRAPPER",
+    "FOREIGN TABLE",
+    "FUNCTION",
+    "GROUP",
+    "INDEX",
+    "LANGUAGE",
+    "LARGE OBJECT",
+    "MATERIALIZED VIEW",
+    "OPERATOR",
+    "POLICY",
+    "PROCEDURE",
+    "PUBLICATION",
+    "ROLE",
+    "RULE",
+    "SCHEMA",
+    "SEQUENCE",
+    "SERVER",
+    "STATISTICS",
+    "SUBSCRIPTION",
+    "SYSTEM",
+    "TABLE",
+    "TABLESPACE",
+    "TEXT SEARCH",
+    "TRIGGER",
+    "TYPE",
+    "USER",
+    "VIEW",
 ];
 /** Sub-actions for ALTER TABLE. */
 export const ALTER_TABLE_ACTIONS = [
-    'ADD',
-    'ALTER',
-    'ATTACH PARTITION',
-    'CLUSTER ON',
-    'DETACH PARTITION',
-    'DISABLE',
-    'DROP',
-    'ENABLE',
-    'INHERIT',
-    'NO INHERIT',
-    'OF',
-    'NOT OF',
-    'OWNER TO',
-    'RENAME',
-    'REPLICA IDENTITY',
-    'RESET',
-    'SET',
-    'VALIDATE CONSTRAINT',
+    "ADD",
+    "ALTER",
+    "ATTACH PARTITION",
+    "CLUSTER ON",
+    "DETACH PARTITION",
+    "DISABLE",
+    "DROP",
+    "ENABLE",
+    "INHERIT",
+    "NO INHERIT",
+    "OF",
+    "NOT OF",
+    "OWNER TO",
+    "RENAME",
+    "REPLICA IDENTITY",
+    "RESET",
+    "SET",
+    "VALIDATE CONSTRAINT",
 ];
 /** Continuation after `ALTER TABLE x ADD`. */
 export const ALTER_TABLE_ADD = [
-    'COLUMN',
-    'CONSTRAINT',
-    'CHECK',
-    'FOREIGN KEY',
-    'PRIMARY KEY',
-    'UNIQUE',
-    'EXCLUDE',
+    "COLUMN",
+    "CONSTRAINT",
+    "CHECK",
+    "FOREIGN KEY",
+    "PRIMARY KEY",
+    "UNIQUE",
+    "EXCLUDE",
 ];
 /** Continuation after `ALTER TABLE x ALTER [COLUMN] y`. */
 export const ALTER_TABLE_ALTER_COLUMN = [
-    'ADD GENERATED',
-    'DROP DEFAULT',
-    'DROP EXPRESSION',
-    'DROP IDENTITY',
-    'DROP NOT NULL',
-    'RESET',
-    'RESTART',
-    'SET',
-    'SET DATA TYPE',
-    'SET DEFAULT',
-    'SET EXPRESSION',
-    'SET GENERATED',
-    'SET NOT NULL',
-    'SET STATISTICS',
-    'SET STORAGE',
-    'TYPE',
+    "ADD GENERATED",
+    "DROP DEFAULT",
+    "DROP EXPRESSION",
+    "DROP IDENTITY",
+    "DROP NOT NULL",
+    "RESET",
+    "RESTART",
+    "SET",
+    "SET DATA TYPE",
+    "SET DEFAULT",
+    "SET EXPRESSION",
+    "SET GENERATED",
+    "SET NOT NULL",
+    "SET STATISTICS",
+    "SET STORAGE",
+    "TYPE",
 ];
 /** Continuation after `ALTER TABLE x DROP`. */
 export const ALTER_TABLE_DROP = [
-    'COLUMN',
-    'CONSTRAINT',
-    'IF EXISTS',
+    "COLUMN",
+    "CONSTRAINT",
+    "IF EXISTS",
 ];
 /** Continuation after `ALTER TABLE x RENAME`. */
 export const ALTER_TABLE_RENAME = [
-    'COLUMN',
-    'CONSTRAINT',
-    'TO',
+    "COLUMN",
+    "CONSTRAINT",
+    "TO",
 ];
 /** Continuation after `ALTER TABLE x SET`. */
 export const ALTER_TABLE_SET = [
-    '(',
-    'LOGGED',
-    'SCHEMA',
-    'TABLESPACE',
-    'UNLOGGED',
-    'WITHOUT CLUSTER',
-    'WITHOUT OIDS',
+    "(",
+    "LOGGED",
+    "SCHEMA",
+    "TABLESPACE",
+    "UNLOGGED",
+    "WITHOUT CLUSTER",
+    "WITHOUT OIDS",
 ];
 /** Continuation after `ALTER TABLE x ENABLE`. */
 export const ALTER_TABLE_ENABLE = [
-    'ALWAYS',
-    'REPLICA',
-    'ROW LEVEL SECURITY',
-    'RULE',
-    'TRIGGER',
+    "ALWAYS",
+    "REPLICA",
+    "ROW LEVEL SECURITY",
+    "RULE",
+    "TRIGGER",
 ];
 /** Continuation after `ALTER TABLE x DISABLE`. */
 export const ALTER_TABLE_DISABLE = [
-    'ROW LEVEL SECURITY',
-    'RULE',
-    'TRIGGER',
+    "ROW LEVEL SECURITY",
+    "RULE",
+    "TRIGGER",
 ];
 /** Continuation after `ALTER TABLE x REPLICA IDENTITY`. */
 export const ALTER_TABLE_REPLICA_IDENTITY = [
-    'DEFAULT',
-    'FULL',
-    'NOTHING',
-    'USING INDEX',
+    "DEFAULT",
+    "FULL",
+    "NOTHING",
+    "USING INDEX",
 ];
 /** Sub-actions for ALTER VIEW. */
 export const ALTER_VIEW_ACTIONS = [
-    'ALTER',
-    'OWNER TO',
-    'RENAME',
-    'RESET',
-    'SET',
+    "ALTER",
+    "OWNER TO",
+    "RENAME",
+    "RESET",
+    "SET",
 ];
 /** Sub-actions for ALTER MATERIALIZED VIEW. */
 export const ALTER_MATVIEW_ACTIONS = [
-    'ALTER',
-    'CLUSTER ON',
-    'DEPENDS ON EXTENSION',
-    'NO DEPENDS ON EXTENSION',
-    'OWNER TO',
-    'RENAME',
-    'RESET',
-    'SET',
+    "ALTER",
+    "CLUSTER ON",
+    "DEPENDS ON EXTENSION",
+    "NO DEPENDS ON EXTENSION",
+    "OWNER TO",
+    "RENAME",
+    "RESET",
+    "SET",
 ];
 /** Sub-actions for ALTER INDEX. */
 export const ALTER_INDEX_ACTIONS = [
-    'ALTER COLUMN',
-    'ATTACH PARTITION',
-    'DEPENDS ON EXTENSION',
-    'NO DEPENDS ON EXTENSION',
-    'OWNER TO',
-    'RENAME',
-    'RESET',
-    'SET',
+    "ALTER COLUMN",
+    "ATTACH PARTITION",
+    "DEPENDS ON EXTENSION",
+    "NO DEPENDS ON EXTENSION",
+    "OWNER TO",
+    "RENAME",
+    "RESET",
+    "SET",
 ];
 /** Sub-actions for ALTER SEQUENCE. */
 export const ALTER_SEQUENCE_ACTIONS = [
-    'AS',
-    'CACHE',
-    'CYCLE',
-    'INCREMENT BY',
-    'MAXVALUE',
-    'MINVALUE',
-    'NO CYCLE',
-    'NO MAXVALUE',
-    'NO MINVALUE',
-    'OWNED BY',
-    'OWNER TO',
-    'RENAME TO',
-    'RESTART',
-    'SET SCHEMA',
-    'START WITH',
+    "AS",
+    "CACHE",
+    "CYCLE",
+    "INCREMENT BY",
+    "MAXVALUE",
+    "MINVALUE",
+    "NO CYCLE",
+    "NO MAXVALUE",
+    "NO MINVALUE",
+    "OWNED BY",
+    "OWNER TO",
+    "RENAME TO",
+    "RESTART",
+    "SET SCHEMA",
+    "START WITH",
 ];
 /** Sub-actions for ALTER FUNCTION / PROCEDURE / ROUTINE. */
 export const ALTER_FUNCTION_ACTIONS = [
-    'CALLED ON NULL INPUT',
-    'COST',
-    'DEPENDS ON EXTENSION',
-    'IMMUTABLE',
-    'LEAKPROOF',
-    'NO DEPENDS ON EXTENSION',
-    'NOT LEAKPROOF',
-    'OWNER TO',
-    'PARALLEL',
-    'RENAME TO',
-    'RESET',
-    'RETURNS NULL ON NULL INPUT',
-    'ROWS',
-    'SECURITY DEFINER',
-    'SECURITY INVOKER',
-    'SET',
-    'SET SCHEMA',
-    'STABLE',
-    'STRICT',
-    'SUPPORT',
-    'VOLATILE',
+    "CALLED ON NULL INPUT",
+    "COST",
+    "DEPENDS ON EXTENSION",
+    "IMMUTABLE",
+    "LEAKPROOF",
+    "NO DEPENDS ON EXTENSION",
+    "NOT LEAKPROOF",
+    "OWNER TO",
+    "PARALLEL",
+    "RENAME TO",
+    "RESET",
+    "RETURNS NULL ON NULL INPUT",
+    "ROWS",
+    "SECURITY DEFINER",
+    "SECURITY INVOKER",
+    "SET",
+    "SET SCHEMA",
+    "STABLE",
+    "STRICT",
+    "SUPPORT",
+    "VOLATILE",
 ];
 /** Sub-actions for ALTER TYPE. */
 export const ALTER_TYPE_ACTIONS = [
-    'ADD ATTRIBUTE',
-    'ADD VALUE',
-    'ALTER ATTRIBUTE',
-    'DROP ATTRIBUTE',
-    'OWNER TO',
-    'RENAME',
-    'RENAME ATTRIBUTE',
-    'RENAME VALUE',
-    'SET SCHEMA',
-    'SET',
+    "ADD ATTRIBUTE",
+    "ADD VALUE",
+    "ALTER ATTRIBUTE",
+    "DROP ATTRIBUTE",
+    "OWNER TO",
+    "RENAME",
+    "RENAME ATTRIBUTE",
+    "RENAME VALUE",
+    "SET SCHEMA",
+    "SET",
 ];
 /** Sub-actions for ALTER ROLE / USER. */
 export const ALTER_ROLE_ACTIONS = [
-    'BYPASSRLS',
-    'CONNECTION LIMIT',
-    'CREATEDB',
-    'CREATEROLE',
-    'ENCRYPTED PASSWORD',
-    'IN DATABASE',
-    'INHERIT',
-    'LOGIN',
-    'NOBYPASSRLS',
-    'NOCREATEDB',
-    'NOCREATEROLE',
-    'NOINHERIT',
-    'NOLOGIN',
-    'NOREPLICATION',
-    'NOSUPERUSER',
-    'PASSWORD',
-    'RENAME TO',
-    'REPLICATION',
-    'RESET',
-    'SET',
-    'SUPERUSER',
-    'VALID UNTIL',
-    'WITH',
+    "BYPASSRLS",
+    "CONNECTION LIMIT",
+    "CREATEDB",
+    "CREATEROLE",
+    "ENCRYPTED PASSWORD",
+    "IN DATABASE",
+    "INHERIT",
+    "LOGIN",
+    "NOBYPASSRLS",
+    "NOCREATEDB",
+    "NOCREATEROLE",
+    "NOINHERIT",
+    "NOLOGIN",
+    "NOREPLICATION",
+    "NOSUPERUSER",
+    "PASSWORD",
+    "RENAME TO",
+    "REPLICATION",
+    "RESET",
+    "SET",
+    "SUPERUSER",
+    "VALID UNTIL",
+    "WITH",
 ];
 /** Sub-actions for ALTER DATABASE. */
 export const ALTER_DATABASE_ACTIONS = [
-    'ALLOW_CONNECTIONS',
-    'CONNECTION LIMIT',
-    'IS_TEMPLATE',
-    'OWNER TO',
-    'REFRESH COLLATION VERSION',
-    'RENAME TO',
-    'RESET',
-    'SET',
-    'SET TABLESPACE',
-    'WITH',
+    "ALLOW_CONNECTIONS",
+    "CONNECTION LIMIT",
+    "IS_TEMPLATE",
+    "OWNER TO",
+    "REFRESH COLLATION VERSION",
+    "RENAME TO",
+    "RESET",
+    "SET",
+    "SET TABLESPACE",
+    "WITH",
 ];
 /** Sub-actions for ALTER SCHEMA. */
 export const ALTER_SCHEMA_ACTIONS = [
-    'OWNER TO',
-    'RENAME TO',
+    "OWNER TO",
+    "RENAME TO",
 ];
 /** Sub-actions for ALTER EXTENSION. */
 export const ALTER_EXTENSION_ACTIONS = [
-    'ADD',
-    'DROP',
-    'SET SCHEMA',
-    'UPDATE',
+    "ADD",
+    "DROP",
+    "SET SCHEMA",
+    "UPDATE",
 ];
 /** Sub-actions for ALTER POLICY. */
-export const ALTER_POLICY_ACTIONS = ['ON', 'RENAME TO'];
+export const ALTER_POLICY_ACTIONS = ["ON", "RENAME TO"];
 /** Sub-actions for ALTER PUBLICATION. */
 export const ALTER_PUBLICATION_ACTIONS = [
-    'ADD',
-    'DROP',
-    'OWNER TO',
-    'RENAME TO',
-    'SET',
+    "ADD",
+    "DROP",
+    "OWNER TO",
+    "RENAME TO",
+    "SET",
 ];
 /** Sub-actions for ALTER SUBSCRIPTION. */
 export const ALTER_SUBSCRIPTION_ACTIONS = [
-    'ADD PUBLICATION',
-    'CONNECTION',
-    'DISABLE',
-    'DROP PUBLICATION',
-    'ENABLE',
-    'OWNER TO',
-    'REFRESH PUBLICATION',
-    'RENAME TO',
-    'SET',
-    'SET PUBLICATION',
-    'SKIP',
+    "ADD PUBLICATION",
+    "CONNECTION",
+    "DISABLE",
+    "DROP PUBLICATION",
+    "ENABLE",
+    "OWNER TO",
+    "REFRESH PUBLICATION",
+    "RENAME TO",
+    "SET",
+    "SET PUBLICATION",
+    "SKIP",
 ];
 /** CREATE INDEX top-level options. */
 export const CREATE_INDEX_OPTIONS = [
-    'CONCURRENTLY',
-    'IF NOT EXISTS',
-    'ON',
-    'UNIQUE',
+    "CONCURRENTLY",
+    "IF NOT EXISTS",
+    "ON",
+    "UNIQUE",
 ];
 /** Window frame clauses after `OVER (`. */
 export const WINDOW_FRAME_KEYWORDS = [
-    'GROUPS',
-    'ORDER BY',
-    'PARTITION BY',
-    'RANGE',
-    'ROWS',
+    "GROUPS",
+    "ORDER BY",
+    "PARTITION BY",
+    "RANGE",
+    "ROWS",
 ];
 /** Tail keywords that follow a `FROM <table>` clause in a query. */
 export const POST_FROM_KEYWORDS = [
-    'AS',
-    'CROSS JOIN',
-    'EXCEPT',
-    'FETCH',
-    'FOR',
-    'FULL JOIN',
-    'FULL OUTER JOIN',
-    'GROUP BY',
-    'HAVING',
-    'INNER JOIN',
-    'INTERSECT',
-    'JOIN',
-    'LATERAL',
-    'LEFT JOIN',
-    'LEFT OUTER JOIN',
-    'LIMIT',
-    'NATURAL JOIN',
-    'OFFSET',
-    'ON',
-    'ORDER BY',
-    'RIGHT JOIN',
-    'RIGHT OUTER JOIN',
-    'TABLESAMPLE',
-    'UNION',
-    'USING',
-    'WHERE',
-    'WINDOW',
+    "AS",
+    "CROSS JOIN",
+    "EXCEPT",
+    "FETCH",
+    "FOR",
+    "FULL JOIN",
+    "FULL OUTER JOIN",
+    "GROUP BY",
+    "HAVING",
+    "INNER JOIN",
+    "INTERSECT",
+    "JOIN",
+    "LATERAL",
+    "LEFT JOIN",
+    "LEFT OUTER JOIN",
+    "LIMIT",
+    "NATURAL JOIN",
+    "OFFSET",
+    "ON",
+    "ORDER BY",
+    "RIGHT JOIN",
+    "RIGHT OUTER JOIN",
+    "TABLESAMPLE",
+    "UNION",
+    "USING",
+    "WHERE",
+    "WINDOW",
 ];
 /** Continuations within a WHERE expression. */
 export const WHERE_CONTINUATIONS = [
-    'AND',
-    'BETWEEN',
-    'IN',
-    'IS',
-    'LIKE',
-    'NOT',
-    'OR',
+    "AND",
+    "BETWEEN",
+    "IN",
+    "IS",
+    "LIKE",
+    "NOT",
+    "OR",
 ];
 /** Boolean-style values used with `\set` for AUTOCOMMIT etc. (extends ON_OFF). */
 export const DATESTYLE_VALUES = [
-    'GERMAN',
-    'ISO',
-    'POSTGRES',
-    'SQL',
+    "GERMAN",
+    "ISO",
+    "POSTGRES",
+    "SQL",
 ];
 /** GRANT / REVOKE privileges. */
 export const PRIVILEGE_KEYWORDS = [
-    'ALL',
-    'CREATE',
-    'CONNECT',
-    'DELETE',
-    'EXECUTE',
-    'INSERT',
-    'REFERENCES',
-    'SELECT',
-    'TEMPORARY',
-    'TRIGGER',
-    'TRUNCATE',
-    'UPDATE',
-    'USAGE',
+    "ALL",
+    "CREATE",
+    "CONNECT",
+    "DELETE",
+    "EXECUTE",
+    "INSERT",
+    "REFERENCES",
+    "SELECT",
+    "TEMPORARY",
+    "TRIGGER",
+    "TRUNCATE",
+    "UPDATE",
+    "USAGE",
 ];
 /** Common transaction/savepoint keywords. */
 export const TRANSACTION_KEYWORDS = [
-    'ISOLATION LEVEL',
-    'READ ONLY',
-    'READ WRITE',
-    'TRANSACTION',
+    "ISOLATION LEVEL",
+    "READ ONLY",
+    "READ WRITE",
+    "TRANSACTION",
 ];
 /**
  * Built-in scalar type keywords that psql tab-completion mixes in
@@ -753,13 +753,13 @@ export const TRANSACTION_KEYWORDS = [
  * boundaries.
  */
 export const BUILTIN_DATATYPE_KEYWORDS = [
-    'bigint',
-    'boolean',
-    'character',
-    'double precision',
-    'integer',
-    'real',
-    'smallint',
+    "bigint",
+    "boolean",
+    "character",
+    "double precision",
+    "integer",
+    "real",
+    "smallint",
 ];
 /**
  * COPY ... FROM ... WITH ( ... ) option keywords. Mirrors upstream's
@@ -768,34 +768,34 @@ export const BUILTIN_DATATYPE_KEYWORDS = [
  * ON_ERROR, REJECT_LIMIT).
  */
 export const COPY_FROM_OPTIONS = [
-    'DELIMITER',
-    'ENCODING',
-    'ESCAPE',
-    'FORMAT',
-    'HEADER',
-    'NULL',
-    'QUOTE',
-    'DEFAULT',
-    'FORCE_NOT_NULL',
-    'FORCE_NULL',
-    'FREEZE',
-    'LOG_VERBOSITY',
-    'ON_ERROR',
-    'REJECT_LIMIT',
+    "DELIMITER",
+    "ENCODING",
+    "ESCAPE",
+    "FORMAT",
+    "HEADER",
+    "NULL",
+    "QUOTE",
+    "DEFAULT",
+    "FORCE_NOT_NULL",
+    "FORCE_NULL",
+    "FREEZE",
+    "LOG_VERBOSITY",
+    "ON_ERROR",
+    "REJECT_LIMIT",
 ];
 /**
  * COPY ... TO ... WITH ( ... ) option keywords. Mirrors upstream's
  * `Copy_to_options` macro = `Copy_common_options` + `FORCE_QUOTE`.
  */
 export const COPY_TO_OPTIONS = [
-    'DELIMITER',
-    'ENCODING',
-    'ESCAPE',
-    'FORMAT',
-    'HEADER',
-    'NULL',
-    'QUOTE',
-    'FORCE_QUOTE',
+    "DELIMITER",
+    "ENCODING",
+    "ESCAPE",
+    "FORMAT",
+    "HEADER",
+    "NULL",
+    "QUOTE",
+    "FORCE_QUOTE",
 ];
 /**
  * Apply a case-insensitive prefix filter. Empty `prefix` returns the whole
@@ -848,14 +848,14 @@ const applyCase = (candidate, typed, settings) => {
     //   - preserve-lower → lowercase.
     // The same rule applies when the first char is a non-letter (digit, `_`,
     // punctuation) — those preserve the mode's default direction.
-    const first = typed[0] ?? '';
+    const first = typed[0] ?? "";
     const firstIsLower = /[a-z]/.test(first);
     const firstIsAlpha = /[A-Za-z]/.test(first);
-    const lowerCaseIt = mode === 'lower' ||
-        ((mode === 'preserve-lower' || mode === 'preserve-upper') &&
+    const lowerCaseIt = mode === "lower" ||
+        ((mode === "preserve-lower" || mode === "preserve-upper") &&
             firstIsLower) ||
-        (mode === 'preserve-lower' && !firstIsAlpha);
-    if (mode === 'upper')
+        (mode === "preserve-lower" && !firstIsAlpha);
+    if (mode === "upper")
         return candidate.toUpperCase();
     return lowerCaseIt ? candidate.toLowerCase() : candidate.toUpperCase();
 };
@@ -867,13 +867,13 @@ const containsNonKeywordChar = (s) => /[^A-Za-z0-9 ]/.test(s);
  * to fold its case in the rendered output.
  */
 const splitSchemaPrefix = (word) => {
-    const dot = word.indexOf('.');
+    const dot = word.indexOf(".");
     if (dot < 0)
         return null;
     // Reject if anything after the dot looks like another dot (we only handle
     // schema.relation, not catalog.schema.relation).
     const after = word.slice(dot + 1);
-    if (after.includes('.'))
+    if (after.includes("."))
         return null;
     // Strip optional quoting on the schema.
     let schema = word.slice(0, dot);
@@ -914,7 +914,7 @@ const parseTableRef = (refTokens) => {
     // token on the dot when the relation half is quoted).
     if (refTokens.length === 2) {
         const first = refTokens[0];
-        if (!first.endsWith('.'))
+        if (!first.endsWith("."))
             return null;
         const s = stripQuote(first.slice(0, -1));
         const t = stripQuote(refTokens[1]);
@@ -937,7 +937,7 @@ const parseTableRef = (refTokens) => {
         if (ch === '"') {
             inQuote = !inQuote;
         }
-        else if (ch === '.' && !inQuote) {
+        else if (ch === "." && !inQuote) {
             dot = i;
             break;
         }
@@ -974,18 +974,18 @@ export const findCompletions = async (prevWords, currentWord, ctx) => {
     // takes priority over anything else. The interpolation forms are valid
     // both inside SQL and inside backslash-command args (`\echo :VERB`),
     // so this branch fires regardless of `prevWords`.
-    if (currentWord.startsWith(':') && !currentWord.startsWith('::')) {
+    if (currentWord.startsWith(":") && !currentWord.startsWith("::")) {
         const names = listVarNames(ctx.settings);
         const lc = (s) => s.toLowerCase();
         // `:{?NAME}` — test-form (psqlscan_test_variable upstream). The
         // candidate must close the `}` so the user's literal `:{?VERB`
         // expands to `:{?VERBOSITY}` in one Tab.
-        if (currentWord.startsWith(':{?')) {
+        if (currentWord.startsWith(":{?")) {
             const prefix = currentWord.slice(3);
             const lp = lc(prefix);
             const cands = names
                 .filter((n) => lc(n).startsWith(lp))
-                .map((n) => ':{?' + n + '}');
+                .map((n) => ":{?" + n + "}");
             return { candidates: cands };
         }
         // `:'NAME'` / `:"NAME"` — quoted-substitution forms (psqlscan emits
@@ -1010,18 +1010,20 @@ export const findCompletions = async (prevWords, currentWord, ctx) => {
         // Plain `:NAME` — bare substitution.
         const prefix = currentWord.slice(1);
         const lp = lc(prefix);
-        const filt = names.filter((n) => lc(n).startsWith(lp)).map((n) => ':' + n);
+        const filt = names
+            .filter((n) => lc(n).startsWith(lp))
+            .map((n) => ":" + n);
         return { candidates: filt };
     }
     // ----- Backslash-command name completion.
     // Trigger: the user is mid-token and the token starts with '\'.
-    if (currentWord.startsWith('\\') && prevWords.length === 0) {
+    if (currentWord.startsWith("\\") && prevWords.length === 0) {
         return {
             candidates: BACKSLASH_COMMANDS.filter((c) => c.toLowerCase().startsWith(currentWord.toLowerCase())),
         };
     }
     // ----- Backslash-command argument completion.
-    if (prevWords.length > 0 && prevWords[0].startsWith('\\')) {
+    if (prevWords.length > 0 && prevWords[0].startsWith("\\")) {
         return await backslashArgRules(prevWords, currentWord, ctx, conn);
     }
     // ----- Multi-line SQL: rules that need to see across the line boundary
@@ -1096,12 +1098,12 @@ const multiLineSqlRules = async (combined, prevWords, currentWord, ctx, conn) =>
     // Our scanner splits `(` and `,` as their own tokens (the C tokenizer
     // keeps `(verbose` as one word), so `ends_with(prev_wd, '(')` becomes
     // "previous token IS `(`" and similarly for `,`.
-    if (HeadMatches(combined, ['ANALYZE']) &&
+    if (HeadMatches(combined, ["ANALYZE"]) &&
         isInsideOpenParen(combined.slice(1))) {
         const lastTok = combined[combined.length - 1];
-        if (lastTok === '(' || lastTok === ',') {
+        if (lastTok === "(" || lastTok === ",") {
             return {
-                candidates: filterAndCase(['VERBOSE', 'SKIP_LOCKED', 'BUFFER_USAGE_LIMIT'], currentWord, ctx.settings),
+                candidates: filterAndCase(["VERBOSE", "SKIP_LOCKED", "BUFFER_USAGE_LIMIT"], currentWord, ctx.settings),
             };
         }
         // Inside the option list with a partial option name in the current
@@ -1109,13 +1111,13 @@ const multiLineSqlRules = async (combined, prevWords, currentWord, ctx, conn) =>
         if (currentWord.length > 0 &&
             (lastTok === undefined || /^[A-Za-z_]+$/.test(currentWord))) {
             return {
-                candidates: filterAndCase(['VERBOSE', 'SKIP_LOCKED', 'BUFFER_USAGE_LIMIT'], currentWord, ctx.settings),
+                candidates: filterAndCase(["VERBOSE", "SKIP_LOCKED", "BUFFER_USAGE_LIMIT"], currentWord, ctx.settings),
             };
         }
         // `VERBOSE` / `SKIP_LOCKED` boolean continuation — ON / OFF.
-        if (TailMatches(combined, ['VERBOSE|SKIP_LOCKED'])) {
+        if (TailMatches(combined, ["VERBOSE|SKIP_LOCKED"])) {
             return {
-                candidates: filterAndCase(['ON', 'OFF'], currentWord, ctx.settings),
+                candidates: filterAndCase(["ON", "OFF"], currentWord, ctx.settings),
             };
         }
     }
@@ -1128,7 +1130,7 @@ const multiLineSqlRules = async (combined, prevWords, currentWord, ctx, conn) =>
     // We allow the rule to fire even when the line-local `prevWords` only
     // sees the trailing `ON` — the COMBINED tokens carry the
     // `COMMENT ON CONSTRAINT <name>` prefix from the previous line.
-    if (TailMatches(combined, ['COMMENT', 'ON', 'CONSTRAINT', MatchAny, 'ON'])) {
+    if (TailMatches(combined, ["COMMENT", "ON", "CONSTRAINT", MatchAny, "ON"])) {
         if (!conn)
             return { candidates: [] };
         // `combined` ends in `ON`. The constraint name is the token just
@@ -1146,7 +1148,7 @@ const multiLineSqlRules = async (combined, prevWords, currentWord, ctx, conn) =>
                 ? split.schema
                 : split.schema.toLowerCase();
             return {
-                candidates: rows.map((r) => canonicalSchema + '.' + r),
+                candidates: rows.map((r) => canonicalSchema + "." + r),
             };
         }
         // Unqualified: list tables that have the constraint, plus the schemas
@@ -1155,7 +1157,7 @@ const multiLineSqlRules = async (combined, prevWords, currentWord, ctx, conn) =>
             runCatalogQuery(conn, Query_for_list_of_tables_for_constraint, currentWord, [constraintName]),
             runCatalogQuery(conn, Query_for_list_of_schemas, currentWord),
         ]);
-        return { candidates: [...tables, ...schemas.map((s) => s + '.')] };
+        return { candidates: [...tables, ...schemas.map((s) => s + ".")] };
     }
     void conn;
     return null;
@@ -1171,11 +1173,11 @@ const isInsideOpenParen = (tokens) => {
     let depth = 0;
     let sawOpen = false;
     for (const t of tokens) {
-        if (t === '(') {
+        if (t === "(") {
             depth++;
             sawOpen = true;
         }
-        else if (t === ')') {
+        else if (t === ")") {
             depth--;
         }
     }
@@ -1184,7 +1186,7 @@ const isInsideOpenParen = (tokens) => {
 /** Strip surrounding `"..."` quoting from a constraint/identifier token. */
 const stripIdentifierQuote = (raw) => {
     if (raw === undefined)
-        return '';
+        return "";
     if (raw.length >= 2 && raw.startsWith('"') && raw.endsWith('"')) {
         return raw.slice(1, -1).replace(/""/g, '"');
     }
@@ -1196,7 +1198,7 @@ const stripIdentifierQuote = (raw) => {
 const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
     const cmd = prevWords[0]; // e.g. '\dt'
     // \c [DBNAME], \connect [DBNAME]: complete database names.
-    if (cmd === '\\c' || cmd === '\\connect') {
+    if (cmd === "\\c" || cmd === "\\connect") {
         if (prevWords.length === 1 && conn) {
             const rows = await runCatalogQuery(conn, Query_for_list_of_databases, currentWord);
             return { candidates: rows };
@@ -1204,7 +1206,7 @@ const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
         return { candidates: [] };
     }
     // \dn[+] [schema]
-    if (cmd === '\\dn' || cmd === '\\dn+') {
+    if (cmd === "\\dn" || cmd === "\\dn+") {
         if (prevWords.length === 1 && conn) {
             const rows = await runCatalogQuery(conn, Query_for_list_of_schemas, currentWord);
             return { candidates: rows };
@@ -1212,16 +1214,16 @@ const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
         return { candidates: [] };
     }
     // \df, \dfa, \dfn, \dfp, \dft, \dfw, \ef, \sf
-    if (cmd === '\\df' ||
-        cmd === '\\df+' ||
-        cmd === '\\dfa' ||
-        cmd === '\\dfn' ||
-        cmd === '\\dfp' ||
-        cmd === '\\dft' ||
-        cmd === '\\dfw' ||
-        cmd === '\\ef' ||
-        cmd === '\\sf' ||
-        cmd === '\\sf+') {
+    if (cmd === "\\df" ||
+        cmd === "\\df+" ||
+        cmd === "\\dfa" ||
+        cmd === "\\dfn" ||
+        cmd === "\\dfp" ||
+        cmd === "\\dft" ||
+        cmd === "\\dfw" ||
+        cmd === "\\ef" ||
+        cmd === "\\sf" ||
+        cmd === "\\sf+") {
         if (prevWords.length === 1 && conn) {
             const rows = await runCatalogQuery(conn, Query_for_list_of_functions, currentWord);
             return { candidates: rows };
@@ -1229,7 +1231,10 @@ const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
         return { candidates: [] };
     }
     // \du, \dg → roles.
-    if (cmd === '\\du' || cmd === '\\dg' || cmd === '\\du+' || cmd === '\\dg+') {
+    if (cmd === "\\du" ||
+        cmd === "\\dg" ||
+        cmd === "\\du+" ||
+        cmd === "\\dg+") {
         if (prevWords.length === 1 && conn) {
             const rows = await runCatalogQuery(conn, Query_for_list_of_roles, currentWord);
             return { candidates: rows };
@@ -1237,7 +1242,7 @@ const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
         return { candidates: [] };
     }
     // \dx → extensions.
-    if (cmd === '\\dx' || cmd === '\\dx+') {
+    if (cmd === "\\dx" || cmd === "\\dx+") {
         if (prevWords.length === 1 && conn) {
             const rows = await runCatalogQuery(conn, Query_for_list_of_extensions, currentWord);
             return { candidates: rows };
@@ -1245,7 +1250,7 @@ const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
         return { candidates: [] };
     }
     // \dL → languages.
-    if (cmd === '\\dL' || cmd === '\\dL+') {
+    if (cmd === "\\dL" || cmd === "\\dL+") {
         if (prevWords.length === 1 && conn) {
             const rows = await runCatalogQuery(conn, Query_for_list_of_languages, currentWord);
             return { candidates: rows };
@@ -1253,7 +1258,7 @@ const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
         return { candidates: [] };
     }
     // \dT → types.
-    if (cmd === '\\dT' || cmd === '\\dT+') {
+    if (cmd === "\\dT" || cmd === "\\dT+") {
         if (prevWords.length === 1 && conn) {
             const rows = await runCatalogQuery(conn, Query_for_list_of_types, currentWord);
             return { candidates: rows };
@@ -1261,10 +1266,10 @@ const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
         return { candidates: [] };
     }
     // \do → operators.
-    if (cmd === '\\do' ||
-        cmd === '\\do+' ||
-        cmd === '\\doS' ||
-        cmd === '\\doS+') {
+    if (cmd === "\\do" ||
+        cmd === "\\do+" ||
+        cmd === "\\doS" ||
+        cmd === "\\doS+") {
         if (prevWords.length === 1 && conn) {
             const rows = await runCatalogQuery(conn, Query_for_list_of_operators, currentWord);
             return { candidates: rows };
@@ -1272,7 +1277,7 @@ const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
         return { candidates: [] };
     }
     // \dC → casts (free-form pattern of "src AS tgt").
-    if (cmd === '\\dC' || cmd === '\\dC+') {
+    if (cmd === "\\dC" || cmd === "\\dC+") {
         if (prevWords.length === 1 && conn) {
             const rows = await runCatalogQuery(conn, Query_for_list_of_casts, currentWord);
             return { candidates: rows };
@@ -1280,13 +1285,13 @@ const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
         return { candidates: [] };
     }
     // \dt / \dtv / \d / \dv / \dm / \di / \ds → relations of various kinds.
-    if (cmd === '\\dt' ||
-        cmd === '\\dt+' ||
-        cmd === '\\dtv' ||
-        cmd === '\\d' ||
-        cmd === '\\d+' ||
-        cmd === '\\dE' ||
-        cmd === '\\dE+') {
+    if (cmd === "\\dt" ||
+        cmd === "\\dt+" ||
+        cmd === "\\dtv" ||
+        cmd === "\\d" ||
+        cmd === "\\d+" ||
+        cmd === "\\dE" ||
+        cmd === "\\dE+") {
         if (prevWords.length === 1 && conn) {
             return {
                 candidates: await completeSchemaOrRelations(conn, currentWord, Query_for_list_of_tables),
@@ -1294,7 +1299,7 @@ const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
         }
         return { candidates: [] };
     }
-    if (cmd === '\\dv' || cmd === '\\dv+') {
+    if (cmd === "\\dv" || cmd === "\\dv+") {
         if (prevWords.length === 1 && conn) {
             return {
                 candidates: await completeSchemaOrRelations(conn, currentWord, Query_for_list_of_views),
@@ -1302,7 +1307,7 @@ const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
         }
         return { candidates: [] };
     }
-    if (cmd === '\\dm' || cmd === '\\dm+') {
+    if (cmd === "\\dm" || cmd === "\\dm+") {
         if (prevWords.length === 1 && conn) {
             return {
                 candidates: await completeSchemaOrRelations(conn, currentWord, Query_for_list_of_matviews),
@@ -1310,7 +1315,7 @@ const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
         }
         return { candidates: [] };
     }
-    if (cmd === '\\di' || cmd === '\\di+') {
+    if (cmd === "\\di" || cmd === "\\di+") {
         if (prevWords.length === 1 && conn) {
             return {
                 candidates: await completeSchemaOrRelations(conn, currentWord, Query_for_list_of_indexes),
@@ -1318,7 +1323,7 @@ const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
         }
         return { candidates: [] };
     }
-    if (cmd === '\\ds' || cmd === '\\ds+') {
+    if (cmd === "\\ds" || cmd === "\\ds+") {
         if (prevWords.length === 1 && conn) {
             return {
                 candidates: await completeSchemaOrRelations(conn, currentWord, Query_for_list_of_sequences),
@@ -1327,10 +1332,10 @@ const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
         return { candidates: [] };
     }
     // \l[+] / \list → databases.
-    if (cmd === '\\l' ||
-        cmd === '\\l+' ||
-        cmd === '\\list' ||
-        cmd === '\\list+') {
+    if (cmd === "\\l" ||
+        cmd === "\\l+" ||
+        cmd === "\\list" ||
+        cmd === "\\list+") {
         if (prevWords.length === 1 && conn) {
             const rows = await runCatalogQuery(conn, Query_for_list_of_databases, currentWord);
             return { candidates: rows };
@@ -1338,14 +1343,14 @@ const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
         return { candidates: [] };
     }
     // \encoding NAME
-    if (cmd === '\\encoding') {
+    if (cmd === "\\encoding") {
         if (prevWords.length === 1) {
             return { candidates: filterCi(ENCODINGS, currentWord) };
         }
         return { candidates: [] };
     }
     // \pset OPT [value]
-    if (cmd === '\\pset') {
+    if (cmd === "\\pset") {
         if (prevWords.length === 1) {
             return { candidates: filterCi(PSET_OPTIONS, currentWord) };
         }
@@ -1358,7 +1363,7 @@ const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
         return { candidates: [] };
     }
     // \set NAME [VALUE]
-    if (cmd === '\\set') {
+    if (cmd === "\\set") {
         if (prevWords.length === 1) {
             return {
                 candidates: filterCi(listAllVarNames(ctx.settings), currentWord),
@@ -1373,15 +1378,17 @@ const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
         return { candidates: [] };
     }
     // \unset NAME — only existing variables.
-    if (cmd === '\\unset') {
+    if (cmd === "\\unset") {
         if (prevWords.length === 1) {
-            return { candidates: filterCi(listVarNames(ctx.settings), currentWord) };
+            return {
+                candidates: filterCi(listVarNames(ctx.settings), currentWord),
+            };
         }
         return { candidates: [] };
     }
     // \echo / \warn / \qecho — variable expansion only (handled above).
     // \prompt — variable name argument is the 1st positional.
-    if (cmd === '\\prompt') {
+    if (cmd === "\\prompt") {
         if (prevWords.length === 2) {
             return {
                 candidates: filterCi(listAllVarNames(ctx.settings), currentWord),
@@ -1392,16 +1399,16 @@ const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
     // \lo_import / \lo_export → filesystem-driven filename completion.
     // psql parses the path as a backslash-argument literal — no SQL string
     // quoting required, so we use the unquoted candidate form.
-    if (cmd === '\\lo_import' || cmd === '\\lo_export') {
+    if (cmd === "\\lo_import" || cmd === "\\lo_export") {
         if (prevWords.length === 1) {
-            return { candidates: completeFilenames(currentWord, 'none') };
+            return { candidates: completeFilenames(currentWord, "none") };
         }
         return { candidates: [] };
     }
     // \copy <table> [FROM|TO] <path> — once the FROM/TO keyword has been
     // typed, the next token is a filename (backslash-context, so bare paths
     // are fine).
-    if (cmd === '\\copy') {
+    if (cmd === "\\copy") {
         // First arg: a table name.
         if (prevWords.length === 1 && conn) {
             return {
@@ -1411,20 +1418,20 @@ const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
         // Second arg: the FROM/TO keyword.
         if (prevWords.length === 2) {
             return {
-                candidates: filterAndCase(['FROM', 'TO'], currentWord, ctx.settings),
+                candidates: filterAndCase(["FROM", "TO"], currentWord, ctx.settings),
             };
         }
         // Third arg (after FROM/TO): the filename.
         if (prevWords.length >= 3) {
             const last = prevWords[prevWords.length - 1].toUpperCase();
-            if (last === 'FROM' || last === 'TO') {
-                return { candidates: completeFilenames(currentWord, 'none') };
+            if (last === "FROM" || last === "TO") {
+                return { candidates: completeFilenames(currentWord, "none") };
             }
         }
         return { candidates: [] };
     }
     // \drds, \drg → roles (for the first arg).
-    if (cmd === '\\drds' || cmd === '\\drg') {
+    if (cmd === "\\drds" || cmd === "\\drg") {
         if (prevWords.length === 1 && conn) {
             const rows = await runCatalogQuery(conn, Query_for_list_of_roles, currentWord);
             return { candidates: rows };
@@ -1451,34 +1458,35 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
     // string-literal context. MUST come before the generic `FROM <prefix>`
     // rule below, which would otherwise treat the path as a table name.
     if (isCopyFromOrTo(prevWords)) {
-        return { candidates: completeFilenames(currentWord, 'sql') };
+        return { candidates: completeFilenames(currentWord, "sql") };
     }
     // FROM <prefix>: tables/views/matviews. EXCLUDE `REVOKE … FROM <role>`,
     // which must complete role names — otherwise this generic rule shadows the
     // REVOKE-roles arm below, making it dead code (review item #26).
-    if (TailMatches(prevWords, ['FROM']) && !HeadMatches(prevWords, ['REVOKE'])) {
+    if (TailMatches(prevWords, ["FROM"]) &&
+        !HeadMatches(prevWords, ["REVOKE"])) {
         return completeTables(Query_for_list_of_tables_views);
     }
     // After FROM x, suggest JOIN/WHERE/etc — handled below.
     // UPDATE <prefix>: tables.
-    if (TailMatches(prevWords, ['UPDATE']))
+    if (TailMatches(prevWords, ["UPDATE"]))
         return completeTables();
     // DELETE FROM <prefix>: tables.
-    if (TailMatches(prevWords, ['DELETE', 'FROM']))
+    if (TailMatches(prevWords, ["DELETE", "FROM"]))
         return completeTables();
     // INSERT INTO <prefix>: tables. The tokenizer might give us
     // ['INSERT'] [INTO] or ['INSERT', 'INTO'] depending on whether the user
     // typed an extra space.
-    if (TailMatches(prevWords, ['INTO']))
+    if (TailMatches(prevWords, ["INTO"]))
         return completeTables();
     // JOIN <prefix>: tables. Most common: SELECT … FROM x JOIN <prefix>.
-    if (TailMatches(prevWords, ['JOIN'])) {
+    if (TailMatches(prevWords, ["JOIN"])) {
         return completeTables(Query_for_list_of_tables_views);
     }
     // After JOIN x, suggest ON or USING.
-    if (TailMatches(prevWords, ['JOIN', MatchAny])) {
+    if (TailMatches(prevWords, ["JOIN", MatchAny])) {
         return {
-            candidates: filterAndCase(['ON', 'USING'], currentWord, ctx.settings),
+            candidates: filterAndCase(["ON", "USING"], currentWord, ctx.settings),
         };
     }
     // After `FROM table_name <TAB>` (or `FROM table AS alias <TAB>`) — offer
@@ -1486,15 +1494,15 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
     // SELECT/INSERT/UPDATE/DELETE (i.e. a SELECT-list-friendly context), so
     // we don't trample more specific rules like `ALTER TABLE x` or
     // `INSERT INTO x` which look "FROM-like" structurally.
-    const inSelectContext = HeadMatches(prevWords, ['SELECT']) ||
-        HeadMatches(prevWords, ['INSERT']) ||
-        HeadMatches(prevWords, ['UPDATE']) ||
-        HeadMatches(prevWords, ['DELETE']) ||
-        HeadMatches(prevWords, ['WITH']) ||
-        HeadMatches(prevWords, ['EXPLAIN']);
+    const inSelectContext = HeadMatches(prevWords, ["SELECT"]) ||
+        HeadMatches(prevWords, ["INSERT"]) ||
+        HeadMatches(prevWords, ["UPDATE"]) ||
+        HeadMatches(prevWords, ["DELETE"]) ||
+        HeadMatches(prevWords, ["WITH"]) ||
+        HeadMatches(prevWords, ["EXPLAIN"]);
     if (inSelectContext &&
-        (TailMatches(prevWords, ['FROM', MatchAny]) ||
-            TailMatches(prevWords, ['FROM', MatchAny, MatchAny]))) {
+        (TailMatches(prevWords, ["FROM", MatchAny]) ||
+            TailMatches(prevWords, ["FROM", MatchAny, MatchAny]))) {
         // `FROM x` or `FROM x alias` → post-FROM continuations.
         return {
             candidates: filterAndCase(POST_FROM_KEYWORDS, currentWord, ctx.settings),
@@ -1502,7 +1510,7 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
     }
     // Window-function frame clause: `OVER (` then `<TAB>`. The tokenizer
     // emits the `(` as its own token, so prevWords ends with '('.
-    if (TailMatches(prevWords, ['OVER', '('])) {
+    if (TailMatches(prevWords, ["OVER", "("])) {
         return {
             candidates: filterAndCase(WINDOW_FRAME_KEYWORDS, currentWord, ctx.settings),
         };
@@ -1512,8 +1520,8 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
     // suggest boolean continuations. We trigger on the simple case
     // `WHERE <ident>` and `WHERE … AND/OR <ident>`.
     if (inSelectContext &&
-        TailMatches(prevWords, ['WHERE', MatchAny]) &&
-        !TailMatches(prevWords, ['WHERE'])) {
+        TailMatches(prevWords, ["WHERE", MatchAny]) &&
+        !TailMatches(prevWords, ["WHERE"])) {
         return {
             candidates: filterAndCase(WHERE_CONTINUATIONS, currentWord, ctx.settings),
         };
@@ -1523,14 +1531,14 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
     // 3-token fallback `ALTER TABLE x` (which lists generic sub-actions).
     // The deeper rules use HeadMatches so they survive an arbitrary trailing
     // option list like `ALTER TABLE foo ADD CONSTRAINT bar CHECK (...)`.
-    if (HeadMatches(prevWords, ['ALTER', 'TABLE']) &&
-        TailMatches(prevWords, ['ADD'])) {
+    if (HeadMatches(prevWords, ["ALTER", "TABLE"]) &&
+        TailMatches(prevWords, ["ADD"])) {
         return {
             candidates: filterAndCase(ALTER_TABLE_ADD, currentWord, ctx.settings),
         };
     }
-    if (HeadMatches(prevWords, ['ALTER', 'TABLE']) &&
-        TailMatches(prevWords, ['DROP'])) {
+    if (HeadMatches(prevWords, ["ALTER", "TABLE"]) &&
+        TailMatches(prevWords, ["DROP"])) {
         return {
             candidates: filterAndCase(ALTER_TABLE_DROP, currentWord, ctx.settings),
         };
@@ -1538,8 +1546,8 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
     // `ALTER TABLE <ref> DROP CONSTRAINT <prefix>` — constraint names on
     // the referenced table. Mirrors upstream tab-complete.in.c ~line 1280
     // (`COMPLETE_WITH_QUERY(Query_for_constraint_of_table)`).
-    if (HeadMatches(prevWords, ['ALTER', 'TABLE']) &&
-        TailMatches(prevWords, ['DROP', 'CONSTRAINT'])) {
+    if (HeadMatches(prevWords, ["ALTER", "TABLE"]) &&
+        TailMatches(prevWords, ["DROP", "CONSTRAINT"])) {
         if (!conn)
             return { candidates: [] };
         const refTokens = prevWords.slice(2, prevWords.length - 2);
@@ -1551,94 +1559,98 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
             : await runCatalogQuery(conn, Query_for_constraint_of_table_in_schema, currentWord, [ref.schema, ref.table]);
         return { candidates: cands };
     }
-    if (HeadMatches(prevWords, ['ALTER', 'TABLE']) &&
-        TailMatches(prevWords, ['RENAME'])) {
+    if (HeadMatches(prevWords, ["ALTER", "TABLE"]) &&
+        TailMatches(prevWords, ["RENAME"])) {
         return {
             candidates: filterAndCase(ALTER_TABLE_RENAME, currentWord, ctx.settings),
         };
     }
-    if (HeadMatches(prevWords, ['ALTER', 'TABLE']) &&
-        (TailMatches(prevWords, ['ALTER']) ||
-            TailMatches(prevWords, ['ALTER', 'COLUMN', MatchAny]))) {
+    if (HeadMatches(prevWords, ["ALTER", "TABLE"]) &&
+        (TailMatches(prevWords, ["ALTER"]) ||
+            TailMatches(prevWords, ["ALTER", "COLUMN", MatchAny]))) {
         return {
             candidates: filterAndCase(ALTER_TABLE_ALTER_COLUMN, currentWord, ctx.settings),
         };
     }
-    if (HeadMatches(prevWords, ['ALTER', 'TABLE']) &&
-        TailMatches(prevWords, ['SET'])) {
+    if (HeadMatches(prevWords, ["ALTER", "TABLE"]) &&
+        TailMatches(prevWords, ["SET"])) {
         return {
             candidates: filterAndCase(ALTER_TABLE_SET, currentWord, ctx.settings),
         };
     }
-    if (HeadMatches(prevWords, ['ALTER', 'TABLE']) &&
-        TailMatches(prevWords, ['ENABLE'])) {
+    if (HeadMatches(prevWords, ["ALTER", "TABLE"]) &&
+        TailMatches(prevWords, ["ENABLE"])) {
         return {
             candidates: filterAndCase(ALTER_TABLE_ENABLE, currentWord, ctx.settings),
         };
     }
-    if (HeadMatches(prevWords, ['ALTER', 'TABLE']) &&
-        TailMatches(prevWords, ['DISABLE'])) {
+    if (HeadMatches(prevWords, ["ALTER", "TABLE"]) &&
+        TailMatches(prevWords, ["DISABLE"])) {
         return {
             candidates: filterAndCase(ALTER_TABLE_DISABLE, currentWord, ctx.settings),
         };
     }
-    if (HeadMatches(prevWords, ['ALTER', 'TABLE']) &&
-        TailMatches(prevWords, ['REPLICA', 'IDENTITY'])) {
+    if (HeadMatches(prevWords, ["ALTER", "TABLE"]) &&
+        TailMatches(prevWords, ["REPLICA", "IDENTITY"])) {
         return {
             candidates: filterAndCase(ALTER_TABLE_REPLICA_IDENTITY, currentWord, ctx.settings),
         };
     }
     // ALTER TABLE x — sub-actions (must come AFTER the deep continuations above).
-    if (TailMatches(prevWords, ['ALTER', 'TABLE', MatchAny])) {
+    if (TailMatches(prevWords, ["ALTER", "TABLE", MatchAny])) {
         return {
             candidates: filterAndCase(ALTER_TABLE_ACTIONS, currentWord, ctx.settings),
         };
     }
     // ALTER TABLE — table name.
-    if (TailMatches(prevWords, ['ALTER', 'TABLE']))
+    if (TailMatches(prevWords, ["ALTER", "TABLE"]))
         return completeTables();
     // ---- ALTER VIEW / MATERIALIZED VIEW ----
-    if (TailMatches(prevWords, ['ALTER', 'VIEW', MatchAny])) {
+    if (TailMatches(prevWords, ["ALTER", "VIEW", MatchAny])) {
         return {
             candidates: filterAndCase(ALTER_VIEW_ACTIONS, currentWord, ctx.settings),
         };
     }
-    if (TailMatches(prevWords, ['ALTER', 'VIEW'])) {
+    if (TailMatches(prevWords, ["ALTER", "VIEW"])) {
         return completeTables(Query_for_list_of_views);
     }
-    if (TailMatches(prevWords, ['ALTER', 'MATERIALIZED', 'VIEW', MatchAny])) {
+    if (TailMatches(prevWords, ["ALTER", "MATERIALIZED", "VIEW", MatchAny])) {
         return {
             candidates: filterAndCase(ALTER_MATVIEW_ACTIONS, currentWord, ctx.settings),
         };
     }
-    if (TailMatches(prevWords, ['ALTER', 'MATERIALIZED', 'VIEW'])) {
+    if (TailMatches(prevWords, ["ALTER", "MATERIALIZED", "VIEW"])) {
         return completeTables(Query_for_list_of_matviews);
     }
     // ---- ALTER INDEX ----
-    if (TailMatches(prevWords, ['ALTER', 'INDEX', MatchAny])) {
+    if (TailMatches(prevWords, ["ALTER", "INDEX", MatchAny])) {
         return {
             candidates: filterAndCase(ALTER_INDEX_ACTIONS, currentWord, ctx.settings),
         };
     }
-    if (TailMatches(prevWords, ['ALTER', 'INDEX'])) {
+    if (TailMatches(prevWords, ["ALTER", "INDEX"])) {
         return completeTables(Query_for_list_of_indexes);
     }
     // ---- ALTER SEQUENCE ----
-    if (TailMatches(prevWords, ['ALTER', 'SEQUENCE', MatchAny])) {
+    if (TailMatches(prevWords, ["ALTER", "SEQUENCE", MatchAny])) {
         return {
             candidates: filterAndCase(ALTER_SEQUENCE_ACTIONS, currentWord, ctx.settings),
         };
     }
-    if (TailMatches(prevWords, ['ALTER', 'SEQUENCE'])) {
+    if (TailMatches(prevWords, ["ALTER", "SEQUENCE"])) {
         return completeTables(Query_for_list_of_sequences);
     }
     // ---- ALTER FUNCTION / PROCEDURE / ROUTINE ----
-    if (TailMatches(prevWords, ['ALTER', 'FUNCTION|PROCEDURE|ROUTINE', MatchAny])) {
+    if (TailMatches(prevWords, [
+        "ALTER",
+        "FUNCTION|PROCEDURE|ROUTINE",
+        MatchAny,
+    ])) {
         return {
             candidates: filterAndCase(ALTER_FUNCTION_ACTIONS, currentWord, ctx.settings),
         };
     }
-    if (TailMatches(prevWords, ['ALTER', 'FUNCTION|PROCEDURE|ROUTINE'])) {
+    if (TailMatches(prevWords, ["ALTER", "FUNCTION|PROCEDURE|ROUTINE"])) {
         if (!conn)
             return { candidates: [] };
         return {
@@ -1649,7 +1661,13 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
     // `ALTER TYPE <enum> RENAME VALUE 'X<TAB>` — enum labels of the named
     // type, wrapped in single quotes since the user is mid-string-literal.
     // Mirrors upstream tab-complete.in.c ~line 1480.
-    if (TailMatches(prevWords, ['ALTER', 'TYPE', MatchAny, 'RENAME', 'VALUE']) &&
+    if (TailMatches(prevWords, [
+        "ALTER",
+        "TYPE",
+        MatchAny,
+        "RENAME",
+        "VALUE",
+    ]) &&
         currentWord.startsWith("'")) {
         if (!conn)
             return { candidates: [] };
@@ -1660,12 +1678,12 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
         const cands = await runCatalogQuery(conn, Query_for_list_of_enum_values_quoted, labelPrefix, [typeName]);
         return { candidates: cands };
     }
-    if (TailMatches(prevWords, ['ALTER', 'TYPE', MatchAny])) {
+    if (TailMatches(prevWords, ["ALTER", "TYPE", MatchAny])) {
         return {
             candidates: filterAndCase(ALTER_TYPE_ACTIONS, currentWord, ctx.settings),
         };
     }
-    if (TailMatches(prevWords, ['ALTER', 'TYPE'])) {
+    if (TailMatches(prevWords, ["ALTER", "TYPE"])) {
         if (!conn)
             return { candidates: [] };
         return {
@@ -1673,12 +1691,12 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
         };
     }
     // ---- ALTER ROLE / USER / GROUP ----
-    if (TailMatches(prevWords, ['ALTER', 'ROLE|USER|GROUP', MatchAny])) {
+    if (TailMatches(prevWords, ["ALTER", "ROLE|USER|GROUP", MatchAny])) {
         return {
             candidates: filterAndCase(ALTER_ROLE_ACTIONS, currentWord, ctx.settings),
         };
     }
-    if (TailMatches(prevWords, ['ALTER', 'ROLE|USER|GROUP'])) {
+    if (TailMatches(prevWords, ["ALTER", "ROLE|USER|GROUP"])) {
         if (!conn)
             return { candidates: [] };
         return {
@@ -1686,12 +1704,12 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
         };
     }
     // ---- ALTER DATABASE ----
-    if (TailMatches(prevWords, ['ALTER', 'DATABASE', MatchAny])) {
+    if (TailMatches(prevWords, ["ALTER", "DATABASE", MatchAny])) {
         return {
             candidates: filterAndCase(ALTER_DATABASE_ACTIONS, currentWord, ctx.settings),
         };
     }
-    if (TailMatches(prevWords, ['ALTER', 'DATABASE'])) {
+    if (TailMatches(prevWords, ["ALTER", "DATABASE"])) {
         if (!conn)
             return { candidates: [] };
         return {
@@ -1699,12 +1717,12 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
         };
     }
     // ---- ALTER SCHEMA ----
-    if (TailMatches(prevWords, ['ALTER', 'SCHEMA', MatchAny])) {
+    if (TailMatches(prevWords, ["ALTER", "SCHEMA", MatchAny])) {
         return {
             candidates: filterAndCase(ALTER_SCHEMA_ACTIONS, currentWord, ctx.settings),
         };
     }
-    if (TailMatches(prevWords, ['ALTER', 'SCHEMA'])) {
+    if (TailMatches(prevWords, ["ALTER", "SCHEMA"])) {
         if (!conn)
             return { candidates: [] };
         return {
@@ -1712,12 +1730,12 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
         };
     }
     // ---- ALTER EXTENSION ----
-    if (TailMatches(prevWords, ['ALTER', 'EXTENSION', MatchAny])) {
+    if (TailMatches(prevWords, ["ALTER", "EXTENSION", MatchAny])) {
         return {
             candidates: filterAndCase(ALTER_EXTENSION_ACTIONS, currentWord, ctx.settings),
         };
     }
-    if (TailMatches(prevWords, ['ALTER', 'EXTENSION'])) {
+    if (TailMatches(prevWords, ["ALTER", "EXTENSION"])) {
         if (!conn)
             return { candidates: [] };
         return {
@@ -1725,26 +1743,26 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
         };
     }
     // ---- ALTER POLICY <name> ON <table> ----
-    if (TailMatches(prevWords, ['ALTER', 'POLICY', MatchAny])) {
+    if (TailMatches(prevWords, ["ALTER", "POLICY", MatchAny])) {
         return {
             candidates: filterAndCase(ALTER_POLICY_ACTIONS, currentWord, ctx.settings),
         };
     }
-    if (HeadMatches(prevWords, ['ALTER', 'POLICY']) &&
-        TailMatches(prevWords, ['ON'])) {
+    if (HeadMatches(prevWords, ["ALTER", "POLICY"]) &&
+        TailMatches(prevWords, ["ON"])) {
         return completeTables();
     }
-    if (TailMatches(prevWords, ['ALTER', 'POLICY'])) {
+    if (TailMatches(prevWords, ["ALTER", "POLICY"])) {
         // Free-form policy name.
         return { candidates: [] };
     }
     // ---- ALTER PUBLICATION ----
-    if (TailMatches(prevWords, ['ALTER', 'PUBLICATION', MatchAny])) {
+    if (TailMatches(prevWords, ["ALTER", "PUBLICATION", MatchAny])) {
         return {
             candidates: filterAndCase(ALTER_PUBLICATION_ACTIONS, currentWord, ctx.settings),
         };
     }
-    if (TailMatches(prevWords, ['ALTER', 'PUBLICATION'])) {
+    if (TailMatches(prevWords, ["ALTER", "PUBLICATION"])) {
         if (!conn)
             return { candidates: [] };
         return {
@@ -1752,12 +1770,12 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
         };
     }
     // ---- ALTER SUBSCRIPTION ----
-    if (TailMatches(prevWords, ['ALTER', 'SUBSCRIPTION', MatchAny])) {
+    if (TailMatches(prevWords, ["ALTER", "SUBSCRIPTION", MatchAny])) {
         return {
             candidates: filterAndCase(ALTER_SUBSCRIPTION_ACTIONS, currentWord, ctx.settings),
         };
     }
-    if (TailMatches(prevWords, ['ALTER', 'SUBSCRIPTION'])) {
+    if (TailMatches(prevWords, ["ALTER", "SUBSCRIPTION"])) {
         if (!conn)
             return { candidates: [] };
         return {
@@ -1765,27 +1783,27 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
         };
     }
     // Bare ALTER — sub-object keywords.
-    if (TailMatches(prevWords, ['ALTER'])) {
+    if (TailMatches(prevWords, ["ALTER"])) {
         return {
             candidates: filterAndCase(ALTER_OBJECTS, currentWord, ctx.settings),
         };
     }
     // DROP TABLE, DROP VIEW, DROP INDEX, ...
-    if (TailMatches(prevWords, ['DROP', 'TABLE']))
+    if (TailMatches(prevWords, ["DROP", "TABLE"]))
         return completeTables();
-    if (TailMatches(prevWords, ['DROP', 'VIEW'])) {
+    if (TailMatches(prevWords, ["DROP", "VIEW"])) {
         return completeTables(Query_for_list_of_views);
     }
-    if (TailMatches(prevWords, ['DROP', 'MATERIALIZED', 'VIEW'])) {
+    if (TailMatches(prevWords, ["DROP", "MATERIALIZED", "VIEW"])) {
         return completeTables(Query_for_list_of_matviews);
     }
-    if (TailMatches(prevWords, ['DROP', 'INDEX'])) {
+    if (TailMatches(prevWords, ["DROP", "INDEX"])) {
         return completeTables(Query_for_list_of_indexes);
     }
-    if (TailMatches(prevWords, ['DROP', 'SEQUENCE'])) {
+    if (TailMatches(prevWords, ["DROP", "SEQUENCE"])) {
         return completeTables(Query_for_list_of_sequences);
     }
-    if (TailMatches(prevWords, ['DROP', 'TYPE'])) {
+    if (TailMatches(prevWords, ["DROP", "TYPE"])) {
         // Built-in scalar type keywords mirror upstream's
         // `Keywords_for_list_of_datatypes` attached to the SchemaQuery; psql
         // mixes them with user-defined types so `DROP TYPE big<TAB>` resolves
@@ -1796,56 +1814,56 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
         const types = await runCatalogQuery(conn, Query_for_list_of_types, currentWord);
         return { candidates: [...keywords, ...types] };
     }
-    if (TailMatches(prevWords, ['DROP', 'SCHEMA'])) {
+    if (TailMatches(prevWords, ["DROP", "SCHEMA"])) {
         if (!conn)
             return { candidates: [] };
         return {
             candidates: await runCatalogQuery(conn, Query_for_list_of_schemas, currentWord),
         };
     }
-    if (TailMatches(prevWords, ['DROP', 'EXTENSION'])) {
+    if (TailMatches(prevWords, ["DROP", "EXTENSION"])) {
         if (!conn)
             return { candidates: [] };
         return {
             candidates: await runCatalogQuery(conn, Query_for_list_of_extensions, currentWord),
         };
     }
-    if (TailMatches(prevWords, ['DROP', 'ROLE|USER|GROUP'])) {
+    if (TailMatches(prevWords, ["DROP", "ROLE|USER|GROUP"])) {
         if (!conn)
             return { candidates: [] };
         return {
             candidates: await runCatalogQuery(conn, Query_for_list_of_roles, currentWord),
         };
     }
-    if (TailMatches(prevWords, ['DROP', 'DATABASE'])) {
+    if (TailMatches(prevWords, ["DROP", "DATABASE"])) {
         if (!conn)
             return { candidates: [] };
         return {
             candidates: await runCatalogQuery(conn, Query_for_list_of_databases, currentWord),
         };
     }
-    if (TailMatches(prevWords, ['DROP', 'FUNCTION'])) {
+    if (TailMatches(prevWords, ["DROP", "FUNCTION"])) {
         if (!conn)
             return { candidates: [] };
         return {
             candidates: await runCatalogQuery(conn, Query_for_list_of_functions, currentWord),
         };
     }
-    if (TailMatches(prevWords, ['DROP', 'LANGUAGE'])) {
+    if (TailMatches(prevWords, ["DROP", "LANGUAGE"])) {
         if (!conn)
             return { candidates: [] };
         return {
             candidates: await runCatalogQuery(conn, Query_for_list_of_languages, currentWord),
         };
     }
-    if (TailMatches(prevWords, ['DROP', 'TABLESPACE'])) {
+    if (TailMatches(prevWords, ["DROP", "TABLESPACE"])) {
         if (!conn)
             return { candidates: [] };
         return {
             candidates: await runCatalogQuery(conn, Query_for_list_of_tablespaces, currentWord),
         };
     }
-    if (TailMatches(prevWords, ['DROP', 'PUBLICATION'])) {
+    if (TailMatches(prevWords, ["DROP", "PUBLICATION"])) {
         // Mirrors upstream's `words_after_create` PUBLICATION entry
         // (VersionedQuery on `Query_for_list_of_publications`). Two-step
         // completion: `DROP PUBLIC<TAB>` first resolves to `PUBLICATION`
@@ -1857,7 +1875,7 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
             candidates: await runCatalogQuery(conn, Query_for_list_of_publications, currentWord),
         };
     }
-    if (TailMatches(prevWords, ['DROP', 'SUBSCRIPTION'])) {
+    if (TailMatches(prevWords, ["DROP", "SUBSCRIPTION"])) {
         // Same shape as DROP PUBLICATION — paired here for parity with the
         // ALTER block above.
         if (!conn)
@@ -1867,7 +1885,7 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
         };
     }
     // Bare DROP — sub-object keywords.
-    if (TailMatches(prevWords, ['DROP'])) {
+    if (TailMatches(prevWords, ["DROP"])) {
         return {
             candidates: filterAndCase(DROP_OBJECTS, currentWord, ctx.settings),
         };
@@ -1875,44 +1893,44 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
     // ---- CREATE INDEX deep handling (specific arms BEFORE generic CREATE). ----
     // CREATE INDEX <TAB> → CONCURRENTLY, IF NOT EXISTS, ON (no name = use ON
     // directly), or a free-form index name.
-    if (TailMatches(prevWords, ['CREATE', 'INDEX'])) {
+    if (TailMatches(prevWords, ["CREATE", "INDEX"])) {
         return {
             candidates: filterAndCase(CREATE_INDEX_OPTIONS, currentWord, ctx.settings),
         };
     }
-    if (TailMatches(prevWords, ['CREATE', 'UNIQUE', 'INDEX'])) {
+    if (TailMatches(prevWords, ["CREATE", "UNIQUE", "INDEX"])) {
         return {
             candidates: filterAndCase(CREATE_INDEX_OPTIONS, currentWord, ctx.settings),
         };
     }
     // CREATE INDEX <name> <TAB> → ON.
-    if (TailMatches(prevWords, ['CREATE', 'INDEX', MatchAny]) ||
-        TailMatches(prevWords, ['CREATE', 'UNIQUE', 'INDEX', MatchAny])) {
-        return { candidates: filterAndCase(['ON'], currentWord, ctx.settings) };
+    if (TailMatches(prevWords, ["CREATE", "INDEX", MatchAny]) ||
+        TailMatches(prevWords, ["CREATE", "UNIQUE", "INDEX", MatchAny])) {
+        return { candidates: filterAndCase(["ON"], currentWord, ctx.settings) };
     }
     // CREATE INDEX ... ON <TAB> → tables.
-    if (TailMatches(prevWords, ['CREATE', 'INDEX', MatchAny, 'ON']) ||
-        TailMatches(prevWords, ['CREATE', 'INDEX', 'ON']) ||
-        TailMatches(prevWords, ['CREATE', 'UNIQUE', 'INDEX', MatchAny, 'ON']) ||
-        TailMatches(prevWords, ['CREATE', 'UNIQUE', 'INDEX', 'ON'])) {
+    if (TailMatches(prevWords, ["CREATE", "INDEX", MatchAny, "ON"]) ||
+        TailMatches(prevWords, ["CREATE", "INDEX", "ON"]) ||
+        TailMatches(prevWords, ["CREATE", "UNIQUE", "INDEX", MatchAny, "ON"]) ||
+        TailMatches(prevWords, ["CREATE", "UNIQUE", "INDEX", "ON"])) {
         return completeTables();
     }
     // CREATE INDEX ... ON <table> <TAB> → USING / (.
-    if ((HeadMatches(prevWords, ['CREATE', 'INDEX']) ||
-        HeadMatches(prevWords, ['CREATE', 'UNIQUE', 'INDEX'])) &&
-        TailMatches(prevWords, ['ON', MatchAny])) {
+    if ((HeadMatches(prevWords, ["CREATE", "INDEX"]) ||
+        HeadMatches(prevWords, ["CREATE", "UNIQUE", "INDEX"])) &&
+        TailMatches(prevWords, ["ON", MatchAny])) {
         return {
-            candidates: filterAndCase(['USING', '('], currentWord, ctx.settings),
+            candidates: filterAndCase(["USING", "("], currentWord, ctx.settings),
         };
     }
     // CREATE INDEX ... USING <TAB> → access methods.
-    if ((HeadMatches(prevWords, ['CREATE', 'INDEX']) ||
-        HeadMatches(prevWords, ['CREATE', 'UNIQUE', 'INDEX'])) &&
-        TailMatches(prevWords, ['USING'])) {
+    if ((HeadMatches(prevWords, ["CREATE", "INDEX"]) ||
+        HeadMatches(prevWords, ["CREATE", "UNIQUE", "INDEX"])) &&
+        TailMatches(prevWords, ["USING"])) {
         if (!conn) {
             // Even without a connection, offer the built-in AMs as a fallback.
             return {
-                candidates: filterAndCase(['btree', 'hash', 'gist', 'gin', 'spgist', 'brin'], currentWord, ctx.settings),
+                candidates: filterAndCase(["btree", "hash", "gist", "gin", "spgist", "brin"], currentWord, ctx.settings),
             };
         }
         return {
@@ -1920,12 +1938,12 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
         };
     }
     // CREATE ... — first sub-object keyword.
-    if (TailMatches(prevWords, ['CREATE'])) {
+    if (TailMatches(prevWords, ["CREATE"])) {
         return {
             candidates: filterAndCase(CREATE_OBJECTS, currentWord, ctx.settings),
         };
     }
-    if (TailMatches(prevWords, ['CREATE', 'TABLE'])) {
+    if (TailMatches(prevWords, ["CREATE", "TABLE"])) {
         // Upstream's `words_after_create` fallback (tab-complete.in.c
         // ~lines 2062-2082) runs `Query_for_list_of_tables` when the
         // word immediately before the cursor is `TABLE`. The intent is to
@@ -1937,31 +1955,38 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
         return completeTables();
     }
     // Inside CREATE TABLE column-list parens: `<col_name> <TAB>` → types.
-    if (HeadMatches(prevWords, ['CREATE', 'TABLE']) &&
-        TailMatches(prevWords, ['(|,', MatchAny])) {
+    if (HeadMatches(prevWords, ["CREATE", "TABLE"]) &&
+        TailMatches(prevWords, ["(|,", MatchAny])) {
         if (!conn)
             return { candidates: [] };
         return {
             candidates: await runCatalogQuery(conn, Query_for_list_of_datatypes, currentWord),
         };
     }
-    if (TailMatches(prevWords, ['CREATE', 'OR', 'REPLACE'])) {
+    if (TailMatches(prevWords, ["CREATE", "OR", "REPLACE"])) {
         return {
-            candidates: filterAndCase(['FUNCTION', 'PROCEDURE', 'VIEW', 'TRIGGER', 'AGGREGATE', 'TRANSFORM'], currentWord, ctx.settings),
+            candidates: filterAndCase([
+                "FUNCTION",
+                "PROCEDURE",
+                "VIEW",
+                "TRIGGER",
+                "AGGREGATE",
+                "TRANSFORM",
+            ], currentWord, ctx.settings),
         };
     }
     // TRUNCATE [TABLE] x
-    if (TailMatches(prevWords, ['TRUNCATE'])) {
+    if (TailMatches(prevWords, ["TRUNCATE"])) {
         return {
             candidates: [
-                ...filterAndCase(['TABLE', 'ONLY'], currentWord, ctx.settings),
+                ...filterAndCase(["TABLE", "ONLY"], currentWord, ctx.settings),
                 ...(await tableCandidates(conn, currentWord)),
             ],
         };
     }
-    if (TailMatches(prevWords, ['TRUNCATE', 'TABLE']))
+    if (TailMatches(prevWords, ["TRUNCATE", "TABLE"]))
         return completeTables();
-    if (TailMatches(prevWords, ['TRUNCATE', 'ONLY']))
+    if (TailMatches(prevWords, ["TRUNCATE", "ONLY"]))
         return completeTables();
     // COPY ... FROM <sth> WITH ( — option keywords inside the WITH
     // parenthesised list. The tokenizer splits `(` and `,` into their
@@ -1973,16 +1998,16 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
     // `Copy_to_options`). The `HeadMatches` guard restricts the rule
     // to a real COPY statement so the generic `(`/`,` pattern doesn't
     // fire inside CREATE TABLE / SELECT lists.
-    if (HeadMatches(prevWords, ['COPY|\\copy']) &&
-        HeadMatches(prevWords, [MatchAny, MatchAny, 'FROM']) &&
-        (TailMatches(prevWords, ['(']) || TailMatches(prevWords, [',']))) {
+    if (HeadMatches(prevWords, ["COPY|\\copy"]) &&
+        HeadMatches(prevWords, [MatchAny, MatchAny, "FROM"]) &&
+        (TailMatches(prevWords, ["("]) || TailMatches(prevWords, [","]))) {
         return {
             candidates: filterAndCase(COPY_FROM_OPTIONS, currentWord, ctx.settings),
         };
     }
-    if (HeadMatches(prevWords, ['COPY|\\copy']) &&
-        HeadMatches(prevWords, [MatchAny, MatchAny, 'TO']) &&
-        (TailMatches(prevWords, ['(']) || TailMatches(prevWords, [',']))) {
+    if (HeadMatches(prevWords, ["COPY|\\copy"]) &&
+        HeadMatches(prevWords, [MatchAny, MatchAny, "TO"]) &&
+        (TailMatches(prevWords, ["("]) || TailMatches(prevWords, [","]))) {
         return {
             candidates: filterAndCase(COPY_TO_OPTIONS, currentWord, ctx.settings),
         };
@@ -1990,46 +2015,53 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
     // COPY x → tables. (The `COPY x FROM/TO <path>` filename completion is
     // handled by the early `isCopyFromOrTo` check at the top of this
     // function so it wins over the generic `FROM <prefix>` table rule.)
-    if (TailMatches(prevWords, ['COPY']))
+    if (TailMatches(prevWords, ["COPY"]))
         return completeTables();
-    if (TailMatches(prevWords, ['COPY', MatchAny])) {
+    if (TailMatches(prevWords, ["COPY", MatchAny])) {
         return {
-            candidates: filterAndCase(['FROM', 'TO'], currentWord, ctx.settings),
+            candidates: filterAndCase(["FROM", "TO"], currentWord, ctx.settings),
         };
     }
     // ANALYZE x → tables (optional VERBOSE first).
-    if (TailMatches(prevWords, ['ANALYZE']) ||
-        TailMatches(prevWords, ['ANALYZE', 'VERBOSE'])) {
+    if (TailMatches(prevWords, ["ANALYZE"]) ||
+        TailMatches(prevWords, ["ANALYZE", "VERBOSE"])) {
         return completeTables();
     }
     // VACUUM x → tables.
-    if (TailMatches(prevWords, ['VACUUM']) ||
-        TailMatches(prevWords, ['VACUUM', 'VERBOSE'])) {
+    if (TailMatches(prevWords, ["VACUUM"]) ||
+        TailMatches(prevWords, ["VACUUM", "VERBOSE"])) {
         return completeTables();
     }
-    if (TailMatches(prevWords, ['VACUUM', 'FULL']))
+    if (TailMatches(prevWords, ["VACUUM", "FULL"]))
         return completeTables();
-    if (TailMatches(prevWords, ['VACUUM', 'ANALYZE']))
+    if (TailMatches(prevWords, ["VACUUM", "ANALYZE"]))
         return completeTables();
     // REINDEX [TABLE|INDEX|SCHEMA|DATABASE] x
-    if (TailMatches(prevWords, ['REINDEX'])) {
+    if (TailMatches(prevWords, ["REINDEX"])) {
         return {
-            candidates: filterAndCase(['TABLE', 'INDEX', 'SCHEMA', 'DATABASE', 'SYSTEM', 'CONCURRENTLY'], currentWord, ctx.settings),
+            candidates: filterAndCase([
+                "TABLE",
+                "INDEX",
+                "SCHEMA",
+                "DATABASE",
+                "SYSTEM",
+                "CONCURRENTLY",
+            ], currentWord, ctx.settings),
         };
     }
-    if (TailMatches(prevWords, ['REINDEX', 'TABLE']))
+    if (TailMatches(prevWords, ["REINDEX", "TABLE"]))
         return completeTables();
-    if (TailMatches(prevWords, ['REINDEX', 'INDEX'])) {
+    if (TailMatches(prevWords, ["REINDEX", "INDEX"])) {
         return completeTables(Query_for_list_of_indexes);
     }
-    if (TailMatches(prevWords, ['REINDEX', 'SCHEMA'])) {
+    if (TailMatches(prevWords, ["REINDEX", "SCHEMA"])) {
         if (!conn)
             return { candidates: [] };
         return {
             candidates: await runCatalogQuery(conn, Query_for_list_of_schemas, currentWord),
         };
     }
-    if (TailMatches(prevWords, ['REINDEX', 'DATABASE'])) {
+    if (TailMatches(prevWords, ["REINDEX", "DATABASE"])) {
         if (!conn)
             return { candidates: [] };
         return {
@@ -2037,25 +2069,27 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
         };
     }
     // GRANT … ON … TO …
-    if (TailMatches(prevWords, ['GRANT']) || TailMatches(prevWords, ['REVOKE'])) {
+    if (TailMatches(prevWords, ["GRANT"]) ||
+        TailMatches(prevWords, ["REVOKE"])) {
         return {
             candidates: filterAndCase(PRIVILEGE_KEYWORDS, currentWord, ctx.settings),
         };
     }
-    if (TailMatches(prevWords, ['ON'])) {
+    if (TailMatches(prevWords, ["ON"])) {
         // Could be either GRANT/REVOKE … ON or CREATE INDEX … ON. We try
         // tables; if the prior keyword set is CREATE INDEX the rule above
         // already short-circuited.
         return completeTables();
     }
-    if (TailMatches(prevWords, ['TO'])) {
-        if (HeadMatches(prevWords, ['GRANT']) && conn) {
+    if (TailMatches(prevWords, ["TO"])) {
+        if (HeadMatches(prevWords, ["GRANT"]) && conn) {
             return {
                 candidates: await runCatalogQuery(conn, Query_for_list_of_roles, currentWord),
             };
         }
     }
-    if (TailMatches(prevWords, ['FROM']) && HeadMatches(prevWords, ['REVOKE'])) {
+    if (TailMatches(prevWords, ["FROM"]) &&
+        HeadMatches(prevWords, ["REVOKE"])) {
         if (!conn)
             return { candidates: [] };
         return {
@@ -2063,45 +2097,45 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
         };
     }
     // LOCK [TABLE] x
-    if (TailMatches(prevWords, ['LOCK'])) {
+    if (TailMatches(prevWords, ["LOCK"])) {
         return {
             candidates: [
-                ...filterAndCase(['TABLE'], currentWord, ctx.settings),
+                ...filterAndCase(["TABLE"], currentWord, ctx.settings),
                 ...(await tableCandidates(conn, currentWord)),
             ],
         };
     }
-    if (TailMatches(prevWords, ['LOCK', 'TABLE']))
+    if (TailMatches(prevWords, ["LOCK", "TABLE"]))
         return completeTables();
     // SET search_path, SET ROLE, SET SCHEMA, etc.
-    if (TailMatches(prevWords, ['SET', 'ROLE'])) {
+    if (TailMatches(prevWords, ["SET", "ROLE"])) {
         if (!conn)
             return { candidates: [] };
         return {
             candidates: await runCatalogQuery(conn, Query_for_list_of_roles, currentWord),
         };
     }
-    if (TailMatches(prevWords, ['SET', 'SCHEMA'])) {
+    if (TailMatches(prevWords, ["SET", "SCHEMA"])) {
         if (!conn)
             return { candidates: [] };
         return {
             candidates: await runCatalogQuery(conn, Query_for_list_of_schemas, currentWord),
         };
     }
-    if (TailMatches(prevWords, ['SET', 'SESSION'])) {
+    if (TailMatches(prevWords, ["SET", "SESSION"])) {
         return {
-            candidates: filterAndCase(['AUTHORIZATION', 'CHARACTERISTICS AS TRANSACTION'], currentWord, ctx.settings),
+            candidates: filterAndCase(["AUTHORIZATION", "CHARACTERISTICS AS TRANSACTION"], currentWord, ctx.settings),
         };
     }
-    if (TailMatches(prevWords, ['SET', 'TRANSACTION'])) {
+    if (TailMatches(prevWords, ["SET", "TRANSACTION"])) {
         return {
-            candidates: filterAndCase(['ISOLATION LEVEL', 'READ ONLY', 'READ WRITE', 'DEFERRABLE'], currentWord, ctx.settings),
+            candidates: filterAndCase(["ISOLATION LEVEL", "READ ONLY", "READ WRITE", "DEFERRABLE"], currentWord, ctx.settings),
         };
     }
     // `SET <name> TO|= <TAB>` — for DateStyle we can suggest the formats.
-    if (TailMatches(prevWords, ['SET', 'DateStyle', 'TO|=']) ||
-        TailMatches(prevWords, ['SET', 'DATESTYLE', 'TO|=']) ||
-        TailMatches(prevWords, ['SET', 'datestyle', 'TO|='])) {
+    if (TailMatches(prevWords, ["SET", "DateStyle", "TO|="]) ||
+        TailMatches(prevWords, ["SET", "DATESTYLE", "TO|="]) ||
+        TailMatches(prevWords, ["SET", "datestyle", "TO|="])) {
         return {
             candidates: filterAndCase(DATESTYLE_VALUES, currentWord, ctx.settings),
         };
@@ -2118,9 +2152,9 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
     //     pattern against the quoted form so the partial `'America/New_`
     //     resolves correctly.
     // Mirrors upstream tab-complete.in.c ~line 4530.
-    if (TailMatches(prevWords, ['SET', 'timezone', 'TO|=']) ||
-        TailMatches(prevWords, ['SET', 'TIMEZONE', 'TO|=']) ||
-        TailMatches(prevWords, ['SET', 'TimeZone', 'TO|='])) {
+    if (TailMatches(prevWords, ["SET", "timezone", "TO|="]) ||
+        TailMatches(prevWords, ["SET", "TIMEZONE", "TO|="]) ||
+        TailMatches(prevWords, ["SET", "TimeZone", "TO|="])) {
         if (!conn)
             return { candidates: [] };
         const query = currentWord.startsWith("'")
@@ -2136,7 +2170,7 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
     // value completion; non-enum GUCs return an empty rowset (no candidates)
     // — matching upstream, which also emits nothing for unknown GUCs once a
     // value position is reached.
-    if (TailMatches(prevWords, ['SET', MatchAny, 'TO|='])) {
+    if (TailMatches(prevWords, ["SET", MatchAny, "TO|="])) {
         if (!conn)
             return { candidates: [] };
         // Walk back to the GUC name (the word before TO/=).
@@ -2150,21 +2184,21 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
     // single unique completion so `set foo<tab><tab>` resolves to
     // `set foo TO ` rather than listing two near-synonymous separators.
     // Verified against vanilla psql 18 + upstream test line 366.
-    if (TailMatches(prevWords, ['SET', MatchAny])) {
+    if (TailMatches(prevWords, ["SET", MatchAny])) {
         return {
-            candidates: filterAndCase(['TO'], currentWord, ctx.settings),
+            candidates: filterAndCase(["TO"], currentWord, ctx.settings),
         };
     }
     // Bare SET <TAB>: GUC name OR top-level SET sub-keywords (ROLE, SCHEMA, …).
-    if (TailMatches(prevWords, ['SET'])) {
+    if (TailMatches(prevWords, ["SET"])) {
         const staticKw = filterAndCase([
-            'CONSTRAINTS',
-            'LOCAL',
-            'ROLE',
-            'SCHEMA',
-            'SESSION',
-            'TIME ZONE',
-            'TRANSACTION',
+            "CONSTRAINTS",
+            "LOCAL",
+            "ROLE",
+            "SCHEMA",
+            "SESSION",
+            "TIME ZONE",
+            "TRANSACTION",
         ], currentWord, ctx.settings);
         if (!conn)
             return { candidates: staticKw };
@@ -2172,21 +2206,21 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
         return { candidates: [...staticKw, ...guc] };
     }
     // SHOW <TAB> — ALL keyword plus the live GUC list.
-    if (TailMatches(prevWords, ['SHOW'])) {
-        const staticKw = filterAndCase(['ALL'], currentWord, ctx.settings);
+    if (TailMatches(prevWords, ["SHOW"])) {
+        const staticKw = filterAndCase(["ALL"], currentWord, ctx.settings);
         if (!conn) {
             return {
                 candidates: [
                     ...staticKw,
                     ...filterAndCase([
-                        'search_path',
-                        'role',
-                        'session_authorization',
-                        'transaction_isolation',
-                        'client_encoding',
-                        'server_encoding',
-                        'server_version',
-                        'timezone',
+                        "search_path",
+                        "role",
+                        "session_authorization",
+                        "transaction_isolation",
+                        "client_encoding",
+                        "server_encoding",
+                        "server_version",
+                        "timezone",
                     ], currentWord, ctx.settings),
                 ],
             };
@@ -2195,47 +2229,48 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
         return { candidates: [...staticKw, ...guc] };
     }
     // RESET <TAB> — ALL or the live GUC list.
-    if (TailMatches(prevWords, ['RESET'])) {
-        const staticKw = filterAndCase(['ALL', 'SESSION AUTHORIZATION', 'ROLE'], currentWord, ctx.settings);
+    if (TailMatches(prevWords, ["RESET"])) {
+        const staticKw = filterAndCase(["ALL", "SESSION AUTHORIZATION", "ROLE"], currentWord, ctx.settings);
         if (!conn)
             return { candidates: staticKw };
         const guc = await runCatalogQuery(conn, Query_for_list_of_set_vars, currentWord);
         return { candidates: [...staticKw, ...guc] };
     }
     // START / BEGIN [TRANSACTION] …
-    if (TailMatches(prevWords, ['BEGIN']) || TailMatches(prevWords, ['START'])) {
+    if (TailMatches(prevWords, ["BEGIN"]) ||
+        TailMatches(prevWords, ["START"])) {
         return {
             candidates: filterAndCase(TRANSACTION_KEYWORDS, currentWord, ctx.settings),
         };
     }
     // COMMIT / ROLLBACK / RELEASE / SAVEPOINT - small completions
-    if (TailMatches(prevWords, ['ROLLBACK'])) {
+    if (TailMatches(prevWords, ["ROLLBACK"])) {
         return {
-            candidates: filterAndCase(['TO SAVEPOINT', 'TRANSACTION', 'AND CHAIN', 'AND NO CHAIN'], currentWord, ctx.settings),
+            candidates: filterAndCase(["TO SAVEPOINT", "TRANSACTION", "AND CHAIN", "AND NO CHAIN"], currentWord, ctx.settings),
         };
     }
     // EXPLAIN … — pass through to SELECT-/INSERT-/UPDATE-style rules by
     // letting subsequent words drive completion. For the first word after
     // EXPLAIN, offer the options + statement keywords.
-    if (TailMatches(prevWords, ['EXPLAIN'])) {
+    if (TailMatches(prevWords, ["EXPLAIN"])) {
         return {
             candidates: filterAndCase([
-                'ANALYZE',
-                'VERBOSE',
-                'SELECT',
-                'INSERT INTO',
-                'UPDATE',
-                'DELETE FROM',
-                '(',
+                "ANALYZE",
+                "VERBOSE",
+                "SELECT",
+                "INSERT INTO",
+                "UPDATE",
+                "DELETE FROM",
+                "(",
             ], currentWord, ctx.settings),
         };
     }
     // DECLARE … CURSOR FOR …
-    if (TailMatches(prevWords, ['DECLARE'])) {
+    if (TailMatches(prevWords, ["DECLARE"])) {
         return { candidates: [] };
     }
     // CALL / DO — no completion beyond keywords (procedure args / language).
-    if (TailMatches(prevWords, ['CALL'])) {
+    if (TailMatches(prevWords, ["CALL"])) {
         if (!conn)
             return { candidates: [] };
         return {
@@ -2243,27 +2278,29 @@ const sqlRules = async (prevWords, currentWord, ctx, conn) => {
         };
     }
     // After SELECT — offer FROM / common functions.
-    if (TailMatches(prevWords, ['SELECT'])) {
+    if (TailMatches(prevWords, ["SELECT"])) {
         // The next word can be anything (column list); offer DISTINCT/ALL/* as a
         // small hint set.
         return {
             candidates: filterAndCase([
-                'DISTINCT',
-                'ALL',
-                '*',
-                'CURRENT_DATE',
-                'CURRENT_TIME',
-                'CURRENT_TIMESTAMP',
-                'CURRENT_USER',
-                'NULL',
-                'TRUE',
-                'FALSE',
+                "DISTINCT",
+                "ALL",
+                "*",
+                "CURRENT_DATE",
+                "CURRENT_TIME",
+                "CURRENT_TIMESTAMP",
+                "CURRENT_USER",
+                "NULL",
+                "TRUE",
+                "FALSE",
             ], currentWord, ctx.settings),
         };
     }
     // Trailing-keyword fallthrough: WHERE, ORDER BY, GROUP BY, LIMIT etc.
-    if (TailMatches(prevWords, ['SELECT', '*'])) {
-        return { candidates: filterAndCase(['FROM'], currentWord, ctx.settings) };
+    if (TailMatches(prevWords, ["SELECT", "*"])) {
+        return {
+            candidates: filterAndCase(["FROM"], currentWord, ctx.settings),
+        };
     }
     // No specific rule fired.
     return { candidates: [] };
@@ -2309,14 +2346,14 @@ const completeSchemaOrRelations = async (conn, word, query) => {
         const canonicalSchema = split.schemaWasQuoted
             ? split.schema
             : split.schema.toLowerCase();
-        return rows.map((r) => canonicalSchema + '.' + r);
+        return rows.map((r) => canonicalSchema + "." + r);
     }
     // Unqualified: combine relations + schemas (schemas suffixed with `.`).
     const [rels, schemas] = await Promise.all([
         runCatalogQuery(conn, query, word),
         runCatalogQuery(conn, Query_for_list_of_schemas, word),
     ]);
-    return [...rels, ...schemas.map((s) => s + '.')];
+    return [...rels, ...schemas.map((s) => s + ".")];
 };
 /**
  * Search the catalog for relations matching a user-supplied prefix that
@@ -2328,7 +2365,7 @@ const completeSchemaOrRelations = async (conn, word, query) => {
  */
 const completeQuotedRelations = async (conn, word, query) => {
     // Strip leading `"` (and any trailing `"` the user pre-typed).
-    const inside = word.slice(1).replace(/"$/, '');
+    const inside = word.slice(1).replace(/"$/, "");
     // Use a case-sensitive raw-relname LIKE — the inside-the-quote portion
     // is taken verbatim.
     const sql = caseSensitiveRelnameVariant(query);
@@ -2351,13 +2388,13 @@ const caseSensitiveRelnameVariant = (sql) => {
     // We rewrite the SELECT/WHERE clauses on the standard relation queries.
     // The only shape we need to support is `c.relname ILIKE $1` against
     // `pg_catalog.pg_class c`, with various `c.relkind IN (...)` filters.
-    if (!sql.includes('pg_catalog.pg_class c'))
+    if (!sql.includes("pg_catalog.pg_class c"))
         return null;
-    if (!sql.includes('c.relname ILIKE $1'))
+    if (!sql.includes("c.relname ILIKE $1"))
         return null;
     return sql
-        .replace('SELECT pg_catalog.quote_ident(c.relname)', 'SELECT c.relname')
-        .replace('c.relname ILIKE $1', 'c.relname LIKE $1');
+        .replace("SELECT pg_catalog.quote_ident(c.relname)", "SELECT c.relname")
+        .replace("c.relname ILIKE $1", "c.relname LIKE $1");
 };
 /** Case-insensitive prefix filter; preserves the candidate's original casing. */
 const filterCi = (candidates, prefix) => {