@fragno-dev/workflows 0.0.1

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/camel-case/camel-case.js

@@ -0,0 +1,80 @@
+import { __commonJS } from "../../../../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/camel-case/camel-case.js
+var require_camel_case = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/camel-case/camel-case.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.createSnakeCaseMapper = createSnakeCaseMapper;
+	exports.createCamelCaseMapper = createCamelCaseMapper;
+	/**
+	* Creates a function that transforms camel case strings to snake case.
+	*/
+	function createSnakeCaseMapper({ upperCase = false, underscoreBeforeDigits = false, underscoreBetweenUppercaseLetters = false } = {}) {
+		return memoize((str) => {
+			if (str.length === 0) return str;
+			const upper = str.toUpperCase();
+			const lower = str.toLowerCase();
+			let out = lower[0];
+			for (let i = 1, l = str.length; i < l; ++i) {
+				const char = str[i];
+				const prevChar = str[i - 1];
+				const upperChar = upper[i];
+				const prevUpperChar = upper[i - 1];
+				const lowerChar = lower[i];
+				const prevLowerChar = lower[i - 1];
+				if (underscoreBeforeDigits && isDigit(char) && !isDigit(prevChar) && !out.endsWith("_")) {
+					out += "_" + char;
+					continue;
+				}
+				if (char === upperChar && upperChar !== lowerChar) if (underscoreBetweenUppercaseLetters || !(prevChar === prevUpperChar && prevUpperChar !== prevLowerChar)) out += "_" + lowerChar;
+				else out += lowerChar;
+				else out += char;
+			}
+			if (upperCase) return out.toUpperCase();
+			else return out;
+		});
+	}
+	/**
+	* Creates a function that transforms snake case strings to camel case.
+	*/
+	function createCamelCaseMapper({ upperCase = false } = {}) {
+		return memoize((str) => {
+			if (str.length === 0) return str;
+			if (upperCase && isAllUpperCaseSnakeCase(str)) str = str.toLowerCase();
+			let out = str[0];
+			for (let i = 1, l = str.length; i < l; ++i) {
+				const char = str[i];
+				const prevChar = str[i - 1];
+				if (char !== "_") if (prevChar === "_") out += char.toUpperCase();
+				else out += char;
+			}
+			return out;
+		});
+	}
+	function isAllUpperCaseSnakeCase(str) {
+		for (let i = 1, l = str.length; i < l; ++i) {
+			const char = str[i];
+			if (char !== "_" && char !== char.toUpperCase()) return false;
+		}
+		return true;
+	}
+	function isDigit(char) {
+		return char >= "0" && char <= "9";
+	}
+	function memoize(func) {
+		const cache = /* @__PURE__ */ new Map();
+		return (str) => {
+			let mapped = cache.get(str);
+			if (!mapped) {
+				mapped = func(str);
+				cache.set(str, mapped);
+			}
+			return mapped;
+		};
+	}
+}) });
+
+//#endregion
+export default require_camel_case();
+
+export { require_camel_case };
+//# sourceMappingURL=camel-case.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/camel-case/camel-case.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"camel-case.js","names":[],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/camel-case/camel-case.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createSnakeCaseMapper = createSnakeCaseMapper;\nexports.createCamelCaseMapper = createCamelCaseMapper;\n/**\n * Creates a function that transforms camel case strings to snake case.\n */\nfunction createSnakeCaseMapper({ upperCase = false, underscoreBeforeDigits = false, underscoreBetweenUppercaseLetters = false, } = {}) {\n    return memoize((str) => {\n        if (str.length === 0) {\n            return str;\n        }\n        const upper = str.toUpperCase();\n        const lower = str.toLowerCase();\n        let out = lower[0];\n        for (let i = 1, l = str.length; i < l; ++i) {\n            const char = str[i];\n            const prevChar = str[i - 1];\n            const upperChar = upper[i];\n            const prevUpperChar = upper[i - 1];\n            const lowerChar = lower[i];\n            const prevLowerChar = lower[i - 1];\n            // If underScoreBeforeDigits is true then, well, insert an underscore\n            // before digits :). Only the first digit gets an underscore if\n            // there are multiple.\n            if (underscoreBeforeDigits &&\n                isDigit(char) &&\n                !isDigit(prevChar) &&\n                !out.endsWith('_')) {\n                out += '_' + char;\n                continue;\n            }\n            // Test if `char` is an upper-case character and that the character\n            // actually has different upper and lower case versions.\n            if (char === upperChar && upperChar !== lowerChar) {\n                const prevCharacterIsUppercase = prevChar === prevUpperChar && prevUpperChar !== prevLowerChar;\n                // If underscoreBetweenUppercaseLetters is true, we always place an underscore\n                // before consecutive uppercase letters (e.g. \"fooBAR\" becomes \"foo_b_a_r\").\n                // Otherwise, we don't (e.g. \"fooBAR\" becomes \"foo_bar\").\n                if (underscoreBetweenUppercaseLetters || !prevCharacterIsUppercase) {\n                    out += '_' + lowerChar;\n                }\n                else {\n                    out += lowerChar;\n                }\n            }\n            else {\n                out += char;\n            }\n        }\n        if (upperCase) {\n            return out.toUpperCase();\n        }\n        else {\n            return out;\n        }\n    });\n}\n/**\n * Creates a function that transforms snake case strings to camel case.\n */\nfunction createCamelCaseMapper({ upperCase = false, } = {}) {\n    return memoize((str) => {\n        if (str.length === 0) {\n            return str;\n        }\n        if (upperCase && isAllUpperCaseSnakeCase(str)) {\n            // Only convert to lower case if the string is all upper\n            // case snake_case. This allows camelCase strings to go\n            // through without changing.\n            str = str.toLowerCase();\n        }\n        let out = str[0];\n        for (let i = 1, l = str.length; i < l; ++i) {\n            const char = str[i];\n            const prevChar = str[i - 1];\n            if (char !== '_') {\n                if (prevChar === '_') {\n                    out += char.toUpperCase();\n                }\n                else {\n                    out += char;\n                }\n            }\n        }\n        return out;\n    });\n}\nfunction isAllUpperCaseSnakeCase(str) {\n    for (let i = 1, l = str.length; i < l; ++i) {\n        const char = str[i];\n        if (char !== '_' && char !== char.toUpperCase()) {\n            return false;\n        }\n    }\n    return true;\n}\nfunction isDigit(char) {\n    return char >= '0' && char <= '9';\n}\nfunction memoize(func) {\n    const cache = new Map();\n    return (str) => {\n        let mapped = cache.get(str);\n        if (!mapped) {\n            mapped = func(str);\n            cache.set(str, mapped);\n        }\n        return mapped;\n    };\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,wBAAwB;AAChC,SAAQ,wBAAwB;;;;CAIhC,SAAS,sBAAsB,EAAE,YAAY,OAAO,yBAAyB,OAAO,oCAAoC,UAAW,EAAE,EAAE;AACnI,SAAO,SAAS,QAAQ;AACpB,OAAI,IAAI,WAAW,EACf,QAAO;GAEX,MAAM,QAAQ,IAAI,aAAa;GAC/B,MAAM,QAAQ,IAAI,aAAa;GAC/B,IAAI,MAAM,MAAM;AAChB,QAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,IAAI,GAAG,EAAE,GAAG;IACxC,MAAM,OAAO,IAAI;IACjB,MAAM,WAAW,IAAI,IAAI;IACzB,MAAM,YAAY,MAAM;IACxB,MAAM,gBAAgB,MAAM,IAAI;IAChC,MAAM,YAAY,MAAM;IACxB,MAAM,gBAAgB,MAAM,IAAI;AAIhC,QAAI,0BACA,QAAQ,KAAK,IACb,CAAC,QAAQ,SAAS,IAClB,CAAC,IAAI,SAAS,IAAI,EAAE;AACpB,YAAO,MAAM;AACb;;AAIJ,QAAI,SAAS,aAAa,cAAc,UAKpC,KAAI,qCAAqC,EAJR,aAAa,iBAAiB,kBAAkB,eAK7E,QAAO,MAAM;QAGb,QAAO;QAIX,QAAO;;AAGf,OAAI,UACA,QAAO,IAAI,aAAa;OAGxB,QAAO;IAEb;;;;;CAKN,SAAS,sBAAsB,EAAE,YAAY,UAAW,EAAE,EAAE;AACxD,SAAO,SAAS,QAAQ;AACpB,OAAI,IAAI,WAAW,EACf,QAAO;AAEX,OAAI,aAAa,wBAAwB,IAAI,CAIzC,OAAM,IAAI,aAAa;GAE3B,IAAI,MAAM,IAAI;AACd,QAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,IAAI,GAAG,EAAE,GAAG;IACxC,MAAM,OAAO,IAAI;IACjB,MAAM,WAAW,IAAI,IAAI;AACzB,QAAI,SAAS,IACT,KAAI,aAAa,IACb,QAAO,KAAK,aAAa;QAGzB,QAAO;;AAInB,UAAO;IACT;;CAEN,SAAS,wBAAwB,KAAK;AAClC,OAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,IAAI,GAAG,EAAE,GAAG;GACxC,MAAM,OAAO,IAAI;AACjB,OAAI,SAAS,OAAO,SAAS,KAAK,aAAa,CAC3C,QAAO;;AAGf,SAAO;;CAEX,SAAS,QAAQ,MAAM;AACnB,SAAO,QAAQ,OAAO,QAAQ;;CAElC,SAAS,QAAQ,MAAM;EACnB,MAAM,wBAAQ,IAAI,KAAK;AACvB,UAAQ,QAAQ;GACZ,IAAI,SAAS,MAAM,IAAI,IAAI;AAC3B,OAAI,CAAC,QAAQ;AACT,aAAS,KAAK,IAAI;AAClB,UAAM,IAAI,KAAK,OAAO;;AAE1B,UAAO"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/deduplicate-joins/deduplicate-joins-plugin.js

