prettier-plugin-sql-cst 0.19.2 → 0.19.3

package/dist/index.js

@@ -1,64 +1,2646 @@
+// src/index.ts
 import { parse } from "sql-parser-cst";
-import { printSql } from "./printSql";
-import { printComment } from "./printComment";
-import { embed } from "./embed";
-import { isNode } from "./utils";
-import { transformCst } from "./transform/transformCst";
-export { options } from "./options";
-export const languages = [
-    {
-        extensions: [".sql", ".sqlite"],
-        name: "SQLite SQL",
-        parsers: ["sqlite"],
+
+// src/utils.ts
+var isDefined = (value) => value !== void 0;
+var isString = (value) => typeof value === "string";
+var isObject = (x) => typeof x === "object" && x !== null && !(x instanceof Array);
+var isArray = (x) => Array.isArray(x);
+var isEmptyArray = (x) => isArray(x) && x.length === 0;
+var isNode = (value) => isObject(value) && isString(value.type) && !isCommentType(value.type);
+var isCommentType = (type) => type === "block_comment" || type === "line_comment";
+var arrayWrap = (x) => isArray(x) ? x : [x];
+var last = (arr) => arr[arr.length - 1];
+
+// src/syntax/alias.ts
+var aliasMap = {
+  alias: (print) => print.spaced(["expr", "asKw", "alias", "columnAliases"])
+};
+
+// src/print_utils.ts
+import { doc, util } from "prettier";
+var {
+  line,
+  hardline,
+  softline,
+  indent,
+  group,
+  lineSuffix,
+  ifBreak,
+  breakParent
+} = doc.builders;
+var { join: origJoin } = doc.builders;
+var { stripTrailingHardline } = doc.utils;
+var join = (sep, docs) => isArray(docs) ? origJoin(sep, docs) : docs;
+var containsNewline = (node, opts) => {
+  if (!node.range) {
+    throw new Error("containsNewline() expected a Node with range info");
+  }
+  return util.hasNewlineInRange(
+    opts.originalText,
+    node.range[0],
+    node.range[1]
+  );
+};
+var hasEmptyLineBetweenNodes = (node1, node2, opts) => {
+  if (!node1.range || !node2.range) {
+    throw new Error("emptyLineBetweenNodes() expects Nodes with range info");
+  }
+  const start = node1.range[1];
+  const end = node2.range[0];
+  const indexes = emptyLineIndexes(opts.originalText.slice(start, end)).map(
+    (i) => start + i
+  );
+  if (indexes.length === 0) {
+    return false;
+  }
+  const comments = [...node1.trailing ?? [], ...node2.leading ?? []];
+  return indexes.filter((index) => !isIndexInsideOrBetweenComments(index, comments)).length > 0;
+};
+function emptyLineIndexes(text) {
+  const indexes = [];
+  const re = /\n[ \t]*\r?\n/g;
+  let match;
+  while (match = re.exec(text)) {
+    indexes.push(match.index);
+  }
+  return indexes;
+}
+function isIndexInsideOrBetweenComments(index, comments) {
+  if (comments.length === 0) {
+    return false;
+  }
+  const start = comments[0].range[0];
+  const end = comments[comments.length - 1].range[1];
+  return start <= index && index <= end;
+}
+
+// src/syntax/constraint.ts
+var constraintMap = {
+  /** cst-ignore: constraint, modifiers */
+  constraint: (print, node) => {
+    if (node.name) {
+      return group([
+        print("name"),
+        indent([line, printUnnamedConstraint(print, node)])
+      ]);
+    } else {
+      return printUnnamedConstraint(print, node);
+    }
+  },
+  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 group([
+        baseDoc,
+        indent([hardline, join(hardline, print("options"))])
+      ]);
+    } else {
+      return baseDoc;
+    }
+  },
+  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: (print) => print.spaced(["index", "withKw", "operator"]),
+  index_tablespace_clause: (print) => print.spaced(["usingIndexTablespaceKw", "name"])
+};
+var printUnnamedConstraint = (print, node) => {
+  if (node.modifiers.length > 0) {
+    return group([
+      print("constraint"),
+      indent([line, print.spaced("modifiers")])
+    ]);
+  } else {
+    return print("constraint");
+  }
+};
+
+// src/syntax/alter_action.ts
+var alterActionMap = {
+  alter_action_rename: (print) => print.spaced(["renameKw", "newName"]),
+  alter_action_rename_column: (print) => print.spaced(["renameKw", "ifExistsKw", "oldName", "toKw", "newName"]),
+  alter_action_add_column: (print) => print.spaced(["addKw", "ifNotExistsKw", "column"]),
+  alter_action_drop_column: (print) => print.spaced(["dropKw", "ifExistsKw", "column", "behaviorKw"]),
+  alter_action_set_bigquery_options: (print) => print.spaced(["setKw", "options"]),
+  alter_action_set_default_collate: (print) => print.spaced(["setDefaultCollateKw", "collation"]),
+  /** cst-ignore: constraint, modifiers */
+  alter_action_add_constraint: (print, node) => group([
+    print.spaced(["addKw", "name"]),
+    indent([line, printUnnamedConstraint(print, node)])
+  ]),
+  alter_action_add_constraint_constraint_name: (print) => print.spaced(["constraintKw", "ifNotExistsKw", "name"]),
+  alter_action_drop_constraint: (print) => print.spaced([
+    "dropConstraintKw",
+    "ifExistsKw",
+    "constraint",
+    "behaviorKw"
+  ]),
+  alter_action_drop_primary_key: (print) => print.spaced(["dropPrimaryKeyKw", "ifExistsKw"]),
+  alter_action_alter_constraint: (print) => print.spaced(["alterConstraintKw", "constraint", "modifiers"]),
+  alter_action_rename_constraint: (print) => print.spaced(["renameConstraintKw", "oldName", "toKw", "newName"]),
+  alter_action_validate_constraint: (print) => print.spaced(["validateConstraintKw", "constraint"]),
+  alter_action_set_visible: (print) => print.spaced("setVisibleKw"),
+  alter_action_set_invisible: (print) => print.spaced("setInvisibleKw"),
+  alter_action_set_tablespace: (print) => print.spaced(["setTablespaceKw", "tablespace", "nowaitKw"]),
+  alter_action_set_schema: (print) => print.spaced(["setSchemaKw", "schema"]),
+  alter_action_enable: (print) => print.spaced(["enableKw", "modeKw", "item"]),
+  alter_action_disable: (print) => print.spaced(["disableKw", "item"]),
+  alter_action_force: (print) => print.spaced(["forceKw", "item"]),
+  alter_action_no_force: (print) => print.spaced(["noForceKw", "item"]),
+  alter_action_cluster_on: (print) => print.spaced(["clusterOnKw", "index"]),
+  alter_action_set_without_cluster: (print) => print.spaced("setWithoutClusterKw"),
+  alter_action_set_without_oids: (print) => print.spaced("setWithoutOidsKw"),
+  alter_action_set_access_method: (print) => print.spaced(["setAccessMethodKw", "method"]),
+  alter_action_set_logged: (print) => print.spaced("setLoggedKw"),
+  alter_action_set_unlogged: (print) => print.spaced("setUnloggedKw"),
+  alter_action_inherit: (print) => print.spaced(["inheritKw", "table"]),
+  alter_action_no_inherit: (print) => print.spaced(["noInheritKw", "table"]),
+  alter_action_of_type: (print) => print.spaced(["ofKw", "typeName"]),
+  alter_action_not_of_type: (print) => print.spaced("notOfKw"),
+  alter_action_owner_to: (print) => print.spaced(["ownerToKw", "owner"]),
+  alter_action_replica_identity: (print) => print.spaced(["replicaIdentityKw", "identity"]),
+  replica_identity_using_index: (print) => print.spaced(["usingIndexKw", "index"]),
+  alter_action_set_postgresql_options: (print) => print.spaced(["setKw", "options"]),
+  alter_action_reset_postgresql_options: (print) => print.spaced(["resetKw", "options"]),
+  alter_action_depends_on_extension: (print) => print.spaced(["dependsOnExtensionKw", "extension"]),
+  alter_action_no_depends_on_extension: (print) => print.spaced(["noDependsOnExtensionKw", "extension"]),
+  alter_action_attach_partition: (print) => print.spaced(["attachPartitionKw", "index"]),
+  alter_action_add_enum_value: (print) => print.spaced(["addValueKw", "ifNotExistsKw", "value", "position"]),
+  alter_action_add_enum_value_position: (print) => print.spaced(["positionKw", "value"]),
+  alter_action_rename_enum_value: (print) => print.spaced(["renameValueKw", "oldValue", "toKw", "newValue"]),
+  alter_action_add_attribute: (print) => print.spaced([
+    "addAttributeKw",
+    "name",
+    "dataType",
+    "constraint",
+    "behaviorKw"
+  ]),
+  alter_action_drop_attribute: (print) => print.spaced(["dropAttributeKw", "ifExistsKw", "name", "behaviorKw"]),
+  alter_action_alter_attribute: (print) => print.spaced([
+    "alterAttributeKw",
+    "name",
+    "setDataTypeKw",
+    "dataType",
+    "constraint",
+    "behaviorKw"
+  ]),
+  alter_action_rename_attribute: (print) => print.spaced([
+    "renameAttributeKw",
+    "oldName",
+    "toKw",
+    "newName",
+    "behaviorKw"
+  ]),
+  // ALTER COLUMN
+  alter_action_alter_column: (print) => group([
+    print.spaced(["alterKw", "ifExistsKw", "column"]),
+    print.dynamicLine(),
+    print("action")
+  ]),
+  alter_action_set_default: (print) => print.spaced(["setDefaultKw", "expr"]),
+  alter_action_drop_default: (print) => print.spaced("dropDefaultKw"),
+  alter_action_set_not_null: (print) => print.spaced("setNotNullKw"),
+  alter_action_drop_not_null: (print) => print.spaced("dropNotNullKw"),
+  alter_action_set_data_type: (print) => print.spaced(["setDataTypeKw", "dataType", "clauses"]),
+  alter_action_set_statistics: (print) => print.spaced(["setStatisticsKw", "value"]),
+  alter_action_set_compression: (print) => print.spaced(["setCompressionKw", "method"]),
+  alter_action_set_storage: (print) => print.spaced(["setStorageKw", "typeKw"]),
+  alter_action_drop_expression: (print) => print.spaced(["dropExpressionKw", "ifExistsKw"]),
+  alter_action_drop_identity: (print) => print.spaced(["dropIdentityKw", "ifExistsKw"]),
+  alter_action_add_identity: (print) => print.spaced([
+    "addGeneratedKw",
+    "whenKw",
+    "asIdentityKw",
+    "sequenceOptions"
+  ]),
+  alter_action_alter_identity: (print) => group(join(line, print("actions"))),
+  alter_action_set_generated: (print) => print.spaced(["setGeneratedKw", "whenKw"]),
+  alter_action_restart: (print) => print.spaced(["restartKw", "withKw", "value"]),
+  alter_action_set_sequence_option: (print) => print.spaced(["setKw", "option"]),
+  alter_action_with_role_options: (print, node) => node.withKw ? group([print("withKw"), indent([line, join(line, print("options"))])]) : (
+    // This works in tandem with the logic inside alter_role_stmt
+    group(join(line, print("options")))
+  ),
+  alter_action_set_postgresql_option: (print) => print.spaced(["setKw", "name", "operator", "value"]),
+  alter_action_set_postgresql_option_from_current: (print) => print.spaced(["setKw", "name", "fromCurrentKw"]),
+  alter_action_reset_postgresql_option: (print) => print.spaced(["resetKw", "name"]),
+  alter_action_add_user: (print) => group(print.spaced(["addUserKw", "users"])),
+  alter_action_drop_user: (print) => group(print.spaced(["dropUserKw", "users"])),
+  // ENABLE/DISABLE ..
+  toggle_trigger: (print) => print.spaced(["triggerKw", "name"]),
+  toggle_rule: (print) => print.spaced(["ruleKw", "name"]),
+  toggle_row_level_security: (print) => print.spaced("rowLevelSecurityKw"),
+  // SET DATA TYPE ...
+  set_data_type_collate_clause: (print) => print.spaced(["collateKw", "collation"]),
+  set_data_type_using_clause: (print) => print.spaced(["usingKw", "expr"])
+};
+
+// src/syntax/alter_table.ts
+var alterTableMap = {
+  alter_table_stmt: (print) => group([
+    print.spaced(["alterTableKw", "ifExistsKw", "table"]),
+    print.dynamicLine(),
+    print("actions")
+  ]),
+  alter_table_all_in_tablespace_stmt: (print) => group([
+    print.spaced([
+      "alterTableKw",
+      "allInTablespaceKw",
+      "tablespace",
+      "ownedBy"
+    ]),
+    print.dynamicLine(),
+    print("action")
+  ]),
+  owned_by_clause: (print) => group([print.spaced("ownedByKw"), indent([line, print("owners")])])
+};
+
+// src/syntax/analyze.ts
+var analyzeMap = {
+  analyze_stmt: (print) => group(print.spaced(["analyzeKw", "tableKw", "tables"]))
+};
+
+// src/node_utils.ts
+var is = (type) => (node) => isObject(node) && node.type === type;
+var isProgram = is("program");
+var isValuesClause = is("values_clause");
+var isFuncCall = is("func_call");
+var isFuncArgs = is("func_args");
+var isCreateTableStmt = is("create_table_stmt");
+var isKeyword = is("keyword");
+var isEmpty = is("empty");
+var isJsonLiteral = is("json_literal");
+var isJsonbLiteral = is("jsonb_literal");
+var isStringLiteral = is("string_literal");
+var isArraySubscript = is("array_subscript");
+var isAsClause = is("as_clause");
+var isParenExpr = is("paren_expr");
+var isMemberExpr = is("member_expr");
+var isSelectStmt = is("select_stmt");
+var isCompoundSelectStmt = is("compound_select_stmt");
+var isListExpr = is("list_expr");
+var isCreateFunctionStmt = is("create_function_stmt");
+var isAlterFunctionStmt = is("alter_function_stmt");
+var isDropFunctionStmt = is("drop_function_stmt");
+var isCreateProcedureStmt = is("create_procedure_stmt");
+var isAlterProcedureStmt = is("alter_procedure_stmt");
+var isDropProcedureStmt = is("drop_procedure_stmt");
+var isAlterActionRename = is("alter_action_rename");
+var isLanguageClause = is("language_clause");
+var isDynamicallyLoadedFunction = is("dynamically_loaded_function");
+var isBigqueryQuotedMemberExpr = is("bigquery_quoted_member_expr");
+var isCreateTriggerStmt = is("create_trigger_stmt");
+var isExecuteClause = is("execute_clause");
+var isFunctionSignature = is("function_signature");
+var isDataTypeName = is("data_type_name");
+var isIntervalDataType = is("interval_data_type");
+var isIntervalUnit = is("interval_unit");
+var isIntervalUnitRange = is("interval_unit_range");
+var isTimeDataType = is("time_data_type");
+var isParametricDataType = is("parametric_data_type");
+var isDataType = ([node, ...ancestors]) => isDataTypeName(node) || isIntervalDataType(node) || isIntervalUnit(node) && isDataType(ancestors) || isIntervalUnitRange(node) && isDataType(ancestors) || isTimeDataType(node) || isParametricDataType(node);
+
+// src/syntax/base.ts
+var baseMap = {
+  /** cst-ignore: name */
+  keyword: (print, node, path, options2) => {
+    const keywordCase = isDataType(path.ancestors) ? options2.sqlTypeCase : options2.sqlKeywordCase;
+    switch (keywordCase) {
+      case "preserve":
+        return path.node.text;
+      case "upper":
+        return path.node.text.toUpperCase();
+      case "lower":
+        return path.node.text.toLowerCase();
+    }
+  },
+  all_columns: () => "*",
+  empty: () => []
+};
+
+// src/syntax/cast.ts
+var castMap = {
+  cast_definition: (print) => group(print.spaced(["from", "asKw", "to"]))
+};
+
+// src/syntax/comment.ts
+var 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"]))
+};
+
+// src/syntax/create_table.ts
+var createTableMap = {
+  /** cst-ignore: clauses */
+  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")];
+    } else if (node.value) {
+      return [print.spaced("name"), " ", print.spaced("value")];
+    } else {
+      return print.spaced("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 = (print, node) => {
+  if (node.clauses.length === 1 && isAsClause(node.clauses[0])) {
+    return [" ", print("clauses")];
+  } else if (node.clauses.length > 0) {
+    return [line, join(line, print("clauses"))];
+  } else {
+    return [];
+  }
+};
+
+// src/syntax/data_type.ts
+var 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: (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 isDataTypeName(node) && isArray(node.name) && node.name.length > 1;
+}
+
+// src/syntax/dcl.ts
+var dclMap = {
+  grant_privilege_stmt: (print) => group(
+    join(print.dynamicLine(), [
+      group([print("grantKw"), indent([line, print("privileges")])]),
+      group(print.spaced(["onKw", "resource"])),
+      group([print("toKw"), indent([line, print("roles")])]),
+      ...print("clauses")
+    ])
+  ),
+  grant_role_stmt: (print) => group(
+    join(print.dynamicLine(), [
+      group(
+        join(line, [
+          group([print("grantKw"), indent([line, print("grantedRoles")])]),
+          group([print("toKw"), indent([line, print("granteeRoles")])])
+        ])
+      ),
+      ...print("clauses")
+    ])
+  ),
+  revoke_privilege_stmt: (print) => group(
+    join(print.dynamicLine(), [
+      group([
+        print.spaced(["revokeKw", "option"]),
+        indent([line, print("privileges")])
+      ]),
+      group(print.spaced(["onKw", "resource"])),
+      group([print("fromKw"), indent([line, print("roles")])]),
+      ...print(["grantedBy", "behaviorKw"])
+    ])
+  ),
+  revoke_role_stmt: (print) => group(
+    join(print.dynamicLine(), [
+      group(
+        join(line, [
+          group([
+            print.spaced(["revokeKw", "option"]),
+            indent([line, print("grantedRoles")])
+          ]),
+          group([print("fromKw"), indent([line, print("granteeRoles")])])
+        ])
+      ),
+      ...print(["grantedBy", "behaviorKw"])
+    ])
+  ),
+  privilege: (print) => print.spaced(["privilegeKw", "columns"]),
+  all_privileges: (print) => print.spaced(["allKw", "privilegesKw", "columns"]),
+  grant_resource_table: (print) => group(print.spaced(["tableKw", "tables"])),
+  grant_resource_view: (print) => group(print.spaced(["viewKw", "views"])),
+  grant_resource_schema: (print) => group(print.spaced(["schemaKw", "schemas"])),
+  grant_resource_sequence: (print) => group(print.spaced(["sequenceKw", "sequences"])),
+  grant_resource_database: (print) => group(print.spaced(["databaseKw", "databases"])),
+  grant_resource_domain: (print) => group(print.spaced(["domainKw", "domains"])),
+  grant_resource_foreign_data_wrapper: (print) => group(print.spaced(["foreignDataWrapperKw", "dataWrappers"])),
+  grant_resource_foreign_server: (print) => group(print.spaced(["foreignServerKw", "servers"])),
+  grant_resource_function: (print) => group(print.spaced(["functionKw", "functions"])),
+  grant_resource_language: (print) => group(print.spaced(["languageKw", "languages"])),
+  grant_resource_large_object: (print) => group(print.spaced(["largeObjectKw", "oids"])),
+  grant_resource_postgresql_option: (print) => group(print.spaced(["parameterKw", "options"])),
+  grant_resource_tablespace: (print) => group(print.spaced(["tablespaceKw", "tablespaces"])),
+  grant_resource_type: (print) => group(print.spaced(["typeKw", "types"])),
+  grant_resource_all_tables_in_schema: (print) => group(print.spaced(["allTablesInSchemaKw", "schemas"])),
+  grant_resource_all_sequences_in_schema: (print) => group(print.spaced(["allSequencesInSchemaKw", "schemas"])),
+  grant_resource_all_functions_in_schema: (print) => group(print.spaced(["allFunctionsInSchemaKw", "schemas"])),
+  with_grant_option_clause: (print) => group(print.spaced(["withKw", "nameKw", "value"])),
+  grant_option_for_clause: (print) => group(print.spaced(["nameKw", "optionForKw"])),
+  granted_by_clause: (print) => group(print.spaced(["grantedByKw", "role"])),
+  grantee_public: (print) => print("publicKw"),
+  grantee_group: (print) => group(print.spaced(["groupKw", "name"])),
+  alter_default_privileges_stmt: (print) => group(
+    join(print.dynamicLine(), [
+      print.spaced("alterDefaultPrivilegesKw"),
+      ...print("clauses"),
+      print("action")
+    ])
+  ),
+  default_acl_for_role_clause: (print) => group(print.spaced(["forKw", "roleKw", "roles"])),
+  default_acl_in_schema_clause: (print) => group(print.spaced(["inKw", "schemaKw", "schemas"])),
+  grant_default_privileges_action: (print) => group(
+    join(line, [
+      group(print.spaced(["grantKw", "privileges", "onKw", "resourcesKw"])),
+      group(print.spaced(["toKw", "roles", "withGrantOption"]))
+    ])
+  ),
+  revoke_default_privileges_action: (print) => group(
+    join(line, [
+      group([
+        print.spaced(["revokeKw", "grantOptionFor"]),
+        indent([
+          line,
+          join(line, [
+            group(print("privileges")),
+            print.spaced(["onKw", "resourcesKw"])
+          ])
+        ])
+      ]),
+      group(print.spaced(["fromKw", "roles", "behaviorKw"]))
+    ])
+  )
+};
+
+// src/syntax/delete.ts
+var deleteMap = {
+  delete_stmt: (print) => group(join(print.dynamicLine(), print("clauses"))),
+  delete_clause: (print) => print.spaced(["deleteKw", "modifiers", "fromKw", "tables"])
+};
+
+// src/syntax/do.ts
+var doMap = {
+  do_stmt: (print) => group(print.spaced(["doKw", "language", "body"]))
+};
+
+// src/syntax/domain.ts
+var domainMap = {
+  create_domain_stmt: (print, node) => group([
+    print.spaced(["createDomainKw", "name", "asKw", "dataType"]),
+    node.constraints.length > 0 ? indent([print.dynamicLine(), join(line, print("constraints"))]) : []
+  ]),
+  alter_domain_stmt: (print) => group(print.spaced(["alterDomainKw", "name", "action"])),
+  drop_domain_stmt: (print) => group(
+    print.spaced(["dropDomainKw", "ifExistsKw", "domains", "behaviorKw"])
+  )
+};
+
+// src/syntax/drop_table.ts
+var dropTableMap = {
+  drop_table_stmt: (print) => group(
+    print.spaced([
+      "dropKw",
+      "kind",
+      "tableKw",
+      "ifExistsKw",
+      "tables",
+      "behaviorKw"
+    ])
+  )
+};
+
+// src/syntax/explain.ts
+var explainMap = {
+  explain_stmt: (print) => group([
+    print.spaced(["explainKw", "analyzeKw", "queryPlanKw"]),
+    indent([line, print("statement")])
+  ])
+};
+
+// src/syntax/expr.ts
+var exprMap = {
+  list_expr: (print, node, path) => {
+    const parent = path.getParentNode();
+    const children = print("items").map((it) => group(it));
+    const lineType = isValuesClause(parent) ? hardline : line;
+    if (isEmpty(last(node.items))) {
+      return [
+        join([",", lineType], children.slice(0, -1)),
+        ",",
+        last(children)
+      ];
+    } else {
+      return join([",", lineType], children);
+    }
+  },
+  paren_expr: (print, node, path) => {
+    if (isParenExpr(node.expr)) {
+      return print("expr");
+    }
+    if (isListExpr(path.getParentNode(0)) && isFuncArgs(path.getParentNode(1)) && !isSelectStmt(node.expr) && !isCompoundSelectStmt(node.expr)) {
+      return print("expr");
+    }
+    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 === "") {
+      return print.spaced(["left", "right"]);
+    }
+    return print.spaced(["left", "operator", "right"]);
+  },
+  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"]),
+    indent([hardline, join(hardline, print("clauses"))]),
+    hardline,
+    print("endKw")
+  ],
+  case_when: (print, node) => {
+    if (isProgram(node.result)) {
+      return [
+        print.spaced(["whenKw", "condition", "thenKw"]),
+        indent([hardline, stripTrailingHardline(print("result"))])
+      ];
+    }
+    return print.spaced(["whenKw", "condition", "thenKw", "result"]);
+  },
+  case_else: (print, node) => {
+    if (isProgram(node.result)) {
+      return [
+        print("elseKw"),
+        indent([hardline, stripTrailingHardline(print("result"))])
+      ];
+    }
+    return print.spaced(["elseKw", "result"]);
+  },
+  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 group([fnCall, indent([line, join(line, extras)])]);
+    } else {
+      return group(join(" ", [fnCall, ...extras]));
+    }
+  },
+  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: (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: (print) => print("text"),
+  /** cst-ignore: value */
+  boolean_literal: (print, node, path, options2) => printLiteral(node.valueKw, options2),
+  /** cst-ignore: value */
+  string_literal: (print) => print("text"),
+  /** cst-ignore: value */
+  blob_literal: (print) => print("text"),
+  /** cst-ignore: value */
+  null_literal: (print, node, path, options2) => printLiteral(node.nullKw, options2),
+  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: (print, node, path, options2) => {
+    if (isQuotedIdentifier(node) || isInsideBigqueryQuotedMemberExpr(path)) {
+      return print("text");
+    } else {
+      if (isFunctionName(node, path)) {
+        return printFunctionName(node, options2);
+      } else {
+        return printIdentifier(node, options2);
+      }
+    }
+  },
+  /** cst-ignore: name */
+  variable: (print, node, path, options2) => isQuotedVariable(node) ? print("text") : printIdentifier(node, options2),
+  parameter: (print, node, path, options2) => isQuotedParameter(node) ? print("text") : printIdentifier(node, options2)
+};
+var printLiteral = (node, options2) => {
+  switch (options2.sqlLiteralCase) {
+    case "preserve":
+      return node.text;
+    case "upper":
+      return node.text.toUpperCase();
+    case "lower":
+      return node.text.toLowerCase();
+  }
+};
+var printIdentifier = (node, options2) => {
+  switch (options2.sqlIdentifierCase) {
+    case "preserve":
+      return node.text;
+    case "upper":
+      return node.text.toUpperCase();
+    case "lower":
+      return node.text.toLowerCase();
+  }
+};
+var printFunctionName = (node, options2) => {
+  switch (options2.sqlFunctionCase) {
+    case "preserve":
+      return node.text;
+    case "upper":
+      return node.text.toUpperCase();
+    case "lower":
+      return node.text.toLowerCase();
+  }
+};
+var isQuotedIdentifier = (node) => node.name !== node.text;
+var isQuotedVariable = (node) => !(node.text === "@" + node.name || node.text === "@@" + node.name);
+var isQuotedParameter = (node) => /`$/.test(node.text);
+var isInsideBigqueryQuotedMemberExpr = (path) => path.ancestors.some(isBigqueryQuotedMemberExpr);
+var isFunctionName = (node, path) => {
+  const parent = path.parent;
+  if (isFunctionContext(parent, path.grandparent)) {
+    return true;
+  }
+  if (isMemberExpr(parent) && parent.property === node) {
+    const [_, gp, ggp] = path.ancestors;
+    return isFunctionContext(gp, ggp);
+  }
+  return false;
+};
+var isFunctionContext = (node, parent) => {
+  return isFuncCall(node) || isFunctionSignature(node) || isCreateFunctionStmt(node) || isCreateProcedureStmt(node) || isAlterActionRename(node) && (isAlterFunctionStmt(parent) || isAlterProcedureStmt(parent)) || isExecuteClause(node) && isCreateTriggerStmt(parent);
+};
+var isBooleanOp = ({ name }) => name === "AND" || name === "OR";
+
+// src/syntax/extension.ts
+var 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"])
+  )
+};
+
+// src/syntax/frame.ts
+var frameMap = {
+  frame_clause: (print, node) => [
+    print.spaced(["unitKw", "extent"]),
+    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"])
+};
+
+// src/syntax/function.ts
+var 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: (print, node) => group([
+    print.spaced(["alterKw", "functionKw"]),
+    " ",
+    print(["signature"]),
+    print.dynamicLine(),
+    join(print.dynamicLine(), print("actions")),
+    node.behaviorKw ? [print.dynamicLine(), print("behaviorKw")] : []
+  ])
+};
+var hasOnlyAsClause = (node) => node.clauses.length === 1 && isAsClause(node.clauses[0]);
+
+// src/syntax/index.ts
+var indexMap = {
+  create_index_stmt: (print) => group(
+    join(print.dynamicLine(), [
+      print.spaced([
+        "createKw",
+        "orReplaceKw",
+        "indexTypeKw",
+        "indexKw",
+        "concurrentlyKw",
+        "ifNotExistsKw",
+        "name",
+        "onKw",
+        "table",
+        "using",
+        "columns"
+      ]),
+      ...print("clauses")
+    ])
+  ),
+  index_specification: (print) => print.spaced(["expr", "opclass", "direction", "nullHandlingKw"]),
+  index_include_clause: (print) => print.spaced(["includeKw", "columns"]),
+  index_nulls_distinct_clause: (print) => print.spaced(["nullsDistinctKw"]),
+  index_nulls_not_distinct_clause: (print) => print.spaced(["nullsNotDistinctKw"]),
+  drop_index_stmt: (print) => group(
+    print.spaced([
+      "dropKw",
+      "indexTypeKw",
+      "indexKw",
+      "concurrentlyKw",
+      "ifExistsKw",
+      "indexes",
+      "onKw",
+      "table",
+      "behaviorKw"
+    ])
+  ),
+  verbose_all_columns: (print) => print.spaced("allColumnsKw"),
+  alter_index_stmt: (print) => group([
+    print.spaced(["alterKw", "indexKw", "ifExistsKw", "index"]),
+    print.dynamicLine(),
+    print("action")
+  ]),
+  alter_index_all_in_tablespace_stmt: (print) => group([
+    print.spaced([
+      "alterIndexKw",
+      "allInTablespaceKw",
+      "tablespace",
+      "ownedBy"
+    ]),
+    print.dynamicLine(),
+    print("action")
+  ]),
+  reindex_stmt: (print) => group(
+    print.spaced([
+      "reindexKw",
+      "options",
+      "targetKw",
+      "concurrentlyKw",
+      "name"
+    ])
+  ),
+  reindex_option_concurrently: (print) => print.spaced(["concurrentlyKw", "value"]),
+  reindex_option_tablespace: (print) => print.spaced(["tablespaceKw", "name"]),
+  reindex_option_verbose: (print) => print.spaced(["verboseKw", "value"])
+};
+
+// src/syntax/insert.ts
+var insertMap = {
+  insert_stmt: (print) => group(join(print.dynamicLine(), print("clauses"))),
+  insert_clause: (print, node) => group([
+    print.spaced(["insertKw", "modifiers", "orAction", "intoKw", "table"]),
+    node.columns ? indent([print.dynamicLine(), print("columns")]) : []
+  ]),
+  values_clause: (print) => group([print("valuesKw"), indent([print.dynamicLine(), print("values")])]),
+  or_alternate_action: (print) => print.spaced(["orKw", "actionKw"]),
+  default: (print) => print("defaultKw"),
+  default_values: (print) => print.spaced("defaultValuesKw"),
+  upsert_clause: (print) => print.spaced(["onConflictKw", "conflictTarget", "where", "doKw", "action"]),
+  conflict_target_on_constraint: (print) => print.spaced(["onConstraintKw", "constraint"]),
+  upsert_action_nothing: (print) => print("nothingKw"),
+  upsert_action_update: (print) => group([
+    print("updateKw"),
+    indent([
+      print.dynamicLine(),
+      join(print.dynamicLine(), print(["set", "where"]))
+    ])
+  ]),
+  row_alias_clause: (print, node) => group([
+    print.spaced(["asKw", "rowAlias"]),
+    node.columnAliases ? indent([print.dynamicLine(), print("columnAliases")]) : []
+  ]),
+  on_duplicate_key_update_clause: (print) => group([
+    print.spaced("onDuplicateKeyUpdateKw"),
+    indent([print.dynamicLine(), print("assignments")])
+  ]),
+  overriding_clause: (print) => print.spaced("overridingKw")
+};
+
+// src/syntax/merge.ts
+var mergeMap = {
+  merge_stmt: (print) => group(join(hardline, print("clauses"))),
+  merge_clause: (print) => join(line, [
+    print.spaced(["mergeKw", "intoKw", "target"]),
+    print.spaced(["usingKw", "source"]),
+    group([print("onKw"), indent([line, print("condition")])])
+  ]),
+  merge_when_clause: (print, node) => [
+    group([
+      print.spaced(["whenKw", "matchedKw", "byKw"]),
+      node.condition ? indent([line, print("condition")]) : [],
+      [line, print("thenKw")]
+    ]),
+    indent([hardline, group(print("action"))])
+  ],
+  merge_when_condition: (print) => print.spaced(["andKw", "expr"]),
+  merge_action_delete: (print) => print("deleteKw"),
+  merge_action_insert: (print, node) => [
+    group([
+      print("insertKw"),
+      node.columns ? indent([hardline, print("columns")]) : []
+    ]),
+    line,
+    join(hardline, print("clauses"))
+  ],
+  merge_action_insert_row_clause: (print) => print("rowKw"),
+  merge_action_update: (print) => print.spaced(["updateKw", "set"]),
+  merge_action_do_nothing: (print) => print.spaced(["doNothingKw"])
+};
+
+// src/syntax/other_clauses.ts
+var otherClausesMap = {
+  // CLUSTER BY clause
+  cluster_by_clause: (print) => group([print.spaced("clusterByKw"), indent([line, print("columns")])]),
+  // RETURNING clause
+  returning_clause: (print) => group([print("returningKw"), indent([line, print("columns")])]),
+  // WHERE CURRENT OF clause
+  where_current_of_clause: (print) => print.spaced(["whereCurrentOfKw", "cursor"])
+};
+
+// src/syntax/rename_table.ts
+var renameTableMap = {
+  rename_table_stmt: (print) => group([
+    print.spaced(["renameKw", "tableKw"]),
+    indent([line, print("actions")])
+  ]),
+  rename_action: (print) => print.spaced(["from", "toKw", "to"])
+};
+
+// src/syntax/role.ts
+var roleMap = {
+  create_role_stmt: (print, node) => group([
+    print.spaced(["createRoleKw", "name", "withKw"]),
+    ...node.options?.length ? [indent([line, join(print.dynamicLine(), print("options"))])] : []
+  ]),
+  alter_role_stmt: (print, node) => group([
+    join(print.dynamicLine(), [
+      group([print.spaced("alterRoleKw"), indent([line, print("name")])]),
+      ...node.database ? print(["database"]) : []
+    ]),
+    node.action.type === "alter_action_with_role_options" && !node.action.withKw ? indent([print.dynamicLine(), print("action")]) : [print.dynamicLine(), print("action")]
+  ]),
+  drop_role_stmt: (print) => group(print.spaced(["dropRoleKw", "ifExistsKw", "names"])),
+  set_role_stmt: (print) => group(print.spaced(["setKw", "scopeKw", "roleKw", "name"])),
+  reset_role_stmt: (print) => group(print.spaced("resetRoleKw")),
+  role_option_keyword: (print) => print("kw"),
+  role_option_connection_limit: (print) => group(print.spaced(["connectionLimitKw", "limit"])),
+  role_option_password: (print) => group(print.spaced(["encryptedKw", "passwordKw", "password"])),
+  role_option_valid_until: (print) => group(print.spaced(["validUntilKw", "timestamp"])),
+  role_option_in_role: (print) => group(print.spaced(["inRoleKw", "names"])),
+  role_option_role: (print) => group(print.spaced(["roleKw", "names"])),
+  role_option_admin: (print) => group(print.spaced(["adminKw", "names"])),
+  role_option_sysid: (print) => group(print.spaced(["sysIdKw", "sysId"])),
+  in_database_clause: (print) => group(print.spaced(["inDatabaseKw", "name"]))
+};
+
+// src/syntax/parameter.ts
+var parameterMap = {
+  // SET
+  set_parameter_stmt: (print) => group(print.spaced(["setKw", "modifierKw", "name", "operator", "value"])),
+  set_time_zone_parameter_stmt: (print) => group(print.spaced(["setKw", "modifierKw", "timeZoneKw", "value"])),
+  set_parameter_clause: (print) => print.spaced(["setKw", "name", "operator", "value"]),
+  local_parameter_value: (print) => print("localKw"),
+  set_parameter_from_current_clause: (print) => print.spaced(["setKw", "name", "fromCurrentKw"]),
+  // RESET
+  reset_parameter_stmt: (print) => group(print.spaced(["resetKw", "name"])),
+  reset_parameter_clause: (print) => print.spaced(["resetKw", "name"]),
+  all_parameters: (print) => print("allKw"),
+  // SHOW
+  show_parameter_stmt: (print) => group(print.spaced(["showKw", "name"])),
+  /** cst-ignore: value */
+  boolean_on_off_literal: (print, node, path, options2) => printLiteral(node.valueKw, options2)
+};
+
+// src/syntax/policy.ts
+var policyMap = {
+  create_policy_stmt: (print, node) => group([
+    print.spaced(["createPolicyKw", "name", "onKw", "table"]),
+    node.clauses.length > 0 ? print.dynamicLine() : [],
+    join(print.dynamicLine(), print("clauses"))
+  ]),
+  policy_permissive_clause: (print) => group(print.spaced(["asKw", "permissiveKw"])),
+  policy_restrictive_clause: (print) => group(print.spaced(["asKw", "restrictiveKw"])),
+  policy_command_clause: (print) => group(print.spaced(["forKw", "commandKw"])),
+  policy_roles_clause: (print) => group(print.spaced(["toKw", "roles"])),
+  policy_using_clause: (print) => group(print.spaced(["usingKw", "expr"])),
+  policy_check_clause: (print) => group(print.spaced(["withKw", "checkKw", "expr"])),
+  alter_policy_stmt: (print) => group([
+    print.spaced(["alterPolicyKw", "name", "onKw", "table"]),
+    print.dynamicLine(),
+    join(print.dynamicLine(), print("actions"))
+  ]),
+  drop_policy_stmt: (print) => group(
+    print.spaced([
+      "dropPolicyKw",
+      "ifExistsKw",
+      "name",
+      "onKw",
+      "table",
+      "behaviorKw"
+    ])
+  )
+};
+
+// src/syntax/prepared_statements.ts
+var preparedStatementsMap = {
+  // EXECUTE
+  execute_stmt: (print, node) => {
+    if (node.args?.type === "execute_using_clause") {
+      return group(print.spaced(["executeKw", "name", "args"]));
+    } else {
+      return group([print.spaced(["executeKw", "name"]), print("args")]);
+    }
+  },
+  execute_immediate_stmt: (print) => group(
+    join(hardline, [
+      group([
+        print.spaced(["executeKw", "immediateKw"]),
+        indent([line, print("expr")])
+      ]),
+      ...print(["into", "using"]).map((clause) => group(clause))
+    ])
+  ),
+  execute_into_clause: (print) => print.spaced(["intoKw", "variables"]),
+  execute_using_clause: (print) => group([print("usingKw"), indent([line, print("values")])]),
+  // PREPARE
+  prepare_stmt: (print) => group(
+    join(" ", [
+      print("prepareKw"),
+      print(["name", "params"]),
+      print("source")
+    ])
+  ),
+  prepare_from_clause: (print) => group([print("fromKw"), indent([line, print("expr")])]),
+  // DEALLOCATE
+  deallocate_stmt: (print) => group(print.spaced(["deallocateKw", "name"])),
+  deallocate_all: (print) => print("allKw")
+};
+
+// src/syntax/procedural_language.ts
+var proceduralLanguageMap = {
+  // BEGIN .. END
+  block_stmt: (print, node) => group([
+    print.spaced(["beginKw", "atomicKw"]),
+    indent([hardline, stripTrailingHardline(print("program"))]),
+    node.exception ? [hardline, print("exception")] : [],
+    hardline,
+    print("endKw")
+  ]),
+  exception_clause: (print) => group([
+    print.spaced(["exceptionKw", "whenKw", "condition", "thenKw"]),
+    indent([hardline, stripTrailingHardline(print("program"))])
+  ]),
+  error_category: (print) => print("errorKw"),
+  // DECLARE
+  declare_stmt: (print) => group(
+    join(" ", [
+      print("declareKw"),
+      group(print("names")),
+      ...print.spaced(["dataType", "default"])
+    ])
+  ),
+  declare_default: (print) => print.spaced(["defaultKw", "expr"]),
+  // SET
+  set_stmt: (print) => group(print.spaced(["setKw", "assignments"])),
+  // IF
+  if_stmt: (print) => group(join(hardline, [...print("clauses"), print.spaced("endIfKw")])),
+  if_clause: (print) => [
+    group([
+      print("ifKw"),
+      indent([line, print("condition")]),
+      line,
+      print("thenKw")
+    ]),
+    indent([hardline, stripTrailingHardline(print("consequent"))])
+  ],
+  elseif_clause: (print) => [
+    group([
+      print("elseifKw"),
+      indent([line, print("condition")]),
+      line,
+      print("thenKw")
+    ]),
+    indent([hardline, stripTrailingHardline(print("consequent"))])
+  ],
+  else_clause: (print) => [
+    print("elseKw"),
+    indent([hardline, stripTrailingHardline(print("consequent"))])
+  ],
+  // CASE
+  case_stmt: (print) => group([
+    print.spaced(["caseKw", "expr"]),
+    indent([hardline, join(hardline, print("clauses"))]),
+    hardline,
+    print.spaced("endCaseKw")
+  ]),
+  // LOOP
+  loop_stmt: (print) => group([
+    print("loopKw"),
+    indent([hardline, stripTrailingHardline(print("body"))]),
+    hardline,
+    print.spaced("endLoopKw")
+  ]),
+  // REPEAT
+  repeat_stmt: (print) => group([
+    print("repeatKw"),
+    indent([hardline, stripTrailingHardline(print("body"))]),
+    hardline,
+    print.spaced(["untilKw", "condition", "endRepeatKw"])
+  ]),
+  // WHILE
+  while_stmt: (print) => group([
+    print.spaced(["whileKw", "condition", "doKw"]),
+    indent([hardline, stripTrailingHardline(print("body"))]),
+    hardline,
+    print.spaced("endWhileKw")
+  ]),
+  // FOR .. IN
+  for_stmt: (print) => group([
+    print.spaced(["forKw", "left", "inKw", "right", "doKw"]),
+    indent([hardline, stripTrailingHardline(print("body"))]),
+    hardline,
+    print.spaced("endForKw")
+  ]),
+  // BREAK/CONTINUE
+  break_stmt: (print) => group(print.spaced(["breakKw", "label"])),
+  continue_stmt: (print) => group(print.spaced(["continueKw", "label"])),
+  labeled_stmt: (print, node) => group([
+    print("beginLabel"),
+    ": ",
+    print("statement"),
+    node.endLabel ? [" ", print(["endLabel"])] : []
+  ]),
+  // CALL
+  call_stmt: (print) => group(print.spaced(["callKw", "func"])),
+  // RETURN
+  return_stmt: (print) => group(print.spaced(["returnKw", "expr"])),
+  // RAISE
+  raise_stmt: (print) => group(print.spaced(["raiseKw", "message"])),
+  raise_message: (print) => [
+    print.spaced("usingMessageKw"),
+    " = ",
+    print("string")
+  ]
+};
+
+// src/syntax/procedure.ts
+var procedureMap = {
+  create_procedure_stmt: (print, node) => group([
+    print.spaced([
+      "createKw",
+      "orReplaceKw",
+      "procedureKw",
+      "ifNotExistsKw",
+      "name"
+    ]),
+    print("params"),
+    hasOnlyAsClause(node) ? [" ", group(print("clauses"))] : [
+      hardline,
+      join(
+        hardline,
+        print("clauses").map((clause) => group(clause))
+      )
+    ]
+  ]),
+  drop_procedure_stmt: (print) => group([
+    print.spaced([
+      "dropKw",
+      "procedureKw",
+      "ifExistsKw",
+      "signatures",
+      "behaviorKw"
+    ])
+  ]),
+  // almost exact copy of alter_function_stmt
+  alter_procedure_stmt: (print, node) => group([
+    print.spaced(["alterKw", "procedureKw"]),
+    " ",
+    print(["signature"]),
+    print.dynamicLine(),
+    join(print.dynamicLine(), print("actions")),
+    node.behaviorKw ? [print.dynamicLine(), print("behaviorKw")] : []
+  ])
+};
+
+// src/syntax/proc_clause.ts
+var procClauseMap = {
+  returns_clause: (print) => print.spaced(["returnsKw", "dataType"]),
+  determinism_clause: (print) => print.spaced("deterministicKw"),
+  language_clause: (print) => print.spaced(["languageKw", "name"]),
+  as_clause: (print, node) => {
+    if (isStringLiteral(node.expr) || isDynamicallyLoadedFunction(node.expr)) {
+      return print.spaced(["asKw", "expr"]);
+    }
+    return [print("asKw"), indent([hardline, print("expr")])];
+  },
+  with_connection_clause: (print) => print.spaced(["withConnectionKw", "connection"])
+};
+
+// src/syntax/program.ts
+var programMap = {
+  program: (print, node, path, options2) => print("statements").map(
+    (doc2, i) => i === node.statements.length - 1 ? printFinalStatement(doc2, i, node.statements, options2) : printStatement(doc2, i, node.statements, options2)
+  )
+};
+var printStatement = (doc2, i, statements, options2) => {
+  const prevNode = statements[i - 1];
+  const node = statements[i];
+  if (i === 0) {
+    return doc2;
+  } else if (node.type !== "empty") {
+    if (hasEmptyLineBetweenNodes(prevNode, node, options2)) {
+      return [";", hardline, hardline, doc2];
+    } else {
+      return [";", hardline, doc2];
+    }
+  } else {
+    return [";", hardline, doc2];
+  }
+};
+var printFinalStatement = (doc2, i, statements, options2) => {
+  const stmtDoc = printStatement(doc2, i, statements, options2);
+  if (statements[i].type === "empty") {
+    return stmtDoc;
+  } else {
+    return [stmtDoc, hardline];
+  }
+};
+
+// src/syntax/publication.ts
+var publicationMap = {
+  create_publication_stmt: (print, node) => group([
+    print.spaced(["createPublicationKw", "name"]),
+    print("clauses").map((printedClause, i) => {
+      if (node.clauses[i].type === "for_publication_objects_clause") {
+        return [" ", printedClause];
+      } else {
+        return [line, printedClause];
+      }
+    })
+  ]),
+  for_publication_objects_clause: (print) => group([print("forKw"), indent([line, print("publicationObjects")])]),
+  all_publication_object: (print) => group(print.spaced(["allKw", "typesKw"])),
+  publication_object_table: (print) => group(print.spaced(["tableKw", "table", "columns", "where"])),
+  publication_object_tables_in_schema: (print) => group(print.spaced(["tablesInSchemaKw", "schema"])),
+  alter_publication_stmt: (print) => group([
+    print.spaced(["alterPublicationKw", "name"]),
+    print.dynamicLine(),
+    print("action")
+  ]),
+  alter_action_add_publication_objects: (print) => group([print("addKw"), indent([line, print("publicationObjects")])]),
+  alter_action_set_publication_objects: (print) => group([print("setKw"), indent([line, print("publicationObjects")])]),
+  alter_action_drop_publication_objects: (print) => group([print("dropKw"), indent([line, print("publicationObjects")])]),
+  drop_publication_stmt: (print) => group(
+    print.spaced(["dropPublicationKw", "ifExistsKw", "names", "behaviorKw"])
+  )
+};
+
+// src/syntax/schema.ts
+var schemaMap = {
+  create_schema_stmt: (print, node) => group([
+    group(
+      join(print.dynamicLine(), [
+        print.spaced(["createSchemaKw", "ifNotExistsKw", "name"]),
+        ...print("clauses")
+      ])
+    ),
+    node.statements.length > 0 ? indent([hardline, join(hardline, print("statements"))]) : []
+  ]),
+  create_schema_authorization_clause: (print) => print.spaced(["authorizationKw", "role"]),
+  drop_schema_stmt: (print) => group(
+    print.spaced(["dropSchemaKw", "ifExistsKw", "schemas", "behaviorKw"])
+  ),
+  alter_schema_stmt: (print) => group(
+    join(print.dynamicLine(), [
+      print.spaced(["alterSchemaKw", "ifExistsKw", "name"]),
+      ...print("actions")
+    ])
+  )
+};
+
+// src/syntax/select.ts
+var selectMap = {
+  compound_select_stmt: (print) => group(
+    join(hardline, [print("left"), print.spaced("operator"), print("right")])
+  ),
+  select_stmt: (print) => group(join(print.dynamicLine(), print("clauses"))),
+  // WITH clause
+  with_clause: (print) => group([
+    print.spaced(["withKw", "recursiveKw"]),
+    indent([line, print("tables")])
+  ]),
+  common_table_expr: (print, node) => [
+    print(["table", "columns"]),
+    " ",
+    print.spaced(["asKw", "materializedKw", "expr"]),
+    group([
+      node.search || node.cycle ? indent([line, print.separated(line, ["search", "cycle"])]) : []
+    ])
+  ],
+  cte_search_clause: (print) => group(
+    join(line, [
+      [print.spaced("searchKw"), group(indent([line, print("columns")]))],
+      print.spaced(["setKw", "resultColumn"])
+    ])
+  ),
+  cte_cycle_clause: (print, node) => group(
+    join(
+      line,
+      [
+        [print("cycleKw"), group(indent([line, print("columns")]))],
+        print.spaced(["setKw", "resultColumn"]),
+        node.values ? print("values") : void 0,
+        print.spaced(["usingKw", "pathColumn"])
+      ].filter(isDefined)
+    )
+  ),
+  cte_cycle_clause_values: (print) => join(line, [
+    print.spaced(["toKw", "markValue"]),
+    print.spaced(["defaultKw", "defaultValue"])
+  ]),
+  // SELECT clause
+  select_clause: (print, node, path, opts) => group([
+    print.spaced(["selectKw", "modifiers"]),
+    node.columns ? indent([line, print("columns")]) : [],
+    containsNewline(node, opts) ? breakParent : []
+  ]),
+  select_all: (print) => print.spaced(["allKw"]),
+  select_distinct: (print) => print.spaced(["distinctKw"]),
+  select_distinct_on: (print) => group([print.spaced(["distinctOnKw", "columns"])]),
+  select_as_struct: (print) => print.spaced(["asStructKw"]),
+  select_as_value: (print) => print.spaced(["asValueKw"]),
+  except_columns: (print) => print.spaced(["expr", "exceptKw", "columns"]),
+  replace_columns: (print) => print.spaced(["expr", "replaceKw", "columns"]),
+  // FROM clause
+  from_clause: (print) => group([print("fromKw"), indent([line, print("expr")])]),
+  join_expr: (print, node) => {
+    if (node.operator === ",") {
+      return join([",", hardline], print(["left", "right"]));
+    } else {
+      return [
+        print("left"),
+        hardline,
+        group(
+          join(" ", [
+            print.spaced("operator"),
+            [
+              print("right"),
+              node.specification ? indent([line, print(["specification"])]) : []
+            ]
+          ])
+        )
+      ];
+    }
+  },
+  join_on_specification: (print) => group(print.spaced(["onKw", "expr"])),
+  join_using_specification: (print) => group(print.spaced(["usingKw", "expr"])),
+  table_with_inheritance: (print) => [print("table"), " ", "*"],
+  table_without_inheritance: (print) => print.spaced(["onlyKw", "table"]),
+  indexed_table: (print) => print.spaced(["table", "indexedByKw", "index"]),
+  not_indexed_table: (print) => print.spaced(["table", "notIndexedKw"]),
+  unnest_expr: (print) => print(["unnestKw", "expr"]),
+  unnest_with_offset_expr: (print) => print.spaced(["unnest", "withOffsetKw"]),
+  pivot_expr: (print) => [print("left"), hardline, print(["pivotKw", "args"])],
+  pivot_for_in: (print) => group(
+    join(line, [
+      group(print("aggregations")),
+      print.spaced(["forKw", "inputColumn"]),
+      print.spaced(["inKw", "pivotColumns"])
+    ])
+  ),
+  unpivot_expr: (print, node) => [
+    print("left"),
+    hardline,
+    (node.nullHandlingKw ? print.spaced : print)([
+      "unpivotKw",
+      "nullHandlingKw",
+      "args"
+    ])
+  ],
+  unpivot_for_in: (print) => group(
+    join(line, [
+      print("valuesColumn"),
+      print.spaced(["forKw", "nameColumn"]),
+      print.spaced(["inKw", "unpivotColumns"])
+    ])
+  ),
+  tablesample_expr: (print) => group([
+    print("left"),
+    line,
+    print.spaced(["tablesampleKw", "method", "args", "repeatable"])
+  ]),
+  tablesample_method: (print) => print.spaced(["methodKw"]),
+  tablesample_percent: (print) => print.spaced(["percent", "percentKw"]),
+  tablesample_repeatable: (print) => print.spaced(["repeatableKw", "seed"]),
+  for_system_time_as_of_expr: (print) => group([print("left"), line, print.spaced(["forSystemTimeAsOfKw", "expr"])]),
+  partitioned_table: (print) => print.spaced(["table", "partitionKw", "partitions"]),
+  dual_table: (print) => print("dualKw"),
+  lateral_derived_table: (print) => print.spaced(["lateralKw", "expr"]),
+  rows_from_expr: (print) => print.spaced(["rowsFromKw", "expr"]),
+  with_ordinality_expr: (print) => print.spaced(["expr", "withOrdinalityKw"]),
+  func_call_with_column_definitions: (print) => print.spaced(["funcCall", "asKw", "columns"]),
+  // WHERE clause
+  where_clause: (print) => group([print("whereKw"), indent([line, print("expr")])]),
+  // ORDER BY clause
+  order_by_clause: (print, node) => group([
+    print.spaced("orderByKw"),
+    indent([line, print.separated(line, ["specifications", "withRollupKw"])])
+  ]),
+  sort_specification: (print) => print.spaced(["expr", "direction", "nullHandlingKw"]),
+  sort_direction_asc: (print) => print("ascKw"),
+  sort_direction_desc: (print) => print("descKw"),
+  sort_direction_using_operator: (print) => print.spaced(["usingKw", "operator"]),
+  // GROUP BY clause
+  group_by_clause: (print, node) => group([
+    print.spaced(["groupByKw", "distinctKw"]),
+    indent([line, print.separated(line, ["columns", "withRollupKw"])])
+  ]),
+  group_by_rollup: (print) => print(["rollupKw", "columns"]),
+  group_by_cube: (print) => print(["cubeKw", "columns"]),
+  group_by_grouping_sets: (print) => print.spaced(["groupingSetsKw", "columns"]),
+  group_by_all: (print) => print(["allKw"]),
+  // PARTITION BY clause
+  partition_by_clause: (print) => group([
+    print.spaced("partitionByKw"),
+    indent([line, print("specifications")])
+  ]),
+  // HAVING clause
+  having_clause: (print) => group([print("havingKw"), indent([line, print("expr")])]),
+  // QUALIFY clause
+  qualify_clause: (print) => group([print("qualifyKw"), indent([line, print("expr")])]),
+  // LIMIT clause
+  /** cst-ignore: count, offsetKw, offset */
+  limit_clause: (print, node) => group([
+    print("limitKw"),
+    indent([
+      line,
+      printLimitValues(print, node),
+      node.rowsExamined ? [line, print("rowsExamined")] : []
+    ])
+  ]),
+  limit_all: (print) => print("allKw"),
+  limit_rows_examined: (print) => print.spaced(["rowsExaminedKw", "count"]),
+  // OFFSET clause
+  offset_clause: (print) => group([
+    print("offsetKw"),
+    indent([line, print.spaced(["offset", "rowsKw"])])
+  ]),
+  // FETCH clause
+  fetch_clause: (print) => print.spaced(["fetchKw", "count", "rowsKw", "withTiesKw"]),
+  // WINDOW clause
+  window_clause: (print, node) => {
+    const lineType = node.namedWindows.items.length > 1 ? hardline : line;
+    return group([
+      print("windowKw"),
+      indent([lineType, print("namedWindows")])
+    ]);
+  },
+  named_window: (print) => print.spaced(["name", "asKw", "window"]),
+  window_definition: (print, node) => {
+    const itemCount = [
+      node.baseWindowName,
+      node.partitionBy,
+      node.orderBy,
+      node.frame
+    ].filter(isDefined).length;
+    const lineType = itemCount > 1 ? hardline : line;
+    return group(
+      join(
+        lineType,
+        print(["baseWindowName", "partitionBy", "orderBy", "frame"])
+      )
+    );
+  },
+  // INTO clause
+  into_table_clause: (print) => print.spaced(["intoKw", "kind", "tableKw", "name"]),
+  into_variables_clause: (print) => group([print("intoKw"), indent([line, print("variables")])]),
+  into_dumpfile_clause: (print) => print.spaced(["intoDumpfileKw", "filename"]),
+  into_outfile_clause: (print, node) => {
+    const hasOptions = node.charset || node.fields || node.lines;
+    return group([
+      print.spaced(["intoOutfileKw", "filename"]),
+      hasOptions ? indent([
+        hardline,
+        join(hardline, print(["charset", "fields", "lines"]))
+      ]) : []
+    ]);
+  },
+  outfile_fields: (print) => print.spaced(["fieldsKw", "options"]),
+  outfile_lines: (print) => print.spaced(["linesKw", "options"]),
+  outfile_option_character_set: (print) => print.spaced(["characterSetKw", "value"]),
+  outfile_option_starting_by: (print) => print.spaced(["startingByKw", "value"]),
+  outfile_option_terminated_by: (print) => print.spaced(["terminatedByKw", "value"]),
+  outfile_option_enclosed_by: (print) => print.spaced(["optionallyKw", "enclosedByKw", "value"]),
+  outfile_option_escaped_by: (print) => print.spaced(["escapedByKw", "value"]),
+  // FOR clause (locking)
+  for_clause: (print, node) => group([
+    print.spaced(["forKw", "lockStrengthKw", "tables"]),
+    node.waitingKw ? indent([line, print.spaced("waitingKw")]) : []
+  ]),
+  for_clause_tables: (print) => [
+    print("ofKw"),
+    indent([line, print("tables")])
+  ],
+  lock_in_share_mode_clause: (print) => print.spaced("lockInShareModeKw"),
+  // TABLE clause
+  table_clause: (print) => print.spaced(["tableKw", "table"])
+};
+var printLimitValues = (print, node) => {
+  if (node.offsetKw) {
+    return print.spaced(["count", "offsetKw", "offset"]);
+  } else if (node.offset) {
+    return join([",", " "], print(["offset", "count"]));
+  } else {
+    return print("count");
+  }
+};
+
+// src/syntax/sequence.ts
+var sequenceMap = {
+  create_sequence_stmt: (print, node) => group([
+    print.spaced(["createKw", "kind", "sequenceKw", "ifNotExistsKw", "name"]),
+    node.options.length > 0 ? indent([print.dynamicLine(), join(line, print("options"))]) : []
+  ]),
+  alter_sequence_stmt: (print) => group([
+    print.spaced(["alterKw", "sequenceKw", "ifExistsKw", "sequence"]),
+    indent([print.dynamicLine(), join(line, print("actions"))])
+  ]),
+  drop_sequence_stmt: (print) => group(
+    print.spaced([
+      "dropKw",
+      "sequenceKw",
+      "ifExistsKw",
+      "sequences",
+      "behaviorKw"
+    ])
+  ),
+  sequence_option_sequence_name: (print) => print.spaced(["sequenceNameKw", "name"]),
+  sequence_option_logged: (print) => print.spaced("loggedKw"),
+  sequence_option_unlogged: (print) => print.spaced("unloggedKw"),
+  sequence_option_as_type: (print) => print.spaced(["asKw", "dataType"]),
+  sequence_option_increment: (print) => print.spaced(["incrementKw", "byKw", "value"]),
+  sequence_option_minvalue: (print) => print.spaced(["minvalueKw", "value"]),
+  sequence_option_maxvalue: (print) => print.spaced(["maxvalueKw", "value"]),
+  sequence_option_no_minvalue: (print) => print.spaced("noMinvalueKw"),
+  sequence_option_no_maxvalue: (print) => print.spaced("noMaxvalueKw"),
+  sequence_option_start: (print) => print.spaced(["startKw", "withKw", "value"]),
+  sequence_option_restart: (print) => print.spaced(["restartKw", "withKw", "value"]),
+  sequence_option_cache: (print) => print.spaced(["cacheKw", "value"]),
+  sequence_option_cycle: (print) => print.spaced("cycleKw"),
+  sequence_option_no_cycle: (print) => print.spaced("noCycleKw"),
+  sequence_option_owned_by: (print) => print.spaced(["ownedByKw", "owner"]),
+  sequence_option_list: (print) => join(line, print("options"))
+};
+
+// src/syntax/subscription.ts
+var subscriptionMap = {
+  create_subscription_stmt: (print, node) => group(
+    join(line, [
+      print.spaced(["createSubscriptionKw", "name"]),
+      print.spaced(["connectionKw", "connectionInfo"]),
+      print.spaced(["publicationKw", "publications"]),
+      ...node.with ? [print.spaced(["with"])] : []
+    ])
+  ),
+  drop_subscription_stmt: (print) => group(
+    print.spaced(["dropSubscriptionKw", "ifExistsKw", "name", "behaviorKw"])
+  )
+};
+
+// src/syntax/transaction.ts
+var transactionMap = {
+  start_transaction_stmt: (print, node) => group([
+    print.spaced(["startKw", "behaviorKw", "transactionKw"]),
+    node.modes ? indent([line, print("modes")]) : []
+  ]),
+  commit_transaction_stmt: (print) => group(print.spaced(["commitKw", "transactionKw", "chain"])),
+  rollback_transaction_stmt: (print) => group(print.spaced(["rollbackKw", "transactionKw", "savepoint", "chain"])),
+  rollback_to_savepoint: (print) => print.spaced(["toKw", "savepointKw", "savepoint"]),
+  savepoint_stmt: (print) => group(print.spaced(["savepointKw", "savepoint"])),
+  release_savepoint_stmt: (print) => group(print.spaced(["releaseKw", "savepointKw", "savepoint"])),
+  transaction_chain_clause: (print) => print.spaced("andChainKw"),
+  transaction_no_chain_clause: (print) => print.spaced("andNoChainKw"),
+  transaction_mode_isolation_level: (print) => print.spaced(["isolationLevelKw", "levelKw"]),
+  transaction_mode_deferrable: (print) => print.spaced("deferrableKw"),
+  transaction_mode_not_deferrable: (print) => print.spaced("notDeferrableKw"),
+  transaction_mode_read_only: (print) => print.spaced("readOnlyKw"),
+  transaction_mode_read_write: (print) => print.spaced("readWriteKw")
+};
+
+// src/syntax/trigger.ts
+var triggerMap = {
+  create_trigger_stmt: (print, node) => group(
+    join(hardline, [
+      print.spaced([
+        "createKw",
+        "orReplaceKw",
+        "kind",
+        "triggerKw",
+        "ifNotExistsKw",
+        "name"
+      ]),
+      group([
+        node.timeKw ? [print.spaced("timeKw"), " "] : [],
+        print("event"),
+        line,
+        print("target")
+      ]),
+      ...print("clauses"),
+      print("body")
+    ])
+  ),
+  trigger_event: (print, node) => group([
+    print.spaced(["eventKw", "ofKw"]),
+    node.columns ? indent([line, print("columns")]) : []
+  ]),
+  trigger_target: (print) => print.spaced(["onKw", "table"]),
+  when_clause: (print) => group([print("whenKw"), indent([line, print("expr")])]),
+  for_each_clause: (print) => print.spaced(["forEachKw", "itemKw"]),
+  execute_clause: (print) => [
+    print.spaced(["executeKw", "functionKw", "name"]),
+    print("args")
+  ],
+  from_referenced_table_clause: (print) => print.spaced(["fromKw", "table"]),
+  trigger_timing_clause: (print) => print.spaced(["timingKw"]),
+  trigger_referencing_clause: (print) => group([
+    print.spaced(["referencingKw"]),
+    indent([line, print("transitions")])
+  ]),
+  trigger_transition: (print) => [
+    print.spaced(["oldOrNewKw", "rowOrTableKw", "asKw", "name"])
+  ],
+  alter_trigger_stmt: (print) => group(
+    join(print.dynamicLine(), [
+      print.spaced(["alterTriggerKw", "trigger", "target"]),
+      print("action")
+    ])
+  ),
+  drop_trigger_stmt: (print) => group(
+    print.spaced([
+      "dropTriggerKw",
+      "ifExistsKw",
+      "trigger",
+      "target",
+      "behaviorKw"
+    ])
+  )
+};
+
+// src/syntax/truncate.ts
+var truncateMap = {
+  truncate_stmt: (print) => group([
+    print.spaced(["truncateKw", "tableKw"]),
+    indent([
+      line,
+      print.separated(line, ["tables", "restartOrContinueKw", "behaviorKw"])
+    ])
+  ])
+};
+
+// src/syntax/type.ts
+var typeMap = {
+  create_type_stmt: (print) => group([print.spaced(["createTypeKw", "name", "definition"])]),
+  composite_type_definition: (print) => group(print.spaced(["asKw", "columns"])),
+  enum_type_definition: (print) => group(print.spaced(["asEnumKw", "values"])),
+  alter_type_stmt: (print, node) => group([
+    print.spaced(["alterTypeKw", "name"]),
+    print.dynamicLine(),
+    print("actions")
+  ]),
+  drop_type_stmt: (print) => group(print.spaced(["dropTypeKw", "ifExistsKw", "types", "behaviorKw"]))
+};
+
+// src/syntax/unsupported_grammar.ts
+var unsupportedGrammarMap = {
+  unsupported_grammar_stmt: (print) => group(print("text"))
+};
+
+// src/syntax/update.ts
+var updateMap = {
+  update_stmt: (print) => group(join(print.dynamicLine(), print("clauses"))),
+  update_clause: (print) => print.spaced(["updateKw", "modifiers", "orAction", "tables"]),
+  set_clause: (print, node) => {
+    if (node.assignments.items.length > 1) {
+      return [print("setKw"), indent([hardline, print("assignments")])];
+    } else {
+      return print.spaced(["setKw", "assignments"]);
+    }
+  },
+  column_assignment: (print) => join([" ", "=", " "], print(["column", "expr"]))
+};
+
+// src/syntax/view.ts
+var viewMap = {
+  create_view_stmt: (print, node) => {
+    const hasOnlyAsClause2 = node.clauses.length === 1;
+    const hasManyClauses = node.clauses.length > 1;
+    return group([
+      print.spaced([
+        "createKw",
+        "orReplaceKw",
+        "kinds",
+        "viewKw",
+        "ifNotExistsKw",
+        "name",
+        "columns"
+      ]),
+      hasOnlyAsClause2 ? [" ", print("clauses")] : [],
+      hasManyClauses ? [hardline, join(hardline, print("clauses"))] : []
+    ]);
+  },
+  with_check_option_clause: (print) => print.spaced(["withKw", "levelKw", "checkOptionKw"]),
+  as_replica_of_clause: (print) => print.spaced(["asReplicaOfKw", "view"]),
+  drop_view_stmt: (print) => group(
+    print.spaced([
+      "dropKw",
+      "kind",
+      "viewKw",
+      "ifExistsKw",
+      "views",
+      "behaviorKw"
+    ])
+  ),
+  alter_view_stmt: (print) => group([
+    print.spaced([
+      "alterKw",
+      "kind",
+      "viewKw",
+      "ifExistsKw",
+      "name",
+      "columns"
+    ]),
+    hardline,
+    print("actions")
+  ]),
+  refresh_materialized_view_stmt: (print, node) => group([
+    print.spaced(["refreshMaterializedViewKw", "concurrentlyKw", "name"]),
+    node.clauses.length > 0 ? [print.dynamicLine(), join(line, print("clauses"))] : []
+  ])
+};
+
+// src/syntax/dialects/bigquery.ts
+var bigqueryMap = {
+  bigquery_options: (print) => print.spaced(["optionsKw", "options"]),
+  bigquery_option_default_collate: (print) => print.spaced(["defaultCollateKw", "collation"]),
+  // ROW ACCESS POLICY
+  create_row_access_policy_stmt: (print) => group(
+    join(hardline, [
+      print.spaced([
+        "createKw",
+        "orReplaceKw",
+        "rowAccessPolicyKw",
+        "ifNotExistsKw",
+        "name",
+        "onKw",
+        "table"
+      ]),
+      ...print("clauses")
+    ])
+  ),
+  row_access_policy_grant_clause: (print) => print.spaced(["grantToKw", "grantees"]),
+  row_access_policy_filter_clause: (print) => print.spaced(["filterUsingKw", "expr"]),
+  drop_row_access_policy_stmt: (print) => group(
+    print.spaced([
+      "dropKw",
+      "allKw",
+      "rowAccessPolicyKw",
+      "ifExistsKw",
+      "name",
+      "onKw",
+      "table"
+    ])
+  ),
+  // CAPACITY
+  create_capacity_stmt: (print) => group([
+    print.spaced(["createKw", "capacityKw", "name"]),
+    hardline,
+    print("options")
+  ]),
+  drop_capacity_stmt: (print) => group(print.spaced(["dropKw", "capacityKw", "ifExistsKw", "name"])),
+  // RESERVATION
+  create_reservation_stmt: (print) => group([
+    print.spaced(["createKw", "reservationKw", "name"]),
+    hardline,
+    print("options")
+  ]),
+  drop_reservation_stmt: (print) => group(print.spaced(["dropKw", "reservationKw", "ifExistsKw", "name"])),
+  // ASSIGNMENT
+  create_assignment_stmt: (print) => group([
+    print.spaced(["createKw", "assignmentKw", "name"]),
+    hardline,
+    print("options")
+  ]),
+  drop_assignment_stmt: (print) => group(print.spaced(["dropKw", "assignmentKw", "ifExistsKw", "name"])),
+  // ALTER ORGANIZATION
+  alter_organization_stmt: (print) => group(
+    join(hardline, [print.spaced("alterOrganizationKw"), print("actions")])
+  ),
+  // ALTER PROJECT
+  alter_project_stmt: (print) => group(
+    join(hardline, [
+      print.spaced(["alterProjectKw", "name"]),
+      print("actions")
+    ])
+  ),
+  alter_bi_capacity_stmt: (print) => group(
+    join(hardline, [
+      print.spaced(["alterBiCapacityKw", "name"]),
+      print("actions")
+    ])
+  ),
+  alter_capacity_stmt: (print) => group(
+    join(hardline, [
+      print.spaced(["alterCapacityKw", "name"]),
+      print("actions")
+    ])
+  ),
+  alter_reservation_stmt: (print) => group(
+    join(hardline, [
+      print.spaced(["alterReservationKw", "name"]),
+      print("actions")
+    ])
+  ),
+  // ASSERT
+  assert_stmt: (print) => group(print.spaced(["assertKw", "expr", "as"])),
+  // EXPORT
+  export_data_stmt: (print) => group(
+    join(hardline, [
+      print.spaced("exportDataKw"),
+      ...print.spaced(["withConnection"]),
+      print.spaced("options"),
+      print.spaced("as")
+    ])
+  ),
+  // LOAD
+  load_data_stmt: (print) => group(
+    join(hardline, [
+      print.spaced(["loadDataKw", "intoKw", "table", "columns"]),
+      ...print("clauses")
+    ])
+  ),
+  from_files_options: (print) => print.spaced(["fromFilesKw", "options"])
+};
+
+// src/syntax/dialects/mysql.ts
+var mysqlMap = {
+  mysql_modifier: (print) => print.spaced("modifierKw")
+};
+
+// src/syntax/dialects/sqlite.ts
+var sqliteMap = {
+  attach_database_stmt: (print) => group(print.spaced(["attachKw", "databaseKw", "file", "asKw", "schema"])),
+  detach_database_stmt: (print) => group(print.spaced(["detachKw", "databaseKw", "schema"])),
+  vacuum_stmt: (print) => group(print.spaced(["vacuumKw", "schema", "intoKw", "file"])),
+  pragma_stmt: (print) => group(print.spaced(["pragmaKw", "pragma"])),
+  pragma_assignment: (print) => join(" = ", print(["name", "value"])),
+  pragma_func_call: (print) => print(["name", "args"])
+};
+
+// src/syntax/dialects/postgresql.ts
+var postgresqlMap = {
+  postgresql_operator_expr: (print) => print(["operatorKw", "expr"]),
+  postgresql_operator: (print) => print("operator"),
+  postgresql_operator_class: (print) => print.spaced(["name", "options"]),
+  postgresql_with_options: (print) => group(print.spaced(["withKw", "options"])),
+  postgresql_options: (print) => print.spaced(["optionsKw", "options"]),
+  postgresql_option_element: (print) => print.spaced(["name", "value"])
+};
+
+// src/syntax/transformMap.ts
+var transformMap = {
+  ...aliasMap,
+  ...alterActionMap,
+  ...alterTableMap,
+  ...analyzeMap,
+  ...baseMap,
+  ...castMap,
+  ...commentMap,
+  ...constraintMap,
+  ...createTableMap,
+  ...dataTypeMap,
+  ...dclMap,
+  ...deleteMap,
+  ...doMap,
+  ...domainMap,
+  ...dropTableMap,
+  ...explainMap,
+  ...exprMap,
+  ...extensionMap,
+  ...frameMap,
+  ...functionMap,
+  ...indexMap,
+  ...insertMap,
+  ...mergeMap,
+  ...otherClausesMap,
+  ...parameterMap,
+  ...policyMap,
+  ...preparedStatementsMap,
+  ...procClauseMap,
+  ...proceduralLanguageMap,
+  ...procedureMap,
+  ...programMap,
+  ...publicationMap,
+  ...renameTableMap,
+  ...roleMap,
+  ...schemaMap,
+  ...selectMap,
+  ...sequenceMap,
+  ...subscriptionMap,
+  ...transactionMap,
+  ...triggerMap,
+  ...truncateMap,
+  ...typeMap,
+  ...unsupportedGrammarMap,
+  ...updateMap,
+  ...viewMap,
+  ...bigqueryMap,
+  ...mysqlMap,
+  ...postgresqlMap,
+  ...sqliteMap
+};
+
+// src/printSql.ts
+function printSql(path, options2, oldPrint) {
+  return printNode(path, options2, createPrintFn(path, oldPrint, options2));
+}
+var cachedPrintFn;
+var cachedPath;
+function createPrintFn(path, oldPrint, opts) {
+  if (cachedPath === path) {
+    return cachedPrintFn;
+  }
+  cachedPath = path;
+  cachedPrintFn = ((selector) => {
+    if (isArray(selector)) {
+      const node = path.node;
+      return selector.filter((sel) => isDefined(node[sel])).map(oldPrint);
+    } else {
+      return oldPrint(selector);
+    }
+  });
+  cachedPrintFn.separated = (separator, selector) => {
+    const node = path.node;
+    const docs = arrayWrap(selector).filter((sel) => isDefined(node[sel])).map((sel) => [sel, oldPrint(sel)]).filter(([sel, doc2]) => !isEmptyArray(doc2)).map(([sel, doc2]) => isArray(node[sel]) ? join(" ", doc2) : doc2);
+    return docs.length > 0 ? [join(separator, docs)] : [];
+  };
+  cachedPrintFn.spaced = (selector) => cachedPrintFn.separated(" ", selector);
+  cachedPrintFn.dynamicLine = () => {
+    const node = path.node;
+    return containsNewline(node, opts) ? hardline : line;
+  };
+  return cachedPrintFn;
+}
+function printNode(path, options2, print) {
+  const node = path.node;
+  if (isArray(node)) {
+    return path.map(print);
+  }
+  if (isString(node)) {
+    return node;
+  }
+  if (!node?.type) {
+    throw new Error(`No type field on node: ${JSON.stringify(node)}`);
+  }
+  const fn = transformMap[node.type];
+  if (!fn) {
+    throw new Error(`Unexpected node type: ${node.type}`);
+  }
+  return fn(print, node, path, options2);
+}
+
+// src/printComment.ts
+var printComment = (path) => {
+  const node = path.node;
+  if (node.type === "line_comment") {
+    if (/^--[^ \t]/.test(node.text)) {
+      return node.text.replace(/^--/, "-- ");
+    }
+    if (/^#[^ \t!]/.test(node.text)) {
+      return node.text.replace(/^#/, "# ");
+    }
+  }
+  return node.text;
+};
+
+// src/embedJs.ts
+var embedJs = (path, options2) => {
+  const node = path.node;
+  const parent = path.getParentNode(0);
+  const grandParent = path.getParentNode(1);
+  if (isStringLiteral(node) && isAsClause(parent) && isCreateFunctionStmt(grandParent) && grandParent.clauses.some(isJavaScriptLanguageClause)) {
+    return async (textToDoc) => {
+      const quotes = detectQuotes(node.value);
+      if (!quotes) {
+        return void 0;
+      }
+      const js = await textToDoc(node.value, {
+        ...options2,
+        parser: "babel"
+      });
+      return [
+        quotes[0],
+        indent([hardline, stripTrailingHardline(js)]),
+        hardline,
+        quotes[1]
+      ];
+    };
+  }
+  return null;
+};
+var isJavaScriptLanguageClause = (clause) => isLanguageClause(clause) && clause.name.name === "js";
+var detectQuotes = (js) => {
+  if (!/'''/.test(js)) {
+    return ["r'''", "'''"];
+  }
+  if (!/"""/.test(js)) {
+    return ['r"""', '"""'];
+  }
+  return void 0;
+};
+
+// src/embedJson.ts
+var embedJson = (path, options2) => {
+  const node = path.node;
+  const parent = path.getParentNode();
+  if (isStringLiteral(node) && (isJsonLiteral(parent) || isJsonbLiteral(parent))) {
+    return async (textToDoc) => {
+      if (containsTripleQuote(node.value) || containsBackslash(node.value) || isRawString(node)) {
+        return void 0;
+      }
+      const json = await textToDoc(node.value, {
+        ...options2,
+        parser: "json"
+      });
+      const inlineQuote = containsSingleQuote(node.value) ? "'''" : "'";
+      return [
+        ifBreak("'''", inlineQuote),
+        indent([softline, stripTrailingHardline(json)]),
+        softline,
+        ifBreak("'''", inlineQuote)
+      ];
+    };
+  }
+  return null;
+};
+var containsSingleQuote = (json) => /'/.test(json);
+var containsTripleQuote = (json) => /'''/.test(json);
+var containsBackslash = (json) => /\\/.test(json);
+var isRawString = (node) => /^R/i.test(node.text);
+
+// src/embedSql.ts
+var embedSql = (path, options2) => {
+  const node = path.node;
+  const parent = path.getParentNode(0);
+  const grandParent = path.getParentNode(1);
+  if (isStringLiteral(node) && isAsClause(parent) && (isCreateFunctionStmt(grandParent) || isCreateProcedureStmt(grandParent)) && grandParent.clauses.some(isSqlLanguageClause)) {
+    return async (textToDoc) => {
+      const quote = detectQuote(node);
+      if (!quote) {
+        return void 0;
+      }
+      const sql = await textToDoc(node.value, options2);
+      return [
+        quote,
+        indent([hardline, stripTrailingHardline(sql)]),
+        hardline,
+        quote
+      ];
+    };
+  }
+  return null;
+};
+var isSqlLanguageClause = (clause) => isLanguageClause(clause) && clause.name.name.toLowerCase() === "sql";
+var detectQuote = (node) => {
+  const match = node.text.match(/^('|\$[^$]*\$)/);
+  const quote = match?.[1];
+  if (quote === "'") {
+    return node.value.includes("$$") ? void 0 : "$$";
+  } else {
+    return quote;
+  }
+};
+
+// src/embed.ts
+var embed = (...args) => {
+  return embedJson(...args) || embedJs(...args) || embedSql(...args);
+};
+
+// src/visitAllNodes.ts
+var visitAllNodes = (node, visit) => {
+  visit(node);
+  for (const child of Object.values(node)) {
+    if (isNode(child)) {
+      visitAllNodes(child, visit);
+    } else if (isArray(child)) {
+      child.filter(isNode).forEach((childNode) => visitAllNodes(childNode, visit));
+    }
+  }
+};
+
+// src/transform/comments.ts
+var moveCommentsToRoot = (cst) => {
+  return {
+    ...cst,
+    comments: extractComments(cst)
+  };
+};
+var extractComments = (cst) => {
+  const comments = [];
+  visitAllNodes(cst, (node) => {
+    comments.push(...node.leading || [], ...node.trailing || []);
+  });
+  return comments;
+};
+
+// src/transform/aliasAs.ts
+import { cstVisitor } from "sql-parser-cst";
+var processAliasAs = (cst) => {
+  cstVisitor({
+    alias: (node) => {
+      node.asKw = node.asKw || { type: "keyword", name: "AS", text: "AS" };
+    }
+  })(cst);
+  return cst;
+};
+
+// src/transform/stripTrailingCommas.ts
+import { cstVisitor as cstVisitor2 } from "sql-parser-cst";
+var stripTrailingCommas = (cst) => {
+  cstVisitor2({
+    select_clause: (node) => {
+      if (node.columns && isEmpty(last(node.columns.items))) {
+        node.columns.items = node.columns.items.slice(0, -1);
+      }
+    }
+  })(cst);
+  return cst;
+};
+
+// src/transform/addFinalSemicolon.ts
+var addFinalSemicolon = (program, originalText) => {
+  if (!isEmpty(last(program.statements))) {
+    const end = originalText.length;
+    program.statements.push({ type: "empty", range: [end, end] });
+  }
+  return program;
+};
+
+// src/transform/canonicKeywords.ts
+import { cstVisitor as cstVisitor3 } from "sql-parser-cst";
+
+// src/transform/transformUtils.ts
+function keyword(name) {
+  return { type: "keyword", name, text: name };
+}
+
+// src/transform/canonicKeywords.ts
+var canonicKeywords = (cst) => {
+  cstVisitor3({
+    // Replaces TEMP with TEMPORARY
+    relation_kind: (node) => {
+      if (Array.isArray(node.kindKw)) {
+      } else {
+        if (node.kindKw.name === "TEMP") {
+          node.kindKw.name = "TEMPORARY";
+          node.kindKw.text = "TEMPORARY";
+        }
+      }
+    },
+    // Replaces MySQL SELECT DISTINCTROW with SELECT DISTINCT
+    select_distinct: (node) => {
+      if (node.distinctKw.name === "DISTINCTROW") {
+        node.distinctKw.name = "DISTINCT";
+        node.distinctKw.text = "DISTINCT";
+      }
     },
-    {
-        extensions: [".bigquery"],
-        name: "BigQuery SQL",
-        parsers: ["bigquery"],
+    // Replaces RENAME & RENAME AS with RENAME TO
+    alter_action_rename: (node) => {
+      if (Array.isArray(node.renameKw)) {
+        if (node.renameKw[1].name === "AS") {
+          node.renameKw[1].name = "TO";
+          node.renameKw[1].text = "TO";
+        }
+      } else {
+        node.renameKw = [node.renameKw, keyword("TO")];
+      }
     },
-    {
-        extensions: [],
-        name: "Experimental MySQL SQL",
-        parsers: ["mysql"],
+    // Replaces INSERT with INSERT INTO
+    insert_clause: (node) => {
+      if (!node.intoKw) {
+        node.intoKw = keyword("INTO");
+      }
     },
-    {
-        extensions: [],
-        name: "Experimental MariaDB SQL",
-        parsers: ["mariadb"],
+    // Replaces MERGE with MERGE INTO
+    merge_clause: (node) => {
+      if (!node.intoKw) {
+        node.intoKw = keyword("INTO");
+      }
     },
-    {
-        extensions: [],
-        name: "Experimental PostgreSQL SQL",
-        parsers: ["postgresql"],
+    // Replaces DELETE with DELETE FROM
+    delete_clause: (node) => {
+      if (!node.fromKw) {
+        node.fromKw = keyword("FROM");
+      }
     },
+    // Replaces TRUNCATE with TRUNCATE TABLE
+    truncate_stmt: (node) => {
+      if (!node.tableKw) {
+        node.tableKw = keyword("TABLE");
+      }
+    }
+  })(cst);
+  return cst;
+};
+
+// src/transform/canonicOperators.ts
+import { cstVisitor as cstVisitor4 } from "sql-parser-cst";
+var canonicOperators = (cst, originalText, options2) => {
+  cstVisitor4({
+    binary_expr: (node) => {
+      if (node.operator === "<>") {
+        node.operator = "!=";
+      }
+      if (options2.parser === "mysql" || options2.parser === "mariadb") {
+        if (node.operator === "&&") {
+          node.operator = keyword("AND");
+        }
+        if (node.operator === "||") {
+          node.operator = keyword("OR");
+        }
+      }
+    },
+    // Replaces PostgreSQL deprecated := operator with =>
+    named_arg: (node) => {
+      if (node.operator === ":=") {
+        node.operator = "=>";
+      }
+    }
+  })(cst);
+  return cst;
+};
+
+// src/transform/transformCst.ts
+var transformCst = (cst, originalText, options2) => {
+  const transforms = [
+    // Note that we first perform moveCommentsToRoot transform,
+    // so we don't need to worry about comments interfering with other transforms
+    moveCommentsToRoot,
+    stripTrailingCommas
+  ];
+  if (options2.sqlFinalSemicolon) {
+    transforms.push(addFinalSemicolon);
+  }
+  if (options2.sqlCanonicalSyntax) {
+    transforms.push(processAliasAs, canonicOperators, canonicKeywords);
+  }
+  return transforms.reduce(
+    (cst2, transform) => transform(cst2, originalText, options2),
+    cst
+  );
+};
+
+// src/options.ts
+var options = {
+  sqlKeywordCase: {
+    type: "choice",
+    category: "SQL",
+    default: "upper",
+    description: "Enforces upper/lower case for SQL keywords",
+    choices: [
+      {
+        value: "preserve",
+        description: "preserves the existing case",
+        since: "0.1.0"
+      },
+      {
+        value: "upper",
+        description: "forces all keywords to uppercase",
+        since: "0.1.0"
+      },
+      {
+        value: "lower",
+        description: "forces all keywords to lowercase",
+        since: "0.1.0"
+      }
+    ]
+  },
+  sqlLiteralCase: {
+    type: "choice",
+    category: "SQL",
+    default: "upper",
+    description: "Enforces upper/lower case for SQL literals (TRUE, FALSE, NULL)",
+    choices: [
+      {
+        value: "preserve",
+        description: "preserves the existing case",
+        since: "0.14.0"
+      },
+      {
+        value: "upper",
+        description: "forces all literals to uppercase",
+        since: "0.14.0"
+      },
+      {
+        value: "lower",
+        description: "forces all literals to lowercase",
+        since: "0.14.0"
+      }
+    ]
+  },
+  sqlTypeCase: {
+    type: "choice",
+    category: "SQL",
+    default: "upper",
+    description: "Enforces upper/lower case for SQL types",
+    choices: [
+      {
+        value: "preserve",
+        description: "preserves the existing case",
+        since: "0.17.0"
+      },
+      {
+        value: "upper",
+        description: "forces all type names to uppercase",
+        since: "0.17.0"
+      },
+      {
+        value: "lower",
+        description: "forces all type names to lowercase",
+        since: "0.17.0"
+      }
+    ]
+  },
+  sqlIdentifierCase: {
+    type: "choice",
+    category: "SQL",
+    default: "preserve",
+    description: "Enforces upper/lower case for unquoted SQL identifiers",
+    choices: [
+      {
+        value: "preserve",
+        description: "preserves the existing case",
+        since: "0.17.0"
+      },
+      {
+        value: "upper",
+        description: "forces all unquoted identifier names to uppercase",
+        since: "0.17.0"
+      },
+      {
+        value: "lower",
+        description: "forces all unquoted identifier names to lowercase",
+        since: "0.17.0"
+      }
+    ]
+  },
+  sqlFunctionCase: {
+    type: "choice",
+    category: "SQL",
+    default: "preserve",
+    description: "Enforces upper/lower case for SQL function names",
+    choices: [
+      {
+        value: "preserve",
+        description: "preserves the existing case",
+        since: "0.17.0"
+      },
+      {
+        value: "upper",
+        description: "forces all unquoted function names to uppercase",
+        since: "0.17.0"
+      },
+      {
+        value: "lower",
+        description: "forces all unquoted function names to lowercase",
+        since: "0.17.0"
+      }
+    ]
+  },
+  sqlParamTypes: {
+    type: "string",
+    array: true,
+    category: "SQL",
+    default: [{ value: [] }],
+    description: "Syntax for bound parameters"
+    // Since 0.7.0
+    // Possible values in array: "?" | "?nr" | "$nr" | ":name" | "$name" | "@name" | "@`name`"
+  },
+  sqlCanonicalSyntax: {
+    type: "boolean",
+    category: "SQL",
+    default: true,
+    description: "Enforces one true style of SQL syntax (adds and removes keywords)"
+    // Since 0.11.0
+  },
+  sqlFinalSemicolon: {
+    type: "boolean",
+    category: "SQL",
+    default: true,
+    description: "Enforces a semicolon at the end of last SQL statement"
+    // Since 0.13.0
+  },
+  sqlAcceptUnsupportedGrammar: {
+    type: "boolean",
+    category: "SQL",
+    default: false,
+    description: "Skips formatting unsupported SQL statements instead of exiting with an error"
+    // Since 0.12.0
+  }
+};
+
+// src/index.ts
+var languages = [
+  {
+    extensions: [".sql", ".sqlite"],
+    name: "SQLite SQL",
+    parsers: ["sqlite"]
+  },
+  {
+    extensions: [".bigquery"],
+    name: "BigQuery SQL",
+    parsers: ["bigquery"]
+  },
+  {
+    extensions: [],
+    name: "Experimental MySQL SQL",
+    parsers: ["mysql"]
+  },
+  {
+    extensions: [],
+    name: "Experimental MariaDB SQL",
+    parsers: ["mariadb"]
+  },
+  {
+    extensions: [],
+    name: "Experimental PostgreSQL SQL",
+    parsers: ["postgresql"]
+  }
 ];
-const createParser = (dialect) => ({
-    parse: (text, options) => transformCst(parse(text, {
-        dialect,
-        includeRange: true,
-        includeComments: true,
-        filename: options.filepath,
-        paramTypes: options.sqlParamTypes,
-        acceptUnsupportedGrammar: options
-            .sqlAcceptUnsupportedGrammar,
-    }), text, options),
-    astFormat: "sql-cst",
-    locStart: (node) => node.range?.[0],
-    locEnd: (node) => node.range?.[1],
+var createParser = (dialect) => ({
+  parse: (text, options2) => transformCst(
+    parse(text, {
+      dialect,
+      includeRange: true,
+      includeComments: true,
+      filename: options2.filepath,
+      paramTypes: options2.sqlParamTypes,
+      acceptUnsupportedGrammar: options2.sqlAcceptUnsupportedGrammar
+    }),
+    text,
+    options2
+  ),
+  astFormat: "sql-cst",
+  locStart: (node) => node.range?.[0],
+  locEnd: (node) => node.range?.[1]
 });
-export const parsers = {
-    sqlite: createParser("sqlite"),
-    bigquery: createParser("bigquery"),
-    mysql: createParser("mysql"),
-    mariadb: createParser("mariadb"),
-    postgresql: createParser("postgresql"),
-};
-export const printers = {
-    "sql-cst": {
-        print: printSql,
-        embed: embed,
-        printComment: printComment,
-        canAttachComment: isNode,
-        isBlockComment: (node) => node.type === "block_comment",
-    },
+var parsers = {
+  sqlite: createParser("sqlite"),
+  bigquery: createParser("bigquery"),
+  mysql: createParser("mysql"),
+  mariadb: createParser("mariadb"),
+  postgresql: createParser("postgresql")
+};
+var printers = {
+  "sql-cst": {
+    print: printSql,
+    embed,
+    printComment,
+    canAttachComment: isNode,
+    isBlockComment: (node) => node.type === "block_comment"
+  }
+};
+export {
+  languages,
+  options,
+  parsers,
+  printers
 };