npm - neonctl - Versions diffs - 2.22.0 → 2.23.0 - Mend

neonctl 2.22.0 → 2.23.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (116) hide show

package/README.md +242 -16
package/analytics.js +5 -2
package/commands/branches.js +9 -1
package/commands/checkout.js +249 -0
package/commands/connection_string.js +15 -2
package/commands/data_api.js +286 -0
package/commands/functions.js +277 -0
package/commands/index.js +12 -0
package/commands/link.js +667 -0
package/commands/neon_auth.js +1013 -0
package/commands/projects.js +9 -1
package/commands/psql.js +62 -0
package/commands/set_context.js +7 -2
package/context.js +86 -14
package/functions_api.js +44 -0
package/index.js +3 -0
package/package.json +60 -51
package/psql/cli.js +51 -0
package/psql/command/cmd_cond.js +437 -0
package/psql/command/cmd_connect.js +815 -0
package/psql/command/cmd_copy.js +1025 -0
package/psql/command/cmd_describe.js +1810 -0
package/psql/command/cmd_format.js +909 -0
package/psql/command/cmd_io.js +2187 -0
package/psql/command/cmd_lo.js +385 -0
package/psql/command/cmd_meta.js +970 -0
package/psql/command/cmd_misc.js +187 -0
package/psql/command/cmd_pipeline.js +1141 -0
package/psql/command/cmd_restrict.js +171 -0
package/psql/command/cmd_show.js +751 -0
package/psql/command/dispatch.js +343 -0
package/psql/command/inputQueue.js +42 -0
package/psql/command/shared.js +71 -0
package/psql/complete/filenames.js +139 -0
package/psql/complete/index.js +104 -0
package/psql/complete/matcher.js +314 -0
package/psql/complete/psqlVars.js +247 -0
package/psql/complete/queries.js +491 -0
package/psql/complete/rules.js +2387 -0
package/psql/core/common.js +1250 -0
package/psql/core/help.js +576 -0
package/psql/core/mainloop.js +1353 -0
package/psql/core/prompt.js +437 -0
package/psql/core/settings.js +684 -0
package/psql/core/sqlHelp.js +1066 -0
package/psql/core/startup.js +840 -0
package/psql/core/syncVars.js +116 -0
package/psql/core/variables.js +287 -0
package/psql/describe/formatters.js +1277 -0
package/psql/describe/processNamePattern.js +270 -0
package/psql/describe/queries.js +2373 -0
package/psql/describe/versionGate.js +43 -0
package/psql/index.js +2005 -0
package/psql/io/history.js +299 -0
package/psql/io/input.js +120 -0
package/psql/io/lineEditor/buffer.js +323 -0
package/psql/io/lineEditor/complete.js +227 -0
package/psql/io/lineEditor/filename.js +159 -0
package/psql/io/lineEditor/index.js +891 -0
package/psql/io/lineEditor/keymap.js +738 -0
package/psql/io/lineEditor/vt100.js +363 -0
package/psql/io/pgpass.js +202 -0
package/psql/io/pgservice.js +194 -0
package/psql/io/psqlrc.js +422 -0
package/psql/print/aligned.js +1756 -0
package/psql/print/asciidoc.js +248 -0
package/psql/print/crosstab.js +460 -0
package/psql/print/csv.js +92 -0
package/psql/print/html.js +258 -0
package/psql/print/json.js +96 -0
package/psql/print/latex.js +396 -0
package/psql/print/pager.js +265 -0
package/psql/print/troff.js +258 -0
package/psql/print/unaligned.js +118 -0
package/psql/print/units.js +135 -0
package/psql/scanner/slash.js +513 -0
package/psql/scanner/sql.js +910 -0
package/psql/scanner/stringutils.js +390 -0
package/psql/types/backslash.js +1 -0
package/psql/types/connection.js +1 -0
package/psql/types/index.js +7 -0
package/psql/types/printer.js +1 -0
package/psql/types/repl.js +1 -0
package/psql/types/scanner.js +24 -0
package/psql/types/settings.js +1 -0
package/psql/types/variables.js +1 -0
package/psql/wire/connection.js +2844 -0
package/psql/wire/copy.js +108 -0
package/psql/wire/notify.js +59 -0
package/psql/wire/pipeline.js +519 -0
package/psql/wire/protocol.js +466 -0
package/psql/wire/sasl.js +296 -0
package/psql/wire/tls.js +596 -0
package/test_utils/fixtures.js +1 -0
package/utils/enrichers.js +18 -1
package/utils/esbuild.js +147 -0
package/utils/middlewares.js +1 -1
package/utils/psql.js +107 -11
package/utils/zip.js +4 -0
package/writer.js +1 -1
package/commands/auth.test.js +0 -211
package/commands/branches.test.js +0 -460
package/commands/connection_string.test.js +0 -196
package/commands/databases.test.js +0 -39
package/commands/help.test.js +0 -9
package/commands/init.test.js +0 -56
package/commands/ip_allow.test.js +0 -59
package/commands/operations.test.js +0 -7
package/commands/orgs.test.js +0 -7
package/commands/projects.test.js +0 -144
package/commands/roles.test.js +0 -37
package/commands/set_context.test.js +0 -159
package/commands/vpc_endpoints.test.js +0 -69
package/env.test.js +0 -55
package/utils/formats.test.js +0 -32
package/writer.test.js +0 -104