@@ -0,0 +1,30 @@
+import { __commonJS } from "../../../../../../../../../_virtual/rolldown_runtime.js";
+import { require_deduplicate_joins_transformer } from "./deduplicate-joins-transformer.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/deduplicate-joins/deduplicate-joins-plugin.js
+var require_deduplicate_joins_plugin = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/deduplicate-joins/deduplicate-joins-plugin.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.DeduplicateJoinsPlugin = void 0;
+	const deduplicate_joins_transformer_js_1 = require_deduplicate_joins_transformer();
+	/**
+	* Plugin that removes duplicate joins from queries.
+	*
+	* See [this recipe](https://github.com/kysely-org/kysely/blob/master/site/docs/recipes/0008-deduplicate-joins.md)
+	*/
+	var DeduplicateJoinsPlugin = class {
+		#transformer = new deduplicate_joins_transformer_js_1.DeduplicateJoinsTransformer();
+		transformQuery(args) {
+			return this.#transformer.transformNode(args.node, args.queryId);
+		}
+		transformResult(args) {
+			return Promise.resolve(args.result);
+		}
+	};
+	exports.DeduplicateJoinsPlugin = DeduplicateJoinsPlugin;
+}) });
+
+//#endregion
+export default require_deduplicate_joins_plugin();
+
+export { require_deduplicate_joins_plugin };
+//# sourceMappingURL=deduplicate-joins-plugin.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/deduplicate-joins/deduplicate-joins-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deduplicate-joins-plugin.js","names":["#transformer"],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/deduplicate-joins/deduplicate-joins-plugin.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.DeduplicateJoinsPlugin = void 0;\nconst deduplicate_joins_transformer_js_1 = require(\"./deduplicate-joins-transformer.js\");\n/**\n * Plugin that removes duplicate joins from queries.\n *\n * See [this recipe](https://github.com/kysely-org/kysely/blob/master/site/docs/recipes/0008-deduplicate-joins.md)\n */\nclass DeduplicateJoinsPlugin {\n    #transformer = new deduplicate_joins_transformer_js_1.DeduplicateJoinsTransformer();\n    transformQuery(args) {\n        return this.#transformer.transformNode(args.node, args.queryId);\n    }\n    transformResult(args) {\n        return Promise.resolve(args.result);\n    }\n}\nexports.DeduplicateJoinsPlugin = DeduplicateJoinsPlugin;\n"],"x_google_ignoreList":[0],"mappings":";;;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,yBAAyB,KAAK;CACtC,MAAM;;;;;;CAMN,IAAM,yBAAN,MAA6B;EACzB,eAAe,IAAI,mCAAmC,6BAA6B;EACnF,eAAe,MAAM;AACjB,UAAO,MAAKA,YAAa,cAAc,KAAK,MAAM,KAAK,QAAQ;;EAEnE,gBAAgB,MAAM;AAClB,UAAO,QAAQ,QAAQ,KAAK,OAAO;;;AAG3C,SAAQ,yBAAyB"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/deduplicate-joins/deduplicate-joins-transformer.js

