@prisma/orm-target-sqlite 8.0.0-rc.2-dev.2 → 8.0.0-rc.20-dev.1

package/dist/codecs-yZoH21Yj-lQXtGlEq.mjs

@@ -0,0 +1,618 @@
+import { a as SQLITE_INTEGER_CODEC_ID, c as SQLITE_TEXT_CODEC_ID, i as SQLITE_DATETIME_CODEC_ID, n as SQLITE_BIGINT_NUMBER_CODEC_ID, o as SQLITE_JSON_CODEC_ID, r as SQLITE_BLOB_CODEC_ID, s as SQLITE_REAL_CODEC_ID, t as SQLITE_BIGINT_CODEC_ID } from "./codec-ids-wgEvkCkg-WltuexMR.mjs";
+import { a as sqliteCodec, r as defineSqliteCodecs, t as SqliteCodecDescriptor } from "./codec-descriptor-DRmF-crq-BALI5Jtz.mjs";
+import { a as sqliteCharacterVarying, d as sqliteReal, f as sqliteText, l as sqliteInteger, r as sqliteCharacter, s as sqliteDatetime, t as sqliteBlob, u as sqliteJson } from "./data-types-coQrCWfS-yMCe4F52.mjs";
+import { n as sqliteError } from "./errors-DnR-sMHS-D_gh214a.mjs";
+import { BinaryExpr, CaseExpr, CastExpr, FunctionCallExpr, LiteralExpr, SqlCharCodec, SqlFloatCodec, SqlIntCodec, SqlRawCodec, SqlVarcharCodec, sqlCharDescriptor, sqlFloatDescriptor, sqlIntDescriptor, sqlRawDescriptor, sqlVarcharDescriptor } from "@prisma/orm-family-sql/relational-core/ast";
+import { CodecImpl, SAFE_INTEGER_BIGINT_RANGE, column, decimalTextBigintLiteral, decimalTextNumberLiteral, floatNumberLiteral, floatToJson, readJsonFloat, readJsonIntegerText, refuseJsonValue, renderTsLiteral } from "@prisma/orm-framework/components/codec";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { sqlRawDataType } from "@prisma/orm-family-sql/contract/data-type";
+//#region ../../../3-targets/sqlite/1-target/dist/codecs-yZoH21Yj.mjs
+/**
+* Projects the expression unchanged, for codecs whose canonical JSON is what
+* SQLite's own JSON conversion already produces.
+*
+* Identity here is a claim about the target's behaviour, not an absence of one:
+* the codec's conformance cases are what test it, including at the boundaries
+* of the representation where a native conversion would be most likely to
+* diverge.
+*/
+const identityJsonProjection = (expression) => expression;
+/**
+* Projects an integer-valued expression as decimal text.
+*
+* The cast is part of the projected expression, so it applies before the JSON
+* constructor sees the value: handed an INTEGER directly, the constructor emits
+* a JSON number, and SQLite's 64-bit range does not survive being read back as
+* a double. Casting the constructor's result would be too late.
+*/
+const decimalTextJsonProjection = (expression) => CastExpr.as(expression, "TEXT");
+/**
+* Projects a blob as a one-element array of its hexadecimal text.
+*
+* SQLite's JSON functions reject a BLOB argument outright, so the encoding has to replace the native
+* conversion rather than post-process it. `hex()` emits uppercase and never wraps. The array is what
+* tells a blob from text: outside a STRICT table a BLOB column may hold text, which passes through as
+* text, as a row carries it, and so does NULL and any other value.
+*/
+const hexJsonProjection = (expression) => CaseExpr.of([{
+	condition: BinaryExpr.eq(FunctionCallExpr.of("typeof", [expression]), LiteralExpr.of("blob")),
+	value: FunctionCallExpr.of("json_array", [FunctionCallExpr.of("hex", [expression])])
+}], expression);
+/**
+* Projects a REAL as SQLite writes it in JSON, except an infinity, which SQLite writes as `9.0e+999` and which becomes the text `Infinity` or `-Infinity` that the codec stores. The test is equality with an infinity, so text or a blob that a REAL column holds outside a STRICT table passes through unchanged.
+*/
+const floatJsonProjection = (expression) => CaseExpr.of([{
+	condition: BinaryExpr.eq(expression, LiteralExpr.of(Number.POSITIVE_INFINITY)),
+	value: LiteralExpr.of("Infinity")
+}, {
+	condition: BinaryExpr.eq(expression, LiteralExpr.of(Number.NEGATIVE_INFINITY)),
+	value: LiteralExpr.of("-Infinity")
+}], expression);
+const JSON_RETAG_FN = "json";
+/**
+* Re-applies SQLite's JSON subtype to a document-valued expression.
+*
+* SQLite carries "this text is JSON" as a subtype on the value rather than in
+* its type, and the subtype does not survive a derived table: a document that
+* `json_object` produced arrives one level out as plain text, so the enclosing
+* constructor embeds it as a *string containing JSON* rather than as a
+* document. `json()` re-applies the subtype, which is what makes the value nest
+* as a document again.
+*
+* The loss happens at the first derived-table boundary and does not compound, so
+* a retag is needed where the document is consumed rather than at every level it
+* passes through.
+*
+* Applying this twice is a no-op — SQLite's `json()` is idempotent, and the
+* wrapper collapses rather than nesting so the rendered SQL says so too. It is
+* safe on any valid JSON text, including scalars, and on NULL; it raises
+* `malformed JSON` on text that is not JSON, which is the correct failure for a
+* value that was never a document.
+*/
+const jsonDocumentRetag = (expression) => isJsonRetag(expression) ? expression : FunctionCallExpr.of(JSON_RETAG_FN, [expression]);
+/** Whether an expression is already a retag, so applying one again would only nest. */
+const isJsonRetag = (expression) => expression instanceof FunctionCallExpr && expression.fn === JSON_RETAG_FN && expression.args.length === 1;
+const DECIMAL_INTEGER = /^-?\d+$/;
+/** Renders the document a `sqlite/json` value's JSON text holds, when it is a string, number or boolean, and nothing for text that is not JSON. */
+function jsonTextLiteral(value) {
+	if (typeof value !== "string") return void 0;
+	try {
+		return renderTsLiteral(JSON.parse(value));
+	} catch {
+		return;
+	}
+}
+/**
+* SQLite stores an infinity but not NaN, which it turns into NULL, so a float codec on SQLite refuses NaN wherever it writes a value: to a parameter, and to the contract.
+*/
+function refuseNaN(codecId, value) {
+	if (Number.isNaN(value)) throw sqliteError("RUNTIME.ENCODE_FAILED", `${codecId} value must be a number other than NaN, which SQLite cannot store`, { meta: {
+		codecId,
+		received: "NaN"
+	} });
+	return value;
+}
+/** Reads a float's JSON form, which on SQLite has no NaN. */
+function readJsonFloatWithoutNaN(codecId, json) {
+	const value = readJsonFloat(codecId, json);
+	if (Number.isNaN(value)) return refuseJsonValue(codecId, "a finite number or the text Infinity or -Infinity; SQLite cannot store NaN", json);
+	return value;
+}
+/** `sql/float@1` as SQLite stores it: without NaN. */
+var SqliteFloatCodec = class extends SqlFloatCodec {
+	async toWire(value, ctx) {
+		return super.toWire(refuseNaN(this.id, value), ctx);
+	}
+	async fromWire(wire, _ctx) {
+		return floatWire(this.id, wire);
+	}
+	fromDataTypeValue(value) {
+		return readJsonFloatWithoutNaN(this.id, value.value);
+	}
+	toDataTypeValue(input) {
+		return super.toDataTypeValue(refuseNaN(this.id, input));
+	}
+};
+/**
+* Requires an application value to be of the JS type the codec reads.
+*
+* A range check reads a value of the wrong type as a value out of range, and
+* reports a number plainly inside the range as outside it — so the type is
+* established first and answered for on its own terms, naming what a caller
+* has to change.
+*/
+const requireJsType = (codecId, expected, value) => {
+	if (typeof value === expected) return;
+	throw sqliteError("RUNTIME.ENCODE_FAILED", `${codecId} value must be a ${expected}, got ${typeof value} ${String(value)}`, { meta: {
+		codecId,
+		received: typeof value
+	} });
+};
+/**
+* Writes an application value as the decimal text `sqlite/bigint@1` carries as
+* its canonical JSON.
+*
+* A schema-written literal default (`BigInt @default(0)`) arrives here as a
+* `number`, since a number literal is the only integer a schema language
+* writes, and one that is a safe integer names its value exactly. Past that
+* range the literal was rounded before any of this ran, so the value written is
+* not the value meant — which this refuses rather than minting an exact-looking
+* value from it. A non-integral number is refused on the same terms.
+*/
+const bigintEncodeJson = (codecId, value) => {
+	if (typeof value !== "number") {
+		requireJsType(codecId, "bigint", value);
+		return value.toString();
+	}
+	if (!Number.isSafeInteger(value)) throw sqliteError("RUNTIME.ENCODE_FAILED", `${codecId} number literal must be an integer within the safe integer range, got ${String(value)}`, { meta: {
+		codecId,
+		received: String(value)
+	} });
+	return BigInt(value).toString();
+};
+/**
+* Requires an integer within ±(2^53 − 1), the range a JS `number` holds
+* exactly. The guard throws rather than rounding: past the boundary a `number`
+* silently loses digits, which is the failure mode these codecs exist to refuse.
+*/
+const safeIntegerNumber = (codecId, value, code) => {
+	if (!Number.isSafeInteger(value)) throw sqliteError(code, `${codecId} value must be an integer within the safe integer range, got ${String(value)}`, { meta: {
+		codecId,
+		received: String(value)
+	} });
+	if (Object.is(value, -0)) return 0;
+	return value;
+};
+/** The application value a number-flavoured integer codec writes: the JS type it reads, within the range that type holds exactly. */
+const encodableSafeInteger = (codecId, value) => {
+	requireJsType(codecId, "number", value);
+	return safeIntegerNumber(codecId, value, "RUNTIME.ENCODE_FAILED");
+};
+/**
+* Converts an exact `bigint` into a safe-range `number`, comparing before any
+* conversion so an out-of-range value throws rather than rounds.
+*/
+const safeIntegerFromBigint = (codecId, value) => {
+	if (value < SAFE_INTEGER_BIGINT_RANGE.min || value > SAFE_INTEGER_BIGINT_RANGE.max) throw sqliteError("RUNTIME.DECODE_FAILED", `${codecId} value must be an integer within the safe integer range, got ${value}`, { meta: {
+		codecId,
+		received: value.toString()
+	} });
+	return Number(value);
+};
+/** `sqlite/integer`'s stored form, read into a `number`: digit text within the safe integer range. */
+const safeIntegerFromDigitText = (codecId, json) => Number(readJsonIntegerText(codecId, json, SAFE_INTEGER_BIGINT_RANGE));
+/** A `number` written as `sqlite/integer`'s stored form. */
+const digitTextOfSafeInteger = (codecId, value) => String(encodableSafeInteger(codecId, value));
+/**
+* Reads an INTEGER's wire value into a `number`: the number the driver returns for a row, or the decimal text an include carries, because its projection casts the integer to text so that no digit is lost in JSON.
+*/
+function safeIntegerWire(codecId, wire) {
+	if (typeof wire === "number") return wire;
+	if (!DECIMAL_INTEGER.test(wire)) throw sqliteError("RUNTIME.DECODE_FAILED", `${codecId} wire value must be an integer or its decimal text`, { meta: {
+		codecId,
+		received: wire
+	} });
+	return safeIntegerFromBigint(codecId, BigInt(wire));
+}
+/**
+* Reads a REAL's wire value: the number the driver returns for a row, or the text `Infinity` or `-Infinity` an include carries, because JSON has no infinity.
+*/
+function floatWire(codecId, wire) {
+	if (typeof wire === "number") return wire;
+	if (wire === "Infinity") return Number.POSITIVE_INFINITY;
+	if (wire === "-Infinity") return Number.NEGATIVE_INFINITY;
+	throw sqliteError("RUNTIME.DECODE_FAILED", `${codecId} wire value must be a number, or the text Infinity or -Infinity`, { meta: {
+		codecId,
+		received: wire
+	} });
+}
+/** The hex text SQLite's `hex()` writes: two uppercase digits for each byte. */
+const BLOB_HEX_TEXT = /^(?:[0-9A-F]{2})*$/;
+/**
+* Projects a `sql/char@1` value without trailing spaces, as its `decode` reads it on a flat read, so an include reads the same value. SQLite does not pad the value; the rule is the family codec's.
+*/
+const unpaddedCharJsonProjection = (expression) => FunctionCallExpr.of("rtrim", [expression, LiteralExpr.of(" ")]);
+const sqliteSqlCharDescriptor = sqliteCodec(sqlCharDescriptor, {
+	dataType: sqliteCharacter,
+	renderValueLiteral: renderTsLiteral,
+	jsonProjection: unpaddedCharJsonProjection,
+	factory: (descriptor, dataType, params) => () => new SqlCharCodec(descriptor, dataType, params)
+});
+const sqliteSqlVarcharDescriptor = sqliteCodec(sqlVarcharDescriptor, {
+	dataType: sqliteCharacterVarying,
+	renderValueLiteral: renderTsLiteral,
+	jsonProjection: identityJsonProjection,
+	factory: (descriptor, dataType, params) => () => new SqlVarcharCodec(descriptor, dataType, params)
+});
+/**
+* `sql/raw@1` as SQLite reads it: a value keeps the shape the driver returns for its storage class. An include carries a BLOB as the array of its hex text that the projection writes, because SQLite's JSON functions refuse a blob; a column value never reaches the JSON constructor as an array, so the array is a BLOB.
+*/
+var SqliteSqlRawCodec = class extends SqlRawCodec {
+	async fromWire(wire, _ctx) {
+		if (!Array.isArray(wire)) return wire;
+		const [hex] = wire.length === 1 ? wire : [];
+		if (typeof hex !== "string" || !BLOB_HEX_TEXT.test(hex)) throw sqliteError("RUNTIME.DECODE_FAILED", `${this.id} wire value in an include must be the array of a BLOB's hex text`, { meta: {
+			codecId: this.id,
+			received: String(wire)
+		} });
+		return new Uint8Array(Buffer.from(hex, "hex"));
+	}
+};
+const sqliteSqlRawDescriptor = sqliteCodec(sqlRawDescriptor, {
+	dataType: sqlRawDataType,
+	jsonProjection: hexJsonProjection,
+	factory: (descriptor, dataType, params) => () => new SqliteSqlRawCodec(descriptor, dataType, params)
+});
+/** `sql/int@1` as SQLite stores it: its stored form is `sqlite/integer`'s digit text. */
+var SqliteSqlIntCodec = class extends SqlIntCodec {
+	async fromWire(wire, _ctx) {
+		return safeIntegerWire(this.id, wire);
+	}
+	fromDataTypeValue(value) {
+		return safeIntegerFromDigitText(this.id, value.value);
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(digitTextOfSafeInteger(this.id, input));
+	}
+};
+const sqliteSqlIntDescriptor = sqliteCodec(sqlIntDescriptor, {
+	dataType: sqliteInteger,
+	renderValueLiteral: decimalTextNumberLiteral,
+	jsonProjection: decimalTextJsonProjection,
+	factory: (descriptor, dataType) => () => new SqliteSqlIntCodec(descriptor, dataType)
+});
+const sqliteSqlFloatDescriptor = sqliteCodec(sqlFloatDescriptor, {
+	dataType: sqliteReal,
+	renderValueLiteral: floatNumberLiteral,
+	jsonProjection: floatJsonProjection,
+	factory: (descriptor, dataType) => () => new SqliteFloatCodec(descriptor, dataType)
+});
+var SqliteTextCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		return value;
+	}
+	async fromWire(wire, _ctx) {
+		return wire;
+	}
+	fromDataTypeValue(value) {
+		return value.value;
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(input);
+	}
+};
+var SqliteTextDescriptor = class extends SqliteCodecDescriptor {
+	jsonProjection(expression) {
+		return expression;
+	}
+	dataType = sqliteText.id;
+	codecId = SQLITE_TEXT_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"textual"
+	];
+	paramsSchema = void 0;
+	renderValueLiteral(value) {
+		return renderTsLiteral(value);
+	}
+	factory() {
+		return () => new SqliteTextCodec(this, sqliteText);
+	}
+};
+const sqliteTextDescriptor = new SqliteTextDescriptor();
+const sqliteTextColumn = () => column(sqliteTextDescriptor.factory(), sqliteTextDescriptor.codecId, void 0);
+var SqliteIntegerCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		return value;
+	}
+	async fromWire(wire, _ctx) {
+		return safeIntegerWire(SQLITE_INTEGER_CODEC_ID, wire);
+	}
+	fromDataTypeValue(value) {
+		return safeIntegerFromDigitText(SQLITE_INTEGER_CODEC_ID, value.value);
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(digitTextOfSafeInteger(SQLITE_INTEGER_CODEC_ID, input));
+	}
+};
+var SqliteIntegerDescriptor = class extends SqliteCodecDescriptor {
+	jsonProjection(expression) {
+		return decimalTextJsonProjection(expression);
+	}
+	dataType = sqliteInteger.id;
+	codecId = SQLITE_INTEGER_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	paramsSchema = void 0;
+	renderValueLiteral(value) {
+		return decimalTextNumberLiteral(value);
+	}
+	factory() {
+		return () => new SqliteIntegerCodec(this, sqliteInteger);
+	}
+};
+const sqliteIntegerDescriptor = new SqliteIntegerDescriptor();
+const sqliteIntegerColumn = () => column(sqliteIntegerDescriptor.factory(), sqliteIntegerDescriptor.codecId, void 0);
+var SqliteRealCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		return refuseNaN(SQLITE_REAL_CODEC_ID, value);
+	}
+	async fromWire(wire, _ctx) {
+		return floatWire(SQLITE_REAL_CODEC_ID, wire);
+	}
+	fromDataTypeValue(value) {
+		return readJsonFloatWithoutNaN(SQLITE_REAL_CODEC_ID, value.value);
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(floatToJson(refuseNaN(SQLITE_REAL_CODEC_ID, input)));
+	}
+};
+var SqliteRealDescriptor = class extends SqliteCodecDescriptor {
+	jsonProjection(expression) {
+		return floatJsonProjection(expression);
+	}
+	dataType = sqliteReal.id;
+	codecId = SQLITE_REAL_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	paramsSchema = void 0;
+	renderValueLiteral(value) {
+		return floatNumberLiteral(value);
+	}
+	factory() {
+		return () => new SqliteRealCodec(this, sqliteReal);
+	}
+};
+const sqliteRealDescriptor = new SqliteRealDescriptor();
+const sqliteRealColumn = () => column(sqliteRealDescriptor.factory(), sqliteRealDescriptor.codecId, void 0);
+var SqliteBlobCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		return value;
+	}
+	/** A row carries the blob's bytes; an include carries the array of their hex text that its projection writes, because SQLite's JSON functions refuse a blob. Anything else a BLOB column holds is refused. */
+	async fromWire(wire, _ctx) {
+		if (wire instanceof Uint8Array) return wire;
+		const [hex] = Array.isArray(wire) && wire.length === 1 ? wire : [];
+		if (typeof hex !== "string" || !BLOB_HEX_TEXT.test(hex)) throw sqliteError("RUNTIME.DECODE_FAILED", "sqlite/blob@1 wire value must be bytes, or the array of their hex text an include carries", { meta: {
+			codecId: SQLITE_BLOB_CODEC_ID,
+			received: String(wire)
+		} });
+		return new Uint8Array(Buffer.from(hex, "hex"));
+	}
+	fromDataTypeValue(value) {
+		return new Uint8Array(Buffer.from(value.value, "hex"));
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(Buffer.from(input).toString("hex").toUpperCase());
+	}
+};
+var SqliteBlobDescriptor = class extends SqliteCodecDescriptor {
+	jsonProjection(expression) {
+		return hexJsonProjection(expression);
+	}
+	dataType = sqliteBlob.id;
+	codecId = SQLITE_BLOB_CODEC_ID;
+	traits = ["equality"];
+	paramsSchema = void 0;
+	factory() {
+		return () => new SqliteBlobCodec(this, sqliteBlob);
+	}
+};
+const sqliteBlobDescriptor = new SqliteBlobDescriptor();
+const sqliteBlobColumn = () => column(sqliteBlobDescriptor.factory(), sqliteBlobDescriptor.codecId, void 0);
+/**
+* Reads what SQLite holds for an instant as `Date` reads it, with text without a UTC offset read as UTC, as SQLite's own date and time functions read it, never in the machine's time zone. A number is milliseconds since 1970, as the Prisma ORM query engine wrote a `DateTime`. Digits below a millisecond are cut, as `Date` cuts them.
+*/
+function decodeSqliteDatetime(value) {
+	const date = new Date(typeof value === "number" ? value : asUtcWhenUnmarked(value));
+	if (Number.isNaN(date.getTime())) throw sqliteError("RUNTIME.DECODE_FAILED", `sqlite/datetime@1 wire value must be a date and time as text, or a number of milliseconds since 1970: ${String(value)}`, { meta: {
+		codecId: SQLITE_DATETIME_CODEC_ID,
+		received: String(value)
+	} });
+	return date;
+}
+const DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+const DATE_TIME_WITHOUT_OFFSET = /^(\d{4}-\d{2}-\d{2})[Tt ](\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)$/;
+/** A date alone as its midnight in UTC, and a date and time without an offset as UTC. */
+function asUtcWhenUnmarked(text) {
+	if (DATE_ONLY.test(text)) return `${text}T00:00:00Z`;
+	const unmarked = DATE_TIME_WITHOUT_OFFSET.exec(text);
+	return unmarked === null ? text : `${unmarked[1]}T${unmarked[2]}Z`;
+}
+/** The text SQLite holds for an instant: what the codec writes for every row, and for a default. */
+function encodeSqliteDatetime(value) {
+	return value.toISOString();
+}
+var SqliteDatetimeCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		return encodeSqliteDatetime(value);
+	}
+	async fromWire(wire, _ctx) {
+		return decodeSqliteDatetime(wire);
+	}
+	fromDataTypeValue(value) {
+		return new Date(value.value);
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(input.toISOString());
+	}
+};
+var SqliteDatetimeDescriptor = class extends SqliteCodecDescriptor {
+	jsonProjection(expression) {
+		return expression;
+	}
+	dataType = sqliteDatetime.id;
+	codecId = SQLITE_DATETIME_CODEC_ID;
+	traits = ["equality", "order"];
+	paramsSchema = void 0;
+	factory() {
+		return () => new SqliteDatetimeCodec(this, sqliteDatetime);
+	}
+};
+const sqliteDatetimeDescriptor = new SqliteDatetimeDescriptor();
+const sqliteDatetimeColumn = () => column(sqliteDatetimeDescriptor.factory(), sqliteDatetimeDescriptor.codecId, void 0);
+var SqliteJsonCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		return JSON.stringify(value);
+	}
+	async fromWire(wire, _ctx) {
+		return typeof wire === "string" ? blindCast(JSON.parse(wire)) : wire;
+	}
+	fromDataTypeValue(value) {
+		return blindCast(JSON.parse(value.value));
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(JSON.stringify(input));
+	}
+};
+/**
+* The column stores the document's JSON text and the stored form is that text, so the stored
+* value is projected as it is: a string the enclosing JSON constructor embeds as a string.
+*/
+var SqliteJsonDescriptor = class extends SqliteCodecDescriptor {
+	jsonProjection(expression) {
+		return expression;
+	}
+	dataType = sqliteJson.id;
+	codecId = SQLITE_JSON_CODEC_ID;
+	traits = ["equality"];
+	paramsSchema = void 0;
+	renderValueLiteral(value) {
+		return jsonTextLiteral(value);
+	}
+	factory() {
+		return () => new SqliteJsonCodec(this, sqliteJson);
+	}
+};
+const sqliteJsonDescriptor = new SqliteJsonDescriptor();
+const sqliteJsonColumn = () => column(sqliteJsonDescriptor.factory(), sqliteJsonDescriptor.codecId, void 0);
+var SqliteBigintCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		requireJsType(SQLITE_BIGINT_CODEC_ID, "bigint", value);
+		return value;
+	}
+	/**
+	* The wire value is text wherever the value could outrun a JS number: an
+	* aggregate SQLite computes leaves the database through the descriptor's cast
+	* to text, because the driver reads an integer no number can hold as an error
+	* rather than a value. A number-typed wire value must therefore be a safe
+	* integer — past ±(2^53 − 1) it has already rounded, and converting it would
+	* mint a spuriously-exact `bigint` that need not equal the stored value.
+	*/
+	async fromWire(wire, _ctx) {
+		if (typeof wire === "number" && !Number.isSafeInteger(wire)) throw sqliteError("RUNTIME.DECODE_FAILED", `sqlite/bigint@1 wire number must be an integer within the safe integer range, got ${String(wire)}`, { meta: {
+			codecId: SQLITE_BIGINT_CODEC_ID,
+			received: String(wire)
+		} });
+		if (typeof wire === "string" && !DECIMAL_INTEGER.test(wire)) throw sqliteError("RUNTIME.DECODE_FAILED", "sqlite/bigint@1 wire value must be a decimal string", { meta: {
+			codecId: SQLITE_BIGINT_CODEC_ID,
+			received: wire
+		} });
+		return BigInt(wire);
+	}
+	fromDataTypeValue(value) {
+		return BigInt(value.value);
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(bigintEncodeJson(SQLITE_BIGINT_CODEC_ID, input));
+	}
+};
+var SqliteBigintDescriptor = class extends SqliteCodecDescriptor {
+	jsonProjection(expression) {
+		return decimalTextJsonProjection(expression);
+	}
+	dataType = sqliteInteger.id;
+	codecId = SQLITE_BIGINT_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	paramsSchema = void 0;
+	renderValueLiteral(value) {
+		return decimalTextBigintLiteral(value);
+	}
+	factory() {
+		return () => new SqliteBigintCodec(this, sqliteInteger);
+	}
+};
+const sqliteBigintDescriptor = new SqliteBigintDescriptor();
+const sqliteBigintColumn = () => column(sqliteBigintDescriptor.factory(), sqliteBigintDescriptor.codecId, void 0);
+/**
+* A SQLite INTEGER decoded as a JS `number`, for columns whose values stay
+* within the safe integer range ±(2^53 − 1). Both directions guard rather than
+* round: decode (wire and JSON) and encode throw a structured error on
+* out-of-range or non-integral input. The canonical JSON is the decimal text
+* `sqlite/integer` carries, which every codec of that data type shares.
+*/
+var SqliteBigintNumberCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		return encodableSafeInteger(SQLITE_BIGINT_NUMBER_CODEC_ID, value);
+	}
+	/**
+	* The driver hands an INTEGER over as a `number` or, in safe-integer mode, a
+	* `bigint`; a bigint (or decimal text) is range-checked exactly before any
+	* conversion to `number`, so an out-of-range value throws rather than rounds.
+	*/
+	async fromWire(wire, _ctx) {
+		if (typeof wire === "number") return safeIntegerNumber(SQLITE_BIGINT_NUMBER_CODEC_ID, wire, "RUNTIME.DECODE_FAILED");
+		if (typeof wire === "string" && !DECIMAL_INTEGER.test(wire)) throw sqliteError("RUNTIME.DECODE_FAILED", "sqlite/bigintnumber@1 wire value must be a decimal string", { meta: {
+			codecId: SQLITE_BIGINT_NUMBER_CODEC_ID,
+			received: wire
+		} });
+		return safeIntegerFromBigint(SQLITE_BIGINT_NUMBER_CODEC_ID, BigInt(wire));
+	}
+	fromDataTypeValue(value) {
+		return safeIntegerFromDigitText(SQLITE_BIGINT_NUMBER_CODEC_ID, value.value);
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(digitTextOfSafeInteger(SQLITE_BIGINT_NUMBER_CODEC_ID, input));
+	}
+};
+var SqliteBigintNumberDescriptor = class extends SqliteCodecDescriptor {
+	jsonProjection(expression) {
+		return decimalTextJsonProjection(expression);
+	}
+	dataType = sqliteInteger.id;
+	codecId = SQLITE_BIGINT_NUMBER_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	paramsSchema = void 0;
+	renderValueLiteral(value) {
+		return decimalTextNumberLiteral(value);
+	}
+	factory() {
+		return () => new SqliteBigintNumberCodec(this, sqliteInteger);
+	}
+};
+const sqliteBigintNumberDescriptor = new SqliteBigintNumberDescriptor();
+const sqliteBigintNumberColumn = () => column(sqliteBigintNumberDescriptor.factory(), sqliteBigintNumberDescriptor.codecId, void 0);
+const codecDescriptors = defineSqliteCodecs([
+	sqliteSqlCharDescriptor,
+	sqliteSqlVarcharDescriptor,
+	sqliteSqlIntDescriptor,
+	sqliteSqlFloatDescriptor,
+	sqliteSqlRawDescriptor,
+	sqliteTextDescriptor,
+	sqliteIntegerDescriptor,
+	sqliteRealDescriptor,
+	sqliteBlobDescriptor,
+	sqliteDatetimeDescriptor,
+	sqliteJsonDescriptor,
+	sqliteBigintDescriptor,
+	sqliteBigintNumberDescriptor
+]);
+//#endregion
+export { sqliteBigintNumberColumn as a, sqliteIntegerColumn as c, sqliteTextColumn as d, sqliteBigintColumn as i, sqliteJsonColumn as l, encodeSqliteDatetime as n, sqliteBlobColumn as o, jsonDocumentRetag as r, sqliteDatetimeColumn as s, codecDescriptors as t, sqliteRealColumn as u };
+
+//# sourceMappingURL=codecs-yZoH21Yj-lQXtGlEq.mjs.map