prettier-plugin-sql-cst 0.18.0 → 0.19.1

package/dist/syntax/cast.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.castMap = void 0;
-var print_utils_1 = require("../print_utils");
-exports.castMap = {
-    cast_definition: function (print) { return (0, print_utils_1.group)(print.spaced(["from", "asKw", "to"])); },
+import { group } from "../print_utils";
+export const castMap = {
+    cast_definition: (print) => group(print.spaced(["from", "asKw", "to"])),
 };

package/dist/syntax/comment.js

@@ -1,123 +1,54 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.commentMap = void 0;
-var print_utils_1 = require("../print_utils");
-exports.commentMap = {
-    comment_stmt: function (print) {
-        return (0, print_utils_1.group)([
-            print.spaced(["commentKw", "onKw", "target", "isKw"]),
-            (0, print_utils_1.indent)([print_utils_1.line, print("message")]),
-        ]);
-    },
-    comment_target_aggregate: function (print) {
-        return (0, print_utils_1.group)([print.spaced(["aggregateKw", "name"]), print(["params"])]);
-    },
-    comment_target_function: function (print) {
-        return (0, print_utils_1.group)([print.spaced(["functionKw", "name"]), print(["params"])]);
-    },
-    comment_target_procedure: function (print) {
-        return (0, print_utils_1.group)([print.spaced(["procedureKw", "name"]), print(["params"])]);
-    },
-    comment_target_routine: function (print) {
-        return (0, print_utils_1.group)([print.spaced(["routineKw", "name"]), print(["params"])]);
-    },
-    comment_target_access_method: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["accessMethodKw", "name"]));
-    },
-    comment_target_cast: function (print) { return (0, print_utils_1.group)(print.spaced(["castKw", "args"])); },
-    comment_target_collation: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["collationKw", "name"]));
-    },
-    comment_target_column: function (print) { return (0, print_utils_1.group)(print.spaced(["columnKw", "name"])); },
-    comment_target_table_constraint: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["constraintKw", "name", "onKw", "tableName"]));
-    },
-    comment_target_domain_constraint: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["constraintKw", "name", "onKw", "domainKw", "domainName"]));
-    },
-    comment_target_conversion: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["conversionKw", "name"]));
-    },
-    comment_target_database: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["databaseKw", "name"]));
-    },
-    comment_target_domain: function (print) { return (0, print_utils_1.group)(print.spaced(["domainKw", "name"])); },
-    comment_target_extension: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["extensionKw", "name"]));
-    },
-    comment_target_event_trigger: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["eventTriggerKw", "name"]));
-    },
-    comment_target_foreign_data_wrapper: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["foreignDataWrapperKw", "name"]));
-    },
-    comment_target_foreign_table: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["foreignTableKw", "name"]));
-    },
-    comment_target_index: function (print) { return (0, print_utils_1.group)(print.spaced(["indexKw", "name"])); },
-    comment_target_language: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["languageKw", "name"]));
-    },
-    comment_target_large_object: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["largeObjectKw", "oid"]));
-    },
-    comment_target_materialized_view: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["materializedViewKw", "name"]));
-    },
-    comment_target_operator_class: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["operatorClassKw", "name", "usingKw", "methodName"]));
-    },
-    comment_target_operator_family: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["operatorFamilyKw", "name", "usingKw", "methodName"]));
-    },
-    comment_target_policy: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["policyKw", "name", "onKw", "tableName"]));
-    },
-    comment_target_publication: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["publicationKw", "name"]));
-    },
-    comment_target_role: function (print) { return (0, print_utils_1.group)(print.spaced(["roleKw", "name"])); },
-    comment_target_rule: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["ruleKw", "name", "onKw", "tableName"]));
-    },
-    comment_target_schema: function (print) { return (0, print_utils_1.group)(print.spaced(["schemaKw", "name"])); },
-    comment_target_sequence: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["sequenceKw", "name"]));
-    },
-    comment_target_server: function (print) { return (0, print_utils_1.group)(print.spaced(["serverKw", "name"])); },
-    comment_target_statistics: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["statisticsKw", "name"]));
-    },
-    comment_target_subscription: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["subscriptionKw", "name"]));
-    },
-    comment_target_table: function (print) { return (0, print_utils_1.group)(print.spaced(["tableKw", "name"])); },
-    comment_target_tablespace: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["tablespaceKw", "name"]));
-    },
-    comment_target_text_search_configuration: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["textSearchConfigurationKw", "name"]));
-    },
-    comment_target_text_search_dictionary: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["textSearchDictionaryKw", "name"]));
-    },
-    comment_target_text_search_parser: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["textSearchParserKw", "name"]));
-    },
-    comment_target_text_search_template: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["textSearchTemplateKw", "name"]));
-    },
-    comment_target_transform: function (print) {
-        return (0, print_utils_1.group)(print.spaced([
-            "transformForKw",
-            "typeName",
-            "languageKw",
-            "languageName",
-        ]));
-    },
-    comment_target_trigger: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["triggerKw", "name", "onKw", "tableName"]));
-    },
-    comment_target_type: function (print) { return (0, print_utils_1.group)(print.spaced(["typeKw", "name"])); },
-    comment_target_view: function (print) { return (0, print_utils_1.group)(print.spaced(["viewKw", "name"])); },
+import { group, indent, line } from "../print_utils";
+export const commentMap = {
+    comment_stmt: (print) => group([
+        print.spaced(["commentKw", "onKw", "target", "isKw"]),
+        indent([line, print("message")]),
+    ]),
+    comment_target_aggregate: (print) => group([print.spaced(["aggregateKw", "name"]), print(["params"])]),
+    comment_target_function: (print) => group([print.spaced(["functionKw", "name"]), print(["params"])]),
+    comment_target_procedure: (print) => group([print.spaced(["procedureKw", "name"]), print(["params"])]),
+    comment_target_routine: (print) => group([print.spaced(["routineKw", "name"]), print(["params"])]),
+    comment_target_access_method: (print) => group(print.spaced(["accessMethodKw", "name"])),
+    comment_target_cast: (print) => group(print.spaced(["castKw", "args"])),
+    comment_target_collation: (print) => group(print.spaced(["collationKw", "name"])),
+    comment_target_column: (print) => group(print.spaced(["columnKw", "name"])),
+    comment_target_table_constraint: (print) => group(print.spaced(["constraintKw", "name", "onKw", "tableName"])),
+    comment_target_domain_constraint: (print) => group(print.spaced(["constraintKw", "name", "onKw", "domainKw", "domainName"])),
+    comment_target_conversion: (print) => group(print.spaced(["conversionKw", "name"])),
+    comment_target_database: (print) => group(print.spaced(["databaseKw", "name"])),
+    comment_target_domain: (print) => group(print.spaced(["domainKw", "name"])),
+    comment_target_extension: (print) => group(print.spaced(["extensionKw", "name"])),
+    comment_target_event_trigger: (print) => group(print.spaced(["eventTriggerKw", "name"])),
+    comment_target_foreign_data_wrapper: (print) => group(print.spaced(["foreignDataWrapperKw", "name"])),
+    comment_target_foreign_table: (print) => group(print.spaced(["foreignTableKw", "name"])),
+    comment_target_index: (print) => group(print.spaced(["indexKw", "name"])),
+    comment_target_language: (print) => group(print.spaced(["languageKw", "name"])),
+    comment_target_large_object: (print) => group(print.spaced(["largeObjectKw", "oid"])),
+    comment_target_materialized_view: (print) => group(print.spaced(["materializedViewKw", "name"])),
+    comment_target_operator_class: (print) => group(print.spaced(["operatorClassKw", "name", "usingKw", "methodName"])),
+    comment_target_operator_family: (print) => group(print.spaced(["operatorFamilyKw", "name", "usingKw", "methodName"])),
+    comment_target_policy: (print) => group(print.spaced(["policyKw", "name", "onKw", "tableName"])),
+    comment_target_publication: (print) => group(print.spaced(["publicationKw", "name"])),
+    comment_target_role: (print) => group(print.spaced(["roleKw", "name"])),
+    comment_target_rule: (print) => group(print.spaced(["ruleKw", "name", "onKw", "tableName"])),
+    comment_target_schema: (print) => group(print.spaced(["schemaKw", "name"])),
+    comment_target_sequence: (print) => group(print.spaced(["sequenceKw", "name"])),
+    comment_target_server: (print) => group(print.spaced(["serverKw", "name"])),
+    comment_target_statistics: (print) => group(print.spaced(["statisticsKw", "name"])),
+    comment_target_subscription: (print) => group(print.spaced(["subscriptionKw", "name"])),
+    comment_target_table: (print) => group(print.spaced(["tableKw", "name"])),
+    comment_target_tablespace: (print) => group(print.spaced(["tablespaceKw", "name"])),
+    comment_target_text_search_configuration: (print) => group(print.spaced(["textSearchConfigurationKw", "name"])),
+    comment_target_text_search_dictionary: (print) => group(print.spaced(["textSearchDictionaryKw", "name"])),
+    comment_target_text_search_parser: (print) => group(print.spaced(["textSearchParserKw", "name"])),
+    comment_target_text_search_template: (print) => group(print.spaced(["textSearchTemplateKw", "name"])),
+    comment_target_transform: (print) => group(print.spaced([
+        "transformForKw",
+        "typeName",
+        "languageKw",
+        "languageName",
+    ])),
+    comment_target_trigger: (print) => group(print.spaced(["triggerKw", "name", "onKw", "tableName"])),
+    comment_target_type: (print) => group(print.spaced(["typeKw", "name"])),
+    comment_target_view: (print) => group(print.spaced(["viewKw", "name"])),
 };