@@ -0,0 +1,48 @@
+import { __commonJS } from "../../../../../../../../../_virtual/rolldown_runtime.js";
+import { require_object_utils } from "../../util/object-utils.js";
+import { require_operation_node_transformer } from "../../operation-node/operation-node-transformer.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/deduplicate-joins/deduplicate-joins-transformer.js
+var require_deduplicate_joins_transformer = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/deduplicate-joins/deduplicate-joins-transformer.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.DeduplicateJoinsTransformer = void 0;
+	const operation_node_transformer_js_1 = require_operation_node_transformer();
+	const object_utils_js_1 = require_object_utils();
+	var DeduplicateJoinsTransformer = class extends operation_node_transformer_js_1.OperationNodeTransformer {
+		transformSelectQuery(node, queryId) {
+			return this.#transformQuery(super.transformSelectQuery(node, queryId));
+		}
+		transformUpdateQuery(node, queryId) {
+			return this.#transformQuery(super.transformUpdateQuery(node, queryId));
+		}
+		transformDeleteQuery(node, queryId) {
+			return this.#transformQuery(super.transformDeleteQuery(node, queryId));
+		}
+		#transformQuery(node) {
+			if (!node.joins || node.joins.length === 0) return node;
+			return (0, object_utils_js_1.freeze)({
+				...node,
+				joins: this.#deduplicateJoins(node.joins)
+			});
+		}
+		#deduplicateJoins(joins) {
+			const out = [];
+			for (let i = 0; i < joins.length; ++i) {
+				let foundDuplicate = false;
+				for (let j = 0; j < out.length; ++j) if ((0, object_utils_js_1.compare)(joins[i], out[j])) {
+					foundDuplicate = true;
+					break;
+				}
+				if (!foundDuplicate) out.push(joins[i]);
+			}
+			return (0, object_utils_js_1.freeze)(out);
+		}
+	};
+	exports.DeduplicateJoinsTransformer = DeduplicateJoinsTransformer;
+}) });
+
+//#endregion
+export default require_deduplicate_joins_transformer();
+
+export { require_deduplicate_joins_transformer };
+//# sourceMappingURL=deduplicate-joins-transformer.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/deduplicate-joins/deduplicate-joins-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deduplicate-joins-transformer.js","names":["#transformQuery","#deduplicateJoins"],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/deduplicate-joins/deduplicate-joins-transformer.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.DeduplicateJoinsTransformer = void 0;\nconst operation_node_transformer_js_1 = require(\"../../operation-node/operation-node-transformer.js\");\nconst object_utils_js_1 = require(\"../../util/object-utils.js\");\nclass DeduplicateJoinsTransformer extends operation_node_transformer_js_1.OperationNodeTransformer {\n    transformSelectQuery(node, queryId) {\n        return this.#transformQuery(super.transformSelectQuery(node, queryId));\n    }\n    transformUpdateQuery(node, queryId) {\n        return this.#transformQuery(super.transformUpdateQuery(node, queryId));\n    }\n    transformDeleteQuery(node, queryId) {\n        return this.#transformQuery(super.transformDeleteQuery(node, queryId));\n    }\n    #transformQuery(node) {\n        if (!node.joins || node.joins.length === 0) {\n            return node;\n        }\n        return (0, object_utils_js_1.freeze)({\n            ...node,\n            joins: this.#deduplicateJoins(node.joins),\n        });\n    }\n    #deduplicateJoins(joins) {\n        const out = [];\n        for (let i = 0; i < joins.length; ++i) {\n            let foundDuplicate = false;\n            for (let j = 0; j < out.length; ++j) {\n                if ((0, object_utils_js_1.compare)(joins[i], out[j])) {\n                    foundDuplicate = true;\n                    break;\n                }\n            }\n            if (!foundDuplicate) {\n                out.push(joins[i]);\n            }\n        }\n        return (0, object_utils_js_1.freeze)(out);\n    }\n}\nexports.DeduplicateJoinsTransformer = DeduplicateJoinsTransformer;\n"],"x_google_ignoreList":[0],"mappings":";;;;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,8BAA8B,KAAK;CAC3C,MAAM;CACN,MAAM;CACN,IAAM,8BAAN,cAA0C,gCAAgC,yBAAyB;EAC/F,qBAAqB,MAAM,SAAS;AAChC,UAAO,MAAKA,eAAgB,MAAM,qBAAqB,MAAM,QAAQ,CAAC;;EAE1E,qBAAqB,MAAM,SAAS;AAChC,UAAO,MAAKA,eAAgB,MAAM,qBAAqB,MAAM,QAAQ,CAAC;;EAE1E,qBAAqB,MAAM,SAAS;AAChC,UAAO,MAAKA,eAAgB,MAAM,qBAAqB,MAAM,QAAQ,CAAC;;EAE1E,gBAAgB,MAAM;AAClB,OAAI,CAAC,KAAK,SAAS,KAAK,MAAM,WAAW,EACrC,QAAO;AAEX,WAAQ,GAAG,kBAAkB,QAAQ;IACjC,GAAG;IACH,OAAO,MAAKC,iBAAkB,KAAK,MAAM;IAC5C,CAAC;;EAEN,kBAAkB,OAAO;GACrB,MAAM,MAAM,EAAE;AACd,QAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,EAAE,GAAG;IACnC,IAAI,iBAAiB;AACrB,SAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,EAAE,EAC9B,MAAK,GAAG,kBAAkB,SAAS,MAAM,IAAI,IAAI,GAAG,EAAE;AAClD,sBAAiB;AACjB;;AAGR,QAAI,CAAC,eACD,KAAI,KAAK,MAAM,GAAG;;AAG1B,WAAQ,GAAG,kBAAkB,QAAQ,IAAI;;;AAGjD,SAAQ,8BAA8B"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/handle-empty-in-lists/handle-empty-in-lists-plugin.js

