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

package/dist/data-types-hoKLBrYZ-h9cAgbOy.mjs

@@ -0,0 +1,624 @@
+import { r as MONGO_BSON_CODEC_ID } from "./codec-ids-WdrumsYA-CZVjuKW8.mjs";
+import { t as mongoTargetError } from "./mongo-target-errors-Btf3ML1w-QOtEG7EX.mjs";
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { INT32_RANGE, INT64_RANGE, SAFE_INTEGER_BIGINT_RANGE, SAFE_INTEGER_RANGE, asFloat, asNumeralText, castUnchanged, decimalTextEqualityKey, isIntegerIn, readJsonBoolean, readJsonFloat, readJsonInteger, readJsonIntegerText, readJsonMatching, readJsonString, refuseJsonValue, refuseWrongShape } from "@prisma/orm-framework/components/codec";
+import { counted } from "@prisma/orm-framework/utils/text";
+import { Binary, Code, Decimal128, Double, EJSON, Long, MinKey, ObjectId } from "bson";
+import { mongoDataType } from "@prisma/orm-family-mongo/contract/data-type";
+import { type } from "arktype";
+import { isDeepStrictEqual } from "node:util";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+//#region ../../../3-targets/mongo/1-target/dist/data-types-hoKLBrYZ.mjs
+const STORED_DECIMAL_TEXT = /^(?:-?\d+(?:\.\d+)?|NaN|-?Infinity)$/;
+const DECIMAL128_TEXT = /^(-?)(\d+)(?:\.(\d+))?(?:E([+-]\d+))?$/;
+const BASE64_TEXT = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+/**
+* Checks the BSON type tag rather than `instanceof`: the driver deserialises with its own load of `bson` (CommonJS, where this module may be loaded as ESM), so a value read from the database need not be an instance of the class imported here.
+*/
+function hasBsonTypeTag(value, tag) {
+	return typeof value === "object" && value !== null && "_bsontype" in value && value._bsontype === tag;
+}
+function isLong(value) {
+	return hasBsonTypeTag(value, "Long");
+}
+function isDecimal128(value) {
+	return hasBsonTypeTag(value, "Decimal128");
+}
+function isBinary(value) {
+	return hasBsonTypeTag(value, "Binary");
+}
+function decodeFailed(codecId, message, received) {
+	throw mongoTargetError("RUNTIME.DECODE_FAILED", `${codecId} ${message}`, { meta: {
+		codecId,
+		received: typeof received
+	} });
+}
+const RECEIVED_PREVIEW_LIMIT = 100;
+function encodeFailed(codecId, message, received) {
+	throw mongoTargetError("RUNTIME.ENCODE_FAILED", `${codecId} ${message}`, { meta: {
+		codecId,
+		received: String(received).slice(0, RECEIVED_PREVIEW_LIMIT)
+	} });
+}
+function describeReceived(value) {
+	if (typeof value === "number") return String(value);
+	if (typeof value === "bigint") return `${value}n`;
+	if (typeof value === "string") return `string ${JSON.stringify(value.slice(0, RECEIVED_PREVIEW_LIMIT))}`;
+	if (value === null) return "null";
+	if (value instanceof Date) return Number.isNaN(value.getTime()) ? "an invalid Date" : "a Date";
+	if (Array.isArray(value)) return "an array";
+	return typeof value;
+}
+function refuseType(codecId, expected, value, received = describeReceived(value)) {
+	return encodeFailed(codecId, `value must be ${expected}; received ${received}`, value);
+}
+function stringEncode(codecId, value) {
+	if (typeof value !== "string") refuseType(codecId, "a string", value);
+	return value;
+}
+function booleanEncode(codecId, value) {
+	if (typeof value !== "boolean") refuseType(codecId, "a boolean", value);
+	return value;
+}
+/**
+* The driver writes an invalid `Date` as the epoch, so one is refused with any other non-`Date` value.
+*/
+function dateEncode(codecId, value) {
+	if (!(value instanceof Date) || Number.isNaN(value.getTime())) refuseType(codecId, "a valid Date", value);
+	return value;
+}
+const OBJECT_ID_TEXT = /^[0-9a-fA-F]{24}$/;
+function hexStringOf(value) {
+	const toHexString = Reflect.get(value, "toHexString");
+	if (typeof toHexString !== "function") return void 0;
+	const hex = Reflect.apply(toHexString, value, []);
+	return typeof hex === "string" && OBJECT_ID_TEXT.test(hex) ? hex : void 0;
+}
+/**
+* `new ObjectId(...)` makes a fresh id from `null` or `undefined` and reads a number as a timestamp, so only a string, which the constructor accepts only as 24 hex digits, or an `ObjectId` is passed to it. An `ObjectId` is rebuilt from its hex string, so one from any major version of `bson` works.
+*/
+function objectIdEncode(codecId, value) {
+	const expected = "a 24-digit hex string or an ObjectId";
+	if (typeof value === "string") try {
+		return new ObjectId(value);
+	} catch {
+		return refuseType(codecId, expected, value);
+	}
+	if (typeof value !== "object" || value === null || !hasBsonTypeTag(value, "ObjectId")) return refuseType(codecId, expected, value);
+	const hex = hexStringOf(value);
+	if (hex === void 0) return refuseType(codecId, expected, value, "an object tagged ObjectId whose toHexString() does not return 24 hex digits");
+	return new ObjectId(hex);
+}
+function vectorEncode(codecId, value) {
+	if (!Array.isArray(value) || !value.every((element) => typeof element === "number")) refuseType(codecId, "an array of numbers", value);
+	return value;
+}
+/**
+* Wraps the number in the driver's `Double`, because the driver writes a whole JavaScript number in the int32 range as a BSON `int`, which a `double` validator refuses.
+*/
+function doubleEncode(codecId, value) {
+	if (typeof value !== "number") encodeFailed(codecId, `value must be a number; received ${describeReceived(value)}`, value);
+	return new Double(value);
+}
+function int32Encode(codecId, value) {
+	if (!isIntegerIn(value, INT32_RANGE)) encodeFailed(codecId, `value must be an integer from ${INT32_RANGE.min} to ${INT32_RANGE.max}; received ${describeReceived(value)}`, value);
+	return value;
+}
+function objectIdToJson(codecId, value) {
+	if (typeof value !== "string" || !OBJECT_ID_TEXT.test(value)) encodeFailed(codecId, "value must be 24 hexadecimal digits", value);
+	return value;
+}
+/** Whether `text` is an ObjectId's 24 hexadecimal digits, in either case. */
+function isObjectIdText(text) {
+	return OBJECT_ID_TEXT.test(text);
+}
+/** Reads ObjectId hex in either case; {@link spellObjectIdJson} writes the lower case the type stores. */
+function readObjectIdJson(owner, json) {
+	return readJsonMatching(owner, json, OBJECT_ID_TEXT, "24 hexadecimal digits");
+}
+/** The ObjectId hex in lower case, as the driver's `toHexString` writes it. */
+function spellObjectIdJson(json) {
+	return typeof json === "string" ? json.toLowerCase() : json;
+}
+function int32ToJson(codecId, value) {
+	if (!isIntegerIn(value, INT32_RANGE)) encodeFailed(codecId, `value must be an integer from ${INT32_RANGE.min} to ${INT32_RANGE.max}`, value);
+	return value;
+}
+function readInt32Json(owner, json) {
+	return readJsonInteger(owner, json, INT32_RANGE);
+}
+function dateToJson(codecId, value) {
+	if (!(value instanceof Date) || Number.isNaN(value.getTime())) encodeFailed(codecId, "value must be a valid Date", value);
+	return value.toISOString();
+}
+/**
+* The JSON form is the text `Date.toISOString()` writes, so a string that does not read back to that same text is refused.
+*/
+function readDateJson(owner, json) {
+	const date = typeof json === "string" ? new Date(json) : void 0;
+	if (date === void 0 || Number.isNaN(date.getTime()) || date.toISOString() !== json) return refuseJsonValue(owner, "a date and time in UTC as Date.toISOString writes it", json);
+	return json;
+}
+/** Reads an array of numbers, of exactly `length` numbers when the column sets one. */
+function readVectorJson(owner, json, length) {
+	const expected = length === void 0 ? "an array of numbers" : `an array of ${counted(length, "number")}`;
+	if (!Array.isArray(json) || length !== void 0 && json.length !== length) return refuseJsonValue(owner, expected, json);
+	const numbers = [];
+	for (const element of json) {
+		if (typeof element !== "number") return refuseJsonValue(owner, expected, element);
+		if (!Number.isFinite(element)) return refuseJsonValue(owner, "an array of finite numbers", json);
+		numbers.push(element);
+	}
+	return numbers;
+}
+/**
+* `Long.fromBigInt` keeps the low 64 bits of any bigint, so an out-of-range value would be stored as a different number without error.
+*/
+function isInt64(value) {
+	return value >= INT64_RANGE.min && value <= INT64_RANGE.max;
+}
+function requireInt64(codecId, value) {
+	if (!isInt64(value)) encodeFailed(codecId, "value is outside the signed 64-bit range", value);
+	return value;
+}
+function int64Encode(codecId, value) {
+	if (typeof value !== "bigint") encodeFailed(codecId, "value must be a bigint", value);
+	return Long.fromBigInt(requireInt64(codecId, value));
+}
+/**
+* A stored double with a fraction, which a 64-bit integer codec cannot read. Such values were written through a Prisma 6 `Int` while its contract used the 32-bit codec, which took any number.
+*/
+function refuseFractionalDouble(codecId, wire) {
+	return decodeFailed(codecId, `wire value is the fractional double ${wire}, and a 64-bit integer holds whole numbers only. Rewrite each such stored value as a long, rounded or cut off ({ $toLong: { $round: [<value>, 0] } }, or $trunc in place of $round), mapping over the list when the value sits in one. The upgrade guide step prisma6-int-written-as-long has the queries for a plain field, a list and a list of composite values.`, wire);
+}
+/**
+* The driver promotes a stored `long` that fits in 53 bits to a `number`, and hands larger ones over as `Long`, so both arrive here.
+*/
+function int64Decode(codecId, wire) {
+	if (typeof wire === "bigint") return wire;
+	if (isLong(wire)) return wire.toBigInt();
+	if (typeof wire === "number" && Number.isSafeInteger(wire)) return BigInt(wire);
+	if (typeof wire === "number" && Number.isFinite(wire) && !Number.isInteger(wire)) return refuseFractionalDouble(codecId, wire);
+	return decodeFailed(codecId, "wire value must be a Long or a safe integer", wire);
+}
+/**
+* A schema-written default arrives as a `number`; one that is a safe integer names its value exactly, so it is accepted like `pg/int8@1` accepts it.
+*/
+function int64ToJson(codecId, value) {
+	if (typeof value === "bigint") return requireInt64(codecId, value).toString();
+	if (typeof value === "number" && Number.isSafeInteger(value)) return BigInt(value).toString();
+	return encodeFailed(codecId, "value must be a bigint or a safe integer", value);
+}
+function readInt64Json(owner, json) {
+	readJsonIntegerText(owner, json, INT64_RANGE);
+	return json;
+}
+const SAFE_INTEGERS = `from ${SAFE_INTEGER_RANGE.min} to ${SAFE_INTEGER_RANGE.max}`;
+function int64NumberEncode(codecId, value) {
+	if (!isIntegerIn(value, SAFE_INTEGER_RANGE)) encodeFailed(codecId, `value must be an integer ${SAFE_INTEGERS}; received ${describeReceived(value)}`, value);
+	return Long.fromNumber(value);
+}
+function safeIntegerOf(codecId, value) {
+	if (value < SAFE_INTEGER_BIGINT_RANGE.min || value > SAFE_INTEGER_BIGINT_RANGE.max) decodeFailed(codecId, `wire value must be a whole number ${SAFE_INTEGERS}; received ${value}`, value);
+	return Number(value);
+}
+/**
+* The driver hands a stored `long` over as a `number` when it fits in 53 bits (the default `promoteLongs`), as a `Long` otherwise or with `promoteLongs: false`, and as a `bigint` with `useBigInt64`.
+*/
+function int64NumberDecode(codecId, wire) {
+	if (typeof wire === "bigint") return safeIntegerOf(codecId, wire);
+	if (isLong(wire)) return safeIntegerOf(codecId, wire.toBigInt());
+	if (isIntegerIn(wire, SAFE_INTEGER_RANGE)) return wire;
+	if (typeof wire === "number" && Number.isFinite(wire) && !Number.isInteger(wire)) return refuseFractionalDouble(codecId, wire);
+	return decodeFailed(codecId, `wire value must be a whole number ${SAFE_INTEGERS}; received ${describeReceived(wire)}`, wire);
+}
+function int64NumberToJson(codecId, value) {
+	return int64NumberEncode(codecId, value).toString();
+}
+/** A `number` holds an integer exactly only within the safe integer range, so digit text past it is refused. */
+function int64NumberFromDigits(codecId, digits) {
+	return Number(readJsonIntegerText(codecId, digits, SAFE_INTEGER_BIGINT_RANGE));
+}
+/**
+* `Decimal128.toString()` writes some values with an exponent (`1E+3`, `1.23E+40`). The application value is decimal text without one, as for Postgres `numeric`: the point moves to where the exponent puts it, trailing zeros stay, and the sign of zero goes.
+*/
+function decimalTextWithoutExponent(text) {
+	if (text === "NaN" || text === "Infinity" || text === "-Infinity") return text;
+	const match = DECIMAL128_TEXT.exec(text);
+	if (match === null) return void 0;
+	const [, sign = "", whole = "", fraction = "", exponent = "0"] = match;
+	const digits = `${whole}${fraction}`;
+	const point = whole.length + Number(exponent);
+	let integerPart;
+	let fractionPart;
+	if (point <= 0) {
+		integerPart = "0";
+		fractionPart = `${"0".repeat(-point)}${digits}`;
+	} else if (point >= digits.length) {
+		integerPart = `${digits}${"0".repeat(point - digits.length)}`;
+		fractionPart = "";
+	} else {
+		integerPart = digits.slice(0, point);
+		fractionPart = digits.slice(point);
+	}
+	const trimmedInteger = integerPart.replace(/^0+(?=\d)/, "");
+	const unsigned = fractionPart === "" ? trimmedInteger : `${trimmedInteger}.${fractionPart}`;
+	return /^[0.]+$/.test(unsigned) ? unsigned : `${sign}${unsigned}`;
+}
+function requireStoredDecimalText(codecId, value) {
+	if (typeof value !== "string" || !STORED_DECIMAL_TEXT.test(value)) encodeFailed(codecId, "value must be decimal text without an exponent, or NaN, Infinity or -Infinity", value);
+	return value;
+}
+function decimal128Encode(codecId, value) {
+	requireStoredDecimalText(codecId, value);
+	try {
+		return Decimal128.fromString(value);
+	} catch (error) {
+		return encodeFailed(codecId, `value cannot be stored as a Decimal128 exactly: ${error instanceof Error ? error.message : String(error)}`, value);
+	}
+}
+function decimal128Decode(codecId, wire) {
+	if (!isDecimal128(wire)) return decodeFailed(codecId, "wire value must be a Decimal128", wire);
+	const text = decimalTextWithoutExponent(wire.toString());
+	if (text === void 0) return decodeFailed(codecId, "wire value is not decimal text", wire);
+	return text;
+}
+function decimal128ToJson(codecId, value) {
+	return requireStoredDecimalText(codecId, value);
+}
+/** Decimal text without its leading zeros, as MongoDB writes it; the sign of zero and trailing zeros stay. */
+function decimalTextWithoutLeadingZeros(text) {
+	return text.replace(/^(-?)0+(?=\d)/, "$1");
+}
+function withoutSignOfZero(text) {
+	return /^-[0.]+$/.test(text) ? text.slice(1) : text;
+}
+/** Whether a Decimal128 holds the decimal text exactly: the text it writes back is the same number, digit for digit. */
+function decimal128HoldsExactly(text) {
+	let written;
+	try {
+		written = Decimal128.fromString(text).toString();
+	} catch {
+		return false;
+	}
+	return decimalTextWithoutExponent(written) === withoutSignOfZero(decimalTextWithoutLeadingZeros(text));
+}
+/**
+* The stored form is what the codec writes, so it follows the encode rule: decimal text without an exponent, or `NaN`, `Infinity` or `-Infinity`, that a Decimal128 holds exactly. A value a Decimal128 would round is refused.
+*/
+function readDecimal128Json(owner, json) {
+	const expected = "decimal text without an exponent that a Decimal128 holds exactly, or NaN, Infinity or -Infinity";
+	const text = readJsonMatching(owner, json, STORED_DECIMAL_TEXT, expected);
+	return decimal128HoldsExactly(text) ? text : refuseJsonValue(owner, expected, json);
+}
+/** The decimal text without leading zeros, as MongoDB writes it, keeping negative zero. */
+function spellDecimal128Json(json) {
+	return typeof json === "string" ? decimalTextWithoutLeadingZeros(json) : json;
+}
+function binaryEncode(codecId, value) {
+	if (!(value instanceof Uint8Array)) encodeFailed(codecId, "value must be a Uint8Array", value);
+	return new Binary(value);
+}
+/**
+* The driver reads binData as a `Binary`, or as a `Buffer` with `promoteBuffers: true`; either becomes a plain `Uint8Array` copy of the bytes.
+*/
+function binaryDecode(codecId, wire) {
+	if (wire instanceof Uint8Array) return new Uint8Array(wire);
+	if (!isBinary(wire)) return decodeFailed(codecId, "wire value must be a Binary or a Uint8Array", wire);
+	return new Uint8Array(wire.value());
+}
+function binaryToBase64(value) {
+	return Buffer.from(value).toString("base64");
+}
+/** Whether `text` is base64, with or without padding bits set. */
+function isBase64Text(text) {
+	return BASE64_TEXT.test(text);
+}
+/** Reads base64 with or without padding bits set; {@link spellBase64Json} writes the base64 the type stores. */
+function readBinaryJson(owner, json) {
+	return readJsonMatching(owner, json, BASE64_TEXT, "base64 text");
+}
+/** The base64 of the same bytes with padding bits zero, as `Buffer` writes it. */
+function spellBase64Json(json) {
+	return typeof json === "string" ? Buffer.from(json, "base64").toString("base64") : json;
+}
+function binaryFromBase64(base64) {
+	return new Uint8Array(Buffer.from(base64, "base64"));
+}
+function where(path) {
+	return path === "" ? "the root" : path;
+}
+function child(path, key) {
+	return path === "" ? String(key) : `${path}.${key}`;
+}
+function isPlainObject(value) {
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function isPlainArray(value) {
+	return Array.isArray(value) && Object.getPrototypeOf(value) === Array.prototype;
+}
+const BSON_VERSION = Symbol.for("@@mdb.bson.version");
+/** The major version of the `bson` this package loads, which every `bson` class instance it can serialise carries. */
+const BSON_MAJOR = Reflect.get(new MinKey(), BSON_VERSION);
+/** Whether a `bson` class instance comes from the same major version of `bson`, rather than being a look-alike or from another version. */
+function createdByBsonMajor(value) {
+	return Reflect.get(value, BSON_VERSION) === BSON_MAJOR;
+}
+function bsonTypeTag(value) {
+	const tag = Reflect.get(value, "_bsontype");
+	return typeof tag === "string" ? tag : void 0;
+}
+/**
+* The `_bsontype` tag of a `bson` class instance. A stored subdocument is read as a plain object even when it has a `_bsontype` key, so a plain object has no tag.
+*/
+function bsonClassTag(value) {
+	return isPlainObject(value) ? void 0 : bsonTypeTag(value);
+}
+function constructorName(value) {
+	const name = Reflect.get(value, "constructor")?.name;
+	return typeof name === "string" && name !== "" ? name : "object";
+}
+/**
+* The `bson` library reads any subdocument with a string `$ref` and an `$id` as a `DBRef`. It was stored as a plain object; these are its entries in stored order, `$ref`, `$id`, `$db` when present, then the other fields.
+*/
+function dbRefEntries(value) {
+	const ref = blindCast(value);
+	const entries = [["$ref", ref.collection], ["$id", ref.oid]];
+	if (ref.db !== void 0) entries.push(["$db", ref.db]);
+	entries.push(...Object.entries(ref.fields));
+	return entries;
+}
+const BSON_VALUE_TAGS = /* @__PURE__ */ new Set([
+	"ObjectId",
+	"Long",
+	"Decimal128",
+	"Binary",
+	"BSONRegExp",
+	"Timestamp",
+	"Int32",
+	"Double",
+	"Code",
+	"MinKey",
+	"MaxKey",
+	"BSONSymbol"
+]);
+const ENCODE_FIX_BY_RECEIVED = { DBRef: "Write it as a { $ref, $id } document instead." };
+function encodeRefused(received, path) {
+	const fix = ENCODE_FIX_BY_RECEIVED[received];
+	throw mongoTargetError("RUNTIME.ENCODE_FAILED", `${MONGO_BSON_CODEC_ID} value must be a BSON value; received ${received} at ${where(path)}${fix === void 0 ? "" : `. ${fix}`}`, { meta: {
+		codecId: MONGO_BSON_CODEC_ID,
+		received,
+		valuePath: path
+	} });
+}
+function assertBsonValue(value, path, ancestors) {
+	if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number") return;
+	if (typeof value !== "object") {
+		encodeRefused(typeof value, path);
+		return;
+	}
+	const tag = bsonTypeTag(value);
+	if (tag !== void 0) {
+		if (!BSON_VALUE_TAGS.has(tag)) encodeRefused(tag, path);
+		if (!createdByBsonMajor(value)) encodeRefused(`${tag} not created by bson ${String(BSON_MAJOR)}`, path);
+		return;
+	}
+	if (value instanceof Date || value instanceof RegExp || value instanceof Uint8Array) return;
+	if (!isPlainArray(value) && !isPlainObject(value)) {
+		encodeRefused(constructorName(value), path);
+		return;
+	}
+	if (ancestors.has(value)) encodeRefused("circular reference", path);
+	ancestors.add(value);
+	if (Array.isArray(value)) for (let index = 0; index < value.length; index++) {
+		if (!(index in value)) encodeRefused("sparse array hole", child(path, index));
+		assertBsonValue(value[index], child(path, index), ancestors);
+	}
+	else for (const [key, entry] of Object.entries(value)) assertBsonValue(entry, child(path, key), ancestors);
+	ancestors.delete(value);
+}
+/**
+* Returns `value` unchanged when it is a BSON value at every depth, and throws `RUNTIME.ENCODE_FAILED` naming the first value that is not, with its path.
+*/
+function encodeBsonValue(value) {
+	assertBsonValue(value, "", /* @__PURE__ */ new Set());
+	return value;
+}
+/**
+* A `Code` value with a scope, recognised by its tag: the driver reads with its own load of `bson`, so its `Code` is not an instance of the class imported here.
+*/
+function codeWithScope(value) {
+	if (bsonClassTag(value) !== "Code") return void 0;
+	const code = Reflect.get(value, "code");
+	const scope = Reflect.get(value, "scope");
+	return typeof code === "string" && typeof scope === "object" && scope !== null ? {
+		code,
+		scope
+	} : void 0;
+}
+function decodeEntries(entries) {
+	return Object.fromEntries(entries.map(([key, entry]) => [key, decodeValue(entry)]));
+}
+function decodeValue(value) {
+	if (typeof value !== "object" || value === null) return value;
+	if (bsonClassTag(value) === "DBRef") return decodeEntries(dbRefEntries(value));
+	if (Array.isArray(value)) {
+		const decoded = value.map(decodeValue);
+		return decoded.some((entry, index) => entry !== value[index]) ? decoded : value;
+	}
+	const code = codeWithScope(value);
+	if (code !== void 0) {
+		const scope = decodeValue(code.scope);
+		return scope === code.scope ? value : new Code(code.code, blindCast(scope));
+	}
+	if (!isPlainObject(value)) return value;
+	const entries = Object.entries(value);
+	const decoded = decodeEntries(entries);
+	return entries.some(([key, entry]) => decoded[key] !== entry) ? decoded : value;
+}
+/**
+* Returns the wire value as the driver produced it, except that a `DBRef` the `bson` library read from a `{ $ref, $id }` subdocument becomes that document again, `{ $ref, $id[, $db], ...fields }`, with its members' BSON types kept, at any depth and inside a `Code` scope. A value holding no `DBRef` is returned as the same object.
+*/
+function decodeBsonValue(wire) {
+	return blindCast(decodeValue(wire));
+}
+function asDriverWrites(value) {
+	if (typeof value === "number") return Number.isInteger(value) && (value < INT32_RANGE.min || value > INT32_RANGE.max) ? new Double(value) : value;
+	if (typeof value !== "object" || value === null) return value;
+	if (value instanceof Uint8Array) return new Binary(value);
+	if (Array.isArray(value)) return value.map(asDriverWrites);
+	if (isPlainObject(value)) return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, asDriverWrites(entry)]));
+	const code = codeWithScope(value);
+	if (code !== void 0) return new Code(code.code, blindCast(asDriverWrites(code.scope)));
+	return value;
+}
+/**
+* Canonical Extended JSON for a BSON value, recording each JavaScript number and `Uint8Array` as the BSON type the driver writes for it: an integer outside the int32 range as a `double`, and bytes as `binData`.
+*/
+function bsonToJson(value) {
+	return blindCast(EJSON.serialize(asDriverWrites(value), { relaxed: false }));
+}
+/**
+* Reads the canonical Extended JSON `bsonToJson` writes. The `bson` reader also takes forms that are not canonical, some of them silently wrong (`{ "$numberInt": "abc" }` reads as 0), so a value that does not write back to the same JSON is refused, naming `owner`.
+*/
+function readBsonJson(owner, json) {
+	let value;
+	try {
+		value = EJSON.deserialize(blindCast(json), { relaxed: false });
+	} catch {
+		return refuseJsonValue(owner, "canonical Extended JSON", json);
+	}
+	if (!isDeepStrictEqual(EJSON.serialize(value, { relaxed: false }), json)) return refuseJsonValue(owner, "canonical Extended JSON", json);
+	return value;
+}
+/** The vector's dimension: the TypeScript type `Vector<n>` and the type's reader read it. */
+const mongoVectorParams = type({ "length?": "number.integer >= 1" });
+/** Text as the ObjectId it names; {@link spellObjectIdJson} gives it the lower case the type stores. */
+const asObjectId = (value) => {
+	if (typeof value !== "string") return refuseWrongShape(value, "text");
+	if (isObjectIdText(value)) return value;
+	throw structuredError("CONTRACT.CAST_REFUSED", `"${value}" is not an ObjectId: write 24 hexadecimal digits.`, {
+		why: "An ObjectId is 12 bytes, written as 24 hexadecimal digits.",
+		fix: "Write the ObjectId as 24 hexadecimal digits, as in \"507f1f77bcf86cd799439011\"."
+	});
+};
+/** The numbers of a written list as a vector stores them, each finite. */
+function vectorElements(elements) {
+	return elements.map((element, index) => {
+		const number = Number(element);
+		if (Number.isFinite(number)) return number;
+		throw structuredError("CONTRACT.CAST_REFUSED", `a vector element is a finite number, and element ${index + 1} is ${String(element)}.`, {
+			why: "A vector holds finite numbers, as a vector search index reads them.",
+			fix: "Write each element as a finite number."
+		});
+	});
+}
+const mongoString = mongoDataType("mongo/string", {
+	read: (json) => readJsonString("mongo/string", json),
+	bsonTypes: ["string"]
+});
+const mongoInt32 = mongoDataType("mongo/int32", {
+	read: (json) => readInt32Json("mongo/int32", json),
+	bsonTypes: ["int"]
+});
+const mongoInt64 = mongoDataType("mongo/int64", {
+	read: (json) => readInt64Json("mongo/int64", json),
+	bsonTypes: ["long"],
+	casts: { [mongoInt32.id]: asNumeralText }
+});
+const mongoDecimal128 = mongoDataType("mongo/decimal128", {
+	read: (json) => readDecimal128Json("mongo/decimal128", json),
+	spell: spellDecimal128Json,
+	equalityKey: decimalTextEqualityKey,
+	bsonTypes: ["decimal"],
+	casts: {
+		[mongoInt32.id]: asNumeralText,
+		[mongoInt64.id]: castUnchanged
+	}
+});
+const mongoDouble = mongoDataType("mongo/double", {
+	read: (json) => {
+		readJsonFloat("mongo/double", json);
+		return json;
+	},
+	bsonTypes: ["double"],
+	casts: {
+		[mongoInt32.id]: asFloat,
+		[mongoInt64.id]: asFloat,
+		[mongoDecimal128.id]: asFloat
+	}
+});
+const mongoObjectId = mongoDataType("mongo/objectid", {
+	read: (json) => readObjectIdJson("mongo/objectid", json),
+	spell: spellObjectIdJson,
+	bsonTypes: ["objectId"],
+	casts: { [mongoString.id]: asObjectId }
+});
+const mongoBool = mongoDataType("mongo/bool", {
+	read: (json) => readJsonBoolean("mongo/bool", json),
+	bsonTypes: ["bool"]
+});
+const mongoDate = mongoDataType("mongo/date", {
+	read: (json) => readDateJson("mongo/date", json),
+	bsonTypes: ["date"]
+});
+const mongoVector = mongoDataType("mongo/vector", {
+	read: (json, params) => readVectorJson("mongo/vector", json, typeof params["length"] === "number" ? params["length"] : void 0),
+	bsonTypes: ["array"],
+	params: mongoVectorParams,
+	listCast: {
+		of: [
+			mongoInt32.id,
+			mongoInt64.id,
+			mongoDecimal128.id,
+			mongoDouble.id
+		],
+		cast: vectorElements
+	}
+});
+const mongoBinary = mongoDataType("mongo/binary", {
+	read: (json) => readBinaryJson("mongo/binary", json),
+	spell: spellBase64Json,
+	bsonTypes: ["binData"]
+});
+const mongoJson = mongoDataType("mongo/json", {
+	read: (json) => json,
+	bsonTypes: [
+		"object",
+		"array",
+		"string",
+		"double",
+		"int",
+		"long",
+		"bool",
+		"null"
+	]
+});
+const mongoBson = mongoDataType("mongo/bson", {
+	read: (json) => {
+		readBsonJson("mongo/bson", json);
+		return json;
+	},
+	bsonTypes: []
+});
+const mongoDataTypes = [
+	mongoObjectId,
+	mongoString,
+	mongoDouble,
+	mongoInt32,
+	mongoBool,
+	mongoDate,
+	mongoVector,
+	mongoInt64,
+	mongoDecimal128,
+	mongoBinary,
+	mongoJson,
+	mongoBson
+];
+/** MongoDB's text data type: `string`. */
+const mongoTextDataTypes = [mongoString.id];
+//#endregion
+export { where as $, isBase64Text as A, mongoInt32 as B, int64Decode as C, int64NumberFromDigits as D, int64NumberEncode as E, mongoBson as F, mongoTextDataTypes as G, mongoJson as H, mongoDataTypes as I, objectIdEncode as J, mongoVector as K, mongoDate as L, isPlainObject as M, mongoBinary as N, int64NumberToJson as O, mongoBool as P, vectorEncode as Q, mongoDecimal128 as R, int32ToJson as S, int64NumberDecode as T, mongoObjectId as U, mongoInt64 as V, mongoString as W, readBsonJson as X, objectIdToJson as Y, stringEncode as Z, decimal128ToJson as _, booleanEncode as a, encodeBsonValue as b, bsonTypeTag as c, dateEncode as d, dateToJson as f, decimal128HoldsExactly as g, decimal128Encode as h, binaryToBase64 as i, isPlainArray as j, int64ToJson as k, child as l, decimal128Decode as m, binaryEncode as n, bsonClassTag as o, dbRefEntries as p, mongoVectorParams as q, binaryFromBase64 as r, bsonToJson as s, binaryDecode as t, constructorName as u, decodeBsonValue as v, int64Encode as w, int32Encode as x, doubleEncode as y, mongoDouble as z };
+
+//# sourceMappingURL=data-types-hoKLBrYZ-h9cAgbOy.mjs.map