prettier-plugin-sql-cst 0.18.0 → 0.19.1

package/dist/syntax/expr.js

@@ -1,58 +1,46 @@
-"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.printLiteral = exports.exprMap = void 0;
-var print_utils_1 = require("../print_utils");
-var node_utils_1 = require("../node_utils");
-var utils_1 = require("../utils");
-exports.exprMap = {
-    list_expr: function (print, node, path) {
-        var parent = path.getParentNode();
-        var children = print("items").map(function (it) { return (0, print_utils_1.group)(it); });
-        var lineType = (0, node_utils_1.isValuesClause)(parent) ? print_utils_1.hardline : print_utils_1.line;
+import { join, line, softline, hardline, indent, group, stripTrailingHardline, } from "../print_utils";
+import { isCreateTableStmt, isKeyword, isValuesClause, isEmpty, isArraySubscript, isParenExpr, isFuncArgs, isListExpr, isProgram, isSelectStmt, isCompoundSelectStmt, isBigqueryQuotedMemberExpr, isFuncCall, isMemberExpr, isCreateFunctionStmt, isAlterFunctionStmt, isAlterActionRename, isCreateProcedureStmt, isAlterProcedureStmt, isCreateTriggerStmt, isExecuteClause, isFunctionSignature, } from "../node_utils";
+import { isString, last } from "../utils";
+export const exprMap = {
+    list_expr: (print, node, path) => {
+        const parent = path.getParentNode();
+        const children = print("items").map((it) => group(it));
+        const lineType = isValuesClause(parent) ? hardline : line;
         // When last item is type:empty, we're dealing with a trailing comma.
         // Don't add a space (or newline) after it.
         // We still want to print it though, as it might have comments attached.
-        if ((0, node_utils_1.isEmpty)((0, utils_1.last)(node.items))) {
+        if (isEmpty(last(node.items))) {
             return [
-                (0, print_utils_1.join)([",", lineType], children.slice(0, -1)),
+                join([",", lineType], children.slice(0, -1)),
                 ",",
-                (0, utils_1.last)(children),
+                last(children),
             ];
         }
         else {
-            return (0, print_utils_1.join)([",", lineType], children);
+            return join([",", lineType], children);
         }
     },
-    paren_expr: function (print, node, path) {
+    paren_expr: (print, node, path) => {
         // discard unnecessary nested ((parentheses))
-        if ((0, node_utils_1.isParenExpr)(node.expr)) {
+        if (isParenExpr(node.expr)) {
             return print("expr");
         }
         // Discard unnecessary parenthesis around function arguments
-        if ((0, node_utils_1.isListExpr)(path.getParentNode(0)) &&
-            (0, node_utils_1.isFuncArgs)(path.getParentNode(1)) &&
-            !(0, node_utils_1.isSelectStmt)(node.expr) &&
-            !(0, node_utils_1.isCompoundSelectStmt)(node.expr)) {
+        if (isListExpr(path.getParentNode(0)) &&
+            isFuncArgs(path.getParentNode(1)) &&
+            !isSelectStmt(node.expr) &&
+            !isCompoundSelectStmt(node.expr)) {
             return print("expr");
         }
-        var parent = path.getParentNode();
-        var lineStyle = (0, node_utils_1.isCreateTableStmt)(parent) && print.dynamicLine() === print_utils_1.hardline
-            ? print_utils_1.hardline
-            : print_utils_1.softline;
-        return (0, print_utils_1.group)(["(", (0, print_utils_1.indent)([lineStyle, print("expr")]), lineStyle, ")"]);
-    },
-    binary_expr: function (print, node) {
-        if ((0, node_utils_1.isKeyword)(node.operator) && isBooleanOp(node.operator)) {
-            return (0, print_utils_1.join)(print_utils_1.line, [print("left"), print.spaced(["operator", "right"])]);
+        const parent = path.getParentNode();
+        const lineStyle = isCreateTableStmt(parent) && print.dynamicLine() === hardline
+            ? hardline
+            : softline;
+        return group(["(", indent([lineStyle, print("expr")]), lineStyle, ")"]);
+    },
+    binary_expr: (print, node) => {
+        if (isKeyword(node.operator) && isBooleanOp(node.operator)) {
+            return join(line, [print("left"), print.spaced(["operator", "right"])]);
         }
         if (node.operator === "") {
             // String concatenation with whitespace (MySQL / MariaDB)
@@ -60,129 +48,109 @@ exports.exprMap = {
         }
         return print.spaced(["left", "operator", "right"]);
     },
-    prefix_op_expr: function (print, node) {
-        return ((0, utils_1.isString)(node.operator) ? print : print.spaced)(["operator", "expr"]);
-    },
-    postfix_op_expr: function (print) { return print.spaced(["expr", "operator"]); },
-    between_expr: function (print) {
-        return print.spaced(["left", "betweenKw", "begin", "andKw", "end"]);
-    },
-    case_expr: function (print) { return [
+    prefix_op_expr: (print, node) => (isString(node.operator) ? print : print.spaced)(["operator", "expr"]),
+    postfix_op_expr: (print) => print.spaced(["expr", "operator"]),
+    between_expr: (print) => print.spaced(["left", "betweenKw", "begin", "andKw", "end"]),
+    case_expr: (print) => [
         print.spaced(["caseKw", "expr"]),
-        (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.join)(print_utils_1.hardline, print("clauses"))]),
-        print_utils_1.hardline,
+        indent([hardline, join(hardline, print("clauses"))]),
+        hardline,
         print("endKw"),
-    ]; },
-    case_when: function (print, node) {
-        if ((0, node_utils_1.isProgram)(node.result)) {
+    ],
+    case_when: (print, node) => {
+        if (isProgram(node.result)) {
             return [
                 print.spaced(["whenKw", "condition", "thenKw"]),
-                (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.stripTrailingHardline)(print("result"))]),
+                indent([hardline, stripTrailingHardline(print("result"))]),
             ];
         }
         return print.spaced(["whenKw", "condition", "thenKw", "result"]);
     },
-    case_else: function (print, node) {
-        if ((0, node_utils_1.isProgram)(node.result)) {
+    case_else: (print, node) => {
+        if (isProgram(node.result)) {
             return [
                 print("elseKw"),
-                (0, print_utils_1.indent)([print_utils_1.hardline, (0, print_utils_1.stripTrailingHardline)(print("result"))]),
+                indent([hardline, stripTrailingHardline(print("result"))]),
             ];
         }
         return print.spaced(["elseKw", "result"]);
     },
-    member_expr: function (print, node) {
-        return (0, node_utils_1.isArraySubscript)(node.property)
-            ? print(["object", "property"])
-            : [print("object"), ".", print("property")];
-    },
-    bigquery_quoted_member_expr: function (print) { return ["`", print("expr"), "`"]; },
-    array_subscript: function (print) {
-        return (0, print_utils_1.group)(["[", (0, print_utils_1.indent)([print_utils_1.softline, print("expr")]), print_utils_1.softline, "]"]);
-    },
-    array_subscript_specifier: function (print) { return print(["specifierKw", "args"]); },
-    array_slice_specifier: function (print) { return [print("from"), ":", print("to")]; },
-    func_call: function (print) {
-        var fnCall = print(["name", "args"]);
-        var extras = print(["filter", "over"]);
+    member_expr: (print, node) => isArraySubscript(node.property)
+        ? print(["object", "property"])
+        : [print("object"), ".", print("property")],
+    bigquery_quoted_member_expr: (print) => ["`", print("expr"), "`"],
+    array_subscript: (print) => group(["[", indent([softline, print("expr")]), softline, "]"]),
+    array_subscript_specifier: (print) => print(["specifierKw", "args"]),
+    array_slice_specifier: (print) => [print("from"), ":", print("to")],
+    func_call: (print) => {
+        const fnCall = print(["name", "args"]);
+        const extras = print(["filter", "over"]);
         if (extras.length > 1) {
-            return (0, print_utils_1.group)([fnCall, (0, print_utils_1.indent)([print_utils_1.line, (0, print_utils_1.join)(print_utils_1.line, extras)])]);
+            return group([fnCall, indent([line, join(line, extras)])]);
         }
         else {
-            return (0, print_utils_1.group)((0, print_utils_1.join)(" ", __spreadArray([fnCall], extras, true)));
+            return group(join(" ", [fnCall, ...extras]));
         }
     },
-    func_args: function (print, node) {
-        return (0, print_utils_1.join)(print_utils_1.line, __spreadArray(__spreadArray(__spreadArray([], print(["distinctKw", "args"]), true), (node.nullHandlingKw ? print.spaced("nullHandlingKw") : []), true), print(["orderBy", "limit", "having"]), true));
-    },
-    filter_arg: function (print) { return print.spaced(["filterKw", "where"]); },
-    over_arg: function (print) { return print.spaced(["overKw", "window"]); },
-    having_arg: function (print) { return print.spaced(["havingKw", "minMaxKw", "expr"]); },
-    named_arg: function (print) {
-        return (0, print_utils_1.group)([
-            print("name"),
-            " ",
-            print("operator"),
-            (0, print_utils_1.indent)([print_utils_1.line, print("value")]),
-        ]);
-    },
-    cast_expr: function (print) { return print(["castKw", "args"]); },
-    cast_arg: function (print) { return print.spaced(["expr", "asKw", "dataType", "format"]); },
-    cast_format: function (print) { return print.spaced(["formatKw", "string", "timezone"]); },
-    cast_format_timezone: function (print) { return print.spaced(["atTimeZoneKw", "timezone"]); },
-    cast_operator_expr: function (print) { return [
+    func_args: (print, node) => join(line, [
+        ...print(["distinctKw", "args"]),
+        ...(node.nullHandlingKw ? print.spaced("nullHandlingKw") : []),
+        ...print(["orderBy", "limit", "having"]),
+    ]),
+    filter_arg: (print) => print.spaced(["filterKw", "where"]),
+    over_arg: (print) => print.spaced(["overKw", "window"]),
+    having_arg: (print) => print.spaced(["havingKw", "minMaxKw", "expr"]),
+    named_arg: (print) => group([
+        print("name"),
+        " ",
+        print("operator"),
+        indent([line, print("value")]),
+    ]),
+    cast_expr: (print) => print(["castKw", "args"]),
+    cast_arg: (print) => print.spaced(["expr", "asKw", "dataType", "format"]),
+    cast_format: (print) => print.spaced(["formatKw", "string", "timezone"]),
+    cast_format_timezone: (print) => print.spaced(["atTimeZoneKw", "timezone"]),
+    cast_operator_expr: (print) => [
         print("left"),
         print("operator"),
         print("right"),
-    ]; },
-    string_with_charset: function (print) { return ["_", print(["charset", "string"])]; },
-    raise_expr: function (print) { return print(["raiseKw", "args"]); },
-    raise_expr_type: function (print) { return print("typeKw"); },
-    extract_expr: function (print) { return print(["extractKw", "args"]); },
-    extract_from: function (print) { return print.spaced(["unit", "fromKw", "expr"]); },
-    week_expr: function (print) { return print(["weekKw", "args"]); },
-    interval_literal: function (print) {
-        return print.spaced(["intervalKw", "precision", "value", "unit"]);
-    },
-    array_literal_expr: function (print) { return print(["arrayKw", "expr"]); },
-    array_expr: function (print) {
-        return (0, print_utils_1.group)(["[", (0, print_utils_1.indent)([print_utils_1.softline, print("expr")]), print_utils_1.softline, "]"]);
-    },
-    struct_expr: function (print) {
-        return (0, print_utils_1.group)(["(", (0, print_utils_1.indent)([print_utils_1.softline, print("expr")]), print_utils_1.softline, ")"]);
-    },
-    typed_expr: function (print) { return print(["dataType", "expr"]); },
-    row_constructor: function (print) { return print(["rowKw", "row"]); },
-    array_constructor: function (print) { return print(["arrayKw", "expr"]); },
-    quantifier_expr: function (print) { return print.spaced(["quantifierKw", "expr"]); },
-    full_text_match_expr: function (print) {
-        return print.spaced(["matchKw", "columns", "againstKw", "args"]);
-    },
-    full_text_match_args: function (print) { return print.spaced(["expr", "modifier"]); },
+    ],
+    string_with_charset: (print) => ["_", print(["charset", "string"])],
+    raise_expr: (print) => print(["raiseKw", "args"]),
+    raise_expr_type: (print) => print("typeKw"),
+    extract_expr: (print) => print(["extractKw", "args"]),
+    extract_from: (print) => print.spaced(["unit", "fromKw", "expr"]),
+    week_expr: (print) => print(["weekKw", "args"]),
+    interval_literal: (print) => print.spaced(["intervalKw", "precision", "value", "unit"]),
+    array_literal_expr: (print) => print(["arrayKw", "expr"]),
+    array_expr: (print) => group(["[", indent([softline, print("expr")]), softline, "]"]),
+    struct_expr: (print) => group(["(", indent([softline, print("expr")]), softline, ")"]),
+    typed_expr: (print) => print(["dataType", "expr"]),
+    row_constructor: (print) => print(["rowKw", "row"]),
+    array_constructor: (print) => print(["arrayKw", "expr"]),
+    quantifier_expr: (print) => print.spaced(["quantifierKw", "expr"]),
+    full_text_match_expr: (print) => print.spaced(["matchKw", "columns", "againstKw", "args"]),
+    full_text_match_args: (print) => print.spaced(["expr", "modifier"]),
     /** cst-ignore: value */
-    number_literal: function (print) { return print("text"); },
+    number_literal: (print) => print("text"),
     /** cst-ignore: value */
-    boolean_literal: function (print, node, path, options) {
-        return (0, exports.printLiteral)(node.valueKw, options);
-    },
+    boolean_literal: (print, node, path, options) => printLiteral(node.valueKw, options),
     /** cst-ignore: value */
-    string_literal: function (print) { return print("text"); },
+    string_literal: (print) => print("text"),
     /** cst-ignore: value */
-    blob_literal: function (print) { return print("text"); },
+    blob_literal: (print) => print("text"),
     /** cst-ignore: value */
-    null_literal: function (print, node, path, options) {
-        return (0, exports.printLiteral)(node.nullKw, options);
-    },
-    numeric_literal: function (print) { return print.spaced(["numericKw", "string"]); },
-    bignumeric_literal: function (print) { return print.spaced(["bignumericKw", "string"]); },
-    date_literal: function (print) { return print.spaced(["dateKw", "string"]); },
-    time_literal: function (print) { return print.spaced(["timeKw", "string"]); },
-    datetime_literal: function (print) { return print.spaced(["datetimeKw", "string"]); },
-    timestamp_literal: function (print) { return print.spaced(["timestampKw", "string"]); },
-    json_literal: function (print) { return print.spaced(["jsonKw", "string"]); },
-    jsonb_literal: function (print) { return print.spaced(["jsonbKw", "string"]); },
+    null_literal: (print, node, path, options) => printLiteral(node.nullKw, options),
+    numeric_literal: (print) => print.spaced(["numericKw", "string"]),
+    bignumeric_literal: (print) => print.spaced(["bignumericKw", "string"]),
+    date_literal: (print) => print.spaced(["dateKw", "string"]),
+    time_literal: (print) => print.spaced(["timeKw", "string"]),
+    datetime_literal: (print) => print.spaced(["datetimeKw", "string"]),
+    timestamp_literal: (print) => print.spaced(["timestampKw", "string"]),
+    json_literal: (print) => print.spaced(["jsonKw", "string"]),
+    jsonb_literal: (print) => print.spaced(["jsonbKw", "string"]),
     /** cst-ignore: name */
-    identifier: function (print, node, path, options) {
+    identifier: (print, node, path, options) => {
         if (isQuotedIdentifier(node) || isInsideBigqueryQuotedMemberExpr(path)) {
             return print("text");
         }
@@ -196,14 +164,10 @@ exports.exprMap = {
         }
     },
     /** cst-ignore: name */
-    variable: function (print, node, path, options) {
-        return isQuotedVariable(node) ? print("text") : printIdentifier(node, options);
-    },
-    parameter: function (print, node, path, options) {
-        return isQuotedParameter(node) ? print("text") : printIdentifier(node, options);
-    },
+    variable: (print, node, path, options) => isQuotedVariable(node) ? print("text") : printIdentifier(node, options),
+    parameter: (print, node, path, options) => isQuotedParameter(node) ? print("text") : printIdentifier(node, options),
 };
-var printLiteral = function (node, options) {
+export const printLiteral = (node, options) => {
     switch (options.sqlLiteralCase) {
         case "preserve":
             return node.text;
@@ -213,8 +177,7 @@ var printLiteral = function (node, options) {
             return node.text.toLowerCase();
     }
 };
-exports.printLiteral = printLiteral;
-var printIdentifier = function (node, options) {
+const printIdentifier = (node, options) => {
     switch (options.sqlIdentifierCase) {
         case "preserve":
             return node.text;
@@ -224,7 +187,7 @@ var printIdentifier = function (node, options) {
             return node.text.toLowerCase();
     }
 };
-var printFunctionName = function (node, options) {
+const printFunctionName = (node, options) => {
     switch (options.sqlFunctionCase) {
         case "preserve":
             return node.text;
@@ -234,40 +197,28 @@ var printFunctionName = function (node, options) {
             return node.text.toLowerCase();
     }
 };
-var isQuotedIdentifier = function (node) {
-    return node.name !== node.text;
-};
-var isQuotedVariable = function (node) {
-    return !(node.text === "@" + node.name || node.text === "@@" + node.name);
-};
-var isQuotedParameter = function (node) { return /`$/.test(node.text); };
-var isInsideBigqueryQuotedMemberExpr = function (path) {
-    return path.ancestors.some(node_utils_1.isBigqueryQuotedMemberExpr);
-};
-var isFunctionName = function (node, path) {
-    var parent = path.parent;
+const isQuotedIdentifier = (node) => node.name !== node.text;
+const isQuotedVariable = (node) => !(node.text === "@" + node.name || node.text === "@@" + node.name);
+const isQuotedParameter = (node) => /`$/.test(node.text);
+const isInsideBigqueryQuotedMemberExpr = (path) => path.ancestors.some(isBigqueryQuotedMemberExpr);
+const isFunctionName = (node, path) => {
+    const parent = path.parent;
     if (isFunctionContext(parent, path.grandparent)) {
         return true;
     }
-    if ((0, node_utils_1.isMemberExpr)(parent) && parent.property === node) {
-        var _a = path.ancestors, _ = _a[0], gp = _a[1], ggp = _a[2];
+    if (isMemberExpr(parent) && parent.property === node) {
+        const [_, gp, ggp] = path.ancestors;
         return isFunctionContext(gp, ggp);
     }
     return false;
 };
-var isFunctionContext = function (node, parent) {
-    return ((0, node_utils_1.isFuncCall)(node) ||
-        (0, node_utils_1.isCreateFunctionStmt)(node) ||
-        (0, node_utils_1.isCreateProcedureStmt)(node) ||
-        (0, node_utils_1.isAlterFunctionStmt)(node) ||
-        (0, node_utils_1.isAlterProcedureStmt)(node) ||
-        ((0, node_utils_1.isAlterActionRename)(node) &&
-            ((0, node_utils_1.isAlterFunctionStmt)(parent) || (0, node_utils_1.isAlterProcedureStmt)(parent))) ||
-        (0, node_utils_1.isDropFunctionStmt)(node) ||
-        (0, node_utils_1.isDropProcedureStmt)(node) ||
-        ((0, node_utils_1.isExecuteClause)(node) && (0, node_utils_1.isCreateTriggerStmt)(parent)));
-};
-var isBooleanOp = function (_a) {
-    var name = _a.name;
-    return name === "AND" || name === "OR";
+const isFunctionContext = (node, parent) => {
+    return (isFuncCall(node) ||
+        isFunctionSignature(node) ||
+        isCreateFunctionStmt(node) ||
+        isCreateProcedureStmt(node) ||
+        (isAlterActionRename(node) &&
+            (isAlterFunctionStmt(parent) || isAlterProcedureStmt(parent))) ||
+        (isExecuteClause(node) && isCreateTriggerStmt(parent)));
 };
+const isBooleanOp = ({ name }) => name === "AND" || name === "OR";

package/dist/syntax/extension.js

@@ -1,22 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extensionMap = void 0;
-var print_utils_1 = require("../print_utils");
-exports.extensionMap = {
-    create_extension_stmt: function (print, node) {
-        return (0, print_utils_1.group)([
-            print.spaced(["createExtensionKw", "ifNotExistsKw", "name"]),
-            node.clauses.length > 0
-                ? (0, print_utils_1.indent)([print_utils_1.line, print.spaced(["withKw", "clauses"])])
-                : [],
-        ]);
-    },
-    extension_cascade_clause: function (print) { return (0, print_utils_1.group)(print.spaced(["cascadeKw"])); },
-    extension_schema_clause: function (print) { return (0, print_utils_1.group)(print.spaced(["schemaKw", "name"])); },
-    extension_version_clause: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["versionKw", "name"]));
-    },
-    drop_extension_stmt: function (print) {
-        return (0, print_utils_1.group)(print.spaced(["dropExtensionKw", "ifExistsKw", "names", "behaviorKw"]));
-    },
+import { group, indent, line } from "../print_utils";
+export const extensionMap = {
+    create_extension_stmt: (print, node) => group([
+        print.spaced(["createExtensionKw", "ifNotExistsKw", "name"]),
+        node.clauses.length > 0
+            ? indent([line, print.spaced(["withKw", "clauses"])])
+            : [],
+    ]),
+    extension_cascade_clause: (print) => group(print.spaced(["cascadeKw"])),
+    extension_schema_clause: (print) => group(print.spaced(["schemaKw", "name"])),
+    extension_version_clause: (print) => group(print.spaced(["versionKw", "name"])),
+    drop_extension_stmt: (print) => group(print.spaced(["dropExtensionKw", "ifExistsKw", "names", "behaviorKw"])),
 };

package/dist/syntax/frame.js

@@ -1,18 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.frameMap = void 0;
-var print_utils_1 = require("../print_utils");
-exports.frameMap = {
-    frame_clause: function (print, node) { return [
+import { hardline } from "../print_utils";
+export const frameMap = {
+    frame_clause: (print, node) => [
         print.spaced(["unitKw", "extent"]),
-        node.exclusion ? [print_utils_1.hardline, print("exclusion")] : [],
-    ]; },
-    frame_bound_current_row: function (print) { return print.spaced("currentRowKw"); },
-    frame_bound_preceding: function (print) { return print.spaced(["expr", "precedingKw"]); },
-    frame_bound_following: function (print) { return print.spaced(["expr", "followingKw"]); },
-    frame_unbounded: function (print) { return print.spaced("unboundedKw"); },
-    frame_between: function (print) {
-        return print.spaced(["betweenKw", "begin", "andKw", "end"]);
-    },
-    frame_exclusion: function (print) { return print.spaced(["excludeKw", "kindKw"]); },
+        node.exclusion ? [hardline, print("exclusion")] : [],
+    ],
+    frame_bound_current_row: (print) => print.spaced("currentRowKw"),
+    frame_bound_preceding: (print) => print.spaced(["expr", "precedingKw"]),
+    frame_bound_following: (print) => print.spaced(["expr", "followingKw"]),
+    frame_unbounded: (print) => print.spaced("unboundedKw"),
+    frame_between: (print) => print.spaced(["betweenKw", "begin", "andKw", "end"]),
+    frame_exclusion: (print) => print.spaced(["excludeKw", "kindKw"]),
 };

package/dist/syntax/function.js

@@ -1,65 +1,55 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasOnlyAsClause = exports.functionMap = void 0;
-var print_utils_1 = require("../print_utils");
-var node_utils_1 = require("../node_utils");
-exports.functionMap = {
-    create_function_stmt: function (print, node) {
-        return (0, print_utils_1.group)([
-            print.spaced([
-                "createKw",
-                "orReplaceKw",
-                "temporaryKw",
-                "tableKw",
-                "functionKw",
-                "ifNotExistsKw",
-                "name",
-            ]),
-            print("params"),
-            (0, exports.hasOnlyAsClause)(node)
-                ? [" ", (0, print_utils_1.group)(print("clauses"))]
-                : [
-                    print_utils_1.hardline,
-                    (0, print_utils_1.join)(print_utils_1.hardline, print("clauses").map(function (cls) { return (0, print_utils_1.group)(cls); })),
-                ],
-        ]);
-    },
-    function_signature: function (print) { return print(["name", "params"]); },
-    function_param: function (print) {
-        return print.spaced(["mode", "name", "dataType", "default"]);
-    },
-    function_param_default: function (print) { return print.spaced(["operator", "expr"]); },
-    return_clause: function (print) { return print.spaced(["returnKw", "expr"]); },
-    function_behavior_clause: function (print) { return print.spaced(["behaviorKw"]); },
-    function_security_clause: function (print) {
-        return print.spaced(["externalKw", "securityKw"]);
-    },
-    function_cost_clause: function (print) { return print.spaced(["costKw", "cost"]); },
-    function_rows_clause: function (print) { return print.spaced(["rowsKw", "rows"]); },
-    function_support_clause: function (print) { return print.spaced(["supportKw", "name"]); },
-    function_window_clause: function (print) { return print.spaced("windowKw"); },
-    function_transform_clause: function (print) { return print.spaced(["transformKw", "types"]); },
-    transform_type: function (print) { return print.spaced(["forTypeKw", "dataType"]); },
-    dynamically_loaded_function: function (print) {
-        return (0, print_utils_1.join)(", ", print(["objectFile", "symbol"]));
-    },
-    drop_function_stmt: function (print) {
-        return (0, print_utils_1.group)([
-            print.spaced(["dropKw", "tableKw", "functionKw", "ifExistsKw", "name"]),
-            print.spaced(["params", "behaviorKw"]),
-        ]);
-    },
+import { group, hardline, join } from "../print_utils";
+import { isAsClause } from "../node_utils";
+export const functionMap = {
+    create_function_stmt: (print, node) => group([
+        print.spaced([
+            "createKw",
+            "orReplaceKw",
+            "temporaryKw",
+            "tableKw",
+            "functionKw",
+            "ifNotExistsKw",
+            "name",
+        ]),
+        print("params"),
+        hasOnlyAsClause(node)
+            ? [" ", group(print("clauses"))]
+            : [
+                hardline,
+                join(hardline, print("clauses").map((cls) => group(cls))),
+            ],
+    ]),
+    function_signature: (print) => print(["name", "params"]),
+    function_param: (print) => print.spaced(["mode", "name", "dataType", "default"]),
+    function_param_default: (print) => print.spaced(["operator", "expr"]),
+    return_clause: (print) => print.spaced(["returnKw", "expr"]),
+    function_behavior_clause: (print) => print.spaced(["behaviorKw"]),
+    function_security_clause: (print) => print.spaced(["externalKw", "securityKw"]),
+    function_cost_clause: (print) => print.spaced(["costKw", "cost"]),
+    function_rows_clause: (print) => print.spaced(["rowsKw", "rows"]),
+    function_support_clause: (print) => print.spaced(["supportKw", "name"]),
+    function_window_clause: (print) => print.spaced("windowKw"),
+    function_transform_clause: (print) => print.spaced(["transformKw", "types"]),
+    transform_type: (print) => print.spaced(["forTypeKw", "dataType"]),
+    dynamically_loaded_function: (print) => join(", ", print(["objectFile", "symbol"])),
+    drop_function_stmt: (print) => group([
+        print.spaced([
+            "dropKw",
+            "tableKw",
+            "functionKw",
+            "ifExistsKw",
+            "signatures",
+            "behaviorKw",
+        ]),
+    ]),
     // almost exact copy of alter_procedure_stmt
-    alter_function_stmt: function (print, node) {
-        return (0, print_utils_1.group)([
-            print.spaced(["alterKw", "functionKw"]),
-            " ",
-            print(["name", "params"]),
-            print.dynamicLine(),
-            (0, print_utils_1.join)(print.dynamicLine(), print("actions")),
-            node.behaviorKw ? [print.dynamicLine(), print("behaviorKw")] : [],
-        ]);
-    },
+    alter_function_stmt: (print, node) => group([
+        print.spaced(["alterKw", "functionKw"]),
+        " ",
+        print(["signature"]),
+        print.dynamicLine(),
+        join(print.dynamicLine(), print("actions")),
+        node.behaviorKw ? [print.dynamicLine(), print("behaviorKw")] : [],
+    ]),
 };
-var hasOnlyAsClause = function (node) { return node.clauses.length === 1 && (0, node_utils_1.isAsClause)(node.clauses[0]); };
-exports.hasOnlyAsClause = hasOnlyAsClause;
+export const hasOnlyAsClause = (node) => node.clauses.length === 1 && isAsClause(node.clauses[0]);