@@ -0,0 +1,173 @@
+import { __commonJS } from "../../../../../../../../../_virtual/rolldown_runtime.js";
+import { require_handle_empty_in_lists_transformer } from "./handle-empty-in-lists-transformer.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/handle-empty-in-lists/handle-empty-in-lists-plugin.js
+var require_handle_empty_in_lists_plugin = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/handle-empty-in-lists/handle-empty-in-lists-plugin.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.HandleEmptyInListsPlugin = void 0;
+	const handle_empty_in_lists_transformer_js_1 = require_handle_empty_in_lists_transformer();
+	/**
+	* A plugin that allows handling `in ()` and `not in ()` expressions.
+	*
+	* These expressions are invalid SQL syntax for many databases, and result in runtime
+	* database errors.
+	*
+	* The workarounds used by other libraries always involve modifying the query under
+	* the hood, which is not aligned with Kysely's philosophy of WYSIWYG. We recommend manually checking
+	* for empty arrays before passing them as arguments to `in` and `not in` expressions
+	* instead, but understand that this can be cumbersome. Hence we're going with an
+	* opt-in approach where you can choose if and how to handle these cases. We do
+	* not want to make this the default behavior, as it can lead to unexpected behavior.
+	* Use it at your own risk. Test it. Make sure it works as expected for you.
+	*
+	* Using this plugin also allows you to throw an error (thus avoiding unnecessary
+	* requests to the database) or print a warning in these cases.
+	*
+	* ### Examples
+	*
+	* The following strategy replaces the `in`/`not in` expression with a noncontingent
+	* expression. A contradiction (falsy) `1 = 0` for `in`, and a tautology (truthy) `1 = 1` for `not in`),
+	* similarily to how {@link https://github.com/knex/knex/blob/176151d8048b2a7feeb89a3d649a5580786d4f4e/docs/src/guide/query-builder.md#L1763 | Knex.js},
+	* {@link https://github.com/prisma/prisma-engines/blob/99168c54187178484dae45d9478aa40cfd1866d2/quaint/src/visitor.rs#L804-L823 | PrismaORM},
+	* {@link https://github.com/laravel/framework/blob/8.x/src/Illuminate/Database/Query/Grammars/Grammar.php#L284-L291 | Laravel},
+	* {@link https://docs.sqlalchemy.org/en/13/core/engines.html#sqlalchemy.create_engine.params.empty_in_strategy | SQLAlchemy}
+	* handle this.
+	*
+	* ```ts
+	* import Sqlite from 'better-sqlite3'
+	* import {
+	*   HandleEmptyInListsPlugin,
+	*   Kysely,
+	*   replaceWithNoncontingentExpression,
+	*   SqliteDialect,
+	* } from 'kysely'
+	* import type { Database } from 'type-editor' // imaginary module
+	*
+	* const db = new Kysely<Database>({
+	*   dialect: new SqliteDialect({
+	*     database: new Sqlite(':memory:'),
+	*   }),
+	*   plugins: [
+	*     new HandleEmptyInListsPlugin({
+	*       strategy: replaceWithNoncontingentExpression
+	*     })
+	*   ],
+	* })
+	*
+	* const results = await db
+	*   .selectFrom('person')
+	*   .where('id', 'in', [])
+	*   .where('first_name', 'not in', [])
+	*   .selectAll()
+	*   .execute()
+	* ```
+	*
+	* The generated SQL (SQLite):
+	*
+	* ```sql
+	* select * from "person" where 1 = 0 and 1 = 1
+	* ```
+	*
+	* The following strategy does the following:
+	*
+	* When `in`, pushes a `null` value into the empty list resulting in `in (null)`,
+	* similiarly to how {@link https://github.com/typeorm/typeorm/blob/0280cdc451c35ef73c830eb1191c95d34f6ce06e/src/query-builder/QueryBuilder.ts#L919-L922 | TypeORM}
+	* and {@link https://github.com/sequelize/sequelize/blob/0f2891c6897e12bf9bf56df344aae5b698f58c7d/packages/core/src/abstract-dialect/where-sql-builder.ts#L368-L379 | Sequelize}
+	* handle `in ()`. `in (null)` is logically the equivalent of `= null`, which returns
+	* `null`, which is a falsy expression in most SQL databases. We recommend NOT
+	* using this strategy if you plan to use `in` in `select`, `returning`, or `output`
+	* clauses, as the return type differs from the `SqlBool` default type for comparisons.
+	*
+	* When `not in`, casts the left operand as `char` and pushes a unique value into
+	* the empty list resulting in `cast({{lhs}} as char) not in ({{VALUE}})`. Casting
+	* is required to avoid database errors with non-string values.
+	*
+	* ```ts
+	* import Sqlite from 'better-sqlite3'
+	* import {
+	*   HandleEmptyInListsPlugin,
+	*   Kysely,
+	*   pushValueIntoList,
+	*   SqliteDialect
+	* } from 'kysely'
+	* import type { Database } from 'type-editor' // imaginary module
+	*
+	* const db = new Kysely<Database>({
+	*   dialect: new SqliteDialect({
+	*     database: new Sqlite(':memory:'),
+	*   }),
+	*   plugins: [
+	*     new HandleEmptyInListsPlugin({
+	*       strategy: pushValueIntoList('__kysely_no_values_were_provided__') // choose a unique value for not in. has to be something with zero chance being in the data.
+	*     })
+	*   ],
+	* })
+	*
+	* const results = await db
+	*   .selectFrom('person')
+	*   .where('id', 'in', [])
+	*   .where('first_name', 'not in', [])
+	*   .selectAll()
+	*   .execute()
+	* ```
+	*
+	* The generated SQL (SQLite):
+	*
+	* ```sql
+	* select * from "person" where "id" in (null) and cast("first_name" as char) not in ('__kysely_no_values_were_provided__')
+	* ```
+	*
+	* The following custom strategy throws an error when an empty list is encountered
+	* to avoid unnecessary requests to the database:
+	*
+	* ```ts
+	* import Sqlite from 'better-sqlite3'
+	* import {
+	*   HandleEmptyInListsPlugin,
+	*   Kysely,
+	*   SqliteDialect
+	* } from 'kysely'
+	* import type { Database } from 'type-editor' // imaginary module
+	*
+	* const db = new Kysely<Database>({
+	*   dialect: new SqliteDialect({
+	*     database: new Sqlite(':memory:'),
+	*   }),
+	*   plugins: [
+	*     new HandleEmptyInListsPlugin({
+	*       strategy: () => {
+	*         throw new Error('Empty in/not-in is not allowed')
+	*       }
+	*     })
+	*   ],
+	* })
+	*
+	* const results = await db
+	*   .selectFrom('person')
+	*   .where('id', 'in', [])
+	*   .selectAll()
+	*   .execute() // throws an error with 'Empty in/not-in is not allowed' message!
+	* ```
+	*/
+	var HandleEmptyInListsPlugin = class {
+		opt;
+		#transformer;
+		constructor(opt) {
+			this.opt = opt;
+			this.#transformer = new handle_empty_in_lists_transformer_js_1.HandleEmptyInListsTransformer(opt.strategy);
+		}
+		transformQuery(args) {
+			return this.#transformer.transformNode(args.node, args.queryId);
+		}
+		async transformResult(args) {
+			return args.result;
+		}
+	};
+	exports.HandleEmptyInListsPlugin = HandleEmptyInListsPlugin;
+}) });
+
+//#endregion
+export default require_handle_empty_in_lists_plugin();
+
+export { require_handle_empty_in_lists_plugin };
+//# sourceMappingURL=handle-empty-in-lists-plugin.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/handle-empty-in-lists/handle-empty-in-lists-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-empty-in-lists-plugin.js","names":["#transformer"],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/handle-empty-in-lists/handle-empty-in-lists-plugin.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.HandleEmptyInListsPlugin = void 0;\nconst handle_empty_in_lists_transformer_js_1 = require(\"./handle-empty-in-lists-transformer.js\");\n/**\n * A plugin that allows handling `in ()` and `not in ()` expressions.\n *\n * These expressions are invalid SQL syntax for many databases, and result in runtime\n * database errors.\n *\n * The workarounds used by other libraries always involve modifying the query under\n * the hood, which is not aligned with Kysely's philosophy of WYSIWYG. We recommend manually checking\n * for empty arrays before passing them as arguments to `in` and `not in` expressions\n * instead, but understand that this can be cumbersome. Hence we're going with an\n * opt-in approach where you can choose if and how to handle these cases. We do\n * not want to make this the default behavior, as it can lead to unexpected behavior.\n * Use it at your own risk. Test it. Make sure it works as expected for you.\n *\n * Using this plugin also allows you to throw an error (thus avoiding unnecessary\n * requests to the database) or print a warning in these cases.\n *\n * ### Examples\n *\n * The following strategy replaces the `in`/`not in` expression with a noncontingent\n * expression. A contradiction (falsy) `1 = 0` for `in`, and a tautology (truthy) `1 = 1` for `not in`),\n * similarily to how {@link https://github.com/knex/knex/blob/176151d8048b2a7feeb89a3d649a5580786d4f4e/docs/src/guide/query-builder.md#L1763 | Knex.js},\n * {@link https://github.com/prisma/prisma-engines/blob/99168c54187178484dae45d9478aa40cfd1866d2/quaint/src/visitor.rs#L804-L823 | PrismaORM},\n * {@link https://github.com/laravel/framework/blob/8.x/src/Illuminate/Database/Query/Grammars/Grammar.php#L284-L291 | Laravel},\n * {@link https://docs.sqlalchemy.org/en/13/core/engines.html#sqlalchemy.create_engine.params.empty_in_strategy | SQLAlchemy}\n * handle this.\n *\n * ```ts\n * import Sqlite from 'better-sqlite3'\n * import {\n *   HandleEmptyInListsPlugin,\n *   Kysely,\n *   replaceWithNoncontingentExpression,\n *   SqliteDialect,\n * } from 'kysely'\n * import type { Database } from 'type-editor' // imaginary module\n *\n * const db = new Kysely<Database>({\n *   dialect: new SqliteDialect({\n *     database: new Sqlite(':memory:'),\n *   }),\n *   plugins: [\n *     new HandleEmptyInListsPlugin({\n *       strategy: replaceWithNoncontingentExpression\n *     })\n *   ],\n * })\n *\n * const results = await db\n *   .selectFrom('person')\n *   .where('id', 'in', [])\n *   .where('first_name', 'not in', [])\n *   .selectAll()\n *   .execute()\n * ```\n *\n * The generated SQL (SQLite):\n *\n * ```sql\n * select * from \"person\" where 1 = 0 and 1 = 1\n * ```\n *\n * The following strategy does the following:\n *\n * When `in`, pushes a `null` value into the empty list resulting in `in (null)`,\n * similiarly to how {@link https://github.com/typeorm/typeorm/blob/0280cdc451c35ef73c830eb1191c95d34f6ce06e/src/query-builder/QueryBuilder.ts#L919-L922 | TypeORM}\n * and {@link https://github.com/sequelize/sequelize/blob/0f2891c6897e12bf9bf56df344aae5b698f58c7d/packages/core/src/abstract-dialect/where-sql-builder.ts#L368-L379 | Sequelize}\n * handle `in ()`. `in (null)` is logically the equivalent of `= null`, which returns\n * `null`, which is a falsy expression in most SQL databases. We recommend NOT\n * using this strategy if you plan to use `in` in `select`, `returning`, or `output`\n * clauses, as the return type differs from the `SqlBool` default type for comparisons.\n *\n * When `not in`, casts the left operand as `char` and pushes a unique value into\n * the empty list resulting in `cast({{lhs}} as char) not in ({{VALUE}})`. Casting\n * is required to avoid database errors with non-string values.\n *\n * ```ts\n * import Sqlite from 'better-sqlite3'\n * import {\n *   HandleEmptyInListsPlugin,\n *   Kysely,\n *   pushValueIntoList,\n *   SqliteDialect\n * } from 'kysely'\n * import type { Database } from 'type-editor' // imaginary module\n *\n * const db = new Kysely<Database>({\n *   dialect: new SqliteDialect({\n *     database: new Sqlite(':memory:'),\n *   }),\n *   plugins: [\n *     new HandleEmptyInListsPlugin({\n *       strategy: pushValueIntoList('__kysely_no_values_were_provided__') // choose a unique value for not in. has to be something with zero chance being in the data.\n *     })\n *   ],\n * })\n *\n * const results = await db\n *   .selectFrom('person')\n *   .where('id', 'in', [])\n *   .where('first_name', 'not in', [])\n *   .selectAll()\n *   .execute()\n * ```\n *\n * The generated SQL (SQLite):\n *\n * ```sql\n * select * from \"person\" where \"id\" in (null) and cast(\"first_name\" as char) not in ('__kysely_no_values_were_provided__')\n * ```\n *\n * The following custom strategy throws an error when an empty list is encountered\n * to avoid unnecessary requests to the database:\n *\n * ```ts\n * import Sqlite from 'better-sqlite3'\n * import {\n *   HandleEmptyInListsPlugin,\n *   Kysely,\n *   SqliteDialect\n * } from 'kysely'\n * import type { Database } from 'type-editor' // imaginary module\n *\n * const db = new Kysely<Database>({\n *   dialect: new SqliteDialect({\n *     database: new Sqlite(':memory:'),\n *   }),\n *   plugins: [\n *     new HandleEmptyInListsPlugin({\n *       strategy: () => {\n *         throw new Error('Empty in/not-in is not allowed')\n *       }\n *     })\n *   ],\n * })\n *\n * const results = await db\n *   .selectFrom('person')\n *   .where('id', 'in', [])\n *   .selectAll()\n *   .execute() // throws an error with 'Empty in/not-in is not allowed' message!\n * ```\n */\nclass HandleEmptyInListsPlugin {\n    opt;\n    #transformer;\n    constructor(opt) {\n        this.opt = opt;\n        this.#transformer = new handle_empty_in_lists_transformer_js_1.HandleEmptyInListsTransformer(opt.strategy);\n    }\n    transformQuery(args) {\n        return this.#transformer.transformNode(args.node, args.queryId);\n    }\n    async transformResult(args) {\n        return args.result;\n    }\n}\nexports.HandleEmptyInListsPlugin = HandleEmptyInListsPlugin;\n"],"x_google_ignoreList":[0],"mappings":";;;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,2BAA2B,KAAK;CACxC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgJN,IAAM,2BAAN,MAA+B;EAC3B;EACA;EACA,YAAY,KAAK;AACb,QAAK,MAAM;AACX,SAAKA,cAAe,IAAI,uCAAuC,8BAA8B,IAAI,SAAS;;EAE9G,eAAe,MAAM;AACjB,UAAO,MAAKA,YAAa,cAAc,KAAK,MAAM,KAAK,QAAQ;;EAEnE,MAAM,gBAAgB,MAAM;AACxB,UAAO,KAAK;;;AAGpB,SAAQ,2BAA2B"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/handle-empty-in-lists/handle-empty-in-lists-transformer.js

