pgsql-deparser 17.18.5 → 17.19.0

package/esm/deparser/index.js

@@ -0,0 +1,15 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
+import { Deparser } from './deparser';
+const deparseMethod = Deparser.deparse;
+// Export the original sync version as deparseSync
+export const deparseSync = deparseMethod;
+// Create an async wrapper for deparse
+export const deparse = async (...args) => {
+    return deparseMethod(...args);
+};
+export { Deparser };
+export { splitSqlLines } from './utils/sql-formatter';
+export { QuoteUtils } from '@pgsql/quotes';

package/esm/{utils → deparser/utils}/list-utils.js

@@ -1,3 +1,7 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
 export class ListUtils {
     static unwrapList(obj) {
         if (obj === undefined || obj === null) {

package/esm/deparser/utils/sql-formatter.js

@@ -0,0 +1,138 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
+const isIdentChar = (ch) => ch !== undefined && (/[A-Za-z0-9_$]/.test(ch) || ch.charCodeAt(0) >= 0x80);
+const DOLLAR_TAG = /\$(?:[A-Za-z_\u0080-\uffff][A-Za-z0-9_\u0080-\uffff]*)?\$/y;
+/**
+ * Splits SQL text into lines, breaking only at newlines that sit between
+ * tokens. A newline inside a string literal ('...', E'...', $tag$...$tag$),
+ * a quoted identifier or a block comment is part of that token's value and
+ * stays inside its line, so callers can re-indent the lines without changing
+ * what the SQL means.
+ */
+export function splitSqlLines(text, newlineChar = '\n') {
+    if (!newlineChar || !text.includes(newlineChar)) {
+        return [text];
+    }
+    const lines = [];
+    const length = text.length;
+    let lineStart = 0;
+    let i = 0;
+    while (i < length) {
+        const ch = text[i];
+        if (ch === "'") {
+            const prev = text[i - 1];
+            const backslashEscapes = (prev === 'E' || prev === 'e') && !isIdentChar(text[i - 2]);
+            i++;
+            while (i < length) {
+                if (backslashEscapes && text[i] === '\\') {
+                    i += 2;
+                }
+                else if (text[i] === "'") {
+                    if (text[i + 1] === "'") {
+                        i += 2;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                else {
+                    i++;
+                }
+            }
+            i++;
+        }
+        else if (ch === '"') {
+            i++;
+            while (i < length) {
+                if (text[i] === '"') {
+                    if (text[i + 1] === '"') {
+                        i += 2;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                else {
+                    i++;
+                }
+            }
+            i++;
+        }
+        else if (ch === '$' && !isIdentChar(text[i - 1])) {
+            DOLLAR_TAG.lastIndex = i;
+            const tag = DOLLAR_TAG.exec(text);
+            if (tag) {
+                const close = text.indexOf(tag[0], i + tag[0].length);
+                i = close === -1 ? length : close + tag[0].length;
+            }
+            else {
+                i++;
+            }
+        }
+        else if (ch === '-' && text[i + 1] === '-') {
+            const end = text.indexOf('\n', i);
+            i = end === -1 ? length : end;
+        }
+        else if (ch === '/' && text[i + 1] === '*') {
+            let depth = 1;
+            i += 2;
+            while (i < length && depth > 0) {
+                if (text[i] === '/' && text[i + 1] === '*') {
+                    depth++;
+                    i += 2;
+                }
+                else if (text[i] === '*' && text[i + 1] === '/') {
+                    depth--;
+                    i += 2;
+                }
+                else {
+                    i++;
+                }
+            }
+        }
+        else if (text.startsWith(newlineChar, i)) {
+            lines.push(text.slice(lineStart, i));
+            i += newlineChar.length;
+            lineStart = i;
+        }
+        else {
+            i++;
+        }
+    }
+    lines.push(text.slice(lineStart));
+    return lines;
+}
+export class SqlFormatter {
+    newlineChar;
+    tabChar;
+    prettyMode;
+    constructor(newlineChar = '\n', tabChar = '  ', prettyMode = true) {
+        this.newlineChar = newlineChar;
+        this.tabChar = tabChar;
+        this.prettyMode = prettyMode;
+    }
+    format(parts, separator = ' ') {
+        return parts.filter(part => part !== null && part !== undefined && part !== '').join(separator);
+    }
+    indent(text, count = 1) {
+        if (!this.prettyMode) {
+            return text;
+        }
+        const indentation = this.tabChar.repeat(count);
+        return splitSqlLines(text, this.newlineChar).map(line => line.trim() ? indentation + line : line).join(this.newlineChar);
+    }
+    parens(content) {
+        return `(${content})`;
+    }
+    newline() {
+        return this.newlineChar;
+    }
+    tab() {
+        return this.tabChar;
+    }
+    isPretty() {
+        return this.prettyMode;
+    }
+}

package/esm/{visitors → deparser/visitors}/base.js

@@ -1,3 +1,7 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-deparser-types.ts
+ */
 import { SqlFormatter } from '../utils/sql-formatter';
 export class DeparserContext {
     indentLevel;

package/esm/index.js

@@ -1,10 +1,24 @@
-import { Deparser } from "./deparser";
-const deparseMethod = Deparser.deparse;
-// Export the original sync version as deparseSync
-export const deparseSync = deparseMethod;
-// Create an async wrapper for deparse
-export const deparse = async (...args) => {
-    return deparseMethod(...args);
-};
-export { Deparser };
+/**
+ * Deparser for PostgreSQL version 17
+ * Auto-generated by generate-version-deparsers.ts
+ */
+import { Deparser as Deparser18 } from './deparser';
+import { PG17ToPG18Transformer } from './v17-to-v18-direct';
+const tx = new PG17ToPG18Transformer();
+const toAst18 = (query) => Array.isArray(query) ? query.map(node => tx.transform(node)) : tx.transform(query);
+export class Deparser extends Deparser18 {
+    constructor(tree, opts = {}) {
+        super(toAst18(tree), opts);
+    }
+    static deparse(query, opts = {}) {
+        return new Deparser(query, opts).deparseQuery();
+    }
+}
+export async function deparse(query, opts) {
+    return Deparser.deparse(query, opts);
+}
+export function deparseSync(query, opts) {
+    return Deparser.deparse(query, opts);
+}
+export { splitSqlLines } from './deparser/utils/sql-formatter';
 export { QuoteUtils } from '@pgsql/quotes';

package/esm/v17-to-v18-direct.js

@@ -0,0 +1,43 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-direct-transformer-types.ts
+ */
+import { V17ToV18Transformer } from "./v17-to-v18";
+/**
+ * Direct transformer from PG17 to PG18
+ * This transformer chains v17->...->v18 transformations
+ */
+export class PG17ToPG18Transformer {
+    v17to18 = new V17ToV18Transformer();
+    transform(node) {
+        if (this.isParseResult(node)) {
+            const transformedStmts = node.stmts.map((stmtWrapper) => {
+                if (stmtWrapper.stmt) {
+                    const transformedStmt = this.v17to18.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
+                    return { ...stmtWrapper, stmt: transformedStmt };
+                }
+                return stmtWrapper;
+            });
+            return {
+                ...node,
+                version: 180004, // PG18 version
+                stmts: transformedStmts
+            };
+        }
+        // Otherwise, transform as a regular node
+        return this.v17to18.transform(node, { parentNodeTypes: [] });
+    }
+    /**
+     * Transform a single statement from PG17 to PG18
+     * @deprecated Use transform() instead, which handles all node types
+     */
+    transformStatement(stmt) {
+        return this.v17to18.transform(stmt, { parentNodeTypes: [] });
+    }
+    /**
+     * Type guard to check if a node is a ParseResult
+     */
+    isParseResult(node) {
+        return node && typeof node === 'object' && 'version' in node && 'stmts' in node;
+    }
+}

package/esm/v17-to-v18.js

@@ -0,0 +1,209 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-transformer-types.ts
+ */
+// @ts-nocheck
+/**
+ * V17 to V18 AST Transformer
+ * Transforms PostgreSQL v17 AST nodes to v18 format
+ *
+ * Structural changes in v18:
+ * - InsertStmt/UpdateStmt/DeleteStmt/MergeStmt: returningList -> returningClause { exprs }
+ * - Constraint: new is_enforced flag (true by default for CHECK/FOREIGN/NOTNULL)
+ * - Constraint: CONSTR_GENERATED gains generated_kind ('s' = STORED, 'v' = VIRTUAL)
+ * - Column-level NOT NULL constraints gain initially_valid: true
+ */
+export class V17ToV18Transformer {
+    transform(node, context = { parentNodeTypes: [] }) {
+        if (node == null) {
+            return null;
+        }
+        if (typeof node === 'number' || node instanceof Number) {
+            return node;
+        }
+        if (typeof node === 'string') {
+            return node;
+        }
+        try {
+            return this.visit(node, context);
+        }
+        catch (error) {
+            const nodeType = Object.keys(node)[0];
+            throw new Error(`Error transforming ${nodeType}: ${error.message}`);
+        }
+    }
+    visit(node, context = { parentNodeTypes: [] }) {
+        if (node && typeof node === 'object' && 'version' in node && 'stmts' in node) {
+            return this.ParseResult(node, context);
+        }
+        const nodeType = this.getNodeType(node);
+        // Handle empty objects
+        if (!nodeType) {
+            return {};
+        }
+        const nodeData = this.getNodeData(node);
+        const methodName = nodeType;
+        if (typeof this[methodName] === 'function') {
+            const childContext = {
+                ...context,
+                parentNodeTypes: [...context.parentNodeTypes, nodeType]
+            };
+            const result = this[methodName](nodeData, childContext);
+            return result;
+        }
+        // No specific method: recurse into children so nested statements
+        // (e.g. DML inside CTEs) still get transformed
+        return this.walkValue(node, context);
+    }
+    /**
+     * Generic recursive walk that re-dispatches wrapped nodes with a
+     * dedicated transformer method and deep-copies everything else.
+     */
+    walkValue(value, context) {
+        if (value == null || typeof value !== 'object') {
+            return value;
+        }
+        if (Array.isArray(value)) {
+            return value.map(item => this.walkValue(item, context));
+        }
+        const keys = Object.keys(value);
+        if (keys.length === 1 && typeof this[keys[0]] === 'function') {
+            // Wrapped node with a dedicated transformer method
+            return this.visit(value, context);
+        }
+        const result = {};
+        for (const key of keys) {
+            result[key] = this.walkValue(value[key], context);
+        }
+        return result;
+    }
+    getNodeType(node) {
+        return Object.keys(node)[0];
+    }
+    getNodeData(node) {
+        const keys = Object.keys(node);
+        if (keys.length === 1 && typeof node[keys[0]] === 'object') {
+            return node[keys[0]];
+        }
+        return node;
+    }
+    ParseResult(node, context) {
+        if (node && typeof node === 'object' && 'version' in node && 'stmts' in node) {
+            return {
+                version: 180004, // PG18 version
+                stmts: node.stmts.map((stmt) => {
+                    if (stmt && typeof stmt === 'object' && 'stmt' in stmt) {
+                        return {
+                            ...stmt,
+                            stmt: this.transform(stmt.stmt, context)
+                        };
+                    }
+                    return this.transform(stmt, context);
+                })
+            };
+        }
+        return node;
+    }
+    RawStmt(node, context) {
+        const result = {};
+        if (node.stmt !== undefined) {
+            result.stmt = this.transform(node.stmt, context);
+        }
+        if (node.stmt_location !== undefined) {
+            result.stmt_location = node.stmt_location;
+        }
+        if (node.stmt_len !== undefined) {
+            result.stmt_len = node.stmt_len;
+        }
+        return { RawStmt: result };
+    }
+    /**
+     * Convert a v17 returningList into a v18 ReturningClause
+     */
+    transformReturningList(returningList, context) {
+        return {
+            exprs: returningList.map(item => this.transform(item, context))
+        };
+    }
+    transformDmlStatement(nodeType, node, context) {
+        const result = {};
+        for (const key of Object.keys(node)) {
+            if (key === 'returningList') {
+                result.returningClause = this.transformReturningList(node.returningList, context);
+            }
+            else {
+                result[key] = this.walkValue(node[key], context);
+            }
+        }
+        return { [nodeType]: result };
+    }
+    InsertStmt(node, context) {
+        return this.transformDmlStatement('InsertStmt', node, context);
+    }
+    UpdateStmt(node, context) {
+        return this.transformDmlStatement('UpdateStmt', node, context);
+    }
+    DeleteStmt(node, context) {
+        return this.transformDmlStatement('DeleteStmt', node, context);
+    }
+    MergeStmt(node, context) {
+        return this.transformDmlStatement('MergeStmt', node, context);
+    }
+    AlterTableCmd(node, context) {
+        const result = {};
+        for (const key of Object.keys(node)) {
+            result[key] = this.walkValue(node[key], context);
+        }
+        // v18 wraps ALTER CONSTRAINT definitions in the new ATAlterConstraint node
+        if (node.subtype === 'AT_AlterConstraint' && node.def?.Constraint) {
+            const constraint = node.def.Constraint;
+            const alterConstraint = {};
+            if (constraint.conname !== undefined) {
+                alterConstraint.conname = constraint.conname;
+            }
+            alterConstraint.is_enforced = true;
+            // v17 ALTER CONSTRAINT could only change deferrability
+            alterConstraint.alterDeferrability = true;
+            if (constraint.deferrable !== undefined) {
+                alterConstraint.deferrable = constraint.deferrable;
+            }
+            if (constraint.initdeferred !== undefined) {
+                alterConstraint.initdeferred = constraint.initdeferred;
+            }
+            result.def = { ATAlterConstraint: alterConstraint };
+        }
+        return { AlterTableCmd: result };
+    }
+    VariableSetStmt(node, context) {
+        const result = {};
+        for (const key of Object.keys(node)) {
+            result[key] = this.walkValue(node[key], context);
+        }
+        // v18 marks SET TRANSACTION / SESSION CHARACTERISTICS args as jumbled
+        if (node.kind === 'VAR_SET_MULTI' && (node.name === 'TRANSACTION' || node.name === 'SESSION CHARACTERISTICS')) {
+            result.jumble_args = true;
+        }
+        return { VariableSetStmt: result };
+    }
+    Constraint(node, context) {
+        const result = {};
+        for (const key of Object.keys(node)) {
+            result[key] = this.walkValue(node[key], context);
+        }
+        // v18 constraints are enforced by default; v17 grammar had no ENFORCED syntax
+        if (node.contype === 'CONSTR_CHECK' || node.contype === 'CONSTR_FOREIGN') {
+            result.is_enforced = true;
+        }
+        if (node.contype === 'CONSTR_NOTNULL') {
+            // v17 only produces column-level NOT NULL constraints, which in v18
+            // carry is_enforced and initially_valid
+            result.is_enforced = true;
+            result.initially_valid = true;
+        }
+        if (node.contype === 'CONSTR_GENERATED' && result.generated_kind === undefined) {
+            // v17 only supports STORED generated columns
+            result.generated_kind = 's';
+        }
+        return { Constraint: result };
+    }
+}

package/index.d.ts

@@ -1,6 +1,16 @@
-import { Deparser, DeparserOptions } from "./deparser";
-declare const deparseMethod: typeof Deparser.deparse;
-export declare const deparseSync: typeof Deparser.deparse;
-export declare const deparse: (...args: Parameters<typeof deparseMethod>) => Promise<ReturnType<typeof deparseMethod>>;
-export { Deparser, DeparserOptions };
+/**
+ * Deparser for PostgreSQL version 17
+ * Auto-generated by generate-version-deparsers.ts
+ */
+import { Node, ParseResult } from '@pgsql/types';
+import { Deparser as Deparser18, DeparserOptions } from './deparser';
+type Query = Node | Node[] | ParseResult;
+export declare class Deparser extends Deparser18 {
+    constructor(tree: Query, opts?: DeparserOptions);
+    static deparse(query: Query, opts?: DeparserOptions): string;
+}
+export declare function deparse(query: Query, opts?: DeparserOptions): Promise<string>;
+export declare function deparseSync(query: Query, opts?: DeparserOptions): string;
+export { DeparserOptions };
+export { splitSqlLines } from './deparser/utils/sql-formatter';
 export { QuoteUtils } from '@pgsql/quotes';

package/index.js

@@ -1,15 +1,32 @@
 "use strict";
+/**
+ * Deparser for PostgreSQL version 17
+ * Auto-generated by generate-version-deparsers.ts
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuoteUtils = exports.Deparser = exports.deparse = exports.deparseSync = void 0;
-const deparser_1 = require("./deparser");
-Object.defineProperty(exports, "Deparser", { enumerable: true, get: function () { return deparser_1.Deparser; } });
-const deparseMethod = deparser_1.Deparser.deparse;
-// Export the original sync version as deparseSync
-exports.deparseSync = deparseMethod;
-// Create an async wrapper for deparse
-const deparse = async (...args) => {
-    return deparseMethod(...args);
-};
+exports.QuoteUtils = exports.splitSqlLines = exports.Deparser = void 0;
 exports.deparse = deparse;
+exports.deparseSync = deparseSync;
+const deparser_1 = require("./deparser");
+const v17_to_v18_direct_1 = require("./v17-to-v18-direct");
+const tx = new v17_to_v18_direct_1.PG17ToPG18Transformer();
+const toAst18 = (query) => Array.isArray(query) ? query.map(node => tx.transform(node)) : tx.transform(query);
+class Deparser extends deparser_1.Deparser {
+    constructor(tree, opts = {}) {
+        super(toAst18(tree), opts);
+    }
+    static deparse(query, opts = {}) {
+        return new Deparser(query, opts).deparseQuery();
+    }
+}
+exports.Deparser = Deparser;
+async function deparse(query, opts) {
+    return Deparser.deparse(query, opts);
+}
+function deparseSync(query, opts) {
+    return Deparser.deparse(query, opts);
+}
+var sql_formatter_1 = require("./deparser/utils/sql-formatter");
+Object.defineProperty(exports, "splitSqlLines", { enumerable: true, get: function () { return sql_formatter_1.splitSqlLines; } });
 var quotes_1 = require("@pgsql/quotes");
 Object.defineProperty(exports, "QuoteUtils", { enumerable: true, get: function () { return quotes_1.QuoteUtils; } });

package/package.json

@@ -1,13 +1,17 @@
 {
-  "name": "pgsql-deparser",
-  "version": "17.18.5",
   "author": "Constructive <developers@constructive.io>",
-  "description": "PostgreSQL AST Deparser",
+  "homepage": "https://github.com/constructive-io/pgsql-parser",
+  "license": "MIT",
   "main": "index.js",
   "module": "esm/index.js",
   "types": "index.d.ts",
-  "homepage": "https://github.com/constructive-io/pgsql-parser",
-  "license": "MIT",
+  "description": "PostgreSQL AST Deparser",
+  "scripts": {
+    "copy": "copyfiles -f ../../../../LICENSE README.md package.json dist",
+    "clean": "rimraf dist",
+    "build": "npm run clean && tsc && tsc -p tsconfig.esm.json && npm run copy",
+    "publish:pkg": "npm publish --tag pg17"
+  },
   "publishConfig": {
     "access": "public",
     "directory": "dist"
@@ -19,29 +23,6 @@
   "bugs": {
     "url": "https://github.com/constructive-io/pgsql-parser/issues"
   },
-  "scripts": {
-    "copy": "makage assets",
-    "clean": "makage clean dist",
-    "prepublishOnly": "npm run build",
-    "build": "npm run clean && tsc && tsc -p tsconfig.esm.json && npm run copy",
-    "build:dev": "npm run clean && tsc --declarationMap && tsc -p tsconfig.esm.json && npm run copy",
-    "kitchen-sink": "npm run fixtures && npm run fixtures:kitchen-sink",
-    "fixtures:kitchen-sink": "ts-node scripts/make-kitchen-sink.ts",
-    "fixtures:ast": "ts-node scripts/make-fixtures-ast.ts",
-    "fixtures:sql": "ts-node scripts/make-fixtures-sql.ts",
-    "fixtures": "ts-node scripts/make-fixtures.ts",
-    "fixtures:upstream-diff": "ts-node scripts/make-upstream-diff.ts",
-    "lint": "eslint . --fix",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "strip-transformer-types": "ts-node scripts/strip-transformer-types.ts",
-    "strip-direct-transformer-types": "ts-node scripts/strip-direct-transformer-types.ts",
-    "strip-deparser-types": "ts-node scripts/strip-deparser-types.ts",
-    "organize-transformers": "ts-node scripts/organize-transformers-by-version.ts",
-    "generate-version-deparsers": "ts-node scripts/generate-version-deparsers.ts",
-    "generate-packages": "ts-node scripts/generate-version-packages.ts",
-    "prepare-versions": "npm run strip-transformer-types && npm run strip-direct-transformer-types && npm run strip-deparser-types && npm run organize-transformers && npm run generate-version-deparsers && npm run generate-packages"
-  },
   "keywords": [
     "sql",
     "postgres",
@@ -52,13 +33,10 @@
     "deparser",
     "database"
   ],
-  "devDependencies": {
-    "libpg-query": "17.7.3",
-    "makage": "^0.1.8"
-  },
+  "name": "pgsql-deparser",
+  "version": "17.19.0",
   "dependencies": {
-    "@pgsql/quotes": "17.1.0",
+    "@pgsql/quotes": "18.2.4",
     "@pgsql/types": "^17.6.2"
-  },
-  "gitHead": "4213e2c9da8ccb8d21c4ec02f35e34aef65b8ced"
-}
+  }
+}

package/v17-to-v18-direct.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-direct-transformer-types.ts
+ */
+/**
+ * Direct transformer from PG17 to PG18
+ * This transformer chains v17->...->v18 transformations
+ */
+export declare class PG17ToPG18Transformer {
+    private v17to18;
+    transform(node: any): any;
+    /**
+     * Transform a single statement from PG17 to PG18
+     * @deprecated Use transform() instead, which handles all node types
+     */
+    transformStatement(stmt: any): any;
+    /**
+     * Type guard to check if a node is a ParseResult
+     */
+    private isParseResult;
+}

package/v17-to-v18-direct.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Auto-generated file with types stripped for better tree-shaking
+ * DO NOT EDIT - Generated by strip-direct-transformer-types.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PG17ToPG18Transformer = void 0;
+const v17_to_v18_1 = require("./v17-to-v18");
+/**
+ * Direct transformer from PG17 to PG18
+ * This transformer chains v17->...->v18 transformations
+ */
+class PG17ToPG18Transformer {
+    v17to18 = new v17_to_v18_1.V17ToV18Transformer();
+    transform(node) {
+        if (this.isParseResult(node)) {
+            const transformedStmts = node.stmts.map((stmtWrapper) => {
+                if (stmtWrapper.stmt) {
+                    const transformedStmt = this.v17to18.transform(stmtWrapper.stmt, { parentNodeTypes: [] });
+                    return { ...stmtWrapper, stmt: transformedStmt };
+                }
+                return stmtWrapper;
+            });
+            return {
+                ...node,
+                version: 180004, // PG18 version
+                stmts: transformedStmts
+            };
+        }
+        // Otherwise, transform as a regular node
+        return this.v17to18.transform(node, { parentNodeTypes: [] });
+    }
+    /**
+     * Transform a single statement from PG17 to PG18
+     * @deprecated Use transform() instead, which handles all node types
+     */
+    transformStatement(stmt) {
+        return this.v17to18.transform(stmt, { parentNodeTypes: [] });
+    }
+    /**
+     * Type guard to check if a node is a ParseResult
+     */
+    isParseResult(node) {
+        return node && typeof node === 'object' && 'version' in node && 'stmts' in node;
+    }
+}
+exports.PG17ToPG18Transformer = PG17ToPG18Transformer;