@phake/lanework 0.1.0

package/dist-local/server/assets/default-query-compiler-PEcjLdrv.js

@@ -0,0 +1,1719 @@
+//#region ../../node_modules/.bun/kysely@0.29.2/node_modules/kysely/dist/util/object-utils.js
+function isUndefined(obj) {
+	return typeof obj === "undefined" || obj === void 0;
+}
+function isString(obj) {
+	return typeof obj === "string";
+}
+function isNumber(obj) {
+	return typeof obj === "number";
+}
+function isBoolean(obj) {
+	return typeof obj === "boolean";
+}
+function isNull(obj) {
+	return obj === null;
+}
+function isDate(obj) {
+	return obj instanceof Date;
+}
+function isBigInt(obj) {
+	return typeof obj === "bigint";
+}
+function isBuffer(obj) {
+	return typeof Buffer !== "undefined" && Buffer.isBuffer(obj);
+}
+function isFunction(obj) {
+	return typeof obj === "function";
+}
+function isObject(obj) {
+	return typeof obj === "object" && obj !== null;
+}
+function freeze(obj) {
+	return Object.freeze(obj);
+}
+function asArray(arg) {
+	if (isReadonlyArray(arg)) return arg;
+	else return [arg];
+}
+function isReadonlyArray(arg) {
+	return Array.isArray(arg);
+}
+function noop(obj) {
+	return obj;
+}
+function getMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region ../../node_modules/.bun/kysely@0.29.2/node_modules/kysely/dist/operation-node/identifier-node.js
+/**
+* @internal
+*/
+var IdentifierNode = freeze({
+	is(node) {
+		return node.kind === "IdentifierNode";
+	},
+	create(name) {
+		return freeze({
+			kind: "IdentifierNode",
+			name
+		});
+	}
+});
+//#endregion
+//#region ../../node_modules/.bun/kysely@0.29.2/node_modules/kysely/dist/operation-node/create-table-node.js
+var ON_COMMIT_ACTIONS = [
+	"preserve rows",
+	"delete rows",
+	"drop"
+];
+/**
+* @internal
+*/
+var CreateTableNode = freeze({
+	is(node) {
+		return node.kind === "CreateTableNode";
+	},
+	create(table) {
+		return freeze({
+			kind: "CreateTableNode",
+			table,
+			columns: freeze([])
+		});
+	},
+	cloneWithColumn(node, column) {
+		return freeze({
+			...node,
+			columns: freeze([...node.columns, column])
+		});
+	},
+	cloneWithConstraint(node, constraint) {
+		return freeze({
+			...node,
+			constraints: node.constraints ? freeze([...node.constraints, constraint]) : freeze([constraint])
+		});
+	},
+	cloneWithIndex(node, index) {
+		return freeze({
+			...node,
+			indexes: node.indexes ? freeze([...node.indexes, index]) : freeze([index])
+		});
+	},
+	cloneWithFrontModifier(node, modifier) {
+		return freeze({
+			...node,
+			frontModifiers: node.frontModifiers ? freeze([...node.frontModifiers, modifier]) : freeze([modifier])
+		});
+	},
+	cloneWithEndModifier(node, modifier) {
+		return freeze({
+			...node,
+			endModifiers: node.endModifiers ? freeze([...node.endModifiers, modifier]) : freeze([modifier])
+		});
+	},
+	cloneWith(node, params) {
+		return freeze({
+			...node,
+			...params
+		});
+	}
+});
+//#endregion
+//#region ../../node_modules/.bun/kysely@0.29.2/node_modules/kysely/dist/operation-node/schemable-identifier-node.js
+/**
+* @internal
+*/
+var SchemableIdentifierNode = freeze({
+	is(node) {
+		return node.kind === "SchemableIdentifierNode";
+	},
+	create(identifier) {
+		return freeze({
+			kind: "SchemableIdentifierNode",
+			identifier: IdentifierNode.create(identifier)
+		});
+	},
+	createWithSchema(schema, identifier) {
+		return freeze({
+			kind: "SchemableIdentifierNode",
+			schema: IdentifierNode.create(schema),
+			identifier: IdentifierNode.create(identifier)
+		});
+	}
+});
+//#endregion
+//#region ../../node_modules/.bun/kysely@0.29.2/node_modules/kysely/dist/operation-node/operator-node.js
+var COMPARISON_OPERATORS_DICTIONARY = freeze({
+	"=": true,
+	"==": true,
+	"!=": true,
+	"<>": true,
+	">": true,
+	">=": true,
+	"<": true,
+	"<=": true,
+	in: true,
+	"not in": true,
+	is: true,
+	"is not": true,
+	like: true,
+	"not like": true,
+	match: true,
+	ilike: true,
+	"not ilike": true,
+	"@>": true,
+	"<@": true,
+	"^@": true,
+	"&&": true,
+	"?": true,
+	"?&": true,
+	"?|": true,
+	"!<": true,
+	"!>": true,
+	"<=>": true,
+	"!~": true,
+	"~": true,
+	"~*": true,
+	"!~*": true,
+	"@@": true,
+	"@@@": true,
+	"!!": true,
+	"<->": true,
+	regexp: true,
+	"is distinct from": true,
+	"is not distinct from": true
+});
+var ARITHMETIC_OPERATORS_DICTIONARY = freeze({
+	"+": true,
+	"-": true,
+	"*": true,
+	"/": true,
+	"%": true,
+	"^": true,
+	"&": true,
+	"|": true,
+	"#": true,
+	"<<": true,
+	">>": true
+});
+var JSON_OPERATORS_DICTIONARY = freeze({
+	"->": true,
+	"->>": true
+});
+/**
+* @deprecated will be removed in version 0.30.x
+*/
+var JSON_OPERATORS = Object.keys(JSON_OPERATORS_DICTIONARY);
+var BINARY_OPERATORS_DICTIONARY = freeze({
+	...COMPARISON_OPERATORS_DICTIONARY,
+	...ARITHMETIC_OPERATORS_DICTIONARY,
+	"||": true
+});
+/**
+* @deprecated will be removed in version 0.30.x
+*/
+var BINARY_OPERATORS = Object.keys(BINARY_OPERATORS_DICTIONARY);
+var UNARY_OPERATORS_DICTIONARY = freeze({
+	...freeze({
+		exists: true,
+		"not exists": true
+	}),
+	"-": true,
+	not: true
+});
+/**
+* @deprecated will be removed in version 0.30.x
+*/
+var UNARY_OPERATORS = Object.keys(UNARY_OPERATORS_DICTIONARY);
+[
+	...BINARY_OPERATORS,
+	...JSON_OPERATORS,
+	...UNARY_OPERATORS
+];
+/**
+* @internal
+*/
+var OperatorNode = freeze({
+	is(node) {
+		return node.kind === "OperatorNode";
+	},
+	create(operator) {
+		return freeze({
+			kind: "OperatorNode",
+			operator
+		});
+	}
+});
+function isBinaryOperator(op) {
+	return isString(op) && BINARY_OPERATORS_DICTIONARY[op];
+}
+function isJSONOperator(op) {
+	return isString(op) && JSON_OPERATORS_DICTIONARY[op];
+}
+function isUnaryOperator(op) {
+	return isString(op) && UNARY_OPERATORS_DICTIONARY[op];
+}
+//#endregion
+//#region ../../node_modules/.bun/kysely@0.29.2/node_modules/kysely/dist/operation-node/raw-node.js
+/**
+* @internal
+*/
+var RawNode = freeze({
+	is(node) {
+		return node.kind === "RawNode";
+	},
+	create(sqlFragments, parameters) {
+		return freeze({
+			kind: "RawNode",
+			sqlFragments: freeze(sqlFragments),
+			parameters: freeze(parameters)
+		});
+	},
+	createWithSql(sql) {
+		return RawNode.create([sql], []);
+	},
+	createWithChild(child) {
+		return RawNode.create(["", ""], [child]);
+	},
+	createWithChildren(children) {
+		return RawNode.create(new Array(children.length + 1).fill(""), children);
+	}
+});
+//#endregion
+//#region ../../node_modules/.bun/kysely@0.29.2/node_modules/kysely/dist/operation-node/parens-node.js
+/**
+* @internal
+*/
+var ParensNode = freeze({
+	is(node) {
+		return node.kind === "ParensNode";
+	},
+	create(node) {
+		return freeze({
+			kind: "ParensNode",
+			node
+		});
+	}
+});
+//#endregion
+//#region ../../node_modules/.bun/kysely@0.29.2/node_modules/kysely/dist/operation-node/insert-query-node.js
+/**
+* @internal
+*/
+var InsertQueryNode = freeze({
+	is(node) {
+		return node.kind === "InsertQueryNode";
+	},
+	create(into, withNode, replace) {
+		return freeze({
+			kind: "InsertQueryNode",
+			into,
+			...withNode && { with: withNode },
+			replace
+		});
+	},
+	createWithoutInto() {
+		return freeze({ kind: "InsertQueryNode" });
+	},
+	cloneWith(insertQuery, props) {
+		return freeze({
+			...insertQuery,
+			...props
+		});
+	}
+});
+//#endregion
+//#region ../../node_modules/.bun/kysely@0.29.2/node_modules/kysely/dist/operation-node/when-node.js
+/**
+* @internal
+*/
+var WhenNode = freeze({
+	is(node) {
+		return node.kind === "WhenNode";
+	},
+	create(condition) {
+		return freeze({
+			kind: "WhenNode",
+			condition
+		});
+	},
+	cloneWithResult(whenNode, result) {
+		return freeze({
+			...whenNode,
+			result
+		});
+	}
+});
+//#endregion
+//#region ../../node_modules/.bun/kysely@0.29.2/node_modules/kysely/dist/operation-node/set-operation-node.js
+/**
+* @internal
+*/
+var SetOperationNode = freeze({
+	is(node) {
+		return node.kind === "SetOperationNode";
+	},
+	create(operator, expression, all) {
+		return freeze({
+			kind: "SetOperationNode",
+			operator,
+			expression,
+			all
+		});
+	}
+});
+//#endregion
+//#region ../../node_modules/.bun/kysely@0.29.2/node_modules/kysely/dist/operation-node/create-view-node.js
+/**
+* @internal
+*/
+var CreateViewNode = freeze({
+	is(node) {
+		return node.kind === "CreateViewNode";
+	},
+	create(name) {
+		return freeze({
+			kind: "CreateViewNode",
+			name: SchemableIdentifierNode.create(name)
+		});
+	},
+	cloneWith(createView, params) {
+		return freeze({
+			...createView,
+			...params
+		});
+	}
+});
+//#endregion
+//#region ../../node_modules/.bun/kysely@0.29.2/node_modules/kysely/dist/operation-node/operation-node-visitor.js
+var OperationNodeVisitor = class {
+	nodeStack = [];
+	get parentNode() {
+		return this.nodeStack[this.nodeStack.length - 2];
+	}
+	#visitors = freeze({
+		AliasNode: this.visitAlias.bind(this),
+		ColumnNode: this.visitColumn.bind(this),
+		IdentifierNode: this.visitIdentifier.bind(this),
+		SchemableIdentifierNode: this.visitSchemableIdentifier.bind(this),
+		RawNode: this.visitRaw.bind(this),
+		ReferenceNode: this.visitReference.bind(this),
+		SelectQueryNode: this.visitSelectQuery.bind(this),
+		SelectionNode: this.visitSelection.bind(this),
+		TableNode: this.visitTable.bind(this),
+		FromNode: this.visitFrom.bind(this),
+		SelectAllNode: this.visitSelectAll.bind(this),
+		AndNode: this.visitAnd.bind(this),
+		OrNode: this.visitOr.bind(this),
+		ValueNode: this.visitValue.bind(this),
+		ValueListNode: this.visitValueList.bind(this),
+		PrimitiveValueListNode: this.visitPrimitiveValueList.bind(this),
+		ParensNode: this.visitParens.bind(this),
+		JoinNode: this.visitJoin.bind(this),
+		OperatorNode: this.visitOperator.bind(this),
+		WhereNode: this.visitWhere.bind(this),
+		InsertQueryNode: this.visitInsertQuery.bind(this),
+		DeleteQueryNode: this.visitDeleteQuery.bind(this),
+		ReturningNode: this.visitReturning.bind(this),
+		CreateTableNode: this.visitCreateTable.bind(this),
+		AddColumnNode: this.visitAddColumn.bind(this),
+		ColumnDefinitionNode: this.visitColumnDefinition.bind(this),
+		DropTableNode: this.visitDropTable.bind(this),
+		DataTypeNode: this.visitDataType.bind(this),
+		OrderByNode: this.visitOrderBy.bind(this),
+		OrderByItemNode: this.visitOrderByItem.bind(this),
+		GroupByNode: this.visitGroupBy.bind(this),
+		GroupByItemNode: this.visitGroupByItem.bind(this),
+		UpdateQueryNode: this.visitUpdateQuery.bind(this),
+		ColumnUpdateNode: this.visitColumnUpdate.bind(this),
+		LimitNode: this.visitLimit.bind(this),
+		OffsetNode: this.visitOffset.bind(this),
+		OnConflictNode: this.visitOnConflict.bind(this),
+		OnDuplicateKeyNode: this.visitOnDuplicateKey.bind(this),
+		CreateIndexNode: this.visitCreateIndex.bind(this),
+		DropIndexNode: this.visitDropIndex.bind(this),
+		ListNode: this.visitList.bind(this),
+		PrimaryKeyConstraintNode: this.visitPrimaryKeyConstraint.bind(this),
+		UniqueConstraintNode: this.visitUniqueConstraint.bind(this),
+		ReferencesNode: this.visitReferences.bind(this),
+		CheckConstraintNode: this.visitCheckConstraint.bind(this),
+		WithNode: this.visitWith.bind(this),
+		CommonTableExpressionNode: this.visitCommonTableExpression.bind(this),
+		CommonTableExpressionNameNode: this.visitCommonTableExpressionName.bind(this),
+		HavingNode: this.visitHaving.bind(this),
+		CreateSchemaNode: this.visitCreateSchema.bind(this),
+		DropSchemaNode: this.visitDropSchema.bind(this),
+		AlterTableNode: this.visitAlterTable.bind(this),
+		DropColumnNode: this.visitDropColumn.bind(this),
+		RenameColumnNode: this.visitRenameColumn.bind(this),
+		AlterColumnNode: this.visitAlterColumn.bind(this),
+		ModifyColumnNode: this.visitModifyColumn.bind(this),
+		AddConstraintNode: this.visitAddConstraint.bind(this),
+		DropConstraintNode: this.visitDropConstraint.bind(this),
+		RenameConstraintNode: this.visitRenameConstraint.bind(this),
+		ForeignKeyConstraintNode: this.visitForeignKeyConstraint.bind(this),
+		CreateViewNode: this.visitCreateView.bind(this),
+		RefreshMaterializedViewNode: this.visitRefreshMaterializedView.bind(this),
+		DropViewNode: this.visitDropView.bind(this),
+		GeneratedNode: this.visitGenerated.bind(this),
+		DefaultValueNode: this.visitDefaultValue.bind(this),
+		OnNode: this.visitOn.bind(this),
+		ValuesNode: this.visitValues.bind(this),
+		SelectModifierNode: this.visitSelectModifier.bind(this),
+		CreateTypeNode: this.visitCreateType.bind(this),
+		DropTypeNode: this.visitDropType.bind(this),
+		ExplainNode: this.visitExplain.bind(this),
+		DefaultInsertValueNode: this.visitDefaultInsertValue.bind(this),
+		AggregateFunctionNode: this.visitAggregateFunction.bind(this),
+		OverNode: this.visitOver.bind(this),
+		PartitionByNode: this.visitPartitionBy.bind(this),
+		PartitionByItemNode: this.visitPartitionByItem.bind(this),
+		SetOperationNode: this.visitSetOperation.bind(this),
+		BinaryOperationNode: this.visitBinaryOperation.bind(this),
+		UnaryOperationNode: this.visitUnaryOperation.bind(this),
+		UsingNode: this.visitUsing.bind(this),
+		FunctionNode: this.visitFunction.bind(this),
+		CaseNode: this.visitCase.bind(this),
+		WhenNode: this.visitWhen.bind(this),
+		JSONReferenceNode: this.visitJSONReference.bind(this),
+		JSONPathNode: this.visitJSONPath.bind(this),
+		JSONPathLegNode: this.visitJSONPathLeg.bind(this),
+		JSONOperatorChainNode: this.visitJSONOperatorChain.bind(this),
+		TupleNode: this.visitTuple.bind(this),
+		MergeQueryNode: this.visitMergeQuery.bind(this),
+		MatchedNode: this.visitMatched.bind(this),
+		AddIndexNode: this.visitAddIndex.bind(this),
+		CastNode: this.visitCast.bind(this),
+		FetchNode: this.visitFetch.bind(this),
+		TopNode: this.visitTop.bind(this),
+		OutputNode: this.visitOutput.bind(this),
+		OrActionNode: this.visitOrAction.bind(this),
+		CollateNode: this.visitCollate.bind(this),
+		AlterTypeNode: this.visitAlterType.bind(this),
+		AddValueNode: this.visitAddValue.bind(this),
+		RenameValueNode: this.visitRenameValue.bind(this)
+	});
+	visitNode = (node) => {
+		this.nodeStack.push(node);
+		this.#visitors[node.kind](node);
+		this.nodeStack.pop();
+	};
+};
+//#endregion
+//#region ../../node_modules/.bun/kysely@0.29.2/node_modules/kysely/dist/query-compiler/default-query-compiler.js
+var LIT_WRAP_REGEX = /'/g;
+var JSON_PATH_MEMBER_WRAP_REGEX = /['"]/g;
+var DefaultQueryCompiler = class extends OperationNodeVisitor {
+	#sql = "";
+	#parameters = [];
+	get numParameters() {
+		return this.#parameters.length;
+	}
+	compileQuery(node, queryId) {
+		this.#sql = "";
+		this.#parameters = [];
+		this.nodeStack.splice(0, this.nodeStack.length);
+		this.visitNode(node);
+		return freeze({
+			query: node,
+			queryId,
+			sql: this.getSql(),
+			parameters: [...this.#parameters]
+		});
+	}
+	getSql() {
+		return this.#sql;
+	}
+	visitSelectQuery(node) {
+		const wrapInParens = this.parentNode !== void 0 && !ParensNode.is(this.parentNode) && !InsertQueryNode.is(this.parentNode) && !CreateTableNode.is(this.parentNode) && !CreateViewNode.is(this.parentNode) && !SetOperationNode.is(this.parentNode);
+		if (this.parentNode === void 0 && node.explain) {
+			this.visitNode(node.explain);
+			this.append(" ");
+		}
+		if (wrapInParens) this.append("(");
+		if (node.with) {
+			this.visitNode(node.with);
+			this.append(" ");
+		}
+		this.append("select");
+		if (node.distinctOn) {
+			this.append(" ");
+			this.compileDistinctOn(node.distinctOn);
+		}
+		if (node.frontModifiers?.length) {
+			this.append(" ");
+			this.compileList(node.frontModifiers, " ");
+		}
+		if (node.top) {
+			this.append(" ");
+			this.visitNode(node.top);
+		}
+		if (node.selections) {
+			this.append(" ");
+			this.compileList(node.selections);
+		}
+		if (node.from) {
+			this.append(" ");
+			this.visitNode(node.from);
+		}
+		if (node.joins) {
+			this.append(" ");
+			this.compileList(node.joins, " ");
+		}
+		if (node.where) {
+			this.append(" ");
+			this.visitNode(node.where);
+		}
+		if (node.groupBy) {
+			this.append(" ");
+			this.visitNode(node.groupBy);
+		}
+		if (node.having) {
+			this.append(" ");
+			this.visitNode(node.having);
+		}
+		if (node.setOperations) {
+			this.append(" ");
+			this.compileList(node.setOperations, " ");
+		}
+		if (node.orderBy) {
+			this.append(" ");
+			this.visitNode(node.orderBy);
+		}
+		if (node.limit) {
+			this.append(" ");
+			this.visitNode(node.limit);
+		}
+		if (node.offset) {
+			this.append(" ");
+			this.visitNode(node.offset);
+		}
+		if (node.fetch) {
+			this.append(" ");
+			this.visitNode(node.fetch);
+		}
+		if (node.endModifiers?.length) {
+			this.append(" ");
+			this.compileList(this.sortSelectModifiers(node.endModifiers), " ");
+		}
+		if (wrapInParens) this.append(")");
+	}
+	visitFrom(node) {
+		this.append("from ");
+		this.compileList(node.froms);
+	}
+	visitSelection(node) {
+		this.visitNode(node.selection);
+	}
+	visitColumn(node) {
+		this.visitNode(node.column);
+	}
+	compileDistinctOn(expressions) {
+		this.append("distinct on (");
+		this.compileList(expressions);
+		this.append(")");
+	}
+	compileList(nodes, separator = ", ") {
+		const lastIndex = nodes.length - 1;
+		for (let i = 0; i <= lastIndex; i++) {
+			this.visitNode(nodes[i]);
+			if (i < lastIndex) this.append(separator);
+		}
+	}
+	visitWhere(node) {
+		this.append("where ");
+		this.visitNode(node.where);
+	}
+	visitHaving(node) {
+		this.append("having ");
+		this.visitNode(node.having);
+	}
+	visitInsertQuery(node) {
+		const wrapInParens = this.parentNode !== void 0 && !ParensNode.is(this.parentNode) && !RawNode.is(this.parentNode) && !WhenNode.is(this.parentNode);
+		if (this.parentNode === void 0 && node.explain) {
+			this.visitNode(node.explain);
+			this.append(" ");
+		}
+		if (wrapInParens) this.append("(");
+		if (node.with) {
+			this.visitNode(node.with);
+			this.append(" ");
+		}
+		this.append(node.replace ? "replace" : "insert");
+		if (node.orAction) {
+			this.append(" ");
+			this.visitNode(node.orAction);
+		}
+		if (node.top) {
+			this.append(" ");
+			this.visitNode(node.top);
+		}
+		if (node.into) {
+			this.append(" into ");
+			this.visitNode(node.into);
+		}
+		if (node.columns) {
+			this.append(" (");
+			this.compileList(node.columns);
+			this.append(")");
+		}
+		if (node.output) {
+			this.append(" ");
+			this.visitNode(node.output);
+		}
+		if (node.values) {
+			this.append(" ");
+			this.visitNode(node.values);
+		}
+		if (node.defaultValues) {
+			this.append(" ");
+			this.append("default values");
+		}
+		if (node.onConflict) {
+			this.append(" ");
+			this.visitNode(node.onConflict);
+		}
+		if (node.onDuplicateKey) {
+			this.append(" ");
+			this.visitNode(node.onDuplicateKey);
+		}
+		if (node.returning) {
+			this.append(" ");
+			this.visitNode(node.returning);
+		}
+		if (wrapInParens) this.append(")");
+		if (node.endModifiers?.length) {
+			this.append(" ");
+			this.compileList(node.endModifiers, " ");
+		}
+	}
+	visitValues(node) {
+		this.append("values ");
+		this.compileList(node.values);
+	}
+	visitDeleteQuery(node) {
+		const wrapInParens = this.parentNode !== void 0 && !ParensNode.is(this.parentNode) && !RawNode.is(this.parentNode);
+		if (this.parentNode === void 0 && node.explain) {
+			this.visitNode(node.explain);
+			this.append(" ");
+		}
+		if (wrapInParens) this.append("(");
+		if (node.with) {
+			this.visitNode(node.with);
+			this.append(" ");
+		}
+		this.append("delete ");
+		if (node.top) {
+			this.visitNode(node.top);
+			this.append(" ");
+		}
+		this.visitNode(node.from);
+		if (node.output) {
+			this.append(" ");
+			this.visitNode(node.output);
+		}
+		if (node.using) {
+			this.append(" ");
+			this.visitNode(node.using);
+		}
+		if (node.joins) {
+			this.append(" ");
+			this.compileList(node.joins, " ");
+		}
+		if (node.where) {
+			this.append(" ");
+			this.visitNode(node.where);
+		}
+		if (node.orderBy) {
+			this.append(" ");
+			this.visitNode(node.orderBy);
+		}
+		if (node.limit) {
+			this.append(" ");
+			this.visitNode(node.limit);
+		}
+		if (node.returning) {
+			this.append(" ");
+			this.visitNode(node.returning);
+		}
+		if (wrapInParens) this.append(")");
+		if (node.endModifiers?.length) {
+			this.append(" ");
+			this.compileList(node.endModifiers, " ");
+		}
+	}
+	visitReturning(node) {
+		this.append("returning ");
+		this.compileList(node.selections);
+	}
+	visitAlias(node) {
+		this.visitNode(node.node);
+		this.append(" as ");
+		this.visitNode(node.alias);
+	}
+	visitReference(node) {
+		if (node.table) {
+			this.visitNode(node.table);
+			this.append(".");
+		}
+		this.visitNode(node.column);
+	}
+	visitSelectAll(_) {
+		this.append("*");
+	}
+	visitIdentifier(node) {
+		this.append(this.getLeftIdentifierWrapper());
+		this.compileUnwrappedIdentifier(node);
+		this.append(this.getRightIdentifierWrapper());
+	}
+	compileUnwrappedIdentifier(node) {
+		if (!isString(node.name)) throw new Error("a non-string identifier was passed to compileUnwrappedIdentifier.");
+		this.append(this.sanitizeIdentifier(node.name));
+	}
+	visitAnd(node) {
+		this.visitNode(node.left);
+		this.append(" and ");
+		this.visitNode(node.right);
+	}
+	visitOr(node) {
+		this.visitNode(node.left);
+		this.append(" or ");
+		this.visitNode(node.right);
+	}
+	visitValue(node) {
+		if (node.immediate) this.appendImmediateValue(node.value);
+		else this.appendValue(node.value);
+	}
+	visitValueList(node) {
+		this.append("(");
+		this.compileList(node.values);
+		this.append(")");
+	}
+	visitTuple(node) {
+		this.append("(");
+		this.compileList(node.values);
+		this.append(")");
+	}
+	visitPrimitiveValueList(node) {
+		this.append("(");
+		const { values } = node;
+		for (let i = 0; i < values.length; ++i) {
+			this.appendValue(values[i]);
+			if (i !== values.length - 1) this.append(", ");
+		}
+		this.append(")");
+	}
+	visitParens(node) {
+		this.append("(");
+		this.visitNode(node.node);
+		this.append(")");
+	}
+	visitJoin(node) {
+		this.append(JOIN_TYPE_SQL[node.joinType]);
+		this.append(" ");
+		this.visitNode(node.table);
+		if (node.on) {
+			this.append(" ");
+			this.visitNode(node.on);
+		}
+	}
+	visitOn(node) {
+		this.append("on ");
+		this.visitNode(node.on);
+	}
+	visitRaw(node) {
+		const { sqlFragments, parameters: params } = node;
+		for (let i = 0; i < sqlFragments.length; ++i) {
+			this.append(sqlFragments[i]);
+			if (params.length > i) this.visitNode(params[i]);
+		}
+	}
+	visitOperator(node) {
+		this.append(node.operator);
+	}
+	visitTable(node) {
+		this.visitNode(node.table);
+	}
+	visitSchemableIdentifier(node) {
+		if (node.schema) {
+			this.visitNode(node.schema);
+			this.append(".");
+		}
+		this.visitNode(node.identifier);
+	}
+	visitCreateTable(node) {
+		this.append("create ");
+		if (node.frontModifiers?.length) {
+			this.compileList(node.frontModifiers, " ");
+			this.append(" ");
+		}
+		if (node.temporary) this.append("temporary ");
+		this.append("table ");
+		if (node.ifNotExists) this.append("if not exists ");
+		this.visitNode(node.table);
+		if (!node.selectQuery) {
+			this.append(" (");
+			this.compileList([
+				...node.columns,
+				...node.constraints ?? [],
+				...node.indexes ?? []
+			]);
+			this.append(")");
+		}
+		if (node.onCommit) {
+			this.append(" on commit ");
+			this.append(node.onCommit);
+		}
+		if (node.endModifiers?.length) {
+			this.append(" ");
+			this.compileList(node.endModifiers, " ");
+		}
+		if (node.selectQuery) {
+			this.append(" as ");
+			this.visitNode(node.selectQuery);
+		}
+	}
+	visitColumnDefinition(node) {
+		if (node.ifNotExists) this.append("if not exists ");
+		this.visitNode(node.column);
+		this.append(" ");
+		this.visitNode(node.dataType);
+		if (node.unsigned) this.append(" unsigned");
+		if (node.frontModifiers && node.frontModifiers.length > 0) {
+			this.append(" ");
+			this.compileList(node.frontModifiers, " ");
+		}
+		if (node.generated) {
+			this.append(" ");
+			this.visitNode(node.generated);
+		}
+		if (node.identity) this.append(" identity");
+		if (node.defaultTo) {
+			this.append(" ");
+			this.visitNode(node.defaultTo);
+		}
+		if (node.notNull) this.append(" not null");
+		if (node.unique) this.append(" unique");
+		if (node.nullsNotDistinct) this.append(" nulls not distinct");
+		if (node.primaryKey) this.append(" primary key");
+		if (node.autoIncrement) {
+			this.append(" ");
+			this.append(this.getAutoIncrement());
+		}
+		if (node.references) {
+			this.append(" ");
+			this.visitNode(node.references);
+		}
+		if (node.check) {
+			this.append(" ");
+			this.visitNode(node.check);
+		}
+		if (node.endModifiers && node.endModifiers.length > 0) {
+			this.append(" ");
+			this.compileList(node.endModifiers, " ");
+		}
+	}
+	getAutoIncrement() {
+		return "auto_increment";
+	}
+	visitReferences(node) {
+		this.append("references ");
+		this.visitNode(node.table);
+		this.append(" (");
+		this.compileList(node.columns);
+		this.append(")");
+		if (node.onDelete) {
+			this.append(" on delete ");
+			this.append(node.onDelete);
+		}
+		if (node.onUpdate) {
+			this.append(" on update ");
+			this.append(node.onUpdate);
+		}
+	}
+	visitDropTable(node) {
+		this.append("drop ");
+		if (node.temporary) this.append("temporary ");
+		this.append("table ");
+		if (node.ifExists) this.append("if exists ");
+		this.visitNode(node.table);
+		if (node.cascade) this.append(" cascade");
+	}
+	visitDataType(node) {
+		this.append(node.dataType);
+	}
+	visitOrderBy(node) {
+		this.append("order by ");
+		this.compileList(node.items);
+	}
+	visitOrderByItem(node) {
+		this.visitNode(node.orderBy);
+		if (node.collation) {
+			this.append(" ");
+			this.visitNode(node.collation);
+		}
+		if (node.direction) {
+			this.append(" ");
+			this.visitNode(node.direction);
+		}
+		if (node.nulls) {
+			this.append(" nulls ");
+			this.append(node.nulls);
+		}
+	}
+	visitGroupBy(node) {
+		this.append("group by ");
+		this.compileList(node.items);
+	}
+	visitGroupByItem(node) {
+		this.visitNode(node.groupBy);
+	}
+	visitUpdateQuery(node) {
+		const wrapInParens = this.parentNode !== void 0 && !ParensNode.is(this.parentNode) && !RawNode.is(this.parentNode) && !WhenNode.is(this.parentNode);
+		if (this.parentNode === void 0 && node.explain) {
+			this.visitNode(node.explain);
+			this.append(" ");
+		}
+		if (wrapInParens) this.append("(");
+		if (node.with) {
+			this.visitNode(node.with);
+			this.append(" ");
+		}
+		this.append("update ");
+		if (node.top) {
+			this.visitNode(node.top);
+			this.append(" ");
+		}
+		if (node.table) {
+			this.visitNode(node.table);
+			this.append(" ");
+		}
+		this.append("set ");
+		if (node.updates) this.compileList(node.updates);
+		if (node.output) {
+			this.append(" ");
+			this.visitNode(node.output);
+		}
+		if (node.from) {
+			this.append(" ");
+			this.visitNode(node.from);
+		}
+		if (node.joins) {
+			if (!node.from) throw new Error("Joins in an update query are only supported as a part of a PostgreSQL 'update set from join' query. If you want to create a MySQL 'update join set' query, see https://kysely.dev/docs/examples/update/my-sql-joins");
+			this.append(" ");
+			this.compileList(node.joins, " ");
+		}
+		if (node.where) {
+			this.append(" ");
+			this.visitNode(node.where);
+		}
+		if (node.returning) {
+			this.append(" ");
+			this.visitNode(node.returning);
+		}
+		if (node.orderBy) {
+			this.append(" ");
+			this.visitNode(node.orderBy);
+		}
+		if (node.limit) {
+			this.append(" ");
+			this.visitNode(node.limit);
+		}
+		if (wrapInParens) this.append(")");
+		if (node.endModifiers?.length) {
+			this.append(" ");
+			this.compileList(node.endModifiers, " ");
+		}
+	}
+	visitColumnUpdate(node) {
+		this.visitNode(node.column);
+		this.append(" = ");
+		this.visitNode(node.value);
+	}
+	visitLimit(node) {
+		this.append("limit ");
+		this.visitNode(node.limit);
+	}
+	visitOffset(node) {
+		this.append("offset ");
+		this.visitNode(node.offset);
+	}
+	visitOnConflict(node) {
+		this.append("on conflict");
+		if (node.columns) {
+			this.append(" (");
+			this.compileList(node.columns);
+			this.append(")");
+		} else if (node.constraint) {
+			this.append(" on constraint ");
+			this.visitNode(node.constraint);
+		} else if (node.indexExpression) {
+			this.append(" (");
+			this.visitNode(node.indexExpression);
+			this.append(")");
+		}
+		if (node.indexWhere) {
+			this.append(" ");
+			this.visitNode(node.indexWhere);
+		}
+		if (node.doNothing === true) this.append(" do nothing");
+		else if (node.updates) {
+			this.append(" do update set ");
+			this.compileList(node.updates);
+			if (node.updateWhere) {
+				this.append(" ");
+				this.visitNode(node.updateWhere);
+			}
+		}
+	}
+	visitOnDuplicateKey(node) {
+		this.append("on duplicate key update ");
+		this.compileList(node.updates);
+	}
+	visitCreateIndex(node) {
+		this.append("create ");
+		if (node.unique) this.append("unique ");
+		this.append("index ");
+		if (node.ifNotExists) this.append("if not exists ");
+		this.visitNode(node.name);
+		if (node.table) {
+			this.append(" on ");
+			this.visitNode(node.table);
+		}
+		if (node.using) {
+			this.append(" using ");
+			this.visitNode(node.using);
+		}
+		if (node.columns) {
+			this.append(" (");
+			this.compileList(node.columns);
+			this.append(")");
+		}
+		if (node.nullsNotDistinct) this.append(" nulls not distinct");
+		if (node.where) {
+			this.append(" ");
+			this.visitNode(node.where);
+		}
+	}
+	visitDropIndex(node) {
+		this.append("drop index ");
+		if (node.ifExists) this.append("if exists ");
+		this.visitNode(node.name);
+		if (node.table) {
+			this.append(" on ");
+			this.visitNode(node.table);
+		}
+		if (node.cascade) this.append(" cascade");
+	}
+	visitCreateSchema(node) {
+		this.append("create schema ");
+		if (node.ifNotExists) this.append("if not exists ");
+		this.visitNode(node.schema);
+	}
+	visitDropSchema(node) {
+		this.append("drop schema ");
+		if (node.ifExists) this.append("if exists ");
+		this.visitNode(node.schema);
+		if (node.cascade) this.append(" cascade");
+	}
+	visitPrimaryKeyConstraint(node) {
+		if (node.name) {
+			this.append("constraint ");
+			this.visitNode(node.name);
+			this.append(" ");
+		}
+		this.append("primary key (");
+		this.compileList(node.columns);
+		this.append(")");
+		this.buildDeferrable(node);
+	}
+	buildDeferrable(node) {
+		if (node.deferrable !== void 0) if (node.deferrable) this.append(" deferrable");
+		else this.append(" not deferrable");
+		if (node.initiallyDeferred !== void 0) if (node.initiallyDeferred) this.append(" initially deferred");
+		else this.append(" initially immediate");
+	}
+	visitUniqueConstraint(node) {
+		if (node.name) {
+			this.append("constraint ");
+			this.visitNode(node.name);
+			this.append(" ");
+		}
+		this.append("unique");
+		if (node.nullsNotDistinct) this.append(" nulls not distinct");
+		this.append(" (");
+		this.compileList(node.columns);
+		this.append(")");
+		this.buildDeferrable(node);
+	}
+	visitCheckConstraint(node) {
+		if (node.name) {
+			this.append("constraint ");
+			this.visitNode(node.name);
+			this.append(" ");
+		}
+		this.append("check (");
+		this.visitNode(node.expression);
+		this.append(")");
+	}
+	visitForeignKeyConstraint(node) {
+		if (node.name) {
+			this.append("constraint ");
+			this.visitNode(node.name);
+			this.append(" ");
+		}
+		this.append("foreign key (");
+		this.compileList(node.columns);
+		this.append(") ");
+		this.visitNode(node.references);
+		if (node.onDelete) {
+			this.append(" on delete ");
+			this.append(node.onDelete);
+		}
+		if (node.onUpdate) {
+			this.append(" on update ");
+			this.append(node.onUpdate);
+		}
+		this.buildDeferrable(node);
+	}
+	visitList(node) {
+		this.compileList(node.items);
+	}
+	visitWith(node) {
+		this.append("with ");
+		if (node.recursive) this.append("recursive ");
+		this.compileList(node.expressions);
+	}
+	visitCommonTableExpression(node) {
+		this.visitNode(node.name);
+		this.append(" as ");
+		if (isBoolean(node.materialized)) {
+			if (!node.materialized) this.append("not ");
+			this.append("materialized ");
+		}
+		this.visitNode(node.expression);
+	}
+	visitCommonTableExpressionName(node) {
+		this.visitNode(node.table);
+		if (node.columns) {
+			this.append("(");
+			this.compileList(node.columns);
+			this.append(")");
+		}
+	}
+	visitAlterTable(node) {
+		this.append("alter table ");
+		this.visitNode(node.table);
+		this.append(" ");
+		if (node.renameTo) {
+			this.append("rename to ");
+			this.visitNode(node.renameTo);
+		}
+		if (node.setSchema) {
+			this.append("set schema ");
+			this.visitNode(node.setSchema);
+		}
+		if (node.addConstraint) this.visitNode(node.addConstraint);
+		if (node.dropConstraint) this.visitNode(node.dropConstraint);
+		if (node.renameConstraint) this.visitNode(node.renameConstraint);
+		if (node.columnAlterations) this.compileColumnAlterations(node.columnAlterations);
+		if (node.addIndex) this.visitNode(node.addIndex);
+		if (node.dropIndex) this.visitNode(node.dropIndex);
+	}
+	visitAddColumn(node) {
+		this.append("add column ");
+		this.visitNode(node.column);
+	}
+	visitRenameColumn(node) {
+		this.append("rename column ");
+		this.visitNode(node.column);
+		this.append(" to ");
+		this.visitNode(node.renameTo);
+	}
+	visitDropColumn(node) {
+		this.append("drop column ");
+		if (node.ifExists) this.append("if exists ");
+		this.visitNode(node.column);
+	}
+	visitAlterColumn(node) {
+		this.append("alter column ");
+		this.visitNode(node.column);
+		this.append(" ");
+		if (node.dataType) {
+			if (this.announcesNewColumnDataType()) this.append("type ");
+			this.visitNode(node.dataType);
+			if (node.dataTypeExpression) {
+				this.append("using ");
+				this.visitNode(node.dataTypeExpression);
+			}
+		}
+		if (node.setDefault) {
+			this.append("set default ");
+			this.visitNode(node.setDefault);
+		}
+		if (node.dropDefault) this.append("drop default");
+		if (node.setNotNull) this.append("set not null");
+		if (node.dropNotNull) this.append("drop not null");
+	}
+	visitModifyColumn(node) {
+		this.append("modify column ");
+		this.visitNode(node.column);
+	}
+	visitAddConstraint(node) {
+		this.append("add ");
+		this.visitNode(node.constraint);
+	}
+	visitDropConstraint(node) {
+		this.append("drop constraint ");
+		if (node.ifExists) this.append("if exists ");
+		this.visitNode(node.constraintName);
+		if (node.modifier === "cascade") this.append(" cascade");
+		else if (node.modifier === "restrict") this.append(" restrict");
+	}
+	visitRenameConstraint(node) {
+		this.append("rename constraint ");
+		this.visitNode(node.oldName);
+		this.append(" to ");
+		this.visitNode(node.newName);
+	}
+	visitSetOperation(node) {
+		this.append(node.operator);
+		this.append(" ");
+		if (node.all) this.append("all ");
+		this.visitNode(node.expression);
+	}
+	visitCreateView(node) {
+		this.append("create ");
+		if (node.orReplace) this.append("or replace ");
+		if (node.materialized) this.append("materialized ");
+		if (node.temporary) this.append("temporary ");
+		this.append("view ");
+		if (node.ifNotExists) this.append("if not exists ");
+		this.visitNode(node.name);
+		this.append(" ");
+		if (node.columns) {
+			this.append("(");
+			this.compileList(node.columns);
+			this.append(") ");
+		}
+		if (node.as) {
+			this.append("as ");
+			this.visitNode(node.as);
+		}
+	}
+	visitRefreshMaterializedView(node) {
+		this.append("refresh materialized view ");
+		if (node.concurrently) this.append("concurrently ");
+		this.visitNode(node.name);
+		if (node.withNoData) this.append(" with no data");
+		else this.append(" with data");
+	}
+	visitDropView(node) {
+		this.append("drop ");
+		if (node.materialized) this.append("materialized ");
+		this.append("view ");
+		if (node.ifExists) this.append("if exists ");
+		this.visitNode(node.name);
+		if (node.cascade) this.append(" cascade");
+	}
+	visitGenerated(node) {
+		this.append("generated ");
+		if (node.always) this.append("always ");
+		if (node.byDefault) this.append("by default ");
+		this.append("as ");
+		if (node.identity) this.append("identity");
+		if (node.expression) {
+			this.append("(");
+			this.visitNode(node.expression);
+			this.append(")");
+		}
+		if (node.stored) this.append(" stored");
+	}
+	visitDefaultValue(node) {
+		this.append("default ");
+		this.visitNode(node.defaultValue);
+	}
+	visitSelectModifier(node) {
+		if (node.rawModifier) this.visitNode(node.rawModifier);
+		else this.append(SELECT_MODIFIER_SQL[node.modifier]);
+		if (node.of) {
+			this.append(" of ");
+			this.compileList(node.of, ", ");
+		}
+	}
+	visitCreateType(node) {
+		this.append("create type ");
+		this.visitNode(node.name);
+		if (node.enum) {
+			this.append(" as enum ");
+			this.visitNode(node.enum);
+		}
+	}
+	visitDropType(node) {
+		this.append("drop type ");
+		if (node.ifExists) this.append("if exists ");
+		this.visitNode(node.name);
+		if (node.additionalNames?.length) {
+			this.append(", ");
+			this.compileList(node.additionalNames);
+		}
+		if (node.cascade) this.append(" cascade");
+	}
+	visitAlterType(node) {
+		this.append("alter type ");
+		this.visitNode(node.name);
+		this.append(" ");
+		if (node.addValue) this.visitNode(node.addValue);
+		else if (node.renameTo) {
+			this.append("rename to ");
+			this.visitNode(node.renameTo);
+		} else if (node.renameValue) this.visitNode(node.renameValue);
+		else if (node.setSchema) {
+			this.append("set schema ");
+			this.visitNode(node.setSchema);
+		}
+	}
+	visitAddValue(node) {
+		this.append("add value ");
+		if (node.ifNotExists) this.append("if not exists ");
+		this.visitNode(node.value);
+		if (node.neighborValue) {
+			this.append(node.isBefore ? " before " : " after ");
+			this.visitNode(node.neighborValue);
+		}
+	}
+	visitRenameValue(node) {
+		this.append("rename value ");
+		this.visitNode(node.oldValue);
+		this.append(" to ");
+		this.visitNode(node.newValue);
+	}
+	visitExplain(node) {
+		this.append("explain");
+		if (node.options || node.format) {
+			this.append(" ");
+			this.append(this.getLeftExplainOptionsWrapper());
+			if (node.options) {
+				this.visitNode(node.options);
+				if (node.format) this.append(this.getExplainOptionsDelimiter());
+			}
+			if (node.format) {
+				this.append("format");
+				this.append(this.getExplainOptionAssignment());
+				this.append(node.format);
+			}
+			this.append(this.getRightExplainOptionsWrapper());
+		}
+	}
+	visitDefaultInsertValue(_) {
+		this.append("default");
+	}
+	visitAggregateFunction(node) {
+		this.append(node.func);
+		this.append("(");
+		if (node.distinct) this.append("distinct ");
+		this.compileList(node.aggregated);
+		if (node.orderBy) {
+			this.append(" ");
+			this.visitNode(node.orderBy);
+		}
+		this.append(")");
+		if (node.withinGroup) {
+			this.append(" within group (");
+			this.visitNode(node.withinGroup);
+			this.append(")");
+		}
+		if (node.filter) {
+			this.append(" filter(");
+			this.visitNode(node.filter);
+			this.append(")");
+		}
+		if (node.over) {
+			this.append(" ");
+			this.visitNode(node.over);
+		}
+	}
+	visitOver(node) {
+		this.append("over(");
+		if (node.partitionBy) {
+			this.visitNode(node.partitionBy);
+			if (node.orderBy) this.append(" ");
+		}
+		if (node.orderBy) this.visitNode(node.orderBy);
+		this.append(")");
+	}
+	visitPartitionBy(node) {
+		this.append("partition by ");
+		this.compileList(node.items);
+	}
+	visitPartitionByItem(node) {
+		this.visitNode(node.partitionBy);
+	}
+	visitBinaryOperation(node) {
+		this.visitNode(node.leftOperand);
+		this.append(" ");
+		this.visitNode(node.operator);
+		this.append(" ");
+		this.visitNode(node.rightOperand);
+	}
+	visitUnaryOperation(node) {
+		this.visitNode(node.operator);
+		if (!this.isMinusOperator(node.operator)) this.append(" ");
+		this.visitNode(node.operand);
+	}
+	isMinusOperator(node) {
+		return OperatorNode.is(node) && node.operator === "-";
+	}
+	visitUsing(node) {
+		this.append("using ");
+		this.compileList(node.tables);
+	}
+	visitFunction(node) {
+		this.append(node.func);
+		this.append("(");
+		this.compileList(node.arguments);
+		this.append(")");
+	}
+	visitCase(node) {
+		this.append("case");
+		if (node.value) {
+			this.append(" ");
+			this.visitNode(node.value);
+		}
+		if (node.when) {
+			this.append(" ");
+			this.compileList(node.when, " ");
+		}
+		if (node.else) {
+			this.append(" else ");
+			this.visitNode(node.else);
+		}
+		this.append(" end");
+		if (node.isStatement) this.append(" case");
+	}
+	visitWhen(node) {
+		this.append("when ");
+		this.visitNode(node.condition);
+		if (node.result) {
+			this.append(" then ");
+			this.visitNode(node.result);
+		}
+	}
+	visitJSONReference(node) {
+		this.visitNode(node.reference);
+		this.visitNode(node.traversal);
+	}
+	visitJSONPath(node) {
+		if (node.inOperator) this.visitNode(node.inOperator);
+		this.append("'$");
+		for (const pathLeg of node.pathLegs) this.visitNode(pathLeg);
+		this.append("'");
+	}
+	visitJSONPathLeg(node) {
+		const isArrayLocation = node.type === "ArrayLocation";
+		const value = String(node.value);
+		if (isArrayLocation) {
+			this.append("[");
+			this.append(this.sanitizeStringLiteral(value));
+			this.append("]");
+		} else {
+			this.append(".\"");
+			this.append(this.sanitizeJSONPathMemberValue(value));
+			this.append("\"");
+		}
+	}
+	visitJSONOperatorChain(node) {
+		for (let i = 0, len = node.values.length; i < len; i++) {
+			if (i === len - 1) this.visitNode(node.operator);
+			else this.append("->");
+			this.visitNode(node.values[i]);
+		}
+	}
+	visitMergeQuery(node) {
+		if (node.with) {
+			this.visitNode(node.with);
+			this.append(" ");
+		}
+		this.append("merge ");
+		if (node.top) {
+			this.visitNode(node.top);
+			this.append(" ");
+		}
+		this.append("into ");
+		this.visitNode(node.into);
+		if (node.using) {
+			this.append(" ");
+			this.visitNode(node.using);
+		}
+		if (node.whens) {
+			this.append(" ");
+			this.compileList(node.whens, " ");
+		}
+		if (node.returning) {
+			this.append(" ");
+			this.visitNode(node.returning);
+		}
+		if (node.output) {
+			this.append(" ");
+			this.visitNode(node.output);
+		}
+		if (node.endModifiers?.length) {
+			this.append(" ");
+			this.compileList(node.endModifiers, " ");
+		}
+	}
+	visitMatched(node) {
+		if (node.not) this.append("not ");
+		this.append("matched");
+		if (node.bySource) this.append(" by source");
+	}
+	visitAddIndex(node) {
+		if (!this.parentNode || !CreateTableNode.is(this.parentNode)) this.append("add ");
+		if (node.unique) this.append("unique ");
+		this.append("index ");
+		this.visitNode(node.name);
+		if (node.columns) {
+			this.append(" (");
+			this.compileList(node.columns);
+			this.append(")");
+		}
+		if (node.using) {
+			this.append(" using ");
+			this.visitNode(node.using);
+		}
+	}
+	visitCast(node) {
+		this.append("cast(");
+		this.visitNode(node.expression);
+		this.append(" as ");
+		this.visitNode(node.dataType);
+		this.append(")");
+	}
+	visitFetch(node) {
+		this.append("fetch next ");
+		this.visitNode(node.rowCount);
+		this.append(` rows ${node.modifier}`);
+	}
+	visitOutput(node) {
+		this.append("output ");
+		this.compileList(node.selections);
+	}
+	visitTop(node) {
+		this.append(`top(${node.expression})`);
+		if (node.modifiers) this.append(` ${node.modifiers}`);
+	}
+	visitOrAction(node) {
+		this.append(node.action);
+	}
+	visitCollate(node) {
+		this.append("collate ");
+		this.visitNode(node.collation);
+	}
+	append(str) {
+		this.#sql += str;
+	}
+	appendValue(parameter) {
+		this.addParameter(parameter);
+		this.append(this.getCurrentParameterPlaceholder());
+	}
+	getLeftIdentifierWrapper() {
+		return "\"";
+	}
+	getRightIdentifierWrapper() {
+		return "\"";
+	}
+	getCurrentParameterPlaceholder() {
+		return "$" + this.numParameters;
+	}
+	getLeftExplainOptionsWrapper() {
+		return "(";
+	}
+	getExplainOptionAssignment() {
+		return " ";
+	}
+	getExplainOptionsDelimiter() {
+		return ", ";
+	}
+	getRightExplainOptionsWrapper() {
+		return ")";
+	}
+	sanitizeIdentifier(identifier) {
+		const leftWrap = this.getLeftIdentifierWrapper();
+		const rightWrap = this.getRightIdentifierWrapper();
+		let sanitized = "";
+		for (const c of identifier) {
+			sanitized += c;
+			if (c === leftWrap) sanitized += leftWrap;
+			else if (c === rightWrap) sanitized += rightWrap;
+		}
+		return sanitized;
+	}
+	sanitizeStringLiteral(value) {
+		return value.replace(LIT_WRAP_REGEX, "''");
+	}
+	sanitizeJSONPathMemberValue(value) {
+		return value.replace(JSON_PATH_MEMBER_WRAP_REGEX, (char) => char === "'" ? "''" : "\\\"");
+	}
+	addParameter(parameter) {
+		this.#parameters.push(parameter);
+	}
+	appendImmediateValue(value) {
+		if (isString(value)) this.appendStringLiteral(value);
+		else if (isNumber(value) || isBoolean(value) || isBigInt(value)) this.append(value.toString());
+		else if (isNull(value)) this.append("null");
+		else if (isDate(value)) this.appendImmediateValue(value.toISOString());
+		else throw new Error(`invalid immediate value ${value}`);
+	}
+	appendStringLiteral(value) {
+		this.append("'");
+		this.append(this.sanitizeStringLiteral(value));
+		this.append("'");
+	}
+	sortSelectModifiers(arr) {
+		return freeze(arr.toSorted((left, right) => left.modifier && right.modifier ? SELECT_MODIFIER_PRIORITY[left.modifier] - SELECT_MODIFIER_PRIORITY[right.modifier] : 1));
+	}
+	compileColumnAlterations(columnAlterations) {
+		this.compileList(columnAlterations);
+	}
+	/**
+	* controls whether the dialect adds a "type" keyword before a column's new data
+	* type in an ALTER TABLE statement.
+	*/
+	announcesNewColumnDataType() {
+		return true;
+	}
+};
+var SELECT_MODIFIER_SQL = freeze({
+	ForKeyShare: "for key share",
+	ForNoKeyUpdate: "for no key update",
+	ForUpdate: "for update",
+	ForShare: "for share",
+	NoWait: "nowait",
+	SkipLocked: "skip locked",
+	Distinct: "distinct"
+});
+var SELECT_MODIFIER_PRIORITY = freeze({
+	ForKeyShare: 1,
+	ForNoKeyUpdate: 1,
+	ForUpdate: 1,
+	ForShare: 1,
+	NoWait: 2,
+	SkipLocked: 2,
+	Distinct: 0
+});
+var JOIN_TYPE_SQL = freeze({
+	InnerJoin: "inner join",
+	LeftJoin: "left join",
+	RightJoin: "right join",
+	FullJoin: "full join",
+	CrossJoin: "cross join",
+	LateralInnerJoin: "inner join lateral",
+	LateralLeftJoin: "left join lateral",
+	LateralCrossJoin: "cross join lateral",
+	OuterApply: "outer apply",
+	CrossApply: "cross apply",
+	Using: "using"
+});
+//#endregion
+export { noop as A, isFunction as C, isReadonlyArray as D, isObject as E, isString as O, isDate as S, isNumber as T, freeze as _, InsertQueryNode as a, isBoolean as b, OperatorNode as c, isUnaryOperator as d, SchemableIdentifierNode as f, asArray as g, IdentifierNode as h, WhenNode as i, isUndefined as k, isBinaryOperator as l, ON_COMMIT_ACTIONS as m, CreateViewNode as n, ParensNode as o, CreateTableNode as p, SetOperationNode as r, RawNode as s, DefaultQueryCompiler as t, isJSONOperator as u, getMessage as v, isNull as w, isBuffer as x, isBigInt as y };