@@ -0,0 +1,37 @@
+import { __commonJS } from "../../../../../../../../../_virtual/rolldown_runtime.js";
+import { require_operator_node } from "../../operation-node/operator-node.js";
+import { require_primitive_value_list_node } from "../../operation-node/primitive-value-list-node.js";
+import { require_value_list_node } from "../../operation-node/value-list-node.js";
+import { require_operation_node_transformer } from "../../operation-node/operation-node-transformer.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/handle-empty-in-lists/handle-empty-in-lists-transformer.js
+var require_handle_empty_in_lists_transformer = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/handle-empty-in-lists/handle-empty-in-lists-transformer.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.HandleEmptyInListsTransformer = void 0;
+	const operation_node_transformer_js_1 = require_operation_node_transformer();
+	const primitive_value_list_node_js_1 = require_primitive_value_list_node();
+	const operator_node_js_1 = require_operator_node();
+	const value_list_node_js_1 = require_value_list_node();
+	var HandleEmptyInListsTransformer = class extends operation_node_transformer_js_1.OperationNodeTransformer {
+		#strategy;
+		constructor(strategy) {
+			super();
+			this.#strategy = strategy;
+		}
+		transformBinaryOperation(node) {
+			if (this.#isEmptyInListNode(node)) return this.#strategy(node);
+			return node;
+		}
+		#isEmptyInListNode(node) {
+			const { operator, rightOperand } = node;
+			return (primitive_value_list_node_js_1.PrimitiveValueListNode.is(rightOperand) || value_list_node_js_1.ValueListNode.is(rightOperand)) && rightOperand.values.length === 0 && operator_node_js_1.OperatorNode.is(operator) && (operator.operator === "in" || operator.operator === "not in");
+		}
+	};
+	exports.HandleEmptyInListsTransformer = HandleEmptyInListsTransformer;
+}) });
+
+//#endregion
+export default require_handle_empty_in_lists_transformer();
+
+export { require_handle_empty_in_lists_transformer };
+//# sourceMappingURL=handle-empty-in-lists-transformer.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/handle-empty-in-lists/handle-empty-in-lists-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-empty-in-lists-transformer.js","names":["#strategy","#isEmptyInListNode"],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/handle-empty-in-lists/handle-empty-in-lists-transformer.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.HandleEmptyInListsTransformer = void 0;\nconst operation_node_transformer_js_1 = require(\"../../operation-node/operation-node-transformer.js\");\nconst primitive_value_list_node_js_1 = require(\"../../operation-node/primitive-value-list-node.js\");\nconst operator_node_js_1 = require(\"../../operation-node/operator-node.js\");\nconst value_list_node_js_1 = require(\"../../operation-node/value-list-node.js\");\nclass HandleEmptyInListsTransformer extends operation_node_transformer_js_1.OperationNodeTransformer {\n    #strategy;\n    constructor(strategy) {\n        super();\n        this.#strategy = strategy;\n    }\n    transformBinaryOperation(node) {\n        if (this.#isEmptyInListNode(node)) {\n            return this.#strategy(node);\n        }\n        return node;\n    }\n    #isEmptyInListNode(node) {\n        const { operator, rightOperand } = node;\n        return ((primitive_value_list_node_js_1.PrimitiveValueListNode.is(rightOperand) ||\n            value_list_node_js_1.ValueListNode.is(rightOperand)) &&\n            rightOperand.values.length === 0 &&\n            operator_node_js_1.OperatorNode.is(operator) &&\n            (operator.operator === 'in' || operator.operator === 'not in'));\n    }\n}\nexports.HandleEmptyInListsTransformer = HandleEmptyInListsTransformer;\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,gCAAgC,KAAK;CAC7C,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACN,IAAM,gCAAN,cAA4C,gCAAgC,yBAAyB;EACjG;EACA,YAAY,UAAU;AAClB,UAAO;AACP,SAAKA,WAAY;;EAErB,yBAAyB,MAAM;AAC3B,OAAI,MAAKC,kBAAmB,KAAK,CAC7B,QAAO,MAAKD,SAAU,KAAK;AAE/B,UAAO;;EAEX,mBAAmB,MAAM;GACrB,MAAM,EAAE,UAAU,iBAAiB;AACnC,WAAS,+BAA+B,uBAAuB,GAAG,aAAa,IAC3E,qBAAqB,cAAc,GAAG,aAAa,KACnD,aAAa,OAAO,WAAW,KAC/B,mBAAmB,aAAa,GAAG,SAAS,KAC3C,SAAS,aAAa,QAAQ,SAAS,aAAa;;;AAGjE,SAAQ,gCAAgC"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/handle-empty-in-lists/handle-empty-in-lists.js