package/dist/syntax/constraint.d.ts

@@ -3,4 +3,4 @@ import { AllConstraintNodes, AlterActionAddConstraint, Constraint } from "sql-pa
 import { CstToDocMap } from "../CstToDocMap";
 import { PrintFn } from "../PrintFn";
 export declare const constraintMap: CstToDocMap<AllConstraintNodes>;
-export declare const printUnnamedConstraint: <T>(print: PrintFn<Constraint<T>, "name" | "modifiers" | "constraint"> | PrintFn<AlterActionAddConstraint, "name" | "modifiers" | "constraint" | "addKw">, node: AlterActionAddConstraint | Constraint<T>) => Doc;
+export declare const printUnnamedConstraint: <T>(print: PrintFn<Constraint<T>> | PrintFn<AlterActionAddConstraint>, node: Constraint<T> | AlterActionAddConstraint) => Doc;

package/dist/syntax/constraint.js

@@ -1,116 +1,80 @@
-"use strict";
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.printUnnamedConstraint = exports.constraintMap = void 0;
-var print_utils_1 = require("../print_utils");
-exports.constraintMap = {
+import { group, indent, line, hardline, join } from "../print_utils";
+export const constraintMap = {
     /** cst-ignore: constraint, modifiers */
-    constraint: function (print, node) {
+    constraint: (print, node) => {
         if (node.name) {
-            return (0, print_utils_1.group)([
+            return group([
                 print("name"),
-                (0, print_utils_1.indent)([print_utils_1.line, (0, exports.printUnnamedConstraint)(print, node)]),
+                indent([line, printUnnamedConstraint(print, node)]),
             ]);
         }
         else {
-            return (0, exports.printUnnamedConstraint)(print, node);
+            return printUnnamedConstraint(print, node);
         }
     },
-    constraint_name: function (print) { return print.spaced(["constraintKw", "name"]); },
-    constraint_modifier: function (print) { return print.spaced("kw"); },
-    constraint_null: function (print) { return print("nullKw"); },
-    constraint_not_null: function (print) { return (0, print_utils_1.group)(print.spaced(["notNullKw", "clauses"])); },
-    constraint_default: function (print) { return (0, print_utils_1.group)(print.spaced(["defaultKw", "expr"])); },
-    constraint_primary_key: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["primaryKeyKw", "direction", "columns", "clauses"]));
-    },
-    constraint_unique: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["uniqueKw", "columns", "nullsKw", "clauses"]));
-    },
-    existing_index: function (print) { return print.spaced(["usingIndexKw", "index"]); },
-    constraint_check: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["checkKw", "expr", "clauses"]));
-    },
-    constraint_collate: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["collateKw", "collation"]));
-    },
-    constraint_foreign_key: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["foreignKeyKw", "indexName", "columns", "references"]));
-    },
-    references_specification: function (print, node) {
-        var baseDoc = print.spaced(["referencesKw", "table", "columns"]);
+    constraint_name: (print) => print.spaced(["constraintKw", "name"]),
+    constraint_modifier: (print) => print.spaced("kw"),
+    constraint_null: (print) => print("nullKw"),
+    constraint_not_null: (print) => group(print.spaced(["notNullKw", "clauses"])),
+    constraint_default: (print) => group(print.spaced(["defaultKw", "expr"])),
+    constraint_primary_key: (print) => group(print.spaced(["primaryKeyKw", "direction", "columns", "clauses"])),
+    constraint_unique: (print) => group(print.spaced(["uniqueKw", "columns", "nullsKw", "clauses"])),
+    existing_index: (print) => print.spaced(["usingIndexKw", "index"]),
+    constraint_check: (print) => group(print.spaced(["checkKw", "expr", "clauses"])),
+    constraint_collate: (print) => group(print.spaced(["collateKw", "collation"])),
+    constraint_foreign_key: (print) => group(print.spaced(["foreignKeyKw", "indexName", "columns", "references"])),
+    references_specification: (print, node) => {
+        const baseDoc = print.spaced(["referencesKw", "table", "columns"]);
         if (node.options.length > 0) {
-            return (0, print_utils_1.group)([
+            return group([
                 baseDoc,
-                (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.join)(print_utils_1.hardline, print("options"))]),
+                indent([hardline, join(hardline, print("options"))]),
             ]);
         }
         else {
             return baseDoc;
         }
     },
-    referential_action: function (print) {
-        return print.spaced(["onKw", "eventKw", "actionKw", "columns"]);
-    },
-    referential_match: function (print) { return print.spaced(["matchKw", "typeKw"]); },
-    constraint_generated: function (print) {
-        return print.spaced([
-            "generatedKw",
-            "asKw",
-            "expr",
-            "storageKw",
-            "sequenceOptions",
-        ]);
-    },
-    identity_column: function (print) { return print("identityKw"); },
-    constraint_auto_increment: function (print) { return print("autoIncrementKw"); },
-    on_conflict_clause: function (print) { return print.spaced(["onConflictKw", "resolutionKw"]); },
-    constraint_comment: function (print) { return print.spaced(["commentKw", "value"]); },
-    constraint_index: function (print) {
-        return print.spaced(["indexTypeKw", "indexKw", "columns"]);
-    },
-    constraint_visible: function (print) { return print.spaced(["visibleKw"]); },
-    constraint_column_format: function (print) {
-        return print.spaced(["columnFormatKw", "formatKw"]);
-    },
-    constraint_storage: function (print) { return print.spaced(["storageKw", "typeKw"]); },
-    constraint_engine_attribute: function (print, node) {
-        return (0, print_utils_1.join)(node.hasEq ? " = " : " ", print(["engineAttributeKw", "value"]));
-    },
-    constraint_compression: function (print) { return print.spaced(["compressionKw", "method"]); },
-    constraint_exclude: function (print, node) {
-        return (0, print_utils_1.group)([
-            print("excludeKw"),
-            (0, print_utils_1.indent)([
-                print_utils_1.line,
-                (0, print_utils_1.join)(print_utils_1.line, __spreadArray([
-                    print.separated(print_utils_1.line, ["using", "params"])
-                ], print("clauses"), true)),
+    referential_action: (print) => print.spaced(["onKw", "eventKw", "actionKw", "columns"]),
+    referential_match: (print) => print.spaced(["matchKw", "typeKw"]),
+    constraint_generated: (print) => print.spaced([
+        "generatedKw",
+        "asKw",
+        "expr",
+        "storageKw",
+        "sequenceOptions",
+    ]),
+    identity_column: (print) => print("identityKw"),
+    constraint_auto_increment: (print) => print("autoIncrementKw"),
+    on_conflict_clause: (print) => print.spaced(["onConflictKw", "resolutionKw"]),
+    constraint_comment: (print) => print.spaced(["commentKw", "value"]),
+    constraint_index: (print) => print.spaced(["indexTypeKw", "indexKw", "columns"]),
+    constraint_visible: (print) => print.spaced(["visibleKw"]),
+    constraint_column_format: (print) => print.spaced(["columnFormatKw", "formatKw"]),
+    constraint_storage: (print) => print.spaced(["storageKw", "typeKw"]),
+    constraint_engine_attribute: (print, node) => join(node.hasEq ? " = " : " ", print(["engineAttributeKw", "value"])),
+    constraint_compression: (print) => print.spaced(["compressionKw", "method"]),
+    constraint_exclude: (print, node) => group([
+        print("excludeKw"),
+        indent([
+            line,
+            join(line, [
+                print.separated(line, ["using", "params"]),
+                ...print("clauses"),
             ]),
-        ]);
-    },
-    exclusion_param: function (print) { return print.spaced(["index", "withKw", "operator"]); },
-    index_tablespace_clause: function (print) {
-        return print.spaced(["usingIndexTablespaceKw", "name"]);
-    },
+        ]),
+    ]),
+    exclusion_param: (print) => print.spaced(["index", "withKw", "operator"]),
+    index_tablespace_clause: (print) => print.spaced(["usingIndexTablespaceKw", "name"]),
 };
-var printUnnamedConstraint = function (print, node) {
+export const printUnnamedConstraint = (print, node) => {
     if (node.modifiers.length > 0) {
-        return (0, print_utils_1.group)([
+        return group([
             print("constraint"),
-            (0, print_utils_1.indent)([print_utils_1.line, print.spaced("modifiers")]),
+            indent([line, print.spaced("modifiers")]),
         ]);
     }
     else {
         return print("constraint");
     }
 };
-exports.printUnnamedConstraint = printUnnamedConstraint;

package/dist/syntax/create_table.js

@@ -1,45 +1,25 @@
-"use strict";
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTableMap = void 0;
-var node_utils_1 = require("../node_utils");
-var print_utils_1 = require("../print_utils");
-exports.createTableMap = {
+import { isAsClause } from "../node_utils";
+import { group, join, line } from "../print_utils";
+export const createTableMap = {
     /** cst-ignore: clauses */
-    create_table_stmt: function (print, node) {
-        var rest = [];
-        for (var _i = 2; _i < arguments.length; _i++) {
-            rest[_i - 2] = arguments[_i];
-        }
-        return (0, print_utils_1.group)([
-            print.spaced([
-                "createKw",
-                "orReplaceKw",
-                "kind",
-                "tableKw",
-                "ifNotExistsKw",
-                "name",
-                "partitionOf",
-                "ofType",
-                "columns",
-            ]),
-            printClauses.apply(void 0, __spreadArray([print, node], rest, false)),
-            node.options ? [print_utils_1.line, (0, print_utils_1.group)(print("options"))] : [],
-        ]);
-    },
-    relation_kind: function (print) { return print.spaced("kindKw"); },
-    column_definition: function (print) {
-        return print.spaced(["name", "dataType", "withOptionsKw", "constraints"]);
-    },
-    table_option: function (print, node) {
+    create_table_stmt: (print, node, ...rest) => group([
+        print.spaced([
+            "createKw",
+            "orReplaceKw",
+            "kind",
+            "tableKw",
+            "ifNotExistsKw",
+            "name",
+            "partitionOf",
+            "ofType",
+            "columns",
+        ]),
+        printClauses(print, node, ...rest),
+        node.options ? [line, group(print("options"))] : [],
+    ]),
+    relation_kind: (print) => print.spaced("kindKw"),
+    column_definition: (print) => print.spaced(["name", "dataType", "withOptionsKw", "constraints"]),
+    table_option: (print, node) => {
         if (node.value && node.hasEq) {
             return [print.spaced("name"), " = ", print.spaced("value")];
         }
@@ -50,56 +30,38 @@ exports.createTableMap = {
             return print.spaced("name");
         }
     },
-    create_table_like_clause: function (print) {
-        return print.spaced(["likeKw", "name", "options"]);
-    },
-    table_like_option: function (print) {
-        return print.spaced(["includingOrExcludingKw", "optionKw"]);
-    },
-    create_table_copy_clause: function (print) { return print.spaced(["copyKw", "name"]); },
-    create_table_clone_clause: function (print) { return print.spaced(["cloneKw", "table"]); },
-    with_partition_columns_clause: function (print) {
-        return print.spaced(["withPartitionColumnsKw", "columns"]);
-    },
-    create_table_using_clause: function (print) { return print.spaced(["usingKw", "module"]); },
-    create_table_inherits_clause: function (print) {
-        return print.spaced(["inheritsKw", "tables"]);
-    },
-    create_table_partition_by_clause: function (print) {
-        return print.spaced(["partitionByKw", "strategyKw", "columns"]);
-    },
-    create_table_partition_of_clause: function (print) {
-        return print.spaced(["partitionOfKw", "table"]);
-    },
-    create_table_partition_bound_clause: function (print) {
-        return print.spaced(["forValuesKw", "bound"]);
-    },
-    partition_bound_in: function (print) { return print.spaced(["inKw", "values"]); },
-    partition_bound_from_to: function (print) {
-        return print.spaced(["fromKw", "from", "toKw", "to"]);
-    },
-    partition_bound_minvalue: function (print) { return print.spaced("minvalueKw"); },
-    partition_bound_maxvalue: function (print) { return print.spaced("maxvalueKw"); },
-    partition_bound_with: function (print) { return print.spaced(["withKw", "values"]); },
-    partition_bound_modulus: function (print) { return print.spaced(["modulusKw", "value"]); },
-    partition_bound_remainder: function (print) { return print.spaced(["remainderKw", "value"]); },
-    create_table_default_partition_clause: function (print) { return print.spaced("defaultKw"); },
-    create_table_of_type_clause: function (print) { return print.spaced(["ofKw", "typeName"]); },
-    using_access_method_clause: function (print) { return print.spaced(["usingKw", "method"]); },
-    tablespace_clause: function (print) { return print.spaced(["tablespaceKw", "name"]); },
-    create_table_without_oids_clause: function (print) { return print.spaced("withoutOidsKw"); },
-    create_table_on_commit_clause: function (print) {
-        return print.spaced(["onCommitKw", "actionKw"]);
-    },
-    with_data_clause: function (print) { return print.spaced("withDataKw"); },
-    create_table_server_clause: function (print) { return print.spaced(["serverKw", "name"]); },
+    create_table_like_clause: (print) => print.spaced(["likeKw", "name", "options"]),
+    table_like_option: (print) => print.spaced(["includingOrExcludingKw", "optionKw"]),
+    create_table_copy_clause: (print) => print.spaced(["copyKw", "name"]),
+    create_table_clone_clause: (print) => print.spaced(["cloneKw", "table"]),
+    with_partition_columns_clause: (print) => print.spaced(["withPartitionColumnsKw", "columns"]),
+    create_table_using_clause: (print) => print.spaced(["usingKw", "module"]),
+    create_table_inherits_clause: (print) => print.spaced(["inheritsKw", "tables"]),
+    create_table_partition_by_clause: (print) => print.spaced(["partitionByKw", "strategyKw", "columns"]),
+    create_table_partition_of_clause: (print) => print.spaced(["partitionOfKw", "table"]),
+    create_table_partition_bound_clause: (print) => print.spaced(["forValuesKw", "bound"]),
+    partition_bound_in: (print) => print.spaced(["inKw", "values"]),
+    partition_bound_from_to: (print) => print.spaced(["fromKw", "from", "toKw", "to"]),
+    partition_bound_minvalue: (print) => print.spaced("minvalueKw"),
+    partition_bound_maxvalue: (print) => print.spaced("maxvalueKw"),
+    partition_bound_with: (print) => print.spaced(["withKw", "values"]),
+    partition_bound_modulus: (print) => print.spaced(["modulusKw", "value"]),
+    partition_bound_remainder: (print) => print.spaced(["remainderKw", "value"]),
+    create_table_default_partition_clause: (print) => print.spaced("defaultKw"),
+    create_table_of_type_clause: (print) => print.spaced(["ofKw", "typeName"]),
+    using_access_method_clause: (print) => print.spaced(["usingKw", "method"]),
+    tablespace_clause: (print) => print.spaced(["tablespaceKw", "name"]),
+    create_table_without_oids_clause: (print) => print.spaced("withoutOidsKw"),
+    create_table_on_commit_clause: (print) => print.spaced(["onCommitKw", "actionKw"]),
+    with_data_clause: (print) => print.spaced("withDataKw"),
+    create_table_server_clause: (print) => print.spaced(["serverKw", "name"]),
 };
-var printClauses = function (print, node) {
-    if (node.clauses.length === 1 && (0, node_utils_1.isAsClause)(node.clauses[0])) {
+const printClauses = (print, node) => {
+    if (node.clauses.length === 1 && isAsClause(node.clauses[0])) {
         return [" ", print("clauses")];
     }
     else if (node.clauses.length > 0) {
-        return [print_utils_1.line, (0, print_utils_1.join)(print_utils_1.line, print("clauses"))];
+        return [line, join(line, print("clauses"))];
     }
     else {
         return [];

package/dist/syntax/data_type.js

@@ -1,48 +1,29 @@
-"use strict";
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dataTypeMap = void 0;
-var utils_1 = require("../utils");
-var print_utils_1 = require("../print_utils");
-var node_utils_1 = require("../node_utils");
-exports.dataTypeMap = {
-    data_type_name: function (print) { return print.spaced("name"); },
+import { isArray } from "../utils";
+import { group, indent, join, softline } from "../print_utils";
+import { isDataTypeName } from "../node_utils";
+export const dataTypeMap = {
+    data_type_name: (print) => print.spaced("name"),
     // print single-word types as `TYPE(10)` and multi-word types as `MY TYPE (10)`
-    modified_data_type: function (print, node) {
-        return (isMultiWordTypeName(node.dataType) ? print.spaced : print)([
-            "dataType",
-            "modifiers",
-        ]);
-    },
-    setof_data_type: function (print) { return print.spaced(["setofKw", "dataType"]); },
-    array_data_type: function (print) { return print(["dataType", "bounds"]); },
-    array_bounds: function (print) { return ["[", print("bounds"), "]"]; },
-    time_data_type: function (print, node) {
-        return (0, print_utils_1.group)((0, print_utils_1.join)(" ", __spreadArray([
-            print(["timeKw", "precision"])
-        ], (node.timeZoneKw ? [print.spaced("timeZoneKw")] : []), true)));
-    },
-    interval_data_type: function (print) { return print.spaced(["intervalKw", "unit"]); },
-    interval_unit_range: function (print) { return print.spaced(["fromUnit", "toKw", "toUnit"]); },
-    interval_unit: function (print) { return print.spaced(["unitKw", "precision"]); },
-    parametric_data_type: function (print) { return print(["typeKw", "params"]); },
-    generic_type_params: function (print) {
-        return (0, print_utils_1.group)(["<", (0, print_utils_1.indent)([print_utils_1.softline, print("params")]), print_utils_1.softline, ">"]);
-    },
-    array_type_param: function (print) { return print.spaced(["dataType", "constraints"]); },
-    struct_type_param: function (print) {
-        return print.spaced(["name", "dataType", "constraints"]);
-    },
-    table_data_type: function (print) { return print.spaced(["tableKw", "columns"]); },
+    modified_data_type: (print, node) => (isMultiWordTypeName(node.dataType) ? print.spaced : print)([
+        "dataType",
+        "modifiers",
+    ]),
+    setof_data_type: (print) => print.spaced(["setofKw", "dataType"]),
+    array_data_type: (print) => print(["dataType", "bounds"]),
+    array_bounds: (print) => ["[", print("bounds"), "]"],
+    time_data_type: (print, node) => group(join(" ", [
+        print(["timeKw", "precision"]),
+        ...(node.timeZoneKw ? [print.spaced("timeZoneKw")] : []),
+    ])),
+    interval_data_type: (print) => print.spaced(["intervalKw", "unit"]),
+    interval_unit_range: (print) => print.spaced(["fromUnit", "toKw", "toUnit"]),
+    interval_unit: (print) => print.spaced(["unitKw", "precision"]),
+    parametric_data_type: (print) => print(["typeKw", "params"]),
+    generic_type_params: (print) => group(["<", indent([softline, print("params")]), softline, ">"]),
+    array_type_param: (print) => print.spaced(["dataType", "constraints"]),
+    struct_type_param: (print) => print.spaced(["name", "dataType", "constraints"]),
+    table_data_type: (print) => print.spaced(["tableKw", "columns"]),
 };
 function isMultiWordTypeName(node) {
-    return (0, node_utils_1.isDataTypeName)(node) && (0, utils_1.isArray)(node.name) && node.name.length > 1;
+    return isDataTypeName(node) && isArray(node.name) && node.name.length > 1;
 }