package/psql/scanner/slash.js ADDED Viewed

@@ -0,0 +1,513 @@
+/**
+ * psql backslash-command argument scanner.
+ *
+ * Hand-port of PostgreSQL's `src/bin/psql/psqlscanslash.l`. The upstream is a
+ * flex-generated state machine with these exclusive states:
+ *
+ *  - `xslashcmd`        — reading the command name (the letters after `\`)
+ *  - `xslashargstart`   — skipping whitespace before the next arg; `|` at
+ *                         this position is special in `filepipe` mode
+ *  - `xslasharg`        — reading an unquoted arg (handles `:var`,
+ *                         `:'var'`, `:"var"` substitutions and the start of
+ *                         `'`, `"`, `` ` `` quoted runs)
+ *  - `xslashquote`      — inside `'…'` (C-string-style escapes processed)
+ *  - `xslashbackquote`  — inside `` `…` `` (variable expansion only; the
+ *                         body is shipped to the shell by upstream)
+ *  - `xslashdquote`     — inside `"…"` (literal copy, double quotes kept)
+ *  - `xslashwholeline`  — slurp rest of line, suppressing leading whitespace
+ *  - `xslashend`        — terminator (we don't model it here; the caller
+ *                         knows where the slash command ended)
+ *
+ * The TS port collapses these into a single {@link scanSlashArgs} function
+ * that takes the post-command-name remainder of the input line plus a
+ * {@link SlashArgMode} and returns the list of parsed arguments. We hand-roll
+ * the state machine instead of attempting to mechanically translate flex
+ * rules; the resulting code is easier to read and trivially testable.
+ *
+ * Behavioural notes vs upstream:
+ *
+ *  - **Whole-line mode** returns a single-element array containing the entire
+ *    rest-of-line, with leading whitespace suppressed. Empty input still
+ *    yields `[]` so callers can treat the result uniformly.
+ *  - **filepipe mode** treats a leading `|` as the start of a shell command
+ *    and slurps the rest of the line as one argument. Anything else is
+ *    handled as a normal arg.
+ *  - **Variable substitution** matches upstream's three forms:
+ *      `:varname`       — plain expansion
+ *      `:'varname'`     — SQL-literal-quoted expansion
+ *      `:"varname"`     — SQL-identifier-quoted expansion
+ *    `varname` is `[A-Za-z0-9_\x80-\xff]+` (upstream's `variable_char`). When
+ *    the variable is unset, the colon form is emitted literally — matching
+ *    the upstream `ECHO` fallback.
+ *  - **no-vars mode** disables all `:var` substitution; the lexer emits the
+ *    raw text. Useful for commands that should never expand variables
+ *    (e.g. `\setenv`'s value argument).
+ *  - **sql-id / sql-id-keep-case modes** post-process each arg through
+ *    `dequoteDowncaseIdentifier`, which mirrors upstream's
+ *    `dequote_downcase_identifier()`: collapse `"…"` quoting, double `""`
+ *    into a single `"`, and (for `sql-id`) lowercase unquoted letters.
+ *  - **Backticks** ARE executed here, synchronously via `child_process.execSync`
+ *    on `sh -c <body>`. Variable references inside the backticked body are
+ *    expanded first (matching upstream's `xslashbackquote` rules), then the
+ *    resulting command is run with the inherited environment but NO shell
+ *    state; the child's stdout (trimmed of one trailing newline) is the
+ *    arg's value. Non-zero exits / spawn failures are reported on stderr
+ *    in the upstream `psql:...: error: \!:` shape and substitute the empty
+ *    string. This is the scanner-level analogue of upstream's `evaluate_backtick`.
+ *  - **Inside-quote escapes** match upstream `xslashquote`: `\n \t \b \r \f`,
+ *    octal `\ooo`, hex `\xhh`, and `\<other>` as a literal character. We
+ *    apply them in-line so the returned arg contains the decoded value.
+ */
+import { execSync } from 'node:child_process';
+import { dequote } from './stringutils.js';
+const WHITESPACE = ' \t\n\r\f\v';
+const VARIABLE_CHAR_RE = /[A-Za-z0-9_\x80-\xff]/;
+const isVarChar = (c) => c !== undefined && VARIABLE_CHAR_RE.test(c);
+const isWhitespace = (c) => c !== undefined && WHITESPACE.includes(c);
+/**
+ * SQL-literal-quote a value for the `:'varname'` substitution form.
+ * Mirrors libpq's `PQescapeLiteral` for the common case: wrap in `'…'`,
+ * double any embedded `'`, and backslash-escape any embedded `\`. Upstream
+ * additionally emits an `E` prefix when the value contains backslashes; we
+ * preserve that behaviour for compatibility with code that round-trips
+ * through the SQL parser.
+ */
+const quoteSqlLiteral = (value) => {
+    let needsEscape = false;
+    let inner = '';
+    for (const c of value) {
+        if (c === "'")
+            inner += "''";
+        else if (c === '\\') {
+            inner += '\\\\';
+            needsEscape = true;
+        }
+        else {
+            inner += c;
+        }
+    }
+    return needsEscape ? `E'${inner}'` : `'${inner}'`;
+};
+/**
+ * SQL-identifier-quote a value for the `:"varname"` substitution form.
+ * Wraps the value in `"…"` and doubles any embedded `"`.
+ */
+const quoteSqlIdent = (value) => {
+    let inner = '';
+    for (const c of value) {
+        inner += c === '"' ? '""' : c;
+    }
+    return `"${inner}"`;
+};
+/**
+ * Match upstream's `dequote_downcase_identifier()`. Strips out `"…"` quoting
+ * (collapsing `""` to `"` inside quotes) and optionally downcases unquoted
+ * letters. The transformation is in-place semantically: a string like
+ * `FOO"BAR"BAZ` becomes `fooBARbaz` (when `downcase`) or `FOOBARBAZ`
+ * (otherwise).
+ */
+const dequoteDowncaseIdentifier = (str, downcase) => {
+    let out = '';
+    let inquotes = false;
+    let i = 0;
+    while (i < str.length) {
+        const c = str[i];
+        if (c === '"') {
+            if (inquotes && str[i + 1] === '"') {
+                // Keep one quote, drop the other.
+                out += '"';
+                i += 2;
+                continue;
+            }
+            inquotes = !inquotes;
+            i++;
+            continue;
+        }
+        out += downcase && !inquotes ? c.toLowerCase() : c;
+        i++;
+    }
+    return out;
+};
+/**
+ * Attempt to consume one of the `:var`, `:'var'`, `:"var"` variable
+ * substitution forms at position `i` in `s`. Returns the new index plus the
+ * substituted text, or `null` if no recognised form is present.
+ *
+ * Caller controls whether the colon forms are honoured at all via
+ * `varLookup`: pass `undefined` to disable substitution entirely (`no-vars`
+ * mode).
+ */
+const tryConsumeVarSubstitution = (s, i, varLookup) => {
+    if (varLookup === undefined)
+        return null;
+    if (s[i] !== ':')
+        return null;
+    // :{?varname} — defined-variable test, emits literal TRUE / FALSE.
+    // Mirrors upstream `psqlscanslash.l`'s `:\{\?{variable_char}+\}` rule
+    // (calls `psqlscan_test_variable`). A malformed expression (missing
+    // closing `}` or empty name) falls through to `null` so the caller emits
+    // the literal `:` and continues.
+    if (s[i + 1] === '{' && s[i + 2] === '?') {
+        let j = i + 3;
+        while (j < s.length && isVarChar(s[j]))
+            j++;
+        if (j > i + 3 && s[j] === '}') {
+            const name = s.slice(i + 3, j);
+            const value = varLookup(name);
+            return { end: j + 1, text: value !== undefined ? 'TRUE' : 'FALSE' };
+        }
+        return null;
+    }
+    // :"varname" — SQL identifier quote
+    if (s[i + 1] === '"') {
+        let j = i + 2;
+        while (j < s.length && isVarChar(s[j]))
+            j++;
+        if (j > i + 2 && s[j] === '"') {
+            const name = s.slice(i + 2, j);
+            const value = varLookup(name);
+            if (value === undefined) {
+                // Upstream still substitutes — passing an empty string would quietly
+                // misparse downstream. We instead pass through the literal so the
+                // caller can see (and report) the unset reference. This matches the
+                // ECHO fallback used by upstream's plain `:varname` form.
+                return { end: j + 1, text: s.slice(i, j + 1) };
+            }
+            return { end: j + 1, text: quoteSqlIdent(value) };
+        }
+        return null;
+    }
+    // :'varname' — SQL literal quote
+    if (s[i + 1] === "'") {
+        let j = i + 2;
+        while (j < s.length && isVarChar(s[j]))
+            j++;
+        if (j > i + 2 && s[j] === "'") {
+            const name = s.slice(i + 2, j);
+            const value = varLookup(name);
+            if (value === undefined) {
+                return { end: j + 1, text: s.slice(i, j + 1) };
+            }
+            return { end: j + 1, text: quoteSqlLiteral(value) };
+        }
+        return null;
+    }
+    // :varname — plain substitution
+    if (isVarChar(s[i + 1])) {
+        let j = i + 1;
+        while (j < s.length && isVarChar(s[j]))
+            j++;
+        const name = s.slice(i + 1, j);
+        const value = varLookup(name);
+        if (value === undefined) {
+            // Unset → emit literally so it stays visible. Upstream ECHOes the
+            // entire `:name` text in this case.
+            return { end: j, text: s.slice(i, j) };
+        }
+        return { end: j, text: value };
+    }
+    return null;
+};
+/**
+ * Process the contents of a `'…'` slash-quoted token: handle psql's C-style
+ * escapes (\n, \t, \b, \r, \f, octal, hex, and \<other>) and undouble `''`.
+ * The opening quote has already been consumed; we read until the matching
+ * closing quote and return the decoded payload plus the new index (pointing
+ * just past the closing quote).
+ */
+const consumeSingleQuoted = (s, start) => {
+    let out = '';
+    let i = start;
+    while (i < s.length) {
+        const c = s[i];
+        if (c === "'") {
+            if (s[i + 1] === "'") {
+                out += "'";
+                i += 2;
+                continue;
+            }
+            return { end: i + 1, text: out };
+        }
+        if (c === '\\' && i + 1 < s.length) {
+            const next = s[i + 1];
+            if (next === 'n') {
+                out += '\n';
+                i += 2;
+                continue;
+            }
+            if (next === 't') {
+                out += '\t';
+                i += 2;
+                continue;
+            }
+            if (next === 'b') {
+                out += '\b';
+                i += 2;
+                continue;
+            }
+            if (next === 'r') {
+                out += '\r';
+                i += 2;
+                continue;
+            }
+            if (next === 'f') {
+                out += '\f';
+                i += 2;
+                continue;
+            }
+            // Octal: \ooo (1–3 digits)
+            if (next >= '0' && next <= '7') {
+                const j = i + 1;
+                let octEnd = j;
+                while (octEnd < s.length &&
+                    octEnd - j < 3 &&
+                    s[octEnd] >= '0' &&
+                    s[octEnd] <= '7') {
+                    octEnd++;
+                }
+                const code = parseInt(s.slice(j, octEnd), 8);
+                out += String.fromCharCode(code);
+                i = octEnd;
+                continue;
+            }
+            // Hex: \xhh (1–2 digits)
+            if (next === 'x') {
+                const j = i + 2;
+                const hexRe = /[0-9a-fA-F]/;
+                let hexEnd = j;
+                while (hexEnd < s.length && hexEnd - j < 2 && hexRe.test(s[hexEnd])) {
+                    hexEnd++;
+                }
+                if (hexEnd > j) {
+                    const code = parseInt(s.slice(j, hexEnd), 16);
+                    out += String.fromCharCode(code);
+                    i = hexEnd;
+                    continue;
+                }
+            }
+            // \<other> → literal next char
+            out += next;
+            i += 2;
+            continue;
+        }
+        out += c;
+        i++;
+    }
+    // Unterminated — return what we have. Upstream reports an error; for the
+    // scanner-as-library shape we'd rather surface the partial text and let
+    // the caller decide. Tests cover both well-formed and unterminated cases.
+    return { end: i, text: out };
+};
+/**
+ * Process the contents of a `"…"` slash-quoted token. Upstream copies the
+ * body verbatim *including the double quotes themselves* (see `xslashdquote`
+ * rule, which ECHOes the opening dquote on entry). That preserves
+ * SQL-identifier semantics — the caller's `dequoteDowncaseIdentifier()` is
+ * what eventually unwraps the quotes for `sql-id` modes.
+ */
+const consumeDoubleQuoted = (s, start) => {
+    let i = start;
+    while (i < s.length) {
+        if (s[i] === '"') {
+            return { end: i + 1, text: s.slice(start - 1, i + 1) };
+        }
+        i++;
+    }
+    // Unterminated — return what we have, including the opening quote.
+    return { end: i, text: s.slice(start - 1, i) };
+};
+/**
+ * Test seam for swapping the shell executor. Vitest sets `current` to its
+ * own mock; production uses `execSync(cmd, { shell: '/bin/sh' })`. Kept as
+ * an exported object so tests can flip it in `beforeEach` without monkey-
+ * patching `child_process`.
+ */
+export const BACKTICK_EXECUTOR = {
+    current: (cmd) => execSync(cmd, {
+        shell: '/bin/sh',
+        encoding: 'utf8',
+        // Children inherit the parent env but get no stdin pipe — matches
+        // upstream's `popen(cmd, "r")` semantics. stderr passes through so
+        // shell error output is visible to the user.
+        stdio: ['ignore', 'pipe', 'inherit'],
+        // Defensive cap: backtick output goes into a slash arg, so a runaway
+        // command shouldn't be able to fill arbitrary memory.
+        maxBuffer: 1 << 20,
+    }),
+};
+/**
+ * Execute the lexed body of a `` `…` `` token via `sh -c` and return its
+ * stdout with one trailing newline stripped (matching shell command-
+ * substitution convention). Errors are reported on stderr in the upstream
+ * `psql: error: \!: <command>: <message>` shape and substitute the empty
+ * string — so a failed backtick never aborts the surrounding slash command.
+ *
+ * Called only by {@link consumeBackQuoted}; lives at module scope so the
+ * scanner stays free of inline I/O and tests can spy on the executor via
+ * {@link BACKTICK_EXECUTOR}.
+ */
+const runBacktickCommand = (cmd) => {
+    if (cmd.length === 0)
+        return '';
+    try {
+        const out = BACKTICK_EXECUTOR.current(cmd);
+        // Trim a single trailing newline; preserve interior newlines so multi-line
+        // output (e.g. `\set FOO `cat file``) lands as-is.
+        return out.endsWith('\n') ? out.slice(0, -1) : out;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        // Upstream prints `psql:file:line: error: \!: <cmd>: <msg>`. We don't
+        // have file/line context in the scanner; emit the prefix verbatim and
+        // include the command for diagnosis.
+        process.stderr.write(`psql: error: \\!: ${cmd}: ${msg}\n`);
+        return '';
+    }
+};
+/**
+ * Process the contents of a `` `…` `` slash-backquoted token.
+ *
+ * Phase 1 (this function): consume the body, expanding `:var` references
+ * along the way (matching upstream's `xslashbackquote` rules).
+ *
+ * Phase 2 (delegated to {@link runBacktickCommand}): run the assembled
+ * command via `sh -c` and return its stdout.
+ *
+ * Returns the command's stdout (one trailing `\n` stripped). Unterminated
+ * backticks still execute the body so partial input doesn't silently
+ * succeed; tests cover both well-formed and unterminated cases.
+ */
+const consumeBackQuoted = (s, start, varLookup) => {
+    let inner = '';
+    let i = start;
+    while (i < s.length) {
+        const c = s[i];
+        if (c === '`') {
+            return { end: i + 1, text: runBacktickCommand(inner) };
+        }
+        const sub = tryConsumeVarSubstitution(s, i, varLookup);
+        if (sub !== null) {
+            inner += sub.text;
+            i = sub.end;
+            continue;
+        }
+        inner += c;
+        i++;
+    }
+    // Unterminated — still run what we accumulated so the user can see the
+    // error from `sh` itself rather than silently dropping the command.
+    return { end: i, text: runBacktickCommand(inner) };
+};
+/**
+ * Lex a single slash-command argument starting at `s[i]`. Returns the parsed
+ * argument text and the index just past it, or `null` if no argument is
+ * available before end of input.
+ */
+const scanOneArg = (s, i, mode, varLookup) => {
+    // Skip leading whitespace (xslashargstart).
+    while (i < s.length && isWhitespace(s[i]))
+        i++;
+    if (i >= s.length)
+        return null;
+    // filepipe special: a leading `|` flips into whole-line mode for this arg.
+    if (mode === 'filepipe' && s[i] === '|') {
+        const rest = s.slice(i);
+        return { end: s.length, arg: rest };
+    }
+    // Accumulate the argument piece by piece. Each iteration consumes either:
+    //  - a single-quoted run
+    //  - a double-quoted run
+    //  - a backticked run
+    //  - a :var / :'var' / :"var" substitution
+    //  - a literal character (the catch-all)
+    // We stop on whitespace or `\` (which begins the next slash command).
+    let out = '';
+    while (i < s.length) {
+        const c = s[i];
+        if (isWhitespace(c))
+            break;
+        if (c === '\\')
+            break;
+        if (c === "'") {
+            const r = consumeSingleQuoted(s, i + 1);
+            out += r.text;
+            i = r.end;
+            continue;
+        }
+        if (c === '"') {
+            const r = consumeDoubleQuoted(s, i + 1);
+            out += r.text;
+            i = r.end;
+            continue;
+        }
+        if (c === '`') {
+            const r = consumeBackQuoted(s, i + 1, varLookup);
+            out += r.text;
+            i = r.end;
+            continue;
+        }
+        const sub = tryConsumeVarSubstitution(s, i, varLookup);
+        if (sub !== null) {
+            out += sub.text;
+            i = sub.end;
+            continue;
+        }
+        out += c;
+        i++;
+    }
+    return { end: i, arg: out };
+};
+/**
+ * Scan the argument portion of a backslash command.
+ *
+ * @param input     the rest of the input line *after* the command name (e.g.
+ *                  `"  foo 'bar baz'"` for `\echo  foo 'bar baz'`)
+ * @param mode      argument processing mode — see {@link SlashArgMode}
+ * @param varLookup callback that resolves `:varname` references. Omit (or
+ *                  pass `undefined`) for `no-vars` mode behaviour even when
+ *                  `mode !== 'no-vars'`.
+ *
+ * @returns array of parsed argument strings; empty input yields `[]`.
+ */
+export const scanSlashArgs = (input, mode, varLookup) => {
+    // Whole-line: return everything, with leading whitespace suppressed and a
+    // single trailing newline (if any) preserved verbatim. Empty (or
+    // whitespace-only) input yields no args.
+    if (mode === 'whole-line') {
+        let start = 0;
+        while (start < input.length && isWhitespace(input[start]))
+            start++;
+        if (start >= input.length)
+            return [];
+        return [input.slice(start)];
+    }
+    const effectiveLookup = mode === 'no-vars' ? undefined : varLookup;
+    const args = [];
+    let i = 0;
+    while (i < input.length) {
+        const result = scanOneArg(input, i, mode, effectiveLookup);
+        if (result === null)
+            break;
+        let arg = result.arg;
+        // sql-id / sql-id-keep-case post-process: collapse SQL-identifier
+        // quoting, optionally downcasing unquoted letters.
+        if (mode === 'sql-id') {
+            arg = dequoteDowncaseIdentifier(arg, true);
+        }
+        else if (mode === 'sql-id-keep-case') {
+            arg = dequoteDowncaseIdentifier(arg, false);
+        }
+        args.push(arg);
+        i = result.end;
+        // Consume the inter-arg whitespace so the next iteration starts cleanly.
+        while (i < input.length && isWhitespace(input[i]))
+            i++;
+        // Stop on a `\` — start of the next backslash command.
+        if (input[i] === '\\')
+            break;
+    }
+    return args;
+};
+// Re-export `dequote` for callers that want to undo `quoteIfNeeded` on
+// scanned args without reaching across modules.
+export { dequote };