@@ -0,0 +1,75 @@
+import { __commonJS } from "../../../../../../../../../_virtual/rolldown_runtime.js";
+import { require_object_utils } from "../../util/object-utils.js";
+import { require_binary_operation_node } from "../../operation-node/binary-operation-node.js";
+import { require_operator_node } from "../../operation-node/operator-node.js";
+import { require_value_list_node } from "../../operation-node/value-list-node.js";
+import { require_value_node } from "../../operation-node/value-node.js";
+import { require_data_type_node } from "../../operation-node/data-type-node.js";
+import { require_cast_node } from "../../operation-node/cast-node.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/handle-empty-in-lists/handle-empty-in-lists.js
+var require_handle_empty_in_lists = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/handle-empty-in-lists/handle-empty-in-lists.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.replaceWithNoncontingentExpression = replaceWithNoncontingentExpression;
+	exports.pushValueIntoList = pushValueIntoList;
+	const binary_operation_node_js_1 = require_binary_operation_node();
+	const cast_node_js_1 = require_cast_node();
+	const data_type_node_js_1 = require_data_type_node();
+	const operator_node_js_1 = require_operator_node();
+	const value_list_node_js_1 = require_value_list_node();
+	const value_node_js_1 = require_value_node();
+	const object_utils_js_1 = require_object_utils();
+	let contradiction;
+	let eq;
+	let one;
+	let tautology;
+	/**
+	* Replaces the `in`/`not in` expression with a noncontingent expression (always true or always
+	* false) depending on the original operator.
+	*
+	* This is how Knex.js, PrismaORM, Laravel, and SQLAlchemy handle `in ()` and `not in ()`.
+	*
+	* See {@link pushValueIntoList} for an alternative strategy.
+	*/
+	function replaceWithNoncontingentExpression(node) {
+		const _one = one ||= value_node_js_1.ValueNode.createImmediate(1);
+		const _eq = eq ||= operator_node_js_1.OperatorNode.create("=");
+		if (node.operator.operator === "in") return contradiction ||= binary_operation_node_js_1.BinaryOperationNode.create(_one, _eq, value_node_js_1.ValueNode.createImmediate(0));
+		return tautology ||= binary_operation_node_js_1.BinaryOperationNode.create(_one, _eq, _one);
+	}
+	let char;
+	let listNull;
+	let listVal;
+	/**
+	* When `in`, pushes a `null` value into the list resulting in `in (null)`. This
+	* is how TypeORM and Sequelize handle `in ()`. `in (null)` is logically the equivalent
+	* of `= null`, which returns `null`, which is a falsy expression in most SQL databases.
+	* We recommend NOT using this strategy if you plan to use `in` in `select`, `returning`,
+	* or `output` clauses, as the return type differs from the `SqlBool` default type.
+	*
+	* When `not in`, casts the left operand as `char` and pushes a literal value into
+	* the list resulting in `cast({{lhs}} as char) not in ({{VALUE}})`. Casting
+	* is required to avoid database errors with non-string columns.
+	*
+	* See {@link replaceWithNoncontingentExpression} for an alternative strategy.
+	*/
+	function pushValueIntoList(uniqueNotInLiteral) {
+		return function pushValueIntoList$1(node) {
+			if (node.operator.operator === "in") return (0, object_utils_js_1.freeze)({
+				...node,
+				rightOperand: listNull ||= value_list_node_js_1.ValueListNode.create([value_node_js_1.ValueNode.createImmediate(null)])
+			});
+			return (0, object_utils_js_1.freeze)({
+				...node,
+				leftOperand: cast_node_js_1.CastNode.create(node.leftOperand, char ||= data_type_node_js_1.DataTypeNode.create("char")),
+				rightOperand: listVal ||= value_list_node_js_1.ValueListNode.create([value_node_js_1.ValueNode.createImmediate(uniqueNotInLiteral)])
+			});
+		};
+	}
+}) });
+
+//#endregion
+export default require_handle_empty_in_lists();
+
+export { require_handle_empty_in_lists };
+//# sourceMappingURL=handle-empty-in-lists.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/handle-empty-in-lists/handle-empty-in-lists.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-empty-in-lists.js","names":["pushValueIntoList"],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/handle-empty-in-lists/handle-empty-in-lists.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.replaceWithNoncontingentExpression = replaceWithNoncontingentExpression;\nexports.pushValueIntoList = pushValueIntoList;\nconst binary_operation_node_js_1 = require(\"../../operation-node/binary-operation-node.js\");\nconst cast_node_js_1 = require(\"../../operation-node/cast-node.js\");\nconst data_type_node_js_1 = require(\"../../operation-node/data-type-node.js\");\nconst operator_node_js_1 = require(\"../../operation-node/operator-node.js\");\nconst value_list_node_js_1 = require(\"../../operation-node/value-list-node.js\");\nconst value_node_js_1 = require(\"../../operation-node/value-node.js\");\nconst object_utils_js_1 = require(\"../../util/object-utils.js\");\nlet contradiction;\nlet eq;\nlet one;\nlet tautology;\n/**\n * Replaces the `in`/`not in` expression with a noncontingent expression (always true or always\n * false) depending on the original operator.\n *\n * This is how Knex.js, PrismaORM, Laravel, and SQLAlchemy handle `in ()` and `not in ()`.\n *\n * See {@link pushValueIntoList} for an alternative strategy.\n */\nfunction replaceWithNoncontingentExpression(node) {\n    const _one = (one ||= value_node_js_1.ValueNode.createImmediate(1));\n    const _eq = (eq ||= operator_node_js_1.OperatorNode.create('='));\n    if (node.operator.operator === 'in') {\n        return (contradiction ||= binary_operation_node_js_1.BinaryOperationNode.create(_one, _eq, value_node_js_1.ValueNode.createImmediate(0)));\n    }\n    return (tautology ||= binary_operation_node_js_1.BinaryOperationNode.create(_one, _eq, _one));\n}\nlet char;\nlet listNull;\nlet listVal;\n/**\n * When `in`, pushes a `null` value into the list resulting in `in (null)`. This\n * is how TypeORM and Sequelize handle `in ()`. `in (null)` is logically the equivalent\n * of `= null`, which returns `null`, which is a falsy expression in most SQL databases.\n * We recommend NOT using this strategy if you plan to use `in` in `select`, `returning`,\n * or `output` clauses, as the return type differs from the `SqlBool` default type.\n *\n * When `not in`, casts the left operand as `char` and pushes a literal value into\n * the list resulting in `cast({{lhs}} as char) not in ({{VALUE}})`. Casting\n * is required to avoid database errors with non-string columns.\n *\n * See {@link replaceWithNoncontingentExpression} for an alternative strategy.\n */\nfunction pushValueIntoList(uniqueNotInLiteral) {\n    return function pushValueIntoList(node) {\n        if (node.operator.operator === 'in') {\n            return (0, object_utils_js_1.freeze)({\n                ...node,\n                rightOperand: (listNull ||= value_list_node_js_1.ValueListNode.create([\n                    value_node_js_1.ValueNode.createImmediate(null),\n                ])),\n            });\n        }\n        return (0, object_utils_js_1.freeze)({\n            ...node,\n            leftOperand: cast_node_js_1.CastNode.create(node.leftOperand, (char ||= data_type_node_js_1.DataTypeNode.create('char'))),\n            rightOperand: (listVal ||= value_list_node_js_1.ValueListNode.create([\n                value_node_js_1.ValueNode.createImmediate(uniqueNotInLiteral),\n            ])),\n        });\n    };\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,qCAAqC;AAC7C,SAAQ,oBAAoB;CAC5B,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACN,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;;;;;;;;;CASJ,SAAS,mCAAmC,MAAM;EAC9C,MAAM,OAAQ,QAAQ,gBAAgB,UAAU,gBAAgB,EAAE;EAClE,MAAM,MAAO,OAAO,mBAAmB,aAAa,OAAO,IAAI;AAC/D,MAAI,KAAK,SAAS,aAAa,KAC3B,QAAQ,kBAAkB,2BAA2B,oBAAoB,OAAO,MAAM,KAAK,gBAAgB,UAAU,gBAAgB,EAAE,CAAC;AAE5I,SAAQ,cAAc,2BAA2B,oBAAoB,OAAO,MAAM,KAAK,KAAK;;CAEhG,IAAI;CACJ,IAAI;CACJ,IAAI;;;;;;;;;;;;;;CAcJ,SAAS,kBAAkB,oBAAoB;AAC3C,SAAO,SAASA,oBAAkB,MAAM;AACpC,OAAI,KAAK,SAAS,aAAa,KAC3B,SAAQ,GAAG,kBAAkB,QAAQ;IACjC,GAAG;IACH,cAAe,aAAa,qBAAqB,cAAc,OAAO,CAClE,gBAAgB,UAAU,gBAAgB,KAAK,CAClD,CAAC;IACL,CAAC;AAEN,WAAQ,GAAG,kBAAkB,QAAQ;IACjC,GAAG;IACH,aAAa,eAAe,SAAS,OAAO,KAAK,aAAc,SAAS,oBAAoB,aAAa,OAAO,OAAO,CAAE;IACzH,cAAe,YAAY,qBAAqB,cAAc,OAAO,CACjE,gBAAgB,UAAU,gBAAgB,mBAAmB,CAChE,CAAC;IACL,CAAC"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/immediate-value/immediate-value-plugin.js

