neon 3.0.0 → 3.1.1

package/dist/psql/command/cmd_show.js

@@ -1,766 +1,607 @@
-/**
- * `\sf [+] FUNCNAME` / `\sv [+] VIEWNAME` show-source commands and their
- * `\ef` / `\ev` edit-form siblings, ported from upstream `command.c`'s
- * `exec_command_sf_sv` and `exec_command_ef_ev`.
- *
- * Behaviour matches upstream byte-for-byte for the show forms:
- *
- *   1. Lookup the object's OID — function via `regproc` (or `regprocedure`
- *      when the name carries an argument list `(int)`), view via `regclass`.
- *   2. Fetch the definition — `pg_get_functiondef(oid)` for functions; for
- *      views we re-assemble the `CREATE OR REPLACE VIEW … AS …` head (with
- *      schema-qualified name, reloptions, and optional `WITH CHECK OPTION`)
- *      around the body returned by `pg_get_viewdef(oid, true)`.
- *   3. Stream the rendered text to `stdout`, optionally prefixed by line
- *      numbers when the user passed `+` (e.g. `\sf+ foo`).
- *
- * Line-number formatting (mirrors upstream `print_with_linenumbers`):
- *
- *   - For functions: lines before the body marker (`AS `, `BEGIN `, or
- *     `RETURN `) are unnumbered and rendered as `        <line>\n` (8 spaces
- *     of padding). Body lines render as `<lineno>      <line>\n` where the
- *     numeric field is left-justified in a 7-character slot, with one
- *     literal space separator. The first body line becomes line 1.
- *   - For views: every line is a "body" line — `lineno` starts at 1 and
- *     increments for every output line, no header padding.
- *
- * Edit forms (`\ef` / `\ev`):
- *   We do not implement editor invocation — that needs TTY interaction and
- *   `$EDITOR` semantics outside the scope of this embedded psql. When the
- *   user supplies a name we route through the same fetch+print path as the
- *   show forms (`\ef foo` ≡ `\sf foo`); without a name we error with a hint
- *   pointing back at `\sf` / `\sv`.
- *
- * Argument parsing matches upstream's `OT_WHOLE_LINE`: we slurp the rest of
- * the line and trim, so `\sf  myschema.foo  ` round-trips cleanly without
- * splitting on the dot or whitespace inside parens.
- */
 import { writeErr, writeOut } from "./shared.js";
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
+//#region src/psql/command/cmd_show.ts
 /**
- * Emit a `\<cmd>: <message>` error to stderr, stash the message on
- * `lastErrorResult` so `\errverbose` / the mainloop fallback see it, and
- * return an error result with `errorWritten: true` so the mainloop doesn't
- * double-print.
- */
+* Emit a `\<cmd>: <message>` error to stderr, stash the message on
+* `lastErrorResult` so `\errverbose` / the mainloop fallback see it, and
+* return an error result with `errorWritten: true` so the mainloop doesn't
+* double-print.
+*/
 const errResult = (ctx, message) => {
-    ctx.settings.lastErrorResult = { message };
-    writeErr(`\\${ctx.cmdName}: ${message}\n`);
-    return { status: "error", errorWritten: true };
+	ctx.settings.lastErrorResult = { message };
+	writeErr(`\\${ctx.cmdName}: ${message}\n`);
+	return {
+		status: "error",
+		errorWritten: true
+	};
 };
 /**
- * Format a server error for stderr the way upstream's
- * `minimal_error_message` does: `<severity>:  <primary message>\n`. Falls
- * back to "ERROR:" + Error.message when the error doesn't carry severity /
- * message fields (e.g. a wire-layer rejection).
- */
+* Format a server error for stderr the way upstream's
+* `minimal_error_message` does: `<severity>:  <primary message>\n`. Falls
+* back to "ERROR:" + Error.message when the error doesn't carry severity /
+* message fields (e.g. a wire-layer rejection).
+*/
 const formatServerError = (err) => {
-    if (err && typeof err === "object") {
-        const e = err;
-        const sev = e.severity ?? "ERROR";
-        const msg = e.message ??
-            (err instanceof Error ? err.message : safeToString(err));
-        return `${sev}:  ${msg}`;
-    }
-    if (err instanceof Error)
-        return `ERROR:  ${err.message}`;
-    return `ERROR:  ${safeToString(err)}`;
+	if (err && typeof err === "object") {
+		const e = err;
+		return `${e.severity ?? "ERROR"}:  ${e.message ?? (err instanceof Error ? err.message : safeToString(err))}`;
+	}
+	if (err instanceof Error) return `ERROR:  ${err.message}`;
+	return `ERROR:  ${safeToString(err)}`;
 };
 /**
- * Coerce an unknown value to a string defensively. Plain non-`Error`
- * objects would render as `[object Object]` via the default `String()`
- * path; we sidestep that by JSON-encoding when possible (falls back to
- * the typeof when JSON throws — e.g. circular structures).
- */
+* Coerce an unknown value to a string defensively. Plain non-`Error`
+* objects would render as `[object Object]` via the default `String()`
+* path; we sidestep that by JSON-encoding when possible (falls back to
+* the typeof when JSON throws — e.g. circular structures).
+*/
 const safeToString = (v) => {
-    if (v === null)
-        return "null";
-    if (v === undefined)
-        return "undefined";
-    if (typeof v === "string")
-        return v;
-    if (typeof v === "number" ||
-        typeof v === "boolean" ||
-        typeof v === "bigint") {
-        return String(v);
-    }
-    try {
-        return JSON.stringify(v) ?? typeof v;
-    }
-    catch {
-        return typeof v;
-    }
+	if (v === null) return "null";
+	if (v === void 0) return "undefined";
+	if (typeof v === "string") return v;
+	if (typeof v === "number" || typeof v === "boolean" || typeof v === "bigint") return String(v);
+	try {
+		return JSON.stringify(v) ?? typeof v;
+	} catch {
+		return typeof v;
+	}
 };
 /**
- * Print a server-side query failure the way upstream does — `<sev>:  <msg>`
- * directly on stderr, without the `\<cmd>: ` prefix that local-only errors
- * use. Also stashes the message on `lastErrorResult` so `\errverbose`
- * survives.
- */
+* Print a server-side query failure the way upstream does — `<sev>:  <msg>`
+* directly on stderr, without the `\<cmd>: ` prefix that local-only errors
+* use. Also stashes the message on `lastErrorResult` so `\errverbose`
+* survives.
+*/
 const queryErrResult = (ctx, err) => {
-    const line = formatServerError(err);
-    ctx.settings.lastErrorResult = {
-        message: err &&
-            typeof err === "object" &&
-            err.message
-            ? err.message
-            : err instanceof Error
-                ? err.message
-                : safeToString(err),
-    };
-    writeErr(`${line}\n`);
-    return { status: "error", errorWritten: true };
+	const line = formatServerError(err);
+	ctx.settings.lastErrorResult = { message: err && typeof err === "object" && err.message ? err.message : err instanceof Error ? err.message : safeToString(err) };
+	writeErr(`${line}\n`);
+	return {
+		status: "error",
+		errorWritten: true
+	};
 };
 const conn = (ctx) => ctx.settings.db;
 const noConn = (ctx) => errResult(ctx, "no connection to the server");
 /**
- * Read the object descriptor as a whole-line argument with surrounding
- * whitespace AND trailing semicolons stripped. Returns `null` when no
- * name was supplied (after the strip — i.e. `\sf   ` or `\sf  ;;` is
- * treated as empty).
- *
- * Upstream `psql_scan_slash_option(scan_state, OT_WHOLE_LINE, …)` keeps
- * the `;` in the returned string, but `exec_command_sf_sv` (and its `ef`/
- * `ev` siblings) trim trailing whitespace + `;` before passing the
- * descriptor to `lookup_object_oid`. Without this, `\sf ts_debug(text);`
- * sends `'ts_debug(text);'::regprocedure` to the server, which the
- * regprocedure input parser rejects with "expected a right parenthesis".
- */
+* Read the object descriptor as a whole-line argument with surrounding
+* whitespace AND trailing semicolons stripped. Returns `null` when no
+* name was supplied (after the strip — i.e. `\sf   ` or `\sf  ;;` is
+* treated as empty).
+*
+* Upstream `psql_scan_slash_option(scan_state, OT_WHOLE_LINE, …)` keeps
+* the `;` in the returned string, but `exec_command_sf_sv` (and its `ef`/
+* `ev` siblings) trim trailing whitespace + `;` before passing the
+* descriptor to `lookup_object_oid`. Without this, `\sf ts_debug(text);`
+* sends `'ts_debug(text);'::regprocedure` to the server, which the
+* regprocedure input parser rejects with "expected a right parenthesis".
+*/
 const readObjDesc = (ctx) => {
-    const raw = ctx.restOfLine();
-    // Strip trailing whitespace and `;` (in any order, any count) so
-    // `\sf foo(arg) ;; ` round-trips like vanilla psql.
-    const trimmed = raw.replace(/[\s;]+$/, "").trimStart();
-    return trimmed.length === 0 ? null : trimmed;
+	const trimmed = ctx.restOfLine().replace(/[\s;]+$/, "").trimStart();
+	return trimmed.length === 0 ? null : trimmed;
 };
 /**
- * Decode whether the command name ends in `+` (request line numbers). The
- * caller knows the base name (`sf`, `sv`, `ef`, `ev`); any extra letters
- * are looked at for a literal `+`.
- */
+* Decode whether the command name ends in `+` (request line numbers). The
+* caller knows the base name (`sf`, `sv`, `ef`, `ev`); any extra letters
+* are looked at for a literal `+`.
+*/
 const decodeShowSuffix = (cmdName, base) => {
-    const tail = cmdName.slice(base.length);
-    return { plus: tail.includes("+") };
+	return { plus: cmdName.slice(base.length).includes("+") };
 };
 /**
- * Look up a function OID from `desc`. Mirrors upstream's
- * `lookup_object_oid(EditableFunction, ...)` exactly:
- *
- *   - If `desc` contains `(`, cast through `regprocedure` (which resolves
- *     by full argument signature, e.g. `foo(int)`).
- *   - Otherwise cast through `regproc` (which matches by bare name and
- *     errors on overloaded ambiguity).
- *
- * The descriptor is passed as a SQL string literal — we use the server's
- * `escapeLiteral` to mirror libpq's `appendStringLiteralConn`.
- */
+* Look up a function OID from `desc`. Mirrors upstream's
+* `lookup_object_oid(EditableFunction, ...)` exactly:
+*
+*   - If `desc` contains `(`, cast through `regprocedure` (which resolves
+*     by full argument signature, e.g. `foo(int)`).
+*   - Otherwise cast through `regproc` (which matches by bare name and
+*     errors on overloaded ambiguity).
+*
+* The descriptor is passed as a SQL string literal — we use the server's
+* `escapeLiteral` to mirror libpq's `appendStringLiteralConn`.
+*/
 const lookupFunctionOid = async (c, desc) => {
-    const cast = desc.includes("(") ? "regprocedure" : "regproc";
-    const sql = `SELECT ${c.escapeLiteral(desc)}::pg_catalog.${cast}::pg_catalog.oid`;
-    try {
-        const rs = await c.query(sql, []);
-        if (rs.rows.length !== 1 || rs.rows[0][0] === null) {
-            return {
-                ok: false,
-                err: new Error("object lookup returned no rows"),
-            };
-        }
-        const raw = cellToString(rs.rows[0][0]);
-        const oid = Number(raw);
-        if (!Number.isFinite(oid)) {
-            return {
-                ok: false,
-                err: new Error(`invalid oid in lookup result: ${raw}`),
-            };
-        }
-        return { ok: true, oid };
-    }
-    catch (err) {
-        return { ok: false, err };
-    }
+	const cast = desc.includes("(") ? "regprocedure" : "regproc";
+	const sql = `SELECT ${c.escapeLiteral(desc)}::pg_catalog.${cast}::pg_catalog.oid`;
+	try {
+		const rs = await c.query(sql, []);
+		if (rs.rows.length !== 1 || rs.rows[0][0] === null) return {
+			ok: false,
+			err: /* @__PURE__ */ new Error("object lookup returned no rows")
+		};
+		const raw = cellToString(rs.rows[0][0]);
+		const oid = Number(raw);
+		if (!Number.isFinite(oid)) return {
+			ok: false,
+			err: /* @__PURE__ */ new Error(`invalid oid in lookup result: ${raw}`)
+		};
+		return {
+			ok: true,
+			oid
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			err
+		};
+	}
 };
 /**
- * Look up a view OID from `desc` via `regclass`. Matches upstream's
- * `lookup_object_oid(EditableView, ...)`. Note that this does NOT verify
- * the relation is actually a view; the kind check happens in
- * `getViewCreateCmd` where upstream catches it via the relkind column.
- */
+* Look up a view OID from `desc` via `regclass`. Matches upstream's
+* `lookup_object_oid(EditableView, ...)`. Note that this does NOT verify
+* the relation is actually a view; the kind check happens in
+* `getViewCreateCmd` where upstream catches it via the relkind column.
+*/
 const lookupRelationOid = async (c, desc) => {
-    const sql = `SELECT ${c.escapeLiteral(desc)}::pg_catalog.regclass::pg_catalog.oid`;
-    try {
-        const rs = await c.query(sql, []);
-        if (rs.rows.length !== 1 || rs.rows[0][0] === null) {
-            return {
-                ok: false,
-                err: new Error("object lookup returned no rows"),
-            };
-        }
-        const raw = cellToString(rs.rows[0][0]);
-        const oid = Number(raw);
-        if (!Number.isFinite(oid)) {
-            return {
-                ok: false,
-                err: new Error(`invalid oid in lookup result: ${raw}`),
-            };
-        }
-        return { ok: true, oid };
-    }
-    catch (err) {
-        return { ok: false, err };
-    }
+	const sql = `SELECT ${c.escapeLiteral(desc)}::pg_catalog.regclass::pg_catalog.oid`;
+	try {
+		const rs = await c.query(sql, []);
+		if (rs.rows.length !== 1 || rs.rows[0][0] === null) return {
+			ok: false,
+			err: /* @__PURE__ */ new Error("object lookup returned no rows")
+		};
+		const raw = cellToString(rs.rows[0][0]);
+		const oid = Number(raw);
+		if (!Number.isFinite(oid)) return {
+			ok: false,
+			err: /* @__PURE__ */ new Error(`invalid oid in lookup result: ${raw}`)
+		};
+		return {
+			ok: true,
+			oid
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			err
+		};
+	}
 };
 /**
- * Coerce a wire-layer cell to a string. Text-mode results arrive as
- * strings; null is treated as "" so missing-row paths fall through to
- * empty output instead of crashing.
- */
+* Coerce a wire-layer cell to a string. Text-mode results arrive as
+* strings; null is treated as "" so missing-row paths fall through to
+* empty output instead of crashing.
+*/
 const cellToString = (v) => {
-    if (v === null || v === undefined)
-        return "";
-    if (typeof v === "string")
-        return v;
-    if (Buffer.isBuffer(v))
-        return v.toString("utf-8");
-    if (typeof v === "number" ||
-        typeof v === "boolean" ||
-        typeof v === "bigint") {
-        return String(v);
-    }
-    // Non-primitive fallback: encode JSON so we never emit a stray
-    // `[object Object]`. The wire layer hands us strings or nulls in
-    // practice, so this branch is defensive only.
-    try {
-        return JSON.stringify(v) ?? "";
-    }
-    catch {
-        return "";
-    }
+	if (v === null || v === void 0) return "";
+	if (typeof v === "string") return v;
+	if (Buffer.isBuffer(v)) return v.toString("utf-8");
+	if (typeof v === "number" || typeof v === "boolean" || typeof v === "bigint") return String(v);
+	try {
+		return JSON.stringify(v) ?? "";
+	} catch {
+		return "";
+	}
 };
 /**
- * Fetch the CREATE FUNCTION source for `oid` via
- * `pg_catalog.pg_get_functiondef(oid)`. Upstream guarantees the result is
- * newline-terminated; we re-assert that here so the caller can stream
- * straight to stdout (or hand to the line-number formatter).
- */
+* Fetch the CREATE FUNCTION source for `oid` via
+* `pg_catalog.pg_get_functiondef(oid)`. Upstream guarantees the result is
+* newline-terminated; we re-assert that here so the caller can stream
+* straight to stdout (or hand to the line-number formatter).
+*/
 const getFunctionCreateCmd = async (c, oid) => {
-    const sql = `SELECT pg_catalog.pg_get_functiondef(${oid})`;
-    try {
-        const rs = await c.query(sql, []);
-        if (rs.rows.length !== 1) {
-            return {
-                ok: false,
-                err: new Error("function definition not found"),
-            };
-        }
-        let def = cellToString(rs.rows[0][0]);
-        if (def.length > 0 && !def.endsWith("\n"))
-            def += "\n";
-        return { ok: true, def };
-    }
-    catch (err) {
-        return { ok: false, err };
-    }
+	const sql = `SELECT pg_catalog.pg_get_functiondef(${oid})`;
+	try {
+		const rs = await c.query(sql, []);
+		if (rs.rows.length !== 1) return {
+			ok: false,
+			err: /* @__PURE__ */ new Error("function definition not found")
+		};
+		let def = cellToString(rs.rows[0][0]);
+		if (def.length > 0 && !def.endsWith("\n")) def += "\n";
+		return {
+			ok: true,
+			def
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			err
+		};
+	}
 };
 /**
- * Quote an SQL identifier when needed. Mirrors libpq's `fmtId`: lowercase
- * ASCII identifiers starting with `[a-z_]` and continuing with
- * `[a-z0-9_$]` may go unquoted; anything else gets double-quoted with
- * embedded double-quotes doubled. Used to schema-qualify view names in
- * the synthesised `CREATE OR REPLACE VIEW …` head.
- */
+* Quote an SQL identifier when needed. Mirrors libpq's `fmtId`: lowercase
+* ASCII identifiers starting with `[a-z_]` and continuing with
+* `[a-z0-9_$]` may go unquoted; anything else gets double-quoted with
+* embedded double-quotes doubled. Used to schema-qualify view names in
+* the synthesised `CREATE OR REPLACE VIEW …` head.
+*/
 const fmtId = (ident) => {
-    if (/^[a-z_][a-z0-9_$]*$/.test(ident) && !RESERVED_WORDS.has(ident)) {
-        return ident;
-    }
-    return `"${ident.replace(/"/g, '""')}"`;
+	if (/^[a-z_][a-z0-9_$]*$/.test(ident) && !RESERVED_WORDS.has(ident)) return ident;
+	return `"${ident.replace(/"/g, "\"\"")}"`;
 };
 /**
- * Minimal reserved-word set used by `fmtId`. Upstream's `fmtId` is much
- * more conservative — any keyword needs quoting regardless of category.
- * For our use case we only quote the keywords that show up as actual
- * relation names; that's vanishingly rare in practice (CREATE VIEW
- * "select" AS … is legal but no one does it). Keeping the set small
- * avoids a large keyword table; the worst case is an un-needed
- * double-quote pair, which is still valid SQL.
- */
-const RESERVED_WORDS = new Set([
-    "all",
-    "analyse",
-    "analyze",
-    "and",
-    "any",
-    "array",
-    "as",
-    "asc",
-    "asymmetric",
-    "both",
-    "case",
-    "cast",
-    "check",
-    "collate",
-    "column",
-    "constraint",
-    "create",
-    "current_catalog",
-    "current_date",
-    "current_role",
-    "current_time",
-    "current_timestamp",
-    "current_user",
-    "default",
-    "deferrable",
-    "desc",
-    "distinct",
-    "do",
-    "else",
-    "end",
-    "except",
-    "false",
-    "fetch",
-    "for",
-    "foreign",
-    "from",
-    "grant",
-    "group",
-    "having",
-    "in",
-    "initially",
-    "intersect",
-    "into",
-    "lateral",
-    "leading",
-    "limit",
-    "localtime",
-    "localtimestamp",
-    "not",
-    "null",
-    "offset",
-    "on",
-    "only",
-    "or",
-    "order",
-    "placing",
-    "primary",
-    "references",
-    "returning",
-    "select",
-    "session_user",
-    "some",
-    "symmetric",
-    "table",
-    "then",
-    "to",
-    "trailing",
-    "true",
-    "union",
-    "unique",
-    "user",
-    "using",
-    "variadic",
-    "when",
-    "where",
-    "window",
-    "with",
+* Minimal reserved-word set used by `fmtId`. Upstream's `fmtId` is much
+* more conservative — any keyword needs quoting regardless of category.
+* For our use case we only quote the keywords that show up as actual
+* relation names; that's vanishingly rare in practice (CREATE VIEW
+* "select" AS … is legal but no one does it). Keeping the set small
+* avoids a large keyword table; the worst case is an un-needed
+* double-quote pair, which is still valid SQL.
+*/
+const RESERVED_WORDS = /* @__PURE__ */ new Set([
+	"all",
+	"analyse",
+	"analyze",
+	"and",
+	"any",
+	"array",
+	"as",
+	"asc",
+	"asymmetric",
+	"both",
+	"case",
+	"cast",
+	"check",
+	"collate",
+	"column",
+	"constraint",
+	"create",
+	"current_catalog",
+	"current_date",
+	"current_role",
+	"current_time",
+	"current_timestamp",
+	"current_user",
+	"default",
+	"deferrable",
+	"desc",
+	"distinct",
+	"do",
+	"else",
+	"end",
+	"except",
+	"false",
+	"fetch",
+	"for",
+	"foreign",
+	"from",
+	"grant",
+	"group",
+	"having",
+	"in",
+	"initially",
+	"intersect",
+	"into",
+	"lateral",
+	"leading",
+	"limit",
+	"localtime",
+	"localtimestamp",
+	"not",
+	"null",
+	"offset",
+	"on",
+	"only",
+	"or",
+	"order",
+	"placing",
+	"primary",
+	"references",
+	"returning",
+	"select",
+	"session_user",
+	"some",
+	"symmetric",
+	"table",
+	"then",
+	"to",
+	"trailing",
+	"true",
+	"union",
+	"unique",
+	"user",
+	"using",
+	"variadic",
+	"when",
+	"where",
+	"window",
+	"with"
 ]);
 /**
- * Re-build a `CREATE OR REPLACE VIEW <schema>.<name>[ WITH (opts)] AS
- * <body>[\n WITH <checkoption> CHECK OPTION]\n` definition the same way
- * upstream's `get_create_object_cmd(EditableView)` does. Returns either
- * the assembled text or a synthetic error when the relation isn't
- * actually a view.
- */
+* Re-build a `CREATE OR REPLACE VIEW <schema>.<name>[ WITH (opts)] AS
+* <body>[\n WITH <checkoption> CHECK OPTION]\n` definition the same way
+* upstream's `get_create_object_cmd(EditableView)` does. Returns either
+* the assembled text or a synthetic error when the relation isn't
+* actually a view.
+*/
 const getViewCreateCmd = async (c, oid) => {
-    const ver = c.serverVersion >= 90400 ? "modern" : "legacy";
-    const sql = ver === "modern"
-        ? `SELECT nspname, relname, relkind, ` +
-            `pg_catalog.pg_get_viewdef(c.oid, true), ` +
-            `pg_catalog.array_remove(pg_catalog.array_remove(c.reloptions,'check_option=local'),'check_option=cascaded') AS reloptions, ` +
-            `CASE WHEN 'check_option=local' = ANY (c.reloptions) THEN 'LOCAL'::text ` +
-            `WHEN 'check_option=cascaded' = ANY (c.reloptions) THEN 'CASCADED'::text ELSE NULL END AS checkoption ` +
-            `FROM pg_catalog.pg_class c ` +
-            `LEFT JOIN pg_catalog.pg_namespace n ` +
-            `ON c.relnamespace = n.oid WHERE c.oid = ${oid}`
-        : `SELECT nspname, relname, relkind, ` +
-            `pg_catalog.pg_get_viewdef(c.oid, true), ` +
-            `c.reloptions AS reloptions, ` +
-            `NULL AS checkoption ` +
-            `FROM pg_catalog.pg_class c ` +
-            `LEFT JOIN pg_catalog.pg_namespace n ` +
-            `ON c.relnamespace = n.oid WHERE c.oid = ${oid}`;
-    let rs;
-    try {
-        rs = await c.query(sql, []);
-    }
-    catch (err) {
-        return { ok: false, err };
-    }
-    if (rs.rows.length !== 1) {
-        return { ok: false, err: new Error("view definition not found") };
-    }
-    const row = rs.rows[0];
-    const nspname = cellToString(row[0]);
-    const relname = cellToString(row[1]);
-    const relkind = cellToString(row[2]);
-    const viewdef = cellToString(row[3]);
-    const reloptions = row[4]; // may be string ("{a=b,c=d}") or null
-    const checkoption = cellToString(row[5]);
-    if (relkind !== "v") {
-        return {
-            ok: false,
-            err: new Error(`"${nspname}.${relname}" is not a view`),
-        };
-    }
-    let out = "CREATE OR REPLACE VIEW ";
-    out += `${fmtId(nspname)}.${fmtId(relname)}`;
-    // reloptions: postgres returns it as a text-mode array literal like
-    // `{foo=bar,baz=qux}`; we only need to detect non-empty (different
-    // from the literal `{}`) and split entries on `,` outside quotes.
-    const reloptStr = reloptions === null ? null : cellToString(reloptions);
-    if (reloptStr !== null && reloptStr.length > 2) {
-        out += "\n WITH (";
-        out += renderReloptions(reloptStr);
-        out += ")";
-    }
-    out += ` AS\n${viewdef}`;
-    // Strip trailing semicolon from pg_get_viewdef.
-    if (out.endsWith(";")) {
-        out = out.slice(0, -1);
-    }
-    if (checkoption !== "") {
-        out += `\n WITH ${checkoption} CHECK OPTION`;
-    }
-    if (!out.endsWith("\n"))
-        out += "\n";
-    return { ok: true, def: out };
+	const sql = (c.serverVersion >= 90400 ? "modern" : "legacy") === "modern" ? `SELECT nspname, relname, relkind, pg_catalog.pg_get_viewdef(c.oid, true), pg_catalog.array_remove(pg_catalog.array_remove(c.reloptions,'check_option=local'),'check_option=cascaded') AS reloptions, CASE WHEN 'check_option=local' = ANY (c.reloptions) THEN 'LOCAL'::text WHEN 'check_option=cascaded' = ANY (c.reloptions) THEN 'CASCADED'::text ELSE NULL END AS checkoption FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid WHERE c.oid = ${oid}` : `SELECT nspname, relname, relkind, pg_catalog.pg_get_viewdef(c.oid, true), c.reloptions AS reloptions, NULL AS checkoption FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid WHERE c.oid = ${oid}`;
+	let rs;
+	try {
+		rs = await c.query(sql, []);
+	} catch (err) {
+		return {
+			ok: false,
+			err
+		};
+	}
+	if (rs.rows.length !== 1) return {
+		ok: false,
+		err: /* @__PURE__ */ new Error("view definition not found")
+	};
+	const row = rs.rows[0];
+	const nspname = cellToString(row[0]);
+	const relname = cellToString(row[1]);
+	const relkind = cellToString(row[2]);
+	const viewdef = cellToString(row[3]);
+	const reloptions = row[4];
+	const checkoption = cellToString(row[5]);
+	if (relkind !== "v") return {
+		ok: false,
+		err: /* @__PURE__ */ new Error(`"${nspname}.${relname}" is not a view`)
+	};
+	let out = "CREATE OR REPLACE VIEW ";
+	out += `${fmtId(nspname)}.${fmtId(relname)}`;
+	const reloptStr = reloptions === null ? null : cellToString(reloptions);
+	if (reloptStr !== null && reloptStr.length > 2) {
+		out += "\n WITH (";
+		out += renderReloptions(reloptStr);
+		out += ")";
+	}
+	out += ` AS\n${viewdef}`;
+	if (out.endsWith(";")) out = out.slice(0, -1);
+	if (checkoption !== "") out += `\n WITH ${checkoption} CHECK OPTION`;
+	if (!out.endsWith("\n")) out += "\n";
+	return {
+		ok: true,
+		def: out
+	};
 };
 /**
- * Render a Postgres text-mode array literal of `key=value` reloption
- * entries (e.g. `{security_barrier=true,security_invoker=false}`) into
- * the comma-separated `key=value, key2=value2` form upstream emits
- * inside the `WITH (…)` clause.
- *
- * Mirrors `appendReloptionsArray`'s output behaviour for the limited
- * surface relevant to views (no per-namespace options, no embedded
- * quotes). For any value that contains characters that would need
- * escaping in SQL — anything other than `[A-Za-z0-9_.\-]` — we render
- * it as a quoted string literal, matching upstream's `appendStringLiteral`
- * fallback.
- */
+* Render a Postgres text-mode array literal of `key=value` reloption
+* entries (e.g. `{security_barrier=true,security_invoker=false}`) into
+* the comma-separated `key=value, key2=value2` form upstream emits
+* inside the `WITH (…)` clause.
+*
+* Mirrors `appendReloptionsArray`'s output behaviour for the limited
+* surface relevant to views (no per-namespace options, no embedded
+* quotes). For any value that contains characters that would need
+* escaping in SQL — anything other than `[A-Za-z0-9_.\-]` — we render
+* it as a quoted string literal, matching upstream's `appendStringLiteral`
+* fallback.
+*/
 const renderReloptions = (literal) => {
-    // Strip surrounding `{}`.
-    if (!literal.startsWith("{") || !literal.endsWith("}")) {
-        return literal;
-    }
-    const inside = literal.slice(1, -1);
-    if (inside.length === 0)
-        return "";
-    // Postgres array literals quote individual elements with `"…"` when
-    // they contain commas or special chars. For reloptions on a view the
-    // values are typically bare `key=value` strings, but we still need to
-    // tolerate the quoted form.
-    const entries = splitArrayElems(inside);
-    const out = [];
-    for (let entry of entries) {
-        // unquote double-quoted entries
-        if (entry.startsWith('"') && entry.endsWith('"')) {
-            entry = entry
-                .slice(1, -1)
-                .replace(/\\"/g, '"')
-                .replace(/\\\\/g, "\\");
-        }
-        const eq = entry.indexOf("=");
-        if (eq < 0) {
-            out.push(entry);
-            continue;
-        }
-        const key = entry.slice(0, eq);
-        const value = entry.slice(eq + 1);
-        if (/^[A-Za-z0-9_.-]+$/.test(value)) {
-            out.push(`${key}=${value}`);
-        }
-        else {
-            // Quote the value as a SQL string literal.
-            out.push(`${key}='${value.replace(/'/g, "''")}'`);
-        }
-    }
-    return out.join(", ");
+	if (!literal.startsWith("{") || !literal.endsWith("}")) return literal;
+	const inside = literal.slice(1, -1);
+	if (inside.length === 0) return "";
+	const entries = splitArrayElems(inside);
+	const out = [];
+	for (let entry of entries) {
+		if (entry.startsWith("\"") && entry.endsWith("\"")) entry = entry.slice(1, -1).replace(/\\"/g, "\"").replace(/\\\\/g, "\\");
+		const eq = entry.indexOf("=");
+		if (eq < 0) {
+			out.push(entry);
+			continue;
+		}
+		const key = entry.slice(0, eq);
+		const value = entry.slice(eq + 1);
+		if (/^[A-Za-z0-9_.-]+$/.test(value)) out.push(`${key}=${value}`);
+		else out.push(`${key}='${value.replace(/'/g, "''")}'`);
+	}
+	return out.join(", ");
 };
 /** Split a Postgres text-mode array's inner content on top-level commas. */
 const splitArrayElems = (s) => {
-    const out = [];
-    let i = 0;
-    let cur = "";
-    let inQuote = false;
-    while (i < s.length) {
-        const ch = s[i];
-        if (ch === "\\" && i + 1 < s.length) {
-            cur += s[i] + s[i + 1];
-            i += 2;
-            continue;
-        }
-        if (ch === '"') {
-            inQuote = !inQuote;
-            cur += ch;
-            i++;
-            continue;
-        }
-        if (ch === "," && !inQuote) {
-            out.push(cur);
-            cur = "";
-            i++;
-            continue;
-        }
-        cur += ch;
-        i++;
-    }
-    if (cur.length > 0 || s.endsWith(","))
-        out.push(cur);
-    return out;
+	const out = [];
+	let i = 0;
+	let cur = "";
+	let inQuote = false;
+	while (i < s.length) {
+		const ch = s[i];
+		if (ch === "\\" && i + 1 < s.length) {
+			cur += s[i] + s[i + 1];
+			i += 2;
+			continue;
+		}
+		if (ch === "\"") {
+			inQuote = !inQuote;
+			cur += ch;
+			i++;
+			continue;
+		}
+		if (ch === "," && !inQuote) {
+			out.push(cur);
+			cur = "";
+			i++;
+			continue;
+		}
+		cur += ch;
+		i++;
+	}
+	if (cur.length > 0 || s.endsWith(",")) out.push(cur);
+	return out;
 };
 /**
- * Print `buf` with line numbers in the upstream format:
- *
- *   - For functions (`isFunc=true`): scan for the first line whose first
- *     three / six / seven bytes are `AS `, `BEGIN `, or `RETURN ` and
- *     treat that as the start of the body. Header lines (before the
- *     marker) render as `        <line>\n`; body lines render as
- *     `<lineno><6 spaces> <line>\n` (`%-7d %s\n`), with `lineno` starting
- *     at 1 on the marker line.
- *   - For views (`isFunc=false`): everything is body; `lineno` starts at
- *     1 and increments per output line.
- */
+* Print `buf` with line numbers in the upstream format:
+*
+*   - For functions (`isFunc=true`): scan for the first line whose first
+*     three / six / seven bytes are `AS `, `BEGIN `, or `RETURN ` and
+*     treat that as the start of the body. Header lines (before the
+*     marker) render as `        <line>\n`; body lines render as
+*     `<lineno><6 spaces> <line>\n` (`%-7d %s\n`), with `lineno` starting
+*     at 1 on the marker line.
+*   - For views (`isFunc=false`): everything is body; `lineno` starts at
+*     1 and increments per output line.
+*/
 const writeWithLineNumbers = (buf, isFunc, out) => {
-    let inHeader = isFunc;
-    let lineno = 0;
-    let i = 0;
-    while (i < buf.length) {
-        // Find end-of-line.
-        const eol = buf.indexOf("\n", i);
-        const line = eol === -1 ? buf.slice(i) : buf.slice(i, eol);
-        if (inHeader &&
-            (line.startsWith("AS ") ||
-                line.startsWith("BEGIN ") ||
-                line.startsWith("RETURN "))) {
-            inHeader = false;
-        }
-        if (!inHeader)
-            lineno++;
-        if (inHeader) {
-            out(`        ${line}\n`);
-        }
-        else {
-            // %-7d → left-justified, padded to 7. Then literal space, then line.
-            const numStr = String(lineno);
-            const pad = numStr.length >= 7 ? "" : " ".repeat(7 - numStr.length);
-            out(`${numStr}${pad} ${line}\n`);
-        }
-        if (eol === -1)
-            break;
-        i = eol + 1;
-    }
+	let inHeader = isFunc;
+	let lineno = 0;
+	let i = 0;
+	while (i < buf.length) {
+		const eol = buf.indexOf("\n", i);
+		const line = eol === -1 ? buf.slice(i) : buf.slice(i, eol);
+		if (inHeader && (line.startsWith("AS ") || line.startsWith("BEGIN ") || line.startsWith("RETURN "))) inHeader = false;
+		if (!inHeader) lineno++;
+		if (inHeader) out(`        ${line}\n`);
+		else {
+			const numStr = String(lineno);
+			out(`${numStr}${numStr.length >= 7 ? "" : " ".repeat(7 - numStr.length)} ${line}\n`);
+		}
+		if (eol === -1) break;
+		i = eol + 1;
+	}
 };
 /** Stream the definition (with or without line numbers) to stdout. */
 const emitDefinition = (def, plus, isFunc) => {
-    if (plus) {
-        writeWithLineNumbers(def, isFunc, writeOut);
-    }
-    else {
-        writeOut(def);
-    }
+	if (plus) writeWithLineNumbers(def, isFunc, writeOut);
+	else writeOut(def);
 };
-// ---------------------------------------------------------------------------
-// Shared core: \sf / \ef (function) and \sv / \ev (view).
-// ---------------------------------------------------------------------------
 /**
- * Resolve a function/view definition and dump it to stdout. Used by
- * both the show forms (`\sf` / `\sv`) and the edit forms (`\ef` / `\ev`)
- * when the user supplies a name.
- */
+* Resolve a function/view definition and dump it to stdout. Used by
+* both the show forms (`\sf` / `\sv`) and the edit forms (`\ef` / `\ev`)
+* when the user supplies a name.
+*/
 const runShowFunction = async (ctx, cmdName, base) => {
-    const c = conn(ctx);
-    if (!c)
-        return noConn(ctx);
-    const { plus } = decodeShowSuffix(cmdName, base);
-    const desc = readObjDesc(ctx);
-    if (desc === null) {
-        return errResult(ctx, "function name is required");
-    }
-    const oidLookup = await lookupFunctionOid(c, desc);
-    if (!oidLookup.ok)
-        return queryErrResult(ctx, oidLookup.err);
-    const defLookup = await getFunctionCreateCmd(c, oidLookup.oid);
-    if (!defLookup.ok)
-        return queryErrResult(ctx, defLookup.err);
-    emitDefinition(defLookup.def, plus, /*isFunc=*/ true);
-    return { status: "ok" };
+	const c = conn(ctx);
+	if (!c) return noConn(ctx);
+	const { plus } = decodeShowSuffix(cmdName, base);
+	const desc = readObjDesc(ctx);
+	if (desc === null) return errResult(ctx, "function name is required");
+	const oidLookup = await lookupFunctionOid(c, desc);
+	if (!oidLookup.ok) return queryErrResult(ctx, oidLookup.err);
+	const defLookup = await getFunctionCreateCmd(c, oidLookup.oid);
+	if (!defLookup.ok) return queryErrResult(ctx, defLookup.err);
+	emitDefinition(defLookup.def, plus, true);
+	return { status: "ok" };
 };
 const runShowView = async (ctx, cmdName, base) => {
-    const c = conn(ctx);
-    if (!c)
-        return noConn(ctx);
-    const { plus } = decodeShowSuffix(cmdName, base);
-    const desc = readObjDesc(ctx);
-    if (desc === null) {
-        return errResult(ctx, "view name is required");
-    }
-    const oidLookup = await lookupRelationOid(c, desc);
-    if (!oidLookup.ok)
-        return queryErrResult(ctx, oidLookup.err);
-    const defLookup = await getViewCreateCmd(c, oidLookup.oid);
-    if (!defLookup.ok)
-        return queryErrResult(ctx, defLookup.err);
-    emitDefinition(defLookup.def, plus, /*isFunc=*/ false);
-    return { status: "ok" };
+	const c = conn(ctx);
+	if (!c) return noConn(ctx);
+	const { plus } = decodeShowSuffix(cmdName, base);
+	const desc = readObjDesc(ctx);
+	if (desc === null) return errResult(ctx, "view name is required");
+	const oidLookup = await lookupRelationOid(c, desc);
+	if (!oidLookup.ok) return queryErrResult(ctx, oidLookup.err);
+	const defLookup = await getViewCreateCmd(c, oidLookup.oid);
+	if (!defLookup.ok) return queryErrResult(ctx, defLookup.err);
+	emitDefinition(defLookup.def, plus, false);
+	return { status: "ok" };
 };
-// ---------------------------------------------------------------------------
-// BackslashCmdSpec exports
-// ---------------------------------------------------------------------------
 /** `\sf [+] FUNCNAME` — show function source. */
-export const cmdShowFunction = {
-    name: "sf",
-    argMode: "whole-line",
-    helpKey: "sf",
-    run: (ctx) => runShowFunction(ctx, ctx.cmdName, "sf"),
+const cmdShowFunction = {
+	name: "sf",
+	argMode: "whole-line",
+	helpKey: "sf",
+	run: (ctx) => runShowFunction(ctx, ctx.cmdName, "sf")
 };
 /** `\sf+ FUNCNAME` — show function source with line numbers. */
-export const cmdShowFunctionPlus = {
-    name: "sf+",
-    argMode: "whole-line",
-    helpKey: "sf",
-    run: (ctx) => runShowFunction(ctx, ctx.cmdName, "sf"),
+const cmdShowFunctionPlus = {
+	name: "sf+",
+	argMode: "whole-line",
+	helpKey: "sf",
+	run: (ctx) => runShowFunction(ctx, ctx.cmdName, "sf")
 };
 /** `\sv [+] VIEWNAME` — show view source. */
-export const cmdShowView = {
-    name: "sv",
-    argMode: "whole-line",
-    helpKey: "sv",
-    run: (ctx) => runShowView(ctx, ctx.cmdName, "sv"),
+const cmdShowView = {
+	name: "sv",
+	argMode: "whole-line",
+	helpKey: "sv",
+	run: (ctx) => runShowView(ctx, ctx.cmdName, "sv")
 };
 /** `\sv+ VIEWNAME` — show view source with line numbers. */
-export const cmdShowViewPlus = {
-    name: "sv+",
-    argMode: "whole-line",
-    helpKey: "sv",
-    run: (ctx) => runShowView(ctx, ctx.cmdName, "sv"),
+const cmdShowViewPlus = {
+	name: "sv+",
+	argMode: "whole-line",
+	helpKey: "sv",
+	run: (ctx) => runShowView(ctx, ctx.cmdName, "sv")
 };
 /**
- * `\ef [+] [FUNCNAME [LINE]]` — upstream opens `$EDITOR` on the function's
- * source. We don't implement editor invocation; when a name is supplied we
- * route through the same fetch+print path as `\sf` (with a stripped line
- * number — the trailing LINE argument is ignored). Without a name we error
- * with a hint pointing at `\sf`.
- */
-export const cmdEditFunction = {
-    name: "ef",
-    argMode: "whole-line",
-    helpKey: "ef",
-    async run(ctx) {
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { plus } = decodeShowSuffix(ctx.cmdName, "ef");
-        const desc = readObjDesc(ctx);
-        if (desc === null) {
-            return errResult(ctx, "editing not supported in embedded psql; supply a name to display the source");
-        }
-        // Strip a possible trailing LINE number (upstream behaviour for \ef
-        // FUNCNAME LINE — the editor opens at that line; we just discard it).
-        const objDesc = stripTrailingLine(desc);
-        const oidLookup = await lookupFunctionOid(c, objDesc);
-        if (!oidLookup.ok)
-            return queryErrResult(ctx, oidLookup.err);
-        const defLookup = await getFunctionCreateCmd(c, oidLookup.oid);
-        if (!defLookup.ok)
-            return queryErrResult(ctx, defLookup.err);
-        emitDefinition(defLookup.def, plus, /*isFunc=*/ true);
-        return { status: "ok" };
-    },
+* `\ef [+] [FUNCNAME [LINE]]` — upstream opens `$EDITOR` on the function's
+* source. We don't implement editor invocation; when a name is supplied we
+* route through the same fetch+print path as `\sf` (with a stripped line
+* number — the trailing LINE argument is ignored). Without a name we error
+* with a hint pointing at `\sf`.
+*/
+const cmdEditFunction = {
+	name: "ef",
+	argMode: "whole-line",
+	helpKey: "ef",
+	async run(ctx) {
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { plus } = decodeShowSuffix(ctx.cmdName, "ef");
+		const desc = readObjDesc(ctx);
+		if (desc === null) return errResult(ctx, "editing not supported in embedded psql; supply a name to display the source");
+		const objDesc = stripTrailingLine(desc);
+		const oidLookup = await lookupFunctionOid(c, objDesc);
+		if (!oidLookup.ok) return queryErrResult(ctx, oidLookup.err);
+		const defLookup = await getFunctionCreateCmd(c, oidLookup.oid);
+		if (!defLookup.ok) return queryErrResult(ctx, defLookup.err);
+		emitDefinition(defLookup.def, plus, true);
+		return { status: "ok" };
+	}
 };
 /**
- * `\ev [+] [VIEWNAME [LINE]]` — same contract as `\ef` but for views.
- */
-export const cmdEditView = {
-    name: "ev",
-    argMode: "whole-line",
-    helpKey: "ev",
-    async run(ctx) {
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { plus } = decodeShowSuffix(ctx.cmdName, "ev");
-        const desc = readObjDesc(ctx);
-        if (desc === null) {
-            return errResult(ctx, "editing not supported in embedded psql; supply a name to display the source");
-        }
-        const objDesc = stripTrailingLine(desc);
-        const oidLookup = await lookupRelationOid(c, objDesc);
-        if (!oidLookup.ok)
-            return queryErrResult(ctx, oidLookup.err);
-        const defLookup = await getViewCreateCmd(c, oidLookup.oid);
-        if (!defLookup.ok)
-            return queryErrResult(ctx, defLookup.err);
-        emitDefinition(defLookup.def, plus, /*isFunc=*/ false);
-        return { status: "ok" };
-    },
+* `\ev [+] [VIEWNAME [LINE]]` — same contract as `\ef` but for views.
+*/
+const cmdEditView = {
+	name: "ev",
+	argMode: "whole-line",
+	helpKey: "ev",
+	async run(ctx) {
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { plus } = decodeShowSuffix(ctx.cmdName, "ev");
+		const desc = readObjDesc(ctx);
+		if (desc === null) return errResult(ctx, "editing not supported in embedded psql; supply a name to display the source");
+		const objDesc = stripTrailingLine(desc);
+		const oidLookup = await lookupRelationOid(c, objDesc);
+		if (!oidLookup.ok) return queryErrResult(ctx, oidLookup.err);
+		const defLookup = await getViewCreateCmd(c, oidLookup.oid);
+		if (!defLookup.ok) return queryErrResult(ctx, defLookup.err);
+		emitDefinition(defLookup.def, plus, false);
+		return { status: "ok" };
+	}
 };
 /**
- * Aliases so that `\ef+` and `\ev+` resolve to the corresponding command;
- * we register the plus variants explicitly because the registry is keyed
- * by full name.
- */
-export const cmdEditFunctionPlus = {
-    ...cmdEditFunction,
-    name: "ef+",
+* Aliases so that `\ef+` and `\ev+` resolve to the corresponding command;
+* we register the plus variants explicitly because the registry is keyed
+* by full name.
+*/
+const cmdEditFunctionPlus = {
+	...cmdEditFunction,
+	name: "ef+"
 };
-export const cmdEditViewPlus = {
-    ...cmdEditView,
-    name: "ev+",
+const cmdEditViewPlus = {
+	...cmdEditView,
+	name: "ev+"
 };
 /**
- * Strip a trailing LINE number from an object descriptor, matching
- * upstream's `strip_lineno_from_objdesc`. We rebuild the simpler subset
- * here because the slash-arg scanner already handed us a single trimmed
- * whole-line string: if it ends with `<digits>` separated from the
- * preceding name by whitespace or `)`, strip the digits.
- *
- * Returns the descriptor with any trailing line number removed. Invalid
- * line numbers (zero) are not detected here — we treat them the same as
- * "no line number" because the LINE arg is meaningless to our
- * show-only impl.
- */
+* Strip a trailing LINE number from an object descriptor, matching
+* upstream's `strip_lineno_from_objdesc`. We rebuild the simpler subset
+* here because the slash-arg scanner already handed us a single trimmed
+* whole-line string: if it ends with `<digits>` separated from the
+* preceding name by whitespace or `)`, strip the digits.
+*
+* Returns the descriptor with any trailing line number removed. Invalid
+* line numbers (zero) are not detected here — we treat them the same as
+* "no line number" because the LINE arg is meaningless to our
+* show-only impl.
+*/
 const stripTrailingLine = (desc) => {
-    let i = desc.length - 1;
-    while (i > 0 && /\s/.test(desc[i]))
-        i--;
-    if (i <= 0 || !/[0-9]/.test(desc[i]))
-        return desc;
-    while (i > 0 && /[0-9]/.test(desc[i]))
-        i--;
-    // The char before the digit run must be whitespace or `)` and not the
-    // very first char.
-    if (i <= 0)
-        return desc;
-    const sep = desc[i];
-    if (!(/\s/.test(sep) || sep === ")"))
-        return desc;
-    return desc.slice(0, i + 1).trimEnd();
+	let i = desc.length - 1;
+	while (i > 0 && /\s/.test(desc[i])) i--;
+	if (i <= 0 || !/[0-9]/.test(desc[i])) return desc;
+	while (i > 0 && /[0-9]/.test(desc[i])) i--;
+	if (i <= 0) return desc;
+	const sep = desc[i];
+	if (!(/\s/.test(sep) || sep === ")")) return desc;
+	return desc.slice(0, i + 1).trimEnd();
 };
-// ---------------------------------------------------------------------------
-// Registration
-// ---------------------------------------------------------------------------
 /**
- * Register `\sf`, `\sf+`, `\sv`, `\sv+`, `\ef`, `\ef+`, `\ev`, `\ev+` on
- * the supplied registry. Wired into `defaultRegistry()` from `dispatch.ts`.
- */
-export const registerShowCommands = (registry) => {
-    registry.register(cmdShowFunction);
-    registry.register(cmdShowFunctionPlus);
-    registry.register(cmdShowView);
-    registry.register(cmdShowViewPlus);
-    registry.register(cmdEditFunction);
-    registry.register(cmdEditFunctionPlus);
-    registry.register(cmdEditView);
-    registry.register(cmdEditViewPlus);
+* Register `\sf`, `\sf+`, `\sv`, `\sv+`, `\ef`, `\ef+`, `\ev`, `\ev+` on
+* the supplied registry. Wired into `defaultRegistry()` from `dispatch.ts`.
+*/
+const registerShowCommands = (registry) => {
+	registry.register(cmdShowFunction);
+	registry.register(cmdShowFunctionPlus);
+	registry.register(cmdShowView);
+	registry.register(cmdShowViewPlus);
+	registry.register(cmdEditFunction);
+	registry.register(cmdEditFunctionPlus);
+	registry.register(cmdEditView);
+	registry.register(cmdEditViewPlus);
 };
+//#endregion
+export { cmdEditFunction, cmdEditFunctionPlus, cmdEditView, cmdEditViewPlus, cmdShowFunction, cmdShowFunctionPlus, cmdShowView, cmdShowViewPlus, registerShowCommands };