@@ -0,0 +1,33 @@
+import { __commonJS } from "../../../../../../../../../_virtual/rolldown_runtime.js";
+import { require_immediate_value_transformer } from "./immediate-value-transformer.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/immediate-value/immediate-value-plugin.js
+var require_immediate_value_plugin = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/immediate-value/immediate-value-plugin.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ImmediateValuePlugin = void 0;
+	const immediate_value_transformer_js_1 = require_immediate_value_transformer();
+	/**
+	* Transforms all ValueNodes to immediate.
+	*
+	* WARNING! This should never be part of the public API. Users should never use this.
+	* This is an internal helper.
+	*
+	* @internal
+	*/
+	var ImmediateValuePlugin = class {
+		#transformer = new immediate_value_transformer_js_1.ImmediateValueTransformer();
+		transformQuery(args) {
+			return this.#transformer.transformNode(args.node, args.queryId);
+		}
+		transformResult(args) {
+			return Promise.resolve(args.result);
+		}
+	};
+	exports.ImmediateValuePlugin = ImmediateValuePlugin;
+}) });
+
+//#endregion
+export default require_immediate_value_plugin();
+
+export { require_immediate_value_plugin };
+//# sourceMappingURL=immediate-value-plugin.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/immediate-value/immediate-value-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"immediate-value-plugin.js","names":["#transformer"],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/immediate-value/immediate-value-plugin.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ImmediateValuePlugin = void 0;\nconst immediate_value_transformer_js_1 = require(\"./immediate-value-transformer.js\");\n/**\n * Transforms all ValueNodes to immediate.\n *\n * WARNING! This should never be part of the public API. Users should never use this.\n * This is an internal helper.\n *\n * @internal\n */\nclass ImmediateValuePlugin {\n    #transformer = new immediate_value_transformer_js_1.ImmediateValueTransformer();\n    transformQuery(args) {\n        return this.#transformer.transformNode(args.node, args.queryId);\n    }\n    transformResult(args) {\n        return Promise.resolve(args.result);\n    }\n}\nexports.ImmediateValuePlugin = ImmediateValuePlugin;\n"],"x_google_ignoreList":[0],"mappings":";;;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,uBAAuB,KAAK;CACpC,MAAM;;;;;;;;;CASN,IAAM,uBAAN,MAA2B;EACvB,eAAe,IAAI,iCAAiC,2BAA2B;EAC/E,eAAe,MAAM;AACjB,UAAO,MAAKA,YAAa,cAAc,KAAK,MAAM,KAAK,QAAQ;;EAEnE,gBAAgB,MAAM;AAClB,UAAO,QAAQ,QAAQ,KAAK,OAAO;;;AAG3C,SAAQ,uBAAuB"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/immediate-value/immediate-value-transformer.js

@@ -0,0 +1,36 @@
+import { __commonJS } from "../../../../../../../../../_virtual/rolldown_runtime.js";
+import { require_value_list_node } from "../../operation-node/value-list-node.js";
+import { require_value_node } from "../../operation-node/value-node.js";
+import { require_operation_node_transformer } from "../../operation-node/operation-node-transformer.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/immediate-value/immediate-value-transformer.js
+var require_immediate_value_transformer = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/immediate-value/immediate-value-transformer.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ImmediateValueTransformer = void 0;
+	const operation_node_transformer_js_1 = require_operation_node_transformer();
+	const value_list_node_js_1 = require_value_list_node();
+	const value_node_js_1 = require_value_node();
+	/**
+	* Transforms all ValueNodes to immediate.
+	*
+	* WARNING! This should never be part of the public API. Users should never use this.
+	* This is an internal helper.
+	*
+	* @internal
+	*/
+	var ImmediateValueTransformer = class extends operation_node_transformer_js_1.OperationNodeTransformer {
+		transformPrimitiveValueList(node) {
+			return value_list_node_js_1.ValueListNode.create(node.values.map(value_node_js_1.ValueNode.createImmediate));
+		}
+		transformValue(node) {
+			return value_node_js_1.ValueNode.createImmediate(node.value);
+		}
+	};
+	exports.ImmediateValueTransformer = ImmediateValueTransformer;
+}) });
+
+//#endregion
+export default require_immediate_value_transformer();
+
+export { require_immediate_value_transformer };
+//# sourceMappingURL=immediate-value-transformer.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/immediate-value/immediate-value-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"immediate-value-transformer.js","names":[],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/immediate-value/immediate-value-transformer.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ImmediateValueTransformer = void 0;\nconst operation_node_transformer_js_1 = require(\"../../operation-node/operation-node-transformer.js\");\nconst value_list_node_js_1 = require(\"../../operation-node/value-list-node.js\");\nconst value_node_js_1 = require(\"../../operation-node/value-node.js\");\n/**\n * Transforms all ValueNodes to immediate.\n *\n * WARNING! This should never be part of the public API. Users should never use this.\n * This is an internal helper.\n *\n * @internal\n */\nclass ImmediateValueTransformer extends operation_node_transformer_js_1.OperationNodeTransformer {\n    transformPrimitiveValueList(node) {\n        return value_list_node_js_1.ValueListNode.create(node.values.map(value_node_js_1.ValueNode.createImmediate));\n    }\n    transformValue(node) {\n        return value_node_js_1.ValueNode.createImmediate(node.value);\n    }\n}\nexports.ImmediateValueTransformer = ImmediateValueTransformer;\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,4BAA4B,KAAK;CACzC,MAAM;CACN,MAAM;CACN,MAAM;;;;;;;;;CASN,IAAM,4BAAN,cAAwC,gCAAgC,yBAAyB;EAC7F,4BAA4B,MAAM;AAC9B,UAAO,qBAAqB,cAAc,OAAO,KAAK,OAAO,IAAI,gBAAgB,UAAU,gBAAgB,CAAC;;EAEhH,eAAe,MAAM;AACjB,UAAO,gBAAgB,UAAU,gBAAgB,KAAK,MAAM;;;AAGpE,SAAQ,4BAA4B"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/kysely-plugin.js

@@ -0,0 +1,12 @@
+import { __commonJS } from "../../../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/kysely-plugin.js
+var require_kysely_plugin = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/kysely-plugin.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+}) });
+
+//#endregion
+export default require_kysely_plugin();
+
+export { require_kysely_plugin };
+//# sourceMappingURL=kysely-plugin.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/kysely-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kysely-plugin.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/plugin/kysely-plugin.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n"],"x_google_ignoreList":[0],"mappings":";;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC"}