4103 lines
154 KiB
JavaScript
4103 lines
154 KiB
JavaScript
function isAnyArrayBuffer(value) {
|
|
return ['[object ArrayBuffer]', '[object SharedArrayBuffer]'].includes(Object.prototype.toString.call(value));
|
|
}
|
|
function isUint8Array(value) {
|
|
return Object.prototype.toString.call(value) === '[object Uint8Array]';
|
|
}
|
|
function isRegExp(d) {
|
|
return Object.prototype.toString.call(d) === '[object RegExp]';
|
|
}
|
|
function isMap(d) {
|
|
return Object.prototype.toString.call(d) === '[object Map]';
|
|
}
|
|
function isDate(d) {
|
|
return Object.prototype.toString.call(d) === '[object Date]';
|
|
}
|
|
function defaultInspect(x, _options) {
|
|
return JSON.stringify(x, (k, v) => {
|
|
if (typeof v === 'bigint') {
|
|
return { $numberLong: `${v}` };
|
|
}
|
|
else if (isMap(v)) {
|
|
return Object.fromEntries(v);
|
|
}
|
|
return v;
|
|
});
|
|
}
|
|
function getStylizeFunction(options) {
|
|
const stylizeExists = options != null &&
|
|
typeof options === 'object' &&
|
|
'stylize' in options &&
|
|
typeof options.stylize === 'function';
|
|
if (stylizeExists) {
|
|
return options.stylize;
|
|
}
|
|
}
|
|
|
|
const BSON_MAJOR_VERSION = 6;
|
|
const BSON_INT32_MAX = 0x7fffffff;
|
|
const BSON_INT32_MIN = -0x80000000;
|
|
const BSON_INT64_MAX = Math.pow(2, 63) - 1;
|
|
const BSON_INT64_MIN = -Math.pow(2, 63);
|
|
const JS_INT_MAX = Math.pow(2, 53);
|
|
const JS_INT_MIN = -Math.pow(2, 53);
|
|
const BSON_DATA_NUMBER = 1;
|
|
const BSON_DATA_STRING = 2;
|
|
const BSON_DATA_OBJECT = 3;
|
|
const BSON_DATA_ARRAY = 4;
|
|
const BSON_DATA_BINARY = 5;
|
|
const BSON_DATA_UNDEFINED = 6;
|
|
const BSON_DATA_OID = 7;
|
|
const BSON_DATA_BOOLEAN = 8;
|
|
const BSON_DATA_DATE = 9;
|
|
const BSON_DATA_NULL = 10;
|
|
const BSON_DATA_REGEXP = 11;
|
|
const BSON_DATA_DBPOINTER = 12;
|
|
const BSON_DATA_CODE = 13;
|
|
const BSON_DATA_SYMBOL = 14;
|
|
const BSON_DATA_CODE_W_SCOPE = 15;
|
|
const BSON_DATA_INT = 16;
|
|
const BSON_DATA_TIMESTAMP = 17;
|
|
const BSON_DATA_LONG = 18;
|
|
const BSON_DATA_DECIMAL128 = 19;
|
|
const BSON_DATA_MIN_KEY = 0xff;
|
|
const BSON_DATA_MAX_KEY = 0x7f;
|
|
const BSON_BINARY_SUBTYPE_DEFAULT = 0;
|
|
const BSON_BINARY_SUBTYPE_UUID_NEW = 4;
|
|
const BSONType = Object.freeze({
|
|
double: 1,
|
|
string: 2,
|
|
object: 3,
|
|
array: 4,
|
|
binData: 5,
|
|
undefined: 6,
|
|
objectId: 7,
|
|
bool: 8,
|
|
date: 9,
|
|
null: 10,
|
|
regex: 11,
|
|
dbPointer: 12,
|
|
javascript: 13,
|
|
symbol: 14,
|
|
javascriptWithScope: 15,
|
|
int: 16,
|
|
timestamp: 17,
|
|
long: 18,
|
|
decimal: 19,
|
|
minKey: -1,
|
|
maxKey: 127
|
|
});
|
|
|
|
class BSONError extends Error {
|
|
get bsonError() {
|
|
return true;
|
|
}
|
|
get name() {
|
|
return 'BSONError';
|
|
}
|
|
constructor(message) {
|
|
super(message);
|
|
}
|
|
static isBSONError(value) {
|
|
return (value != null &&
|
|
typeof value === 'object' &&
|
|
'bsonError' in value &&
|
|
value.bsonError === true &&
|
|
'name' in value &&
|
|
'message' in value &&
|
|
'stack' in value);
|
|
}
|
|
}
|
|
class BSONVersionError extends BSONError {
|
|
get name() {
|
|
return 'BSONVersionError';
|
|
}
|
|
constructor() {
|
|
super(`Unsupported BSON version, bson types must be from bson ${BSON_MAJOR_VERSION}.x.x`);
|
|
}
|
|
}
|
|
class BSONRuntimeError extends BSONError {
|
|
get name() {
|
|
return 'BSONRuntimeError';
|
|
}
|
|
constructor(message) {
|
|
super(message);
|
|
}
|
|
}
|
|
|
|
function nodejsMathRandomBytes(byteLength) {
|
|
return nodeJsByteUtils.fromNumberArray(Array.from({ length: byteLength }, () => Math.floor(Math.random() * 256)));
|
|
}
|
|
const nodejsRandomBytes = await (async () => {
|
|
try {
|
|
return (await import('crypto')).randomBytes;
|
|
}
|
|
catch {
|
|
return nodejsMathRandomBytes;
|
|
}
|
|
})();
|
|
const nodeJsByteUtils = {
|
|
toLocalBufferType(potentialBuffer) {
|
|
if (Buffer.isBuffer(potentialBuffer)) {
|
|
return potentialBuffer;
|
|
}
|
|
if (ArrayBuffer.isView(potentialBuffer)) {
|
|
return Buffer.from(potentialBuffer.buffer, potentialBuffer.byteOffset, potentialBuffer.byteLength);
|
|
}
|
|
const stringTag = potentialBuffer?.[Symbol.toStringTag] ?? Object.prototype.toString.call(potentialBuffer);
|
|
if (stringTag === 'ArrayBuffer' ||
|
|
stringTag === 'SharedArrayBuffer' ||
|
|
stringTag === '[object ArrayBuffer]' ||
|
|
stringTag === '[object SharedArrayBuffer]') {
|
|
return Buffer.from(potentialBuffer);
|
|
}
|
|
throw new BSONError(`Cannot create Buffer from ${String(potentialBuffer)}`);
|
|
},
|
|
allocate(size) {
|
|
return Buffer.alloc(size);
|
|
},
|
|
equals(a, b) {
|
|
return nodeJsByteUtils.toLocalBufferType(a).equals(b);
|
|
},
|
|
fromNumberArray(array) {
|
|
return Buffer.from(array);
|
|
},
|
|
fromBase64(base64) {
|
|
return Buffer.from(base64, 'base64');
|
|
},
|
|
toBase64(buffer) {
|
|
return nodeJsByteUtils.toLocalBufferType(buffer).toString('base64');
|
|
},
|
|
fromISO88591(codePoints) {
|
|
return Buffer.from(codePoints, 'binary');
|
|
},
|
|
toISO88591(buffer) {
|
|
return nodeJsByteUtils.toLocalBufferType(buffer).toString('binary');
|
|
},
|
|
fromHex(hex) {
|
|
return Buffer.from(hex, 'hex');
|
|
},
|
|
toHex(buffer) {
|
|
return nodeJsByteUtils.toLocalBufferType(buffer).toString('hex');
|
|
},
|
|
fromUTF8(text) {
|
|
return Buffer.from(text, 'utf8');
|
|
},
|
|
toUTF8(buffer, start, end) {
|
|
return nodeJsByteUtils.toLocalBufferType(buffer).toString('utf8', start, end);
|
|
},
|
|
utf8ByteLength(input) {
|
|
return Buffer.byteLength(input, 'utf8');
|
|
},
|
|
encodeUTF8Into(buffer, source, byteOffset) {
|
|
return nodeJsByteUtils.toLocalBufferType(buffer).write(source, byteOffset, undefined, 'utf8');
|
|
},
|
|
randomBytes: nodejsRandomBytes
|
|
};
|
|
|
|
function isReactNative() {
|
|
const { navigator } = globalThis;
|
|
return typeof navigator === 'object' && navigator.product === 'ReactNative';
|
|
}
|
|
function webMathRandomBytes(byteLength) {
|
|
if (byteLength < 0) {
|
|
throw new RangeError(`The argument 'byteLength' is invalid. Received ${byteLength}`);
|
|
}
|
|
return webByteUtils.fromNumberArray(Array.from({ length: byteLength }, () => Math.floor(Math.random() * 256)));
|
|
}
|
|
const webRandomBytes = (() => {
|
|
const { crypto } = globalThis;
|
|
if (crypto != null && typeof crypto.getRandomValues === 'function') {
|
|
return (byteLength) => {
|
|
return crypto.getRandomValues(webByteUtils.allocate(byteLength));
|
|
};
|
|
}
|
|
else {
|
|
if (isReactNative()) {
|
|
const { console } = globalThis;
|
|
console?.warn?.('BSON: For React Native please polyfill crypto.getRandomValues, e.g. using: https://www.npmjs.com/package/react-native-get-random-values.');
|
|
}
|
|
return webMathRandomBytes;
|
|
}
|
|
})();
|
|
const HEX_DIGIT = /(\d|[a-f])/i;
|
|
const webByteUtils = {
|
|
toLocalBufferType(potentialUint8array) {
|
|
const stringTag = potentialUint8array?.[Symbol.toStringTag] ??
|
|
Object.prototype.toString.call(potentialUint8array);
|
|
if (stringTag === 'Uint8Array') {
|
|
return potentialUint8array;
|
|
}
|
|
if (ArrayBuffer.isView(potentialUint8array)) {
|
|
return new Uint8Array(potentialUint8array.buffer.slice(potentialUint8array.byteOffset, potentialUint8array.byteOffset + potentialUint8array.byteLength));
|
|
}
|
|
if (stringTag === 'ArrayBuffer' ||
|
|
stringTag === 'SharedArrayBuffer' ||
|
|
stringTag === '[object ArrayBuffer]' ||
|
|
stringTag === '[object SharedArrayBuffer]') {
|
|
return new Uint8Array(potentialUint8array);
|
|
}
|
|
throw new BSONError(`Cannot make a Uint8Array from ${String(potentialUint8array)}`);
|
|
},
|
|
allocate(size) {
|
|
if (typeof size !== 'number') {
|
|
throw new TypeError(`The "size" argument must be of type number. Received ${String(size)}`);
|
|
}
|
|
return new Uint8Array(size);
|
|
},
|
|
equals(a, b) {
|
|
if (a.byteLength !== b.byteLength) {
|
|
return false;
|
|
}
|
|
for (let i = 0; i < a.byteLength; i++) {
|
|
if (a[i] !== b[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
},
|
|
fromNumberArray(array) {
|
|
return Uint8Array.from(array);
|
|
},
|
|
fromBase64(base64) {
|
|
return Uint8Array.from(atob(base64), c => c.charCodeAt(0));
|
|
},
|
|
toBase64(uint8array) {
|
|
return btoa(webByteUtils.toISO88591(uint8array));
|
|
},
|
|
fromISO88591(codePoints) {
|
|
return Uint8Array.from(codePoints, c => c.charCodeAt(0) & 0xff);
|
|
},
|
|
toISO88591(uint8array) {
|
|
return Array.from(Uint16Array.from(uint8array), b => String.fromCharCode(b)).join('');
|
|
},
|
|
fromHex(hex) {
|
|
const evenLengthHex = hex.length % 2 === 0 ? hex : hex.slice(0, hex.length - 1);
|
|
const buffer = [];
|
|
for (let i = 0; i < evenLengthHex.length; i += 2) {
|
|
const firstDigit = evenLengthHex[i];
|
|
const secondDigit = evenLengthHex[i + 1];
|
|
if (!HEX_DIGIT.test(firstDigit)) {
|
|
break;
|
|
}
|
|
if (!HEX_DIGIT.test(secondDigit)) {
|
|
break;
|
|
}
|
|
const hexDigit = Number.parseInt(`${firstDigit}${secondDigit}`, 16);
|
|
buffer.push(hexDigit);
|
|
}
|
|
return Uint8Array.from(buffer);
|
|
},
|
|
toHex(uint8array) {
|
|
return Array.from(uint8array, byte => byte.toString(16).padStart(2, '0')).join('');
|
|
},
|
|
fromUTF8(text) {
|
|
return new TextEncoder().encode(text);
|
|
},
|
|
toUTF8(uint8array, start, end) {
|
|
return new TextDecoder('utf8', { fatal: false }).decode(uint8array.slice(start, end));
|
|
},
|
|
utf8ByteLength(input) {
|
|
return webByteUtils.fromUTF8(input).byteLength;
|
|
},
|
|
encodeUTF8Into(buffer, source, byteOffset) {
|
|
const bytes = webByteUtils.fromUTF8(source);
|
|
buffer.set(bytes, byteOffset);
|
|
return bytes.byteLength;
|
|
},
|
|
randomBytes: webRandomBytes
|
|
};
|
|
|
|
const hasGlobalBuffer = typeof Buffer === 'function' && Buffer.prototype?._isBuffer !== true;
|
|
const ByteUtils = hasGlobalBuffer ? nodeJsByteUtils : webByteUtils;
|
|
class BSONDataView extends DataView {
|
|
static fromUint8Array(input) {
|
|
return new DataView(input.buffer, input.byteOffset, input.byteLength);
|
|
}
|
|
}
|
|
|
|
class BSONValue {
|
|
get [Symbol.for('@@mdb.bson.version')]() {
|
|
return BSON_MAJOR_VERSION;
|
|
}
|
|
[Symbol.for('nodejs.util.inspect.custom')](depth, options, inspect) {
|
|
return this.inspect(depth, options, inspect);
|
|
}
|
|
}
|
|
|
|
class Binary extends BSONValue {
|
|
get _bsontype() {
|
|
return 'Binary';
|
|
}
|
|
constructor(buffer, subType) {
|
|
super();
|
|
if (!(buffer == null) &&
|
|
typeof buffer === 'string' &&
|
|
!ArrayBuffer.isView(buffer) &&
|
|
!isAnyArrayBuffer(buffer) &&
|
|
!Array.isArray(buffer)) {
|
|
throw new BSONError('Binary can only be constructed from Uint8Array or number[]');
|
|
}
|
|
this.sub_type = subType ?? Binary.BSON_BINARY_SUBTYPE_DEFAULT;
|
|
if (buffer == null) {
|
|
this.buffer = ByteUtils.allocate(Binary.BUFFER_SIZE);
|
|
this.position = 0;
|
|
}
|
|
else {
|
|
this.buffer = Array.isArray(buffer)
|
|
? ByteUtils.fromNumberArray(buffer)
|
|
: ByteUtils.toLocalBufferType(buffer);
|
|
this.position = this.buffer.byteLength;
|
|
}
|
|
}
|
|
put(byteValue) {
|
|
if (typeof byteValue === 'string' && byteValue.length !== 1) {
|
|
throw new BSONError('only accepts single character String');
|
|
}
|
|
else if (typeof byteValue !== 'number' && byteValue.length !== 1)
|
|
throw new BSONError('only accepts single character Uint8Array or Array');
|
|
let decodedByte;
|
|
if (typeof byteValue === 'string') {
|
|
decodedByte = byteValue.charCodeAt(0);
|
|
}
|
|
else if (typeof byteValue === 'number') {
|
|
decodedByte = byteValue;
|
|
}
|
|
else {
|
|
decodedByte = byteValue[0];
|
|
}
|
|
if (decodedByte < 0 || decodedByte > 255) {
|
|
throw new BSONError('only accepts number in a valid unsigned byte range 0-255');
|
|
}
|
|
if (this.buffer.byteLength > this.position) {
|
|
this.buffer[this.position++] = decodedByte;
|
|
}
|
|
else {
|
|
const newSpace = ByteUtils.allocate(Binary.BUFFER_SIZE + this.buffer.length);
|
|
newSpace.set(this.buffer, 0);
|
|
this.buffer = newSpace;
|
|
this.buffer[this.position++] = decodedByte;
|
|
}
|
|
}
|
|
write(sequence, offset) {
|
|
offset = typeof offset === 'number' ? offset : this.position;
|
|
if (this.buffer.byteLength < offset + sequence.length) {
|
|
const newSpace = ByteUtils.allocate(this.buffer.byteLength + sequence.length);
|
|
newSpace.set(this.buffer, 0);
|
|
this.buffer = newSpace;
|
|
}
|
|
if (ArrayBuffer.isView(sequence)) {
|
|
this.buffer.set(ByteUtils.toLocalBufferType(sequence), offset);
|
|
this.position =
|
|
offset + sequence.byteLength > this.position ? offset + sequence.length : this.position;
|
|
}
|
|
else if (typeof sequence === 'string') {
|
|
throw new BSONError('input cannot be string');
|
|
}
|
|
}
|
|
read(position, length) {
|
|
length = length && length > 0 ? length : this.position;
|
|
return this.buffer.slice(position, position + length);
|
|
}
|
|
value() {
|
|
return this.buffer.length === this.position
|
|
? this.buffer
|
|
: this.buffer.subarray(0, this.position);
|
|
}
|
|
length() {
|
|
return this.position;
|
|
}
|
|
toJSON() {
|
|
return ByteUtils.toBase64(this.buffer);
|
|
}
|
|
toString(encoding) {
|
|
if (encoding === 'hex')
|
|
return ByteUtils.toHex(this.buffer);
|
|
if (encoding === 'base64')
|
|
return ByteUtils.toBase64(this.buffer);
|
|
if (encoding === 'utf8' || encoding === 'utf-8')
|
|
return ByteUtils.toUTF8(this.buffer, 0, this.buffer.byteLength);
|
|
return ByteUtils.toUTF8(this.buffer, 0, this.buffer.byteLength);
|
|
}
|
|
toExtendedJSON(options) {
|
|
options = options || {};
|
|
const base64String = ByteUtils.toBase64(this.buffer);
|
|
const subType = Number(this.sub_type).toString(16);
|
|
if (options.legacy) {
|
|
return {
|
|
$binary: base64String,
|
|
$type: subType.length === 1 ? '0' + subType : subType
|
|
};
|
|
}
|
|
return {
|
|
$binary: {
|
|
base64: base64String,
|
|
subType: subType.length === 1 ? '0' + subType : subType
|
|
}
|
|
};
|
|
}
|
|
toUUID() {
|
|
if (this.sub_type === Binary.SUBTYPE_UUID) {
|
|
return new UUID(this.buffer.slice(0, this.position));
|
|
}
|
|
throw new BSONError(`Binary sub_type "${this.sub_type}" is not supported for converting to UUID. Only "${Binary.SUBTYPE_UUID}" is currently supported.`);
|
|
}
|
|
static createFromHexString(hex, subType) {
|
|
return new Binary(ByteUtils.fromHex(hex), subType);
|
|
}
|
|
static createFromBase64(base64, subType) {
|
|
return new Binary(ByteUtils.fromBase64(base64), subType);
|
|
}
|
|
static fromExtendedJSON(doc, options) {
|
|
options = options || {};
|
|
let data;
|
|
let type;
|
|
if ('$binary' in doc) {
|
|
if (options.legacy && typeof doc.$binary === 'string' && '$type' in doc) {
|
|
type = doc.$type ? parseInt(doc.$type, 16) : 0;
|
|
data = ByteUtils.fromBase64(doc.$binary);
|
|
}
|
|
else {
|
|
if (typeof doc.$binary !== 'string') {
|
|
type = doc.$binary.subType ? parseInt(doc.$binary.subType, 16) : 0;
|
|
data = ByteUtils.fromBase64(doc.$binary.base64);
|
|
}
|
|
}
|
|
}
|
|
else if ('$uuid' in doc) {
|
|
type = 4;
|
|
data = UUID.bytesFromString(doc.$uuid);
|
|
}
|
|
if (!data) {
|
|
throw new BSONError(`Unexpected Binary Extended JSON format ${JSON.stringify(doc)}`);
|
|
}
|
|
return type === BSON_BINARY_SUBTYPE_UUID_NEW ? new UUID(data) : new Binary(data, type);
|
|
}
|
|
inspect(depth, options, inspect) {
|
|
inspect ??= defaultInspect;
|
|
const base64 = ByteUtils.toBase64(this.buffer.subarray(0, this.position));
|
|
const base64Arg = inspect(base64, options);
|
|
const subTypeArg = inspect(this.sub_type, options);
|
|
return `Binary.createFromBase64(${base64Arg}, ${subTypeArg})`;
|
|
}
|
|
}
|
|
Binary.BSON_BINARY_SUBTYPE_DEFAULT = 0;
|
|
Binary.BUFFER_SIZE = 256;
|
|
Binary.SUBTYPE_DEFAULT = 0;
|
|
Binary.SUBTYPE_FUNCTION = 1;
|
|
Binary.SUBTYPE_BYTE_ARRAY = 2;
|
|
Binary.SUBTYPE_UUID_OLD = 3;
|
|
Binary.SUBTYPE_UUID = 4;
|
|
Binary.SUBTYPE_MD5 = 5;
|
|
Binary.SUBTYPE_ENCRYPTED = 6;
|
|
Binary.SUBTYPE_COLUMN = 7;
|
|
Binary.SUBTYPE_USER_DEFINED = 128;
|
|
const UUID_BYTE_LENGTH = 16;
|
|
const UUID_WITHOUT_DASHES = /^[0-9A-F]{32}$/i;
|
|
const UUID_WITH_DASHES = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i;
|
|
class UUID extends Binary {
|
|
constructor(input) {
|
|
let bytes;
|
|
if (input == null) {
|
|
bytes = UUID.generate();
|
|
}
|
|
else if (input instanceof UUID) {
|
|
bytes = ByteUtils.toLocalBufferType(new Uint8Array(input.buffer));
|
|
}
|
|
else if (ArrayBuffer.isView(input) && input.byteLength === UUID_BYTE_LENGTH) {
|
|
bytes = ByteUtils.toLocalBufferType(input);
|
|
}
|
|
else if (typeof input === 'string') {
|
|
bytes = UUID.bytesFromString(input);
|
|
}
|
|
else {
|
|
throw new BSONError('Argument passed in UUID constructor must be a UUID, a 16 byte Buffer or a 32/36 character hex string (dashes excluded/included, format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).');
|
|
}
|
|
super(bytes, BSON_BINARY_SUBTYPE_UUID_NEW);
|
|
}
|
|
get id() {
|
|
return this.buffer;
|
|
}
|
|
set id(value) {
|
|
this.buffer = value;
|
|
}
|
|
toHexString(includeDashes = true) {
|
|
if (includeDashes) {
|
|
return [
|
|
ByteUtils.toHex(this.buffer.subarray(0, 4)),
|
|
ByteUtils.toHex(this.buffer.subarray(4, 6)),
|
|
ByteUtils.toHex(this.buffer.subarray(6, 8)),
|
|
ByteUtils.toHex(this.buffer.subarray(8, 10)),
|
|
ByteUtils.toHex(this.buffer.subarray(10, 16))
|
|
].join('-');
|
|
}
|
|
return ByteUtils.toHex(this.buffer);
|
|
}
|
|
toString(encoding) {
|
|
if (encoding === 'hex')
|
|
return ByteUtils.toHex(this.id);
|
|
if (encoding === 'base64')
|
|
return ByteUtils.toBase64(this.id);
|
|
return this.toHexString();
|
|
}
|
|
toJSON() {
|
|
return this.toHexString();
|
|
}
|
|
equals(otherId) {
|
|
if (!otherId) {
|
|
return false;
|
|
}
|
|
if (otherId instanceof UUID) {
|
|
return ByteUtils.equals(otherId.id, this.id);
|
|
}
|
|
try {
|
|
return ByteUtils.equals(new UUID(otherId).id, this.id);
|
|
}
|
|
catch {
|
|
return false;
|
|
}
|
|
}
|
|
toBinary() {
|
|
return new Binary(this.id, Binary.SUBTYPE_UUID);
|
|
}
|
|
static generate() {
|
|
const bytes = ByteUtils.randomBytes(UUID_BYTE_LENGTH);
|
|
bytes[6] = (bytes[6] & 0x0f) | 0x40;
|
|
bytes[8] = (bytes[8] & 0x3f) | 0x80;
|
|
return bytes;
|
|
}
|
|
static isValid(input) {
|
|
if (!input) {
|
|
return false;
|
|
}
|
|
if (typeof input === 'string') {
|
|
return UUID.isValidUUIDString(input);
|
|
}
|
|
if (isUint8Array(input)) {
|
|
return input.byteLength === UUID_BYTE_LENGTH;
|
|
}
|
|
return (input._bsontype === 'Binary' &&
|
|
input.sub_type === this.SUBTYPE_UUID &&
|
|
input.buffer.byteLength === 16);
|
|
}
|
|
static createFromHexString(hexString) {
|
|
const buffer = UUID.bytesFromString(hexString);
|
|
return new UUID(buffer);
|
|
}
|
|
static createFromBase64(base64) {
|
|
return new UUID(ByteUtils.fromBase64(base64));
|
|
}
|
|
static bytesFromString(representation) {
|
|
if (!UUID.isValidUUIDString(representation)) {
|
|
throw new BSONError('UUID string representation must be 32 hex digits or canonical hyphenated representation');
|
|
}
|
|
return ByteUtils.fromHex(representation.replace(/-/g, ''));
|
|
}
|
|
static isValidUUIDString(representation) {
|
|
return UUID_WITHOUT_DASHES.test(representation) || UUID_WITH_DASHES.test(representation);
|
|
}
|
|
inspect(depth, options, inspect) {
|
|
inspect ??= defaultInspect;
|
|
return `new UUID(${inspect(this.toHexString(), options)})`;
|
|
}
|
|
}
|
|
|
|
class Code extends BSONValue {
|
|
get _bsontype() {
|
|
return 'Code';
|
|
}
|
|
constructor(code, scope) {
|
|
super();
|
|
this.code = code.toString();
|
|
this.scope = scope ?? null;
|
|
}
|
|
toJSON() {
|
|
if (this.scope != null) {
|
|
return { code: this.code, scope: this.scope };
|
|
}
|
|
return { code: this.code };
|
|
}
|
|
toExtendedJSON() {
|
|
if (this.scope) {
|
|
return { $code: this.code, $scope: this.scope };
|
|
}
|
|
return { $code: this.code };
|
|
}
|
|
static fromExtendedJSON(doc) {
|
|
return new Code(doc.$code, doc.$scope);
|
|
}
|
|
inspect(depth, options, inspect) {
|
|
inspect ??= defaultInspect;
|
|
let parametersString = inspect(this.code, options);
|
|
const multiLineFn = parametersString.includes('\n');
|
|
if (this.scope != null) {
|
|
parametersString += `,${multiLineFn ? '\n' : ' '}${inspect(this.scope, options)}`;
|
|
}
|
|
const endingNewline = multiLineFn && this.scope === null;
|
|
return `new Code(${multiLineFn ? '\n' : ''}${parametersString}${endingNewline ? '\n' : ''})`;
|
|
}
|
|
}
|
|
|
|
function isDBRefLike(value) {
|
|
return (value != null &&
|
|
typeof value === 'object' &&
|
|
'$id' in value &&
|
|
value.$id != null &&
|
|
'$ref' in value &&
|
|
typeof value.$ref === 'string' &&
|
|
(!('$db' in value) || ('$db' in value && typeof value.$db === 'string')));
|
|
}
|
|
class DBRef extends BSONValue {
|
|
get _bsontype() {
|
|
return 'DBRef';
|
|
}
|
|
constructor(collection, oid, db, fields) {
|
|
super();
|
|
const parts = collection.split('.');
|
|
if (parts.length === 2) {
|
|
db = parts.shift();
|
|
collection = parts.shift();
|
|
}
|
|
this.collection = collection;
|
|
this.oid = oid;
|
|
this.db = db;
|
|
this.fields = fields || {};
|
|
}
|
|
get namespace() {
|
|
return this.collection;
|
|
}
|
|
set namespace(value) {
|
|
this.collection = value;
|
|
}
|
|
toJSON() {
|
|
const o = Object.assign({
|
|
$ref: this.collection,
|
|
$id: this.oid
|
|
}, this.fields);
|
|
if (this.db != null)
|
|
o.$db = this.db;
|
|
return o;
|
|
}
|
|
toExtendedJSON(options) {
|
|
options = options || {};
|
|
let o = {
|
|
$ref: this.collection,
|
|
$id: this.oid
|
|
};
|
|
if (options.legacy) {
|
|
return o;
|
|
}
|
|
if (this.db)
|
|
o.$db = this.db;
|
|
o = Object.assign(o, this.fields);
|
|
return o;
|
|
}
|
|
static fromExtendedJSON(doc) {
|
|
const copy = Object.assign({}, doc);
|
|
delete copy.$ref;
|
|
delete copy.$id;
|
|
delete copy.$db;
|
|
return new DBRef(doc.$ref, doc.$id, doc.$db, copy);
|
|
}
|
|
inspect(depth, options, inspect) {
|
|
inspect ??= defaultInspect;
|
|
const args = [
|
|
inspect(this.namespace, options),
|
|
inspect(this.oid, options),
|
|
...(this.db ? [inspect(this.db, options)] : []),
|
|
...(Object.keys(this.fields).length > 0 ? [inspect(this.fields, options)] : [])
|
|
];
|
|
args[1] = inspect === defaultInspect ? `new ObjectId(${args[1]})` : args[1];
|
|
return `new DBRef(${args.join(', ')})`;
|
|
}
|
|
}
|
|
|
|
let wasm = undefined;
|
|
try {
|
|
wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 13, 2, 96, 0, 1, 127, 96, 4, 127, 127, 127, 127, 1, 127, 3, 7, 6, 0, 1, 1, 1, 1, 1, 6, 6, 1, 127, 1, 65, 0, 11, 7, 50, 6, 3, 109, 117, 108, 0, 1, 5, 100, 105, 118, 95, 115, 0, 2, 5, 100, 105, 118, 95, 117, 0, 3, 5, 114, 101, 109, 95, 115, 0, 4, 5, 114, 101, 109, 95, 117, 0, 5, 8, 103, 101, 116, 95, 104, 105, 103, 104, 0, 0, 10, 191, 1, 6, 4, 0, 35, 0, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 126, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 127, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 128, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 129, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 130, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11])), {}).exports;
|
|
}
|
|
catch {
|
|
}
|
|
const TWO_PWR_16_DBL = 1 << 16;
|
|
const TWO_PWR_24_DBL = 1 << 24;
|
|
const TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;
|
|
const TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;
|
|
const TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;
|
|
const INT_CACHE = {};
|
|
const UINT_CACHE = {};
|
|
const MAX_INT64_STRING_LENGTH = 20;
|
|
const DECIMAL_REG_EX = /^(\+?0|(\+|-)?[1-9][0-9]*)$/;
|
|
class Long extends BSONValue {
|
|
get _bsontype() {
|
|
return 'Long';
|
|
}
|
|
get __isLong__() {
|
|
return true;
|
|
}
|
|
constructor(low = 0, high, unsigned) {
|
|
super();
|
|
if (typeof low === 'bigint') {
|
|
Object.assign(this, Long.fromBigInt(low, !!high));
|
|
}
|
|
else if (typeof low === 'string') {
|
|
Object.assign(this, Long.fromString(low, !!high));
|
|
}
|
|
else {
|
|
this.low = low | 0;
|
|
this.high = high | 0;
|
|
this.unsigned = !!unsigned;
|
|
}
|
|
}
|
|
static fromBits(lowBits, highBits, unsigned) {
|
|
return new Long(lowBits, highBits, unsigned);
|
|
}
|
|
static fromInt(value, unsigned) {
|
|
let obj, cachedObj, cache;
|
|
if (unsigned) {
|
|
value >>>= 0;
|
|
if ((cache = 0 <= value && value < 256)) {
|
|
cachedObj = UINT_CACHE[value];
|
|
if (cachedObj)
|
|
return cachedObj;
|
|
}
|
|
obj = Long.fromBits(value, (value | 0) < 0 ? -1 : 0, true);
|
|
if (cache)
|
|
UINT_CACHE[value] = obj;
|
|
return obj;
|
|
}
|
|
else {
|
|
value |= 0;
|
|
if ((cache = -128 <= value && value < 128)) {
|
|
cachedObj = INT_CACHE[value];
|
|
if (cachedObj)
|
|
return cachedObj;
|
|
}
|
|
obj = Long.fromBits(value, value < 0 ? -1 : 0, false);
|
|
if (cache)
|
|
INT_CACHE[value] = obj;
|
|
return obj;
|
|
}
|
|
}
|
|
static fromNumber(value, unsigned) {
|
|
if (isNaN(value))
|
|
return unsigned ? Long.UZERO : Long.ZERO;
|
|
if (unsigned) {
|
|
if (value < 0)
|
|
return Long.UZERO;
|
|
if (value >= TWO_PWR_64_DBL)
|
|
return Long.MAX_UNSIGNED_VALUE;
|
|
}
|
|
else {
|
|
if (value <= -TWO_PWR_63_DBL)
|
|
return Long.MIN_VALUE;
|
|
if (value + 1 >= TWO_PWR_63_DBL)
|
|
return Long.MAX_VALUE;
|
|
}
|
|
if (value < 0)
|
|
return Long.fromNumber(-value, unsigned).neg();
|
|
return Long.fromBits(value % TWO_PWR_32_DBL | 0, (value / TWO_PWR_32_DBL) | 0, unsigned);
|
|
}
|
|
static fromBigInt(value, unsigned) {
|
|
return Long.fromString(value.toString(), unsigned);
|
|
}
|
|
static fromString(str, unsigned, radix) {
|
|
if (str.length === 0)
|
|
throw new BSONError('empty string');
|
|
if (str === 'NaN' || str === 'Infinity' || str === '+Infinity' || str === '-Infinity')
|
|
return Long.ZERO;
|
|
if (typeof unsigned === 'number') {
|
|
(radix = unsigned), (unsigned = false);
|
|
}
|
|
else {
|
|
unsigned = !!unsigned;
|
|
}
|
|
radix = radix || 10;
|
|
if (radix < 2 || 36 < radix)
|
|
throw new BSONError('radix');
|
|
let p;
|
|
if ((p = str.indexOf('-')) > 0)
|
|
throw new BSONError('interior hyphen');
|
|
else if (p === 0) {
|
|
return Long.fromString(str.substring(1), unsigned, radix).neg();
|
|
}
|
|
const radixToPower = Long.fromNumber(Math.pow(radix, 8));
|
|
let result = Long.ZERO;
|
|
for (let i = 0; i < str.length; i += 8) {
|
|
const size = Math.min(8, str.length - i), value = parseInt(str.substring(i, i + size), radix);
|
|
if (size < 8) {
|
|
const power = Long.fromNumber(Math.pow(radix, size));
|
|
result = result.mul(power).add(Long.fromNumber(value));
|
|
}
|
|
else {
|
|
result = result.mul(radixToPower);
|
|
result = result.add(Long.fromNumber(value));
|
|
}
|
|
}
|
|
result.unsigned = unsigned;
|
|
return result;
|
|
}
|
|
static fromBytes(bytes, unsigned, le) {
|
|
return le ? Long.fromBytesLE(bytes, unsigned) : Long.fromBytesBE(bytes, unsigned);
|
|
}
|
|
static fromBytesLE(bytes, unsigned) {
|
|
return new Long(bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24), bytes[4] | (bytes[5] << 8) | (bytes[6] << 16) | (bytes[7] << 24), unsigned);
|
|
}
|
|
static fromBytesBE(bytes, unsigned) {
|
|
return new Long((bytes[4] << 24) | (bytes[5] << 16) | (bytes[6] << 8) | bytes[7], (bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3], unsigned);
|
|
}
|
|
static isLong(value) {
|
|
return (value != null &&
|
|
typeof value === 'object' &&
|
|
'__isLong__' in value &&
|
|
value.__isLong__ === true);
|
|
}
|
|
static fromValue(val, unsigned) {
|
|
if (typeof val === 'number')
|
|
return Long.fromNumber(val, unsigned);
|
|
if (typeof val === 'string')
|
|
return Long.fromString(val, unsigned);
|
|
return Long.fromBits(val.low, val.high, typeof unsigned === 'boolean' ? unsigned : val.unsigned);
|
|
}
|
|
add(addend) {
|
|
if (!Long.isLong(addend))
|
|
addend = Long.fromValue(addend);
|
|
const a48 = this.high >>> 16;
|
|
const a32 = this.high & 0xffff;
|
|
const a16 = this.low >>> 16;
|
|
const a00 = this.low & 0xffff;
|
|
const b48 = addend.high >>> 16;
|
|
const b32 = addend.high & 0xffff;
|
|
const b16 = addend.low >>> 16;
|
|
const b00 = addend.low & 0xffff;
|
|
let c48 = 0, c32 = 0, c16 = 0, c00 = 0;
|
|
c00 += a00 + b00;
|
|
c16 += c00 >>> 16;
|
|
c00 &= 0xffff;
|
|
c16 += a16 + b16;
|
|
c32 += c16 >>> 16;
|
|
c16 &= 0xffff;
|
|
c32 += a32 + b32;
|
|
c48 += c32 >>> 16;
|
|
c32 &= 0xffff;
|
|
c48 += a48 + b48;
|
|
c48 &= 0xffff;
|
|
return Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);
|
|
}
|
|
and(other) {
|
|
if (!Long.isLong(other))
|
|
other = Long.fromValue(other);
|
|
return Long.fromBits(this.low & other.low, this.high & other.high, this.unsigned);
|
|
}
|
|
compare(other) {
|
|
if (!Long.isLong(other))
|
|
other = Long.fromValue(other);
|
|
if (this.eq(other))
|
|
return 0;
|
|
const thisNeg = this.isNegative(), otherNeg = other.isNegative();
|
|
if (thisNeg && !otherNeg)
|
|
return -1;
|
|
if (!thisNeg && otherNeg)
|
|
return 1;
|
|
if (!this.unsigned)
|
|
return this.sub(other).isNegative() ? -1 : 1;
|
|
return other.high >>> 0 > this.high >>> 0 ||
|
|
(other.high === this.high && other.low >>> 0 > this.low >>> 0)
|
|
? -1
|
|
: 1;
|
|
}
|
|
comp(other) {
|
|
return this.compare(other);
|
|
}
|
|
divide(divisor) {
|
|
if (!Long.isLong(divisor))
|
|
divisor = Long.fromValue(divisor);
|
|
if (divisor.isZero())
|
|
throw new BSONError('division by zero');
|
|
if (wasm) {
|
|
if (!this.unsigned &&
|
|
this.high === -0x80000000 &&
|
|
divisor.low === -1 &&
|
|
divisor.high === -1) {
|
|
return this;
|
|
}
|
|
const low = (this.unsigned ? wasm.div_u : wasm.div_s)(this.low, this.high, divisor.low, divisor.high);
|
|
return Long.fromBits(low, wasm.get_high(), this.unsigned);
|
|
}
|
|
if (this.isZero())
|
|
return this.unsigned ? Long.UZERO : Long.ZERO;
|
|
let approx, rem, res;
|
|
if (!this.unsigned) {
|
|
if (this.eq(Long.MIN_VALUE)) {
|
|
if (divisor.eq(Long.ONE) || divisor.eq(Long.NEG_ONE))
|
|
return Long.MIN_VALUE;
|
|
else if (divisor.eq(Long.MIN_VALUE))
|
|
return Long.ONE;
|
|
else {
|
|
const halfThis = this.shr(1);
|
|
approx = halfThis.div(divisor).shl(1);
|
|
if (approx.eq(Long.ZERO)) {
|
|
return divisor.isNegative() ? Long.ONE : Long.NEG_ONE;
|
|
}
|
|
else {
|
|
rem = this.sub(divisor.mul(approx));
|
|
res = approx.add(rem.div(divisor));
|
|
return res;
|
|
}
|
|
}
|
|
}
|
|
else if (divisor.eq(Long.MIN_VALUE))
|
|
return this.unsigned ? Long.UZERO : Long.ZERO;
|
|
if (this.isNegative()) {
|
|
if (divisor.isNegative())
|
|
return this.neg().div(divisor.neg());
|
|
return this.neg().div(divisor).neg();
|
|
}
|
|
else if (divisor.isNegative())
|
|
return this.div(divisor.neg()).neg();
|
|
res = Long.ZERO;
|
|
}
|
|
else {
|
|
if (!divisor.unsigned)
|
|
divisor = divisor.toUnsigned();
|
|
if (divisor.gt(this))
|
|
return Long.UZERO;
|
|
if (divisor.gt(this.shru(1)))
|
|
return Long.UONE;
|
|
res = Long.UZERO;
|
|
}
|
|
rem = this;
|
|
while (rem.gte(divisor)) {
|
|
approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));
|
|
const log2 = Math.ceil(Math.log(approx) / Math.LN2);
|
|
const delta = log2 <= 48 ? 1 : Math.pow(2, log2 - 48);
|
|
let approxRes = Long.fromNumber(approx);
|
|
let approxRem = approxRes.mul(divisor);
|
|
while (approxRem.isNegative() || approxRem.gt(rem)) {
|
|
approx -= delta;
|
|
approxRes = Long.fromNumber(approx, this.unsigned);
|
|
approxRem = approxRes.mul(divisor);
|
|
}
|
|
if (approxRes.isZero())
|
|
approxRes = Long.ONE;
|
|
res = res.add(approxRes);
|
|
rem = rem.sub(approxRem);
|
|
}
|
|
return res;
|
|
}
|
|
div(divisor) {
|
|
return this.divide(divisor);
|
|
}
|
|
equals(other) {
|
|
if (!Long.isLong(other))
|
|
other = Long.fromValue(other);
|
|
if (this.unsigned !== other.unsigned && this.high >>> 31 === 1 && other.high >>> 31 === 1)
|
|
return false;
|
|
return this.high === other.high && this.low === other.low;
|
|
}
|
|
eq(other) {
|
|
return this.equals(other);
|
|
}
|
|
getHighBits() {
|
|
return this.high;
|
|
}
|
|
getHighBitsUnsigned() {
|
|
return this.high >>> 0;
|
|
}
|
|
getLowBits() {
|
|
return this.low;
|
|
}
|
|
getLowBitsUnsigned() {
|
|
return this.low >>> 0;
|
|
}
|
|
getNumBitsAbs() {
|
|
if (this.isNegative()) {
|
|
return this.eq(Long.MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();
|
|
}
|
|
const val = this.high !== 0 ? this.high : this.low;
|
|
let bit;
|
|
for (bit = 31; bit > 0; bit--)
|
|
if ((val & (1 << bit)) !== 0)
|
|
break;
|
|
return this.high !== 0 ? bit + 33 : bit + 1;
|
|
}
|
|
greaterThan(other) {
|
|
return this.comp(other) > 0;
|
|
}
|
|
gt(other) {
|
|
return this.greaterThan(other);
|
|
}
|
|
greaterThanOrEqual(other) {
|
|
return this.comp(other) >= 0;
|
|
}
|
|
gte(other) {
|
|
return this.greaterThanOrEqual(other);
|
|
}
|
|
ge(other) {
|
|
return this.greaterThanOrEqual(other);
|
|
}
|
|
isEven() {
|
|
return (this.low & 1) === 0;
|
|
}
|
|
isNegative() {
|
|
return !this.unsigned && this.high < 0;
|
|
}
|
|
isOdd() {
|
|
return (this.low & 1) === 1;
|
|
}
|
|
isPositive() {
|
|
return this.unsigned || this.high >= 0;
|
|
}
|
|
isZero() {
|
|
return this.high === 0 && this.low === 0;
|
|
}
|
|
lessThan(other) {
|
|
return this.comp(other) < 0;
|
|
}
|
|
lt(other) {
|
|
return this.lessThan(other);
|
|
}
|
|
lessThanOrEqual(other) {
|
|
return this.comp(other) <= 0;
|
|
}
|
|
lte(other) {
|
|
return this.lessThanOrEqual(other);
|
|
}
|
|
modulo(divisor) {
|
|
if (!Long.isLong(divisor))
|
|
divisor = Long.fromValue(divisor);
|
|
if (wasm) {
|
|
const low = (this.unsigned ? wasm.rem_u : wasm.rem_s)(this.low, this.high, divisor.low, divisor.high);
|
|
return Long.fromBits(low, wasm.get_high(), this.unsigned);
|
|
}
|
|
return this.sub(this.div(divisor).mul(divisor));
|
|
}
|
|
mod(divisor) {
|
|
return this.modulo(divisor);
|
|
}
|
|
rem(divisor) {
|
|
return this.modulo(divisor);
|
|
}
|
|
multiply(multiplier) {
|
|
if (this.isZero())
|
|
return Long.ZERO;
|
|
if (!Long.isLong(multiplier))
|
|
multiplier = Long.fromValue(multiplier);
|
|
if (wasm) {
|
|
const low = wasm.mul(this.low, this.high, multiplier.low, multiplier.high);
|
|
return Long.fromBits(low, wasm.get_high(), this.unsigned);
|
|
}
|
|
if (multiplier.isZero())
|
|
return Long.ZERO;
|
|
if (this.eq(Long.MIN_VALUE))
|
|
return multiplier.isOdd() ? Long.MIN_VALUE : Long.ZERO;
|
|
if (multiplier.eq(Long.MIN_VALUE))
|
|
return this.isOdd() ? Long.MIN_VALUE : Long.ZERO;
|
|
if (this.isNegative()) {
|
|
if (multiplier.isNegative())
|
|
return this.neg().mul(multiplier.neg());
|
|
else
|
|
return this.neg().mul(multiplier).neg();
|
|
}
|
|
else if (multiplier.isNegative())
|
|
return this.mul(multiplier.neg()).neg();
|
|
if (this.lt(Long.TWO_PWR_24) && multiplier.lt(Long.TWO_PWR_24))
|
|
return Long.fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);
|
|
const a48 = this.high >>> 16;
|
|
const a32 = this.high & 0xffff;
|
|
const a16 = this.low >>> 16;
|
|
const a00 = this.low & 0xffff;
|
|
const b48 = multiplier.high >>> 16;
|
|
const b32 = multiplier.high & 0xffff;
|
|
const b16 = multiplier.low >>> 16;
|
|
const b00 = multiplier.low & 0xffff;
|
|
let c48 = 0, c32 = 0, c16 = 0, c00 = 0;
|
|
c00 += a00 * b00;
|
|
c16 += c00 >>> 16;
|
|
c00 &= 0xffff;
|
|
c16 += a16 * b00;
|
|
c32 += c16 >>> 16;
|
|
c16 &= 0xffff;
|
|
c16 += a00 * b16;
|
|
c32 += c16 >>> 16;
|
|
c16 &= 0xffff;
|
|
c32 += a32 * b00;
|
|
c48 += c32 >>> 16;
|
|
c32 &= 0xffff;
|
|
c32 += a16 * b16;
|
|
c48 += c32 >>> 16;
|
|
c32 &= 0xffff;
|
|
c32 += a00 * b32;
|
|
c48 += c32 >>> 16;
|
|
c32 &= 0xffff;
|
|
c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
|
|
c48 &= 0xffff;
|
|
return Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);
|
|
}
|
|
mul(multiplier) {
|
|
return this.multiply(multiplier);
|
|
}
|
|
negate() {
|
|
if (!this.unsigned && this.eq(Long.MIN_VALUE))
|
|
return Long.MIN_VALUE;
|
|
return this.not().add(Long.ONE);
|
|
}
|
|
neg() {
|
|
return this.negate();
|
|
}
|
|
not() {
|
|
return Long.fromBits(~this.low, ~this.high, this.unsigned);
|
|
}
|
|
notEquals(other) {
|
|
return !this.equals(other);
|
|
}
|
|
neq(other) {
|
|
return this.notEquals(other);
|
|
}
|
|
ne(other) {
|
|
return this.notEquals(other);
|
|
}
|
|
or(other) {
|
|
if (!Long.isLong(other))
|
|
other = Long.fromValue(other);
|
|
return Long.fromBits(this.low | other.low, this.high | other.high, this.unsigned);
|
|
}
|
|
shiftLeft(numBits) {
|
|
if (Long.isLong(numBits))
|
|
numBits = numBits.toInt();
|
|
if ((numBits &= 63) === 0)
|
|
return this;
|
|
else if (numBits < 32)
|
|
return Long.fromBits(this.low << numBits, (this.high << numBits) | (this.low >>> (32 - numBits)), this.unsigned);
|
|
else
|
|
return Long.fromBits(0, this.low << (numBits - 32), this.unsigned);
|
|
}
|
|
shl(numBits) {
|
|
return this.shiftLeft(numBits);
|
|
}
|
|
shiftRight(numBits) {
|
|
if (Long.isLong(numBits))
|
|
numBits = numBits.toInt();
|
|
if ((numBits &= 63) === 0)
|
|
return this;
|
|
else if (numBits < 32)
|
|
return Long.fromBits((this.low >>> numBits) | (this.high << (32 - numBits)), this.high >> numBits, this.unsigned);
|
|
else
|
|
return Long.fromBits(this.high >> (numBits - 32), this.high >= 0 ? 0 : -1, this.unsigned);
|
|
}
|
|
shr(numBits) {
|
|
return this.shiftRight(numBits);
|
|
}
|
|
shiftRightUnsigned(numBits) {
|
|
if (Long.isLong(numBits))
|
|
numBits = numBits.toInt();
|
|
numBits &= 63;
|
|
if (numBits === 0)
|
|
return this;
|
|
else {
|
|
const high = this.high;
|
|
if (numBits < 32) {
|
|
const low = this.low;
|
|
return Long.fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits, this.unsigned);
|
|
}
|
|
else if (numBits === 32)
|
|
return Long.fromBits(high, 0, this.unsigned);
|
|
else
|
|
return Long.fromBits(high >>> (numBits - 32), 0, this.unsigned);
|
|
}
|
|
}
|
|
shr_u(numBits) {
|
|
return this.shiftRightUnsigned(numBits);
|
|
}
|
|
shru(numBits) {
|
|
return this.shiftRightUnsigned(numBits);
|
|
}
|
|
subtract(subtrahend) {
|
|
if (!Long.isLong(subtrahend))
|
|
subtrahend = Long.fromValue(subtrahend);
|
|
return this.add(subtrahend.neg());
|
|
}
|
|
sub(subtrahend) {
|
|
return this.subtract(subtrahend);
|
|
}
|
|
toInt() {
|
|
return this.unsigned ? this.low >>> 0 : this.low;
|
|
}
|
|
toNumber() {
|
|
if (this.unsigned)
|
|
return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0);
|
|
return this.high * TWO_PWR_32_DBL + (this.low >>> 0);
|
|
}
|
|
toBigInt() {
|
|
return BigInt(this.toString());
|
|
}
|
|
toBytes(le) {
|
|
return le ? this.toBytesLE() : this.toBytesBE();
|
|
}
|
|
toBytesLE() {
|
|
const hi = this.high, lo = this.low;
|
|
return [
|
|
lo & 0xff,
|
|
(lo >>> 8) & 0xff,
|
|
(lo >>> 16) & 0xff,
|
|
lo >>> 24,
|
|
hi & 0xff,
|
|
(hi >>> 8) & 0xff,
|
|
(hi >>> 16) & 0xff,
|
|
hi >>> 24
|
|
];
|
|
}
|
|
toBytesBE() {
|
|
const hi = this.high, lo = this.low;
|
|
return [
|
|
hi >>> 24,
|
|
(hi >>> 16) & 0xff,
|
|
(hi >>> 8) & 0xff,
|
|
hi & 0xff,
|
|
lo >>> 24,
|
|
(lo >>> 16) & 0xff,
|
|
(lo >>> 8) & 0xff,
|
|
lo & 0xff
|
|
];
|
|
}
|
|
toSigned() {
|
|
if (!this.unsigned)
|
|
return this;
|
|
return Long.fromBits(this.low, this.high, false);
|
|
}
|
|
toString(radix) {
|
|
radix = radix || 10;
|
|
if (radix < 2 || 36 < radix)
|
|
throw new BSONError('radix');
|
|
if (this.isZero())
|
|
return '0';
|
|
if (this.isNegative()) {
|
|
if (this.eq(Long.MIN_VALUE)) {
|
|
const radixLong = Long.fromNumber(radix), div = this.div(radixLong), rem1 = div.mul(radixLong).sub(this);
|
|
return div.toString(radix) + rem1.toInt().toString(radix);
|
|
}
|
|
else
|
|
return '-' + this.neg().toString(radix);
|
|
}
|
|
const radixToPower = Long.fromNumber(Math.pow(radix, 6), this.unsigned);
|
|
let rem = this;
|
|
let result = '';
|
|
while (true) {
|
|
const remDiv = rem.div(radixToPower);
|
|
const intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0;
|
|
let digits = intval.toString(radix);
|
|
rem = remDiv;
|
|
if (rem.isZero()) {
|
|
return digits + result;
|
|
}
|
|
else {
|
|
while (digits.length < 6)
|
|
digits = '0' + digits;
|
|
result = '' + digits + result;
|
|
}
|
|
}
|
|
}
|
|
toUnsigned() {
|
|
if (this.unsigned)
|
|
return this;
|
|
return Long.fromBits(this.low, this.high, true);
|
|
}
|
|
xor(other) {
|
|
if (!Long.isLong(other))
|
|
other = Long.fromValue(other);
|
|
return Long.fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);
|
|
}
|
|
eqz() {
|
|
return this.isZero();
|
|
}
|
|
le(other) {
|
|
return this.lessThanOrEqual(other);
|
|
}
|
|
toExtendedJSON(options) {
|
|
if (options && options.relaxed)
|
|
return this.toNumber();
|
|
return { $numberLong: this.toString() };
|
|
}
|
|
static fromExtendedJSON(doc, options) {
|
|
const { useBigInt64 = false, relaxed = true } = { ...options };
|
|
if (doc.$numberLong.length > MAX_INT64_STRING_LENGTH) {
|
|
throw new BSONError('$numberLong string is too long');
|
|
}
|
|
if (!DECIMAL_REG_EX.test(doc.$numberLong)) {
|
|
throw new BSONError(`$numberLong string "${doc.$numberLong}" is in an invalid format`);
|
|
}
|
|
if (useBigInt64) {
|
|
const bigIntResult = BigInt(doc.$numberLong);
|
|
return BigInt.asIntN(64, bigIntResult);
|
|
}
|
|
const longResult = Long.fromString(doc.$numberLong);
|
|
if (relaxed) {
|
|
return longResult.toNumber();
|
|
}
|
|
return longResult;
|
|
}
|
|
inspect(depth, options, inspect) {
|
|
inspect ??= defaultInspect;
|
|
const longVal = inspect(this.toString(), options);
|
|
const unsignedVal = this.unsigned ? `, ${inspect(this.unsigned, options)}` : '';
|
|
return `new Long(${longVal}${unsignedVal})`;
|
|
}
|
|
}
|
|
Long.TWO_PWR_24 = Long.fromInt(TWO_PWR_24_DBL);
|
|
Long.MAX_UNSIGNED_VALUE = Long.fromBits(0xffffffff | 0, 0xffffffff | 0, true);
|
|
Long.ZERO = Long.fromInt(0);
|
|
Long.UZERO = Long.fromInt(0, true);
|
|
Long.ONE = Long.fromInt(1);
|
|
Long.UONE = Long.fromInt(1, true);
|
|
Long.NEG_ONE = Long.fromInt(-1);
|
|
Long.MAX_VALUE = Long.fromBits(0xffffffff | 0, 0x7fffffff | 0, false);
|
|
Long.MIN_VALUE = Long.fromBits(0, 0x80000000 | 0, false);
|
|
|
|
const PARSE_STRING_REGEXP = /^(\+|-)?(\d+|(\d*\.\d*))?(E|e)?([-+])?(\d+)?$/;
|
|
const PARSE_INF_REGEXP = /^(\+|-)?(Infinity|inf)$/i;
|
|
const PARSE_NAN_REGEXP = /^(\+|-)?NaN$/i;
|
|
const EXPONENT_MAX = 6111;
|
|
const EXPONENT_MIN = -6176;
|
|
const EXPONENT_BIAS = 6176;
|
|
const MAX_DIGITS = 34;
|
|
const NAN_BUFFER = ByteUtils.fromNumberArray([
|
|
0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
|
].reverse());
|
|
const INF_NEGATIVE_BUFFER = ByteUtils.fromNumberArray([
|
|
0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
|
].reverse());
|
|
const INF_POSITIVE_BUFFER = ByteUtils.fromNumberArray([
|
|
0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
|
].reverse());
|
|
const EXPONENT_REGEX = /^([-+])?(\d+)?$/;
|
|
const COMBINATION_MASK = 0x1f;
|
|
const EXPONENT_MASK = 0x3fff;
|
|
const COMBINATION_INFINITY = 30;
|
|
const COMBINATION_NAN = 31;
|
|
function isDigit(value) {
|
|
return !isNaN(parseInt(value, 10));
|
|
}
|
|
function divideu128(value) {
|
|
const DIVISOR = Long.fromNumber(1000 * 1000 * 1000);
|
|
let _rem = Long.fromNumber(0);
|
|
if (!value.parts[0] && !value.parts[1] && !value.parts[2] && !value.parts[3]) {
|
|
return { quotient: value, rem: _rem };
|
|
}
|
|
for (let i = 0; i <= 3; i++) {
|
|
_rem = _rem.shiftLeft(32);
|
|
_rem = _rem.add(new Long(value.parts[i], 0));
|
|
value.parts[i] = _rem.div(DIVISOR).low;
|
|
_rem = _rem.modulo(DIVISOR);
|
|
}
|
|
return { quotient: value, rem: _rem };
|
|
}
|
|
function multiply64x2(left, right) {
|
|
if (!left && !right) {
|
|
return { high: Long.fromNumber(0), low: Long.fromNumber(0) };
|
|
}
|
|
const leftHigh = left.shiftRightUnsigned(32);
|
|
const leftLow = new Long(left.getLowBits(), 0);
|
|
const rightHigh = right.shiftRightUnsigned(32);
|
|
const rightLow = new Long(right.getLowBits(), 0);
|
|
let productHigh = leftHigh.multiply(rightHigh);
|
|
let productMid = leftHigh.multiply(rightLow);
|
|
const productMid2 = leftLow.multiply(rightHigh);
|
|
let productLow = leftLow.multiply(rightLow);
|
|
productHigh = productHigh.add(productMid.shiftRightUnsigned(32));
|
|
productMid = new Long(productMid.getLowBits(), 0)
|
|
.add(productMid2)
|
|
.add(productLow.shiftRightUnsigned(32));
|
|
productHigh = productHigh.add(productMid.shiftRightUnsigned(32));
|
|
productLow = productMid.shiftLeft(32).add(new Long(productLow.getLowBits(), 0));
|
|
return { high: productHigh, low: productLow };
|
|
}
|
|
function lessThan(left, right) {
|
|
const uhleft = left.high >>> 0;
|
|
const uhright = right.high >>> 0;
|
|
if (uhleft < uhright) {
|
|
return true;
|
|
}
|
|
else if (uhleft === uhright) {
|
|
const ulleft = left.low >>> 0;
|
|
const ulright = right.low >>> 0;
|
|
if (ulleft < ulright)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function invalidErr(string, message) {
|
|
throw new BSONError(`"${string}" is not a valid Decimal128 string - ${message}`);
|
|
}
|
|
class Decimal128 extends BSONValue {
|
|
get _bsontype() {
|
|
return 'Decimal128';
|
|
}
|
|
constructor(bytes) {
|
|
super();
|
|
if (typeof bytes === 'string') {
|
|
this.bytes = Decimal128.fromString(bytes).bytes;
|
|
}
|
|
else if (isUint8Array(bytes)) {
|
|
if (bytes.byteLength !== 16) {
|
|
throw new BSONError('Decimal128 must take a Buffer of 16 bytes');
|
|
}
|
|
this.bytes = bytes;
|
|
}
|
|
else {
|
|
throw new BSONError('Decimal128 must take a Buffer or string');
|
|
}
|
|
}
|
|
static fromString(representation) {
|
|
return Decimal128._fromString(representation, { allowRounding: false });
|
|
}
|
|
static fromStringWithRounding(representation) {
|
|
return Decimal128._fromString(representation, { allowRounding: true });
|
|
}
|
|
static _fromString(representation, options) {
|
|
let isNegative = false;
|
|
let sawSign = false;
|
|
let sawRadix = false;
|
|
let foundNonZero = false;
|
|
let significantDigits = 0;
|
|
let nDigitsRead = 0;
|
|
let nDigits = 0;
|
|
let radixPosition = 0;
|
|
let firstNonZero = 0;
|
|
const digits = [0];
|
|
let nDigitsStored = 0;
|
|
let digitsInsert = 0;
|
|
let lastDigit = 0;
|
|
let exponent = 0;
|
|
let significandHigh = new Long(0, 0);
|
|
let significandLow = new Long(0, 0);
|
|
let biasedExponent = 0;
|
|
let index = 0;
|
|
if (representation.length >= 7000) {
|
|
throw new BSONError('' + representation + ' not a valid Decimal128 string');
|
|
}
|
|
const stringMatch = representation.match(PARSE_STRING_REGEXP);
|
|
const infMatch = representation.match(PARSE_INF_REGEXP);
|
|
const nanMatch = representation.match(PARSE_NAN_REGEXP);
|
|
if ((!stringMatch && !infMatch && !nanMatch) || representation.length === 0) {
|
|
throw new BSONError('' + representation + ' not a valid Decimal128 string');
|
|
}
|
|
if (stringMatch) {
|
|
const unsignedNumber = stringMatch[2];
|
|
const e = stringMatch[4];
|
|
const expSign = stringMatch[5];
|
|
const expNumber = stringMatch[6];
|
|
if (e && expNumber === undefined)
|
|
invalidErr(representation, 'missing exponent power');
|
|
if (e && unsignedNumber === undefined)
|
|
invalidErr(representation, 'missing exponent base');
|
|
if (e === undefined && (expSign || expNumber)) {
|
|
invalidErr(representation, 'missing e before exponent');
|
|
}
|
|
}
|
|
if (representation[index] === '+' || representation[index] === '-') {
|
|
sawSign = true;
|
|
isNegative = representation[index++] === '-';
|
|
}
|
|
if (!isDigit(representation[index]) && representation[index] !== '.') {
|
|
if (representation[index] === 'i' || representation[index] === 'I') {
|
|
return new Decimal128(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER);
|
|
}
|
|
else if (representation[index] === 'N') {
|
|
return new Decimal128(NAN_BUFFER);
|
|
}
|
|
}
|
|
while (isDigit(representation[index]) || representation[index] === '.') {
|
|
if (representation[index] === '.') {
|
|
if (sawRadix)
|
|
invalidErr(representation, 'contains multiple periods');
|
|
sawRadix = true;
|
|
index = index + 1;
|
|
continue;
|
|
}
|
|
if (nDigitsStored < MAX_DIGITS) {
|
|
if (representation[index] !== '0' || foundNonZero) {
|
|
if (!foundNonZero) {
|
|
firstNonZero = nDigitsRead;
|
|
}
|
|
foundNonZero = true;
|
|
digits[digitsInsert++] = parseInt(representation[index], 10);
|
|
nDigitsStored = nDigitsStored + 1;
|
|
}
|
|
}
|
|
if (foundNonZero)
|
|
nDigits = nDigits + 1;
|
|
if (sawRadix)
|
|
radixPosition = radixPosition + 1;
|
|
nDigitsRead = nDigitsRead + 1;
|
|
index = index + 1;
|
|
}
|
|
if (sawRadix && !nDigitsRead)
|
|
throw new BSONError('' + representation + ' not a valid Decimal128 string');
|
|
if (representation[index] === 'e' || representation[index] === 'E') {
|
|
const match = representation.substr(++index).match(EXPONENT_REGEX);
|
|
if (!match || !match[2])
|
|
return new Decimal128(NAN_BUFFER);
|
|
exponent = parseInt(match[0], 10);
|
|
index = index + match[0].length;
|
|
}
|
|
if (representation[index])
|
|
return new Decimal128(NAN_BUFFER);
|
|
if (!nDigitsStored) {
|
|
digits[0] = 0;
|
|
nDigits = 1;
|
|
nDigitsStored = 1;
|
|
significantDigits = 0;
|
|
}
|
|
else {
|
|
lastDigit = nDigitsStored - 1;
|
|
significantDigits = nDigits;
|
|
if (significantDigits !== 1) {
|
|
while (representation[firstNonZero + significantDigits - 1 + Number(sawSign) + Number(sawRadix)] === '0') {
|
|
significantDigits = significantDigits - 1;
|
|
}
|
|
}
|
|
}
|
|
if (exponent <= radixPosition && radixPosition > exponent + (1 << 14)) {
|
|
exponent = EXPONENT_MIN;
|
|
}
|
|
else {
|
|
exponent = exponent - radixPosition;
|
|
}
|
|
while (exponent > EXPONENT_MAX) {
|
|
lastDigit = lastDigit + 1;
|
|
if (lastDigit >= MAX_DIGITS) {
|
|
if (significantDigits === 0) {
|
|
exponent = EXPONENT_MAX;
|
|
break;
|
|
}
|
|
invalidErr(representation, 'overflow');
|
|
}
|
|
exponent = exponent - 1;
|
|
}
|
|
if (options.allowRounding) {
|
|
while (exponent < EXPONENT_MIN || nDigitsStored < nDigits) {
|
|
if (lastDigit === 0 && significantDigits < nDigitsStored) {
|
|
exponent = EXPONENT_MIN;
|
|
significantDigits = 0;
|
|
break;
|
|
}
|
|
if (nDigitsStored < nDigits) {
|
|
nDigits = nDigits - 1;
|
|
}
|
|
else {
|
|
lastDigit = lastDigit - 1;
|
|
}
|
|
if (exponent < EXPONENT_MAX) {
|
|
exponent = exponent + 1;
|
|
}
|
|
else {
|
|
const digitsString = digits.join('');
|
|
if (digitsString.match(/^0+$/)) {
|
|
exponent = EXPONENT_MAX;
|
|
break;
|
|
}
|
|
invalidErr(representation, 'overflow');
|
|
}
|
|
}
|
|
if (lastDigit + 1 < significantDigits) {
|
|
let endOfString = nDigitsRead;
|
|
if (sawRadix) {
|
|
firstNonZero = firstNonZero + 1;
|
|
endOfString = endOfString + 1;
|
|
}
|
|
if (sawSign) {
|
|
firstNonZero = firstNonZero + 1;
|
|
endOfString = endOfString + 1;
|
|
}
|
|
const roundDigit = parseInt(representation[firstNonZero + lastDigit + 1], 10);
|
|
let roundBit = 0;
|
|
if (roundDigit >= 5) {
|
|
roundBit = 1;
|
|
if (roundDigit === 5) {
|
|
roundBit = digits[lastDigit] % 2 === 1 ? 1 : 0;
|
|
for (let i = firstNonZero + lastDigit + 2; i < endOfString; i++) {
|
|
if (parseInt(representation[i], 10)) {
|
|
roundBit = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (roundBit) {
|
|
let dIdx = lastDigit;
|
|
for (; dIdx >= 0; dIdx--) {
|
|
if (++digits[dIdx] > 9) {
|
|
digits[dIdx] = 0;
|
|
if (dIdx === 0) {
|
|
if (exponent < EXPONENT_MAX) {
|
|
exponent = exponent + 1;
|
|
digits[dIdx] = 1;
|
|
}
|
|
else {
|
|
return new Decimal128(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
while (exponent < EXPONENT_MIN || nDigitsStored < nDigits) {
|
|
if (lastDigit === 0) {
|
|
if (significantDigits === 0) {
|
|
exponent = EXPONENT_MIN;
|
|
break;
|
|
}
|
|
invalidErr(representation, 'exponent underflow');
|
|
}
|
|
if (nDigitsStored < nDigits) {
|
|
if (representation[nDigits - 1 + Number(sawSign) + Number(sawRadix)] !== '0' &&
|
|
significantDigits !== 0) {
|
|
invalidErr(representation, 'inexact rounding');
|
|
}
|
|
nDigits = nDigits - 1;
|
|
}
|
|
else {
|
|
if (digits[lastDigit] !== 0) {
|
|
invalidErr(representation, 'inexact rounding');
|
|
}
|
|
lastDigit = lastDigit - 1;
|
|
}
|
|
if (exponent < EXPONENT_MAX) {
|
|
exponent = exponent + 1;
|
|
}
|
|
else {
|
|
invalidErr(representation, 'overflow');
|
|
}
|
|
}
|
|
if (lastDigit + 1 < significantDigits) {
|
|
if (sawRadix) {
|
|
firstNonZero = firstNonZero + 1;
|
|
}
|
|
if (sawSign) {
|
|
firstNonZero = firstNonZero + 1;
|
|
}
|
|
const roundDigit = parseInt(representation[firstNonZero + lastDigit + 1], 10);
|
|
if (roundDigit !== 0) {
|
|
invalidErr(representation, 'inexact rounding');
|
|
}
|
|
}
|
|
}
|
|
significandHigh = Long.fromNumber(0);
|
|
significandLow = Long.fromNumber(0);
|
|
if (significantDigits === 0) {
|
|
significandHigh = Long.fromNumber(0);
|
|
significandLow = Long.fromNumber(0);
|
|
}
|
|
else if (lastDigit < 17) {
|
|
let dIdx = 0;
|
|
significandLow = Long.fromNumber(digits[dIdx++]);
|
|
significandHigh = new Long(0, 0);
|
|
for (; dIdx <= lastDigit; dIdx++) {
|
|
significandLow = significandLow.multiply(Long.fromNumber(10));
|
|
significandLow = significandLow.add(Long.fromNumber(digits[dIdx]));
|
|
}
|
|
}
|
|
else {
|
|
let dIdx = 0;
|
|
significandHigh = Long.fromNumber(digits[dIdx++]);
|
|
for (; dIdx <= lastDigit - 17; dIdx++) {
|
|
significandHigh = significandHigh.multiply(Long.fromNumber(10));
|
|
significandHigh = significandHigh.add(Long.fromNumber(digits[dIdx]));
|
|
}
|
|
significandLow = Long.fromNumber(digits[dIdx++]);
|
|
for (; dIdx <= lastDigit; dIdx++) {
|
|
significandLow = significandLow.multiply(Long.fromNumber(10));
|
|
significandLow = significandLow.add(Long.fromNumber(digits[dIdx]));
|
|
}
|
|
}
|
|
const significand = multiply64x2(significandHigh, Long.fromString('100000000000000000'));
|
|
significand.low = significand.low.add(significandLow);
|
|
if (lessThan(significand.low, significandLow)) {
|
|
significand.high = significand.high.add(Long.fromNumber(1));
|
|
}
|
|
biasedExponent = exponent + EXPONENT_BIAS;
|
|
const dec = { low: Long.fromNumber(0), high: Long.fromNumber(0) };
|
|
if (significand.high.shiftRightUnsigned(49).and(Long.fromNumber(1)).equals(Long.fromNumber(1))) {
|
|
dec.high = dec.high.or(Long.fromNumber(0x3).shiftLeft(61));
|
|
dec.high = dec.high.or(Long.fromNumber(biasedExponent).and(Long.fromNumber(0x3fff).shiftLeft(47)));
|
|
dec.high = dec.high.or(significand.high.and(Long.fromNumber(0x7fffffffffff)));
|
|
}
|
|
else {
|
|
dec.high = dec.high.or(Long.fromNumber(biasedExponent & 0x3fff).shiftLeft(49));
|
|
dec.high = dec.high.or(significand.high.and(Long.fromNumber(0x1ffffffffffff)));
|
|
}
|
|
dec.low = significand.low;
|
|
if (isNegative) {
|
|
dec.high = dec.high.or(Long.fromString('9223372036854775808'));
|
|
}
|
|
const buffer = ByteUtils.allocate(16);
|
|
index = 0;
|
|
buffer[index++] = dec.low.low & 0xff;
|
|
buffer[index++] = (dec.low.low >> 8) & 0xff;
|
|
buffer[index++] = (dec.low.low >> 16) & 0xff;
|
|
buffer[index++] = (dec.low.low >> 24) & 0xff;
|
|
buffer[index++] = dec.low.high & 0xff;
|
|
buffer[index++] = (dec.low.high >> 8) & 0xff;
|
|
buffer[index++] = (dec.low.high >> 16) & 0xff;
|
|
buffer[index++] = (dec.low.high >> 24) & 0xff;
|
|
buffer[index++] = dec.high.low & 0xff;
|
|
buffer[index++] = (dec.high.low >> 8) & 0xff;
|
|
buffer[index++] = (dec.high.low >> 16) & 0xff;
|
|
buffer[index++] = (dec.high.low >> 24) & 0xff;
|
|
buffer[index++] = dec.high.high & 0xff;
|
|
buffer[index++] = (dec.high.high >> 8) & 0xff;
|
|
buffer[index++] = (dec.high.high >> 16) & 0xff;
|
|
buffer[index++] = (dec.high.high >> 24) & 0xff;
|
|
return new Decimal128(buffer);
|
|
}
|
|
toString() {
|
|
let biased_exponent;
|
|
let significand_digits = 0;
|
|
const significand = new Array(36);
|
|
for (let i = 0; i < significand.length; i++)
|
|
significand[i] = 0;
|
|
let index = 0;
|
|
let is_zero = false;
|
|
let significand_msb;
|
|
let significand128 = { parts: [0, 0, 0, 0] };
|
|
let j, k;
|
|
const string = [];
|
|
index = 0;
|
|
const buffer = this.bytes;
|
|
const low = buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);
|
|
const midl = buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);
|
|
const midh = buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);
|
|
const high = buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);
|
|
index = 0;
|
|
const dec = {
|
|
low: new Long(low, midl),
|
|
high: new Long(midh, high)
|
|
};
|
|
if (dec.high.lessThan(Long.ZERO)) {
|
|
string.push('-');
|
|
}
|
|
const combination = (high >> 26) & COMBINATION_MASK;
|
|
if (combination >> 3 === 3) {
|
|
if (combination === COMBINATION_INFINITY) {
|
|
return string.join('') + 'Infinity';
|
|
}
|
|
else if (combination === COMBINATION_NAN) {
|
|
return 'NaN';
|
|
}
|
|
else {
|
|
biased_exponent = (high >> 15) & EXPONENT_MASK;
|
|
significand_msb = 0x08 + ((high >> 14) & 0x01);
|
|
}
|
|
}
|
|
else {
|
|
significand_msb = (high >> 14) & 0x07;
|
|
biased_exponent = (high >> 17) & EXPONENT_MASK;
|
|
}
|
|
const exponent = biased_exponent - EXPONENT_BIAS;
|
|
significand128.parts[0] = (high & 0x3fff) + ((significand_msb & 0xf) << 14);
|
|
significand128.parts[1] = midh;
|
|
significand128.parts[2] = midl;
|
|
significand128.parts[3] = low;
|
|
if (significand128.parts[0] === 0 &&
|
|
significand128.parts[1] === 0 &&
|
|
significand128.parts[2] === 0 &&
|
|
significand128.parts[3] === 0) {
|
|
is_zero = true;
|
|
}
|
|
else {
|
|
for (k = 3; k >= 0; k--) {
|
|
let least_digits = 0;
|
|
const result = divideu128(significand128);
|
|
significand128 = result.quotient;
|
|
least_digits = result.rem.low;
|
|
if (!least_digits)
|
|
continue;
|
|
for (j = 8; j >= 0; j--) {
|
|
significand[k * 9 + j] = least_digits % 10;
|
|
least_digits = Math.floor(least_digits / 10);
|
|
}
|
|
}
|
|
}
|
|
if (is_zero) {
|
|
significand_digits = 1;
|
|
significand[index] = 0;
|
|
}
|
|
else {
|
|
significand_digits = 36;
|
|
while (!significand[index]) {
|
|
significand_digits = significand_digits - 1;
|
|
index = index + 1;
|
|
}
|
|
}
|
|
const scientific_exponent = significand_digits - 1 + exponent;
|
|
if (scientific_exponent >= 34 || scientific_exponent <= -7 || exponent > 0) {
|
|
if (significand_digits > 34) {
|
|
string.push(`${0}`);
|
|
if (exponent > 0)
|
|
string.push(`E+${exponent}`);
|
|
else if (exponent < 0)
|
|
string.push(`E${exponent}`);
|
|
return string.join('');
|
|
}
|
|
string.push(`${significand[index++]}`);
|
|
significand_digits = significand_digits - 1;
|
|
if (significand_digits) {
|
|
string.push('.');
|
|
}
|
|
for (let i = 0; i < significand_digits; i++) {
|
|
string.push(`${significand[index++]}`);
|
|
}
|
|
string.push('E');
|
|
if (scientific_exponent > 0) {
|
|
string.push(`+${scientific_exponent}`);
|
|
}
|
|
else {
|
|
string.push(`${scientific_exponent}`);
|
|
}
|
|
}
|
|
else {
|
|
if (exponent >= 0) {
|
|
for (let i = 0; i < significand_digits; i++) {
|
|
string.push(`${significand[index++]}`);
|
|
}
|
|
}
|
|
else {
|
|
let radix_position = significand_digits + exponent;
|
|
if (radix_position > 0) {
|
|
for (let i = 0; i < radix_position; i++) {
|
|
string.push(`${significand[index++]}`);
|
|
}
|
|
}
|
|
else {
|
|
string.push('0');
|
|
}
|
|
string.push('.');
|
|
while (radix_position++ < 0) {
|
|
string.push('0');
|
|
}
|
|
for (let i = 0; i < significand_digits - Math.max(radix_position - 1, 0); i++) {
|
|
string.push(`${significand[index++]}`);
|
|
}
|
|
}
|
|
}
|
|
return string.join('');
|
|
}
|
|
toJSON() {
|
|
return { $numberDecimal: this.toString() };
|
|
}
|
|
toExtendedJSON() {
|
|
return { $numberDecimal: this.toString() };
|
|
}
|
|
static fromExtendedJSON(doc) {
|
|
return Decimal128.fromString(doc.$numberDecimal);
|
|
}
|
|
inspect(depth, options, inspect) {
|
|
inspect ??= defaultInspect;
|
|
const d128string = inspect(this.toString(), options);
|
|
return `new Decimal128(${d128string})`;
|
|
}
|
|
}
|
|
|
|
class Double extends BSONValue {
|
|
get _bsontype() {
|
|
return 'Double';
|
|
}
|
|
constructor(value) {
|
|
super();
|
|
if (value instanceof Number) {
|
|
value = value.valueOf();
|
|
}
|
|
this.value = +value;
|
|
}
|
|
valueOf() {
|
|
return this.value;
|
|
}
|
|
toJSON() {
|
|
return this.value;
|
|
}
|
|
toString(radix) {
|
|
return this.value.toString(radix);
|
|
}
|
|
toExtendedJSON(options) {
|
|
if (options && (options.legacy || (options.relaxed && isFinite(this.value)))) {
|
|
return this.value;
|
|
}
|
|
if (Object.is(Math.sign(this.value), -0)) {
|
|
return { $numberDouble: '-0.0' };
|
|
}
|
|
return {
|
|
$numberDouble: Number.isInteger(this.value) ? this.value.toFixed(1) : this.value.toString()
|
|
};
|
|
}
|
|
static fromExtendedJSON(doc, options) {
|
|
const doubleValue = parseFloat(doc.$numberDouble);
|
|
return options && options.relaxed ? doubleValue : new Double(doubleValue);
|
|
}
|
|
inspect(depth, options, inspect) {
|
|
inspect ??= defaultInspect;
|
|
return `new Double(${inspect(this.value, options)})`;
|
|
}
|
|
}
|
|
|
|
class Int32 extends BSONValue {
|
|
get _bsontype() {
|
|
return 'Int32';
|
|
}
|
|
constructor(value) {
|
|
super();
|
|
if (value instanceof Number) {
|
|
value = value.valueOf();
|
|
}
|
|
this.value = +value | 0;
|
|
}
|
|
valueOf() {
|
|
return this.value;
|
|
}
|
|
toString(radix) {
|
|
return this.value.toString(radix);
|
|
}
|
|
toJSON() {
|
|
return this.value;
|
|
}
|
|
toExtendedJSON(options) {
|
|
if (options && (options.relaxed || options.legacy))
|
|
return this.value;
|
|
return { $numberInt: this.value.toString() };
|
|
}
|
|
static fromExtendedJSON(doc, options) {
|
|
return options && options.relaxed ? parseInt(doc.$numberInt, 10) : new Int32(doc.$numberInt);
|
|
}
|
|
inspect(depth, options, inspect) {
|
|
inspect ??= defaultInspect;
|
|
return `new Int32(${inspect(this.value, options)})`;
|
|
}
|
|
}
|
|
|
|
class MaxKey extends BSONValue {
|
|
get _bsontype() {
|
|
return 'MaxKey';
|
|
}
|
|
toExtendedJSON() {
|
|
return { $maxKey: 1 };
|
|
}
|
|
static fromExtendedJSON() {
|
|
return new MaxKey();
|
|
}
|
|
inspect() {
|
|
return 'new MaxKey()';
|
|
}
|
|
}
|
|
|
|
class MinKey extends BSONValue {
|
|
get _bsontype() {
|
|
return 'MinKey';
|
|
}
|
|
toExtendedJSON() {
|
|
return { $minKey: 1 };
|
|
}
|
|
static fromExtendedJSON() {
|
|
return new MinKey();
|
|
}
|
|
inspect() {
|
|
return 'new MinKey()';
|
|
}
|
|
}
|
|
|
|
const checkForHexRegExp = new RegExp('^[0-9a-fA-F]{24}$');
|
|
let PROCESS_UNIQUE = null;
|
|
const kId = Symbol('id');
|
|
class ObjectId extends BSONValue {
|
|
get _bsontype() {
|
|
return 'ObjectId';
|
|
}
|
|
constructor(inputId) {
|
|
super();
|
|
let workingId;
|
|
if (typeof inputId === 'object' && inputId && 'id' in inputId) {
|
|
if (typeof inputId.id !== 'string' && !ArrayBuffer.isView(inputId.id)) {
|
|
throw new BSONError('Argument passed in must have an id that is of type string or Buffer');
|
|
}
|
|
if ('toHexString' in inputId && typeof inputId.toHexString === 'function') {
|
|
workingId = ByteUtils.fromHex(inputId.toHexString());
|
|
}
|
|
else {
|
|
workingId = inputId.id;
|
|
}
|
|
}
|
|
else {
|
|
workingId = inputId;
|
|
}
|
|
if (workingId == null || typeof workingId === 'number') {
|
|
this[kId] = ObjectId.generate(typeof workingId === 'number' ? workingId : undefined);
|
|
}
|
|
else if (ArrayBuffer.isView(workingId) && workingId.byteLength === 12) {
|
|
this[kId] = ByteUtils.toLocalBufferType(workingId);
|
|
}
|
|
else if (typeof workingId === 'string') {
|
|
if (workingId.length === 24 && checkForHexRegExp.test(workingId)) {
|
|
this[kId] = ByteUtils.fromHex(workingId);
|
|
}
|
|
else {
|
|
throw new BSONError('input must be a 24 character hex string, 12 byte Uint8Array, or an integer');
|
|
}
|
|
}
|
|
else {
|
|
throw new BSONError('Argument passed in does not match the accepted types');
|
|
}
|
|
if (ObjectId.cacheHexString) {
|
|
this.__id = ByteUtils.toHex(this.id);
|
|
}
|
|
}
|
|
get id() {
|
|
return this[kId];
|
|
}
|
|
set id(value) {
|
|
this[kId] = value;
|
|
if (ObjectId.cacheHexString) {
|
|
this.__id = ByteUtils.toHex(value);
|
|
}
|
|
}
|
|
toHexString() {
|
|
if (ObjectId.cacheHexString && this.__id) {
|
|
return this.__id;
|
|
}
|
|
const hexString = ByteUtils.toHex(this.id);
|
|
if (ObjectId.cacheHexString && !this.__id) {
|
|
this.__id = hexString;
|
|
}
|
|
return hexString;
|
|
}
|
|
static getInc() {
|
|
return (ObjectId.index = (ObjectId.index + 1) % 0xffffff);
|
|
}
|
|
static generate(time) {
|
|
if ('number' !== typeof time) {
|
|
time = Math.floor(Date.now() / 1000);
|
|
}
|
|
const inc = ObjectId.getInc();
|
|
const buffer = ByteUtils.allocate(12);
|
|
BSONDataView.fromUint8Array(buffer).setUint32(0, time, false);
|
|
if (PROCESS_UNIQUE === null) {
|
|
PROCESS_UNIQUE = ByteUtils.randomBytes(5);
|
|
}
|
|
buffer[4] = PROCESS_UNIQUE[0];
|
|
buffer[5] = PROCESS_UNIQUE[1];
|
|
buffer[6] = PROCESS_UNIQUE[2];
|
|
buffer[7] = PROCESS_UNIQUE[3];
|
|
buffer[8] = PROCESS_UNIQUE[4];
|
|
buffer[11] = inc & 0xff;
|
|
buffer[10] = (inc >> 8) & 0xff;
|
|
buffer[9] = (inc >> 16) & 0xff;
|
|
return buffer;
|
|
}
|
|
toString(encoding) {
|
|
if (encoding === 'base64')
|
|
return ByteUtils.toBase64(this.id);
|
|
if (encoding === 'hex')
|
|
return this.toHexString();
|
|
return this.toHexString();
|
|
}
|
|
toJSON() {
|
|
return this.toHexString();
|
|
}
|
|
static is(variable) {
|
|
return (variable != null &&
|
|
typeof variable === 'object' &&
|
|
'_bsontype' in variable &&
|
|
variable._bsontype === 'ObjectId');
|
|
}
|
|
equals(otherId) {
|
|
if (otherId === undefined || otherId === null) {
|
|
return false;
|
|
}
|
|
if (ObjectId.is(otherId)) {
|
|
return this[kId][11] === otherId[kId][11] && ByteUtils.equals(this[kId], otherId[kId]);
|
|
}
|
|
if (typeof otherId === 'string') {
|
|
return otherId.toLowerCase() === this.toHexString();
|
|
}
|
|
if (typeof otherId === 'object' && typeof otherId.toHexString === 'function') {
|
|
const otherIdString = otherId.toHexString();
|
|
const thisIdString = this.toHexString();
|
|
return typeof otherIdString === 'string' && otherIdString.toLowerCase() === thisIdString;
|
|
}
|
|
return false;
|
|
}
|
|
getTimestamp() {
|
|
const timestamp = new Date();
|
|
const time = BSONDataView.fromUint8Array(this.id).getUint32(0, false);
|
|
timestamp.setTime(Math.floor(time) * 1000);
|
|
return timestamp;
|
|
}
|
|
static createPk() {
|
|
return new ObjectId();
|
|
}
|
|
static createFromTime(time) {
|
|
const buffer = ByteUtils.fromNumberArray([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
|
|
BSONDataView.fromUint8Array(buffer).setUint32(0, time, false);
|
|
return new ObjectId(buffer);
|
|
}
|
|
static createFromHexString(hexString) {
|
|
if (hexString?.length !== 24) {
|
|
throw new BSONError('hex string must be 24 characters');
|
|
}
|
|
return new ObjectId(ByteUtils.fromHex(hexString));
|
|
}
|
|
static createFromBase64(base64) {
|
|
if (base64?.length !== 16) {
|
|
throw new BSONError('base64 string must be 16 characters');
|
|
}
|
|
return new ObjectId(ByteUtils.fromBase64(base64));
|
|
}
|
|
static isValid(id) {
|
|
if (id == null)
|
|
return false;
|
|
try {
|
|
new ObjectId(id);
|
|
return true;
|
|
}
|
|
catch {
|
|
return false;
|
|
}
|
|
}
|
|
toExtendedJSON() {
|
|
if (this.toHexString)
|
|
return { $oid: this.toHexString() };
|
|
return { $oid: this.toString('hex') };
|
|
}
|
|
static fromExtendedJSON(doc) {
|
|
return new ObjectId(doc.$oid);
|
|
}
|
|
inspect(depth, options, inspect) {
|
|
inspect ??= defaultInspect;
|
|
return `new ObjectId(${inspect(this.toHexString(), options)})`;
|
|
}
|
|
}
|
|
ObjectId.index = Math.floor(Math.random() * 0xffffff);
|
|
|
|
function internalCalculateObjectSize(object, serializeFunctions, ignoreUndefined) {
|
|
let totalLength = 4 + 1;
|
|
if (Array.isArray(object)) {
|
|
for (let i = 0; i < object.length; i++) {
|
|
totalLength += calculateElement(i.toString(), object[i], serializeFunctions, true, ignoreUndefined);
|
|
}
|
|
}
|
|
else {
|
|
if (typeof object?.toBSON === 'function') {
|
|
object = object.toBSON();
|
|
}
|
|
for (const key of Object.keys(object)) {
|
|
totalLength += calculateElement(key, object[key], serializeFunctions, false, ignoreUndefined);
|
|
}
|
|
}
|
|
return totalLength;
|
|
}
|
|
function calculateElement(name, value, serializeFunctions = false, isArray = false, ignoreUndefined = false) {
|
|
if (typeof value?.toBSON === 'function') {
|
|
value = value.toBSON();
|
|
}
|
|
switch (typeof value) {
|
|
case 'string':
|
|
return 1 + ByteUtils.utf8ByteLength(name) + 1 + 4 + ByteUtils.utf8ByteLength(value) + 1;
|
|
case 'number':
|
|
if (Math.floor(value) === value &&
|
|
value >= JS_INT_MIN &&
|
|
value <= JS_INT_MAX) {
|
|
if (value >= BSON_INT32_MIN && value <= BSON_INT32_MAX) {
|
|
return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (4 + 1);
|
|
}
|
|
else {
|
|
return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (8 + 1);
|
|
}
|
|
}
|
|
else {
|
|
return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (8 + 1);
|
|
}
|
|
case 'undefined':
|
|
if (isArray || !ignoreUndefined)
|
|
return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + 1;
|
|
return 0;
|
|
case 'boolean':
|
|
return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (1 + 1);
|
|
case 'object':
|
|
if (value != null &&
|
|
typeof value._bsontype === 'string' &&
|
|
value[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
|
|
throw new BSONVersionError();
|
|
}
|
|
else if (value == null || value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
|
|
return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + 1;
|
|
}
|
|
else if (value._bsontype === 'ObjectId') {
|
|
return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (12 + 1);
|
|
}
|
|
else if (value instanceof Date || isDate(value)) {
|
|
return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (8 + 1);
|
|
}
|
|
else if (ArrayBuffer.isView(value) ||
|
|
value instanceof ArrayBuffer ||
|
|
isAnyArrayBuffer(value)) {
|
|
return ((name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (1 + 4 + 1) + value.byteLength);
|
|
}
|
|
else if (value._bsontype === 'Long' ||
|
|
value._bsontype === 'Double' ||
|
|
value._bsontype === 'Timestamp') {
|
|
return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (8 + 1);
|
|
}
|
|
else if (value._bsontype === 'Decimal128') {
|
|
return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (16 + 1);
|
|
}
|
|
else if (value._bsontype === 'Code') {
|
|
if (value.scope != null && Object.keys(value.scope).length > 0) {
|
|
return ((name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +
|
|
1 +
|
|
4 +
|
|
4 +
|
|
ByteUtils.utf8ByteLength(value.code.toString()) +
|
|
1 +
|
|
internalCalculateObjectSize(value.scope, serializeFunctions, ignoreUndefined));
|
|
}
|
|
else {
|
|
return ((name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +
|
|
1 +
|
|
4 +
|
|
ByteUtils.utf8ByteLength(value.code.toString()) +
|
|
1);
|
|
}
|
|
}
|
|
else if (value._bsontype === 'Binary') {
|
|
const binary = value;
|
|
if (binary.sub_type === Binary.SUBTYPE_BYTE_ARRAY) {
|
|
return ((name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +
|
|
(binary.position + 1 + 4 + 1 + 4));
|
|
}
|
|
else {
|
|
return ((name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (binary.position + 1 + 4 + 1));
|
|
}
|
|
}
|
|
else if (value._bsontype === 'Symbol') {
|
|
return ((name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +
|
|
ByteUtils.utf8ByteLength(value.value) +
|
|
4 +
|
|
1 +
|
|
1);
|
|
}
|
|
else if (value._bsontype === 'DBRef') {
|
|
const ordered_values = Object.assign({
|
|
$ref: value.collection,
|
|
$id: value.oid
|
|
}, value.fields);
|
|
if (value.db != null) {
|
|
ordered_values['$db'] = value.db;
|
|
}
|
|
return ((name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +
|
|
1 +
|
|
internalCalculateObjectSize(ordered_values, serializeFunctions, ignoreUndefined));
|
|
}
|
|
else if (value instanceof RegExp || isRegExp(value)) {
|
|
return ((name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +
|
|
1 +
|
|
ByteUtils.utf8ByteLength(value.source) +
|
|
1 +
|
|
(value.global ? 1 : 0) +
|
|
(value.ignoreCase ? 1 : 0) +
|
|
(value.multiline ? 1 : 0) +
|
|
1);
|
|
}
|
|
else if (value._bsontype === 'BSONRegExp') {
|
|
return ((name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +
|
|
1 +
|
|
ByteUtils.utf8ByteLength(value.pattern) +
|
|
1 +
|
|
ByteUtils.utf8ByteLength(value.options) +
|
|
1);
|
|
}
|
|
else {
|
|
return ((name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +
|
|
internalCalculateObjectSize(value, serializeFunctions, ignoreUndefined) +
|
|
1);
|
|
}
|
|
case 'function':
|
|
if (serializeFunctions) {
|
|
return ((name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +
|
|
1 +
|
|
4 +
|
|
ByteUtils.utf8ByteLength(value.toString()) +
|
|
1);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
function alphabetize(str) {
|
|
return str.split('').sort().join('');
|
|
}
|
|
class BSONRegExp extends BSONValue {
|
|
get _bsontype() {
|
|
return 'BSONRegExp';
|
|
}
|
|
constructor(pattern, options) {
|
|
super();
|
|
this.pattern = pattern;
|
|
this.options = alphabetize(options ?? '');
|
|
if (this.pattern.indexOf('\x00') !== -1) {
|
|
throw new BSONError(`BSON Regex patterns cannot contain null bytes, found: ${JSON.stringify(this.pattern)}`);
|
|
}
|
|
if (this.options.indexOf('\x00') !== -1) {
|
|
throw new BSONError(`BSON Regex options cannot contain null bytes, found: ${JSON.stringify(this.options)}`);
|
|
}
|
|
for (let i = 0; i < this.options.length; i++) {
|
|
if (!(this.options[i] === 'i' ||
|
|
this.options[i] === 'm' ||
|
|
this.options[i] === 'x' ||
|
|
this.options[i] === 'l' ||
|
|
this.options[i] === 's' ||
|
|
this.options[i] === 'u')) {
|
|
throw new BSONError(`The regular expression option [${this.options[i]}] is not supported`);
|
|
}
|
|
}
|
|
}
|
|
static parseOptions(options) {
|
|
return options ? options.split('').sort().join('') : '';
|
|
}
|
|
toExtendedJSON(options) {
|
|
options = options || {};
|
|
if (options.legacy) {
|
|
return { $regex: this.pattern, $options: this.options };
|
|
}
|
|
return { $regularExpression: { pattern: this.pattern, options: this.options } };
|
|
}
|
|
static fromExtendedJSON(doc) {
|
|
if ('$regex' in doc) {
|
|
if (typeof doc.$regex !== 'string') {
|
|
if (doc.$regex._bsontype === 'BSONRegExp') {
|
|
return doc;
|
|
}
|
|
}
|
|
else {
|
|
return new BSONRegExp(doc.$regex, BSONRegExp.parseOptions(doc.$options));
|
|
}
|
|
}
|
|
if ('$regularExpression' in doc) {
|
|
return new BSONRegExp(doc.$regularExpression.pattern, BSONRegExp.parseOptions(doc.$regularExpression.options));
|
|
}
|
|
throw new BSONError(`Unexpected BSONRegExp EJSON object form: ${JSON.stringify(doc)}`);
|
|
}
|
|
inspect(depth, options, inspect) {
|
|
const stylize = getStylizeFunction(options) ?? (v => v);
|
|
inspect ??= defaultInspect;
|
|
const pattern = stylize(inspect(this.pattern), 'regexp');
|
|
const flags = stylize(inspect(this.options), 'regexp');
|
|
return `new BSONRegExp(${pattern}, ${flags})`;
|
|
}
|
|
}
|
|
|
|
class BSONSymbol extends BSONValue {
|
|
get _bsontype() {
|
|
return 'BSONSymbol';
|
|
}
|
|
constructor(value) {
|
|
super();
|
|
this.value = value;
|
|
}
|
|
valueOf() {
|
|
return this.value;
|
|
}
|
|
toString() {
|
|
return this.value;
|
|
}
|
|
toJSON() {
|
|
return this.value;
|
|
}
|
|
toExtendedJSON() {
|
|
return { $symbol: this.value };
|
|
}
|
|
static fromExtendedJSON(doc) {
|
|
return new BSONSymbol(doc.$symbol);
|
|
}
|
|
inspect(depth, options, inspect) {
|
|
inspect ??= defaultInspect;
|
|
return `new BSONSymbol(${inspect(this.value, options)})`;
|
|
}
|
|
}
|
|
|
|
const LongWithoutOverridesClass = Long;
|
|
class Timestamp extends LongWithoutOverridesClass {
|
|
get _bsontype() {
|
|
return 'Timestamp';
|
|
}
|
|
constructor(low) {
|
|
if (low == null) {
|
|
super(0, 0, true);
|
|
}
|
|
else if (typeof low === 'bigint') {
|
|
super(low, true);
|
|
}
|
|
else if (Long.isLong(low)) {
|
|
super(low.low, low.high, true);
|
|
}
|
|
else if (typeof low === 'object' && 't' in low && 'i' in low) {
|
|
if (typeof low.t !== 'number' && (typeof low.t !== 'object' || low.t._bsontype !== 'Int32')) {
|
|
throw new BSONError('Timestamp constructed from { t, i } must provide t as a number');
|
|
}
|
|
if (typeof low.i !== 'number' && (typeof low.i !== 'object' || low.i._bsontype !== 'Int32')) {
|
|
throw new BSONError('Timestamp constructed from { t, i } must provide i as a number');
|
|
}
|
|
const t = Number(low.t);
|
|
const i = Number(low.i);
|
|
if (t < 0 || Number.isNaN(t)) {
|
|
throw new BSONError('Timestamp constructed from { t, i } must provide a positive t');
|
|
}
|
|
if (i < 0 || Number.isNaN(i)) {
|
|
throw new BSONError('Timestamp constructed from { t, i } must provide a positive i');
|
|
}
|
|
if (t > 4294967295) {
|
|
throw new BSONError('Timestamp constructed from { t, i } must provide t equal or less than uint32 max');
|
|
}
|
|
if (i > 4294967295) {
|
|
throw new BSONError('Timestamp constructed from { t, i } must provide i equal or less than uint32 max');
|
|
}
|
|
super(i, t, true);
|
|
}
|
|
else {
|
|
throw new BSONError('A Timestamp can only be constructed with: bigint, Long, or { t: number; i: number }');
|
|
}
|
|
}
|
|
toJSON() {
|
|
return {
|
|
$timestamp: this.toString()
|
|
};
|
|
}
|
|
static fromInt(value) {
|
|
return new Timestamp(Long.fromInt(value, true));
|
|
}
|
|
static fromNumber(value) {
|
|
return new Timestamp(Long.fromNumber(value, true));
|
|
}
|
|
static fromBits(lowBits, highBits) {
|
|
return new Timestamp({ i: lowBits, t: highBits });
|
|
}
|
|
static fromString(str, optRadix) {
|
|
return new Timestamp(Long.fromString(str, true, optRadix));
|
|
}
|
|
toExtendedJSON() {
|
|
return { $timestamp: { t: this.high >>> 0, i: this.low >>> 0 } };
|
|
}
|
|
static fromExtendedJSON(doc) {
|
|
const i = Long.isLong(doc.$timestamp.i)
|
|
? doc.$timestamp.i.getLowBitsUnsigned()
|
|
: doc.$timestamp.i;
|
|
const t = Long.isLong(doc.$timestamp.t)
|
|
? doc.$timestamp.t.getLowBitsUnsigned()
|
|
: doc.$timestamp.t;
|
|
return new Timestamp({ t, i });
|
|
}
|
|
inspect(depth, options, inspect) {
|
|
inspect ??= defaultInspect;
|
|
const t = inspect(this.high >>> 0, options);
|
|
const i = inspect(this.low >>> 0, options);
|
|
return `new Timestamp({ t: ${t}, i: ${i} })`;
|
|
}
|
|
}
|
|
Timestamp.MAX_VALUE = Long.MAX_UNSIGNED_VALUE;
|
|
|
|
const FIRST_BIT = 0x80;
|
|
const FIRST_TWO_BITS = 0xc0;
|
|
const FIRST_THREE_BITS = 0xe0;
|
|
const FIRST_FOUR_BITS = 0xf0;
|
|
const FIRST_FIVE_BITS = 0xf8;
|
|
const TWO_BIT_CHAR = 0xc0;
|
|
const THREE_BIT_CHAR = 0xe0;
|
|
const FOUR_BIT_CHAR = 0xf0;
|
|
const CONTINUING_CHAR = 0x80;
|
|
function validateUtf8(bytes, start, end) {
|
|
let continuation = 0;
|
|
for (let i = start; i < end; i += 1) {
|
|
const byte = bytes[i];
|
|
if (continuation) {
|
|
if ((byte & FIRST_TWO_BITS) !== CONTINUING_CHAR) {
|
|
return false;
|
|
}
|
|
continuation -= 1;
|
|
}
|
|
else if (byte & FIRST_BIT) {
|
|
if ((byte & FIRST_THREE_BITS) === TWO_BIT_CHAR) {
|
|
continuation = 1;
|
|
}
|
|
else if ((byte & FIRST_FOUR_BITS) === THREE_BIT_CHAR) {
|
|
continuation = 2;
|
|
}
|
|
else if ((byte & FIRST_FIVE_BITS) === FOUR_BIT_CHAR) {
|
|
continuation = 3;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return !continuation;
|
|
}
|
|
|
|
const JS_INT_MAX_LONG = Long.fromNumber(JS_INT_MAX);
|
|
const JS_INT_MIN_LONG = Long.fromNumber(JS_INT_MIN);
|
|
function internalDeserialize(buffer, options, isArray) {
|
|
options = options == null ? {} : options;
|
|
const index = options && options.index ? options.index : 0;
|
|
const size = buffer[index] |
|
|
(buffer[index + 1] << 8) |
|
|
(buffer[index + 2] << 16) |
|
|
(buffer[index + 3] << 24);
|
|
if (size < 5) {
|
|
throw new BSONError(`bson size must be >= 5, is ${size}`);
|
|
}
|
|
if (options.allowObjectSmallerThanBufferSize && buffer.length < size) {
|
|
throw new BSONError(`buffer length ${buffer.length} must be >= bson size ${size}`);
|
|
}
|
|
if (!options.allowObjectSmallerThanBufferSize && buffer.length !== size) {
|
|
throw new BSONError(`buffer length ${buffer.length} must === bson size ${size}`);
|
|
}
|
|
if (size + index > buffer.byteLength) {
|
|
throw new BSONError(`(bson size ${size} + options.index ${index} must be <= buffer length ${buffer.byteLength})`);
|
|
}
|
|
if (buffer[index + size - 1] !== 0) {
|
|
throw new BSONError("One object, sized correctly, with a spot for an EOO, but the EOO isn't 0x00");
|
|
}
|
|
return deserializeObject(buffer, index, options, isArray);
|
|
}
|
|
const allowedDBRefKeys = /^\$ref$|^\$id$|^\$db$/;
|
|
function deserializeObject(buffer, index, options, isArray = false) {
|
|
const fieldsAsRaw = options['fieldsAsRaw'] == null ? null : options['fieldsAsRaw'];
|
|
const raw = options['raw'] == null ? false : options['raw'];
|
|
const bsonRegExp = typeof options['bsonRegExp'] === 'boolean' ? options['bsonRegExp'] : false;
|
|
const promoteBuffers = options.promoteBuffers ?? false;
|
|
const promoteLongs = options.promoteLongs ?? true;
|
|
const promoteValues = options.promoteValues ?? true;
|
|
const useBigInt64 = options.useBigInt64 ?? false;
|
|
if (useBigInt64 && !promoteValues) {
|
|
throw new BSONError('Must either request bigint or Long for int64 deserialization');
|
|
}
|
|
if (useBigInt64 && !promoteLongs) {
|
|
throw new BSONError('Must either request bigint or Long for int64 deserialization');
|
|
}
|
|
const validation = options.validation == null ? { utf8: true } : options.validation;
|
|
let globalUTFValidation = true;
|
|
let validationSetting;
|
|
const utf8KeysSet = new Set();
|
|
const utf8ValidatedKeys = validation.utf8;
|
|
if (typeof utf8ValidatedKeys === 'boolean') {
|
|
validationSetting = utf8ValidatedKeys;
|
|
}
|
|
else {
|
|
globalUTFValidation = false;
|
|
const utf8ValidationValues = Object.keys(utf8ValidatedKeys).map(function (key) {
|
|
return utf8ValidatedKeys[key];
|
|
});
|
|
if (utf8ValidationValues.length === 0) {
|
|
throw new BSONError('UTF-8 validation setting cannot be empty');
|
|
}
|
|
if (typeof utf8ValidationValues[0] !== 'boolean') {
|
|
throw new BSONError('Invalid UTF-8 validation option, must specify boolean values');
|
|
}
|
|
validationSetting = utf8ValidationValues[0];
|
|
if (!utf8ValidationValues.every(item => item === validationSetting)) {
|
|
throw new BSONError('Invalid UTF-8 validation option - keys must be all true or all false');
|
|
}
|
|
}
|
|
if (!globalUTFValidation) {
|
|
for (const key of Object.keys(utf8ValidatedKeys)) {
|
|
utf8KeysSet.add(key);
|
|
}
|
|
}
|
|
const startIndex = index;
|
|
if (buffer.length < 5)
|
|
throw new BSONError('corrupt bson message < 5 bytes long');
|
|
const size = buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);
|
|
if (size < 5 || size > buffer.length)
|
|
throw new BSONError('corrupt bson message');
|
|
const object = isArray ? [] : {};
|
|
let arrayIndex = 0;
|
|
const done = false;
|
|
let isPossibleDBRef = isArray ? false : null;
|
|
const dataview = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
|
|
while (!done) {
|
|
const elementType = buffer[index++];
|
|
if (elementType === 0)
|
|
break;
|
|
let i = index;
|
|
while (buffer[i] !== 0x00 && i < buffer.length) {
|
|
i++;
|
|
}
|
|
if (i >= buffer.byteLength)
|
|
throw new BSONError('Bad BSON Document: illegal CString');
|
|
const name = isArray ? arrayIndex++ : ByteUtils.toUTF8(buffer, index, i);
|
|
let shouldValidateKey = true;
|
|
if (globalUTFValidation || utf8KeysSet.has(name)) {
|
|
shouldValidateKey = validationSetting;
|
|
}
|
|
else {
|
|
shouldValidateKey = !validationSetting;
|
|
}
|
|
if (isPossibleDBRef !== false && name[0] === '$') {
|
|
isPossibleDBRef = allowedDBRefKeys.test(name);
|
|
}
|
|
let value;
|
|
index = i + 1;
|
|
if (elementType === BSON_DATA_STRING) {
|
|
const stringSize = buffer[index++] |
|
|
(buffer[index++] << 8) |
|
|
(buffer[index++] << 16) |
|
|
(buffer[index++] << 24);
|
|
if (stringSize <= 0 ||
|
|
stringSize > buffer.length - index ||
|
|
buffer[index + stringSize - 1] !== 0) {
|
|
throw new BSONError('bad string length in bson');
|
|
}
|
|
value = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);
|
|
index = index + stringSize;
|
|
}
|
|
else if (elementType === BSON_DATA_OID) {
|
|
const oid = ByteUtils.allocate(12);
|
|
oid.set(buffer.subarray(index, index + 12));
|
|
value = new ObjectId(oid);
|
|
index = index + 12;
|
|
}
|
|
else if (elementType === BSON_DATA_INT && promoteValues === false) {
|
|
value = new Int32(buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24));
|
|
}
|
|
else if (elementType === BSON_DATA_INT) {
|
|
value =
|
|
buffer[index++] |
|
|
(buffer[index++] << 8) |
|
|
(buffer[index++] << 16) |
|
|
(buffer[index++] << 24);
|
|
}
|
|
else if (elementType === BSON_DATA_NUMBER && promoteValues === false) {
|
|
value = new Double(dataview.getFloat64(index, true));
|
|
index = index + 8;
|
|
}
|
|
else if (elementType === BSON_DATA_NUMBER) {
|
|
value = dataview.getFloat64(index, true);
|
|
index = index + 8;
|
|
}
|
|
else if (elementType === BSON_DATA_DATE) {
|
|
const lowBits = buffer[index++] |
|
|
(buffer[index++] << 8) |
|
|
(buffer[index++] << 16) |
|
|
(buffer[index++] << 24);
|
|
const highBits = buffer[index++] |
|
|
(buffer[index++] << 8) |
|
|
(buffer[index++] << 16) |
|
|
(buffer[index++] << 24);
|
|
value = new Date(new Long(lowBits, highBits).toNumber());
|
|
}
|
|
else if (elementType === BSON_DATA_BOOLEAN) {
|
|
if (buffer[index] !== 0 && buffer[index] !== 1)
|
|
throw new BSONError('illegal boolean type value');
|
|
value = buffer[index++] === 1;
|
|
}
|
|
else if (elementType === BSON_DATA_OBJECT) {
|
|
const _index = index;
|
|
const objectSize = buffer[index] |
|
|
(buffer[index + 1] << 8) |
|
|
(buffer[index + 2] << 16) |
|
|
(buffer[index + 3] << 24);
|
|
if (objectSize <= 0 || objectSize > buffer.length - index)
|
|
throw new BSONError('bad embedded document length in bson');
|
|
if (raw) {
|
|
value = buffer.slice(index, index + objectSize);
|
|
}
|
|
else {
|
|
let objectOptions = options;
|
|
if (!globalUTFValidation) {
|
|
objectOptions = { ...options, validation: { utf8: shouldValidateKey } };
|
|
}
|
|
value = deserializeObject(buffer, _index, objectOptions, false);
|
|
}
|
|
index = index + objectSize;
|
|
}
|
|
else if (elementType === BSON_DATA_ARRAY) {
|
|
const _index = index;
|
|
const objectSize = buffer[index] |
|
|
(buffer[index + 1] << 8) |
|
|
(buffer[index + 2] << 16) |
|
|
(buffer[index + 3] << 24);
|
|
let arrayOptions = options;
|
|
const stopIndex = index + objectSize;
|
|
if (fieldsAsRaw && fieldsAsRaw[name]) {
|
|
arrayOptions = { ...options, raw: true };
|
|
}
|
|
if (!globalUTFValidation) {
|
|
arrayOptions = { ...arrayOptions, validation: { utf8: shouldValidateKey } };
|
|
}
|
|
value = deserializeObject(buffer, _index, arrayOptions, true);
|
|
index = index + objectSize;
|
|
if (buffer[index - 1] !== 0)
|
|
throw new BSONError('invalid array terminator byte');
|
|
if (index !== stopIndex)
|
|
throw new BSONError('corrupted array bson');
|
|
}
|
|
else if (elementType === BSON_DATA_UNDEFINED) {
|
|
value = undefined;
|
|
}
|
|
else if (elementType === BSON_DATA_NULL) {
|
|
value = null;
|
|
}
|
|
else if (elementType === BSON_DATA_LONG) {
|
|
const dataview = BSONDataView.fromUint8Array(buffer.subarray(index, index + 8));
|
|
const lowBits = buffer[index++] |
|
|
(buffer[index++] << 8) |
|
|
(buffer[index++] << 16) |
|
|
(buffer[index++] << 24);
|
|
const highBits = buffer[index++] |
|
|
(buffer[index++] << 8) |
|
|
(buffer[index++] << 16) |
|
|
(buffer[index++] << 24);
|
|
const long = new Long(lowBits, highBits);
|
|
if (useBigInt64) {
|
|
value = dataview.getBigInt64(0, true);
|
|
}
|
|
else if (promoteLongs && promoteValues === true) {
|
|
value =
|
|
long.lessThanOrEqual(JS_INT_MAX_LONG) && long.greaterThanOrEqual(JS_INT_MIN_LONG)
|
|
? long.toNumber()
|
|
: long;
|
|
}
|
|
else {
|
|
value = long;
|
|
}
|
|
}
|
|
else if (elementType === BSON_DATA_DECIMAL128) {
|
|
const bytes = ByteUtils.allocate(16);
|
|
bytes.set(buffer.subarray(index, index + 16), 0);
|
|
index = index + 16;
|
|
value = new Decimal128(bytes);
|
|
}
|
|
else if (elementType === BSON_DATA_BINARY) {
|
|
let binarySize = buffer[index++] |
|
|
(buffer[index++] << 8) |
|
|
(buffer[index++] << 16) |
|
|
(buffer[index++] << 24);
|
|
const totalBinarySize = binarySize;
|
|
const subType = buffer[index++];
|
|
if (binarySize < 0)
|
|
throw new BSONError('Negative binary type element size found');
|
|
if (binarySize > buffer.byteLength)
|
|
throw new BSONError('Binary type size larger than document size');
|
|
if (buffer['slice'] != null) {
|
|
if (subType === Binary.SUBTYPE_BYTE_ARRAY) {
|
|
binarySize =
|
|
buffer[index++] |
|
|
(buffer[index++] << 8) |
|
|
(buffer[index++] << 16) |
|
|
(buffer[index++] << 24);
|
|
if (binarySize < 0)
|
|
throw new BSONError('Negative binary type element size found for subtype 0x02');
|
|
if (binarySize > totalBinarySize - 4)
|
|
throw new BSONError('Binary type with subtype 0x02 contains too long binary size');
|
|
if (binarySize < totalBinarySize - 4)
|
|
throw new BSONError('Binary type with subtype 0x02 contains too short binary size');
|
|
}
|
|
if (promoteBuffers && promoteValues) {
|
|
value = ByteUtils.toLocalBufferType(buffer.slice(index, index + binarySize));
|
|
}
|
|
else {
|
|
value = new Binary(buffer.slice(index, index + binarySize), subType);
|
|
if (subType === BSON_BINARY_SUBTYPE_UUID_NEW && UUID.isValid(value)) {
|
|
value = value.toUUID();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
const _buffer = ByteUtils.allocate(binarySize);
|
|
if (subType === Binary.SUBTYPE_BYTE_ARRAY) {
|
|
binarySize =
|
|
buffer[index++] |
|
|
(buffer[index++] << 8) |
|
|
(buffer[index++] << 16) |
|
|
(buffer[index++] << 24);
|
|
if (binarySize < 0)
|
|
throw new BSONError('Negative binary type element size found for subtype 0x02');
|
|
if (binarySize > totalBinarySize - 4)
|
|
throw new BSONError('Binary type with subtype 0x02 contains too long binary size');
|
|
if (binarySize < totalBinarySize - 4)
|
|
throw new BSONError('Binary type with subtype 0x02 contains too short binary size');
|
|
}
|
|
for (i = 0; i < binarySize; i++) {
|
|
_buffer[i] = buffer[index + i];
|
|
}
|
|
if (promoteBuffers && promoteValues) {
|
|
value = _buffer;
|
|
}
|
|
else {
|
|
value = new Binary(buffer.slice(index, index + binarySize), subType);
|
|
if (subType === BSON_BINARY_SUBTYPE_UUID_NEW && UUID.isValid(value)) {
|
|
value = value.toUUID();
|
|
}
|
|
}
|
|
}
|
|
index = index + binarySize;
|
|
}
|
|
else if (elementType === BSON_DATA_REGEXP && bsonRegExp === false) {
|
|
i = index;
|
|
while (buffer[i] !== 0x00 && i < buffer.length) {
|
|
i++;
|
|
}
|
|
if (i >= buffer.length)
|
|
throw new BSONError('Bad BSON Document: illegal CString');
|
|
const source = ByteUtils.toUTF8(buffer, index, i);
|
|
index = i + 1;
|
|
i = index;
|
|
while (buffer[i] !== 0x00 && i < buffer.length) {
|
|
i++;
|
|
}
|
|
if (i >= buffer.length)
|
|
throw new BSONError('Bad BSON Document: illegal CString');
|
|
const regExpOptions = ByteUtils.toUTF8(buffer, index, i);
|
|
index = i + 1;
|
|
const optionsArray = new Array(regExpOptions.length);
|
|
for (i = 0; i < regExpOptions.length; i++) {
|
|
switch (regExpOptions[i]) {
|
|
case 'm':
|
|
optionsArray[i] = 'm';
|
|
break;
|
|
case 's':
|
|
optionsArray[i] = 'g';
|
|
break;
|
|
case 'i':
|
|
optionsArray[i] = 'i';
|
|
break;
|
|
}
|
|
}
|
|
value = new RegExp(source, optionsArray.join(''));
|
|
}
|
|
else if (elementType === BSON_DATA_REGEXP && bsonRegExp === true) {
|
|
i = index;
|
|
while (buffer[i] !== 0x00 && i < buffer.length) {
|
|
i++;
|
|
}
|
|
if (i >= buffer.length)
|
|
throw new BSONError('Bad BSON Document: illegal CString');
|
|
const source = ByteUtils.toUTF8(buffer, index, i);
|
|
index = i + 1;
|
|
i = index;
|
|
while (buffer[i] !== 0x00 && i < buffer.length) {
|
|
i++;
|
|
}
|
|
if (i >= buffer.length)
|
|
throw new BSONError('Bad BSON Document: illegal CString');
|
|
const regExpOptions = ByteUtils.toUTF8(buffer, index, i);
|
|
index = i + 1;
|
|
value = new BSONRegExp(source, regExpOptions);
|
|
}
|
|
else if (elementType === BSON_DATA_SYMBOL) {
|
|
const stringSize = buffer[index++] |
|
|
(buffer[index++] << 8) |
|
|
(buffer[index++] << 16) |
|
|
(buffer[index++] << 24);
|
|
if (stringSize <= 0 ||
|
|
stringSize > buffer.length - index ||
|
|
buffer[index + stringSize - 1] !== 0) {
|
|
throw new BSONError('bad string length in bson');
|
|
}
|
|
const symbol = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);
|
|
value = promoteValues ? symbol : new BSONSymbol(symbol);
|
|
index = index + stringSize;
|
|
}
|
|
else if (elementType === BSON_DATA_TIMESTAMP) {
|
|
const i = buffer[index++] +
|
|
buffer[index++] * (1 << 8) +
|
|
buffer[index++] * (1 << 16) +
|
|
buffer[index++] * (1 << 24);
|
|
const t = buffer[index++] +
|
|
buffer[index++] * (1 << 8) +
|
|
buffer[index++] * (1 << 16) +
|
|
buffer[index++] * (1 << 24);
|
|
value = new Timestamp({ i, t });
|
|
}
|
|
else if (elementType === BSON_DATA_MIN_KEY) {
|
|
value = new MinKey();
|
|
}
|
|
else if (elementType === BSON_DATA_MAX_KEY) {
|
|
value = new MaxKey();
|
|
}
|
|
else if (elementType === BSON_DATA_CODE) {
|
|
const stringSize = buffer[index++] |
|
|
(buffer[index++] << 8) |
|
|
(buffer[index++] << 16) |
|
|
(buffer[index++] << 24);
|
|
if (stringSize <= 0 ||
|
|
stringSize > buffer.length - index ||
|
|
buffer[index + stringSize - 1] !== 0) {
|
|
throw new BSONError('bad string length in bson');
|
|
}
|
|
const functionString = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);
|
|
value = new Code(functionString);
|
|
index = index + stringSize;
|
|
}
|
|
else if (elementType === BSON_DATA_CODE_W_SCOPE) {
|
|
const totalSize = buffer[index++] |
|
|
(buffer[index++] << 8) |
|
|
(buffer[index++] << 16) |
|
|
(buffer[index++] << 24);
|
|
if (totalSize < 4 + 4 + 4 + 1) {
|
|
throw new BSONError('code_w_scope total size shorter minimum expected length');
|
|
}
|
|
const stringSize = buffer[index++] |
|
|
(buffer[index++] << 8) |
|
|
(buffer[index++] << 16) |
|
|
(buffer[index++] << 24);
|
|
if (stringSize <= 0 ||
|
|
stringSize > buffer.length - index ||
|
|
buffer[index + stringSize - 1] !== 0) {
|
|
throw new BSONError('bad string length in bson');
|
|
}
|
|
const functionString = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);
|
|
index = index + stringSize;
|
|
const _index = index;
|
|
const objectSize = buffer[index] |
|
|
(buffer[index + 1] << 8) |
|
|
(buffer[index + 2] << 16) |
|
|
(buffer[index + 3] << 24);
|
|
const scopeObject = deserializeObject(buffer, _index, options, false);
|
|
index = index + objectSize;
|
|
if (totalSize < 4 + 4 + objectSize + stringSize) {
|
|
throw new BSONError('code_w_scope total size is too short, truncating scope');
|
|
}
|
|
if (totalSize > 4 + 4 + objectSize + stringSize) {
|
|
throw new BSONError('code_w_scope total size is too long, clips outer document');
|
|
}
|
|
value = new Code(functionString, scopeObject);
|
|
}
|
|
else if (elementType === BSON_DATA_DBPOINTER) {
|
|
const stringSize = buffer[index++] |
|
|
(buffer[index++] << 8) |
|
|
(buffer[index++] << 16) |
|
|
(buffer[index++] << 24);
|
|
if (stringSize <= 0 ||
|
|
stringSize > buffer.length - index ||
|
|
buffer[index + stringSize - 1] !== 0)
|
|
throw new BSONError('bad string length in bson');
|
|
if (validation != null && validation.utf8) {
|
|
if (!validateUtf8(buffer, index, index + stringSize - 1)) {
|
|
throw new BSONError('Invalid UTF-8 string in BSON document');
|
|
}
|
|
}
|
|
const namespace = ByteUtils.toUTF8(buffer, index, index + stringSize - 1);
|
|
index = index + stringSize;
|
|
const oidBuffer = ByteUtils.allocate(12);
|
|
oidBuffer.set(buffer.subarray(index, index + 12), 0);
|
|
const oid = new ObjectId(oidBuffer);
|
|
index = index + 12;
|
|
value = new DBRef(namespace, oid);
|
|
}
|
|
else {
|
|
throw new BSONError(`Detected unknown BSON type ${elementType.toString(16)} for fieldname "${name}"`);
|
|
}
|
|
if (name === '__proto__') {
|
|
Object.defineProperty(object, name, {
|
|
value,
|
|
writable: true,
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
}
|
|
else {
|
|
object[name] = value;
|
|
}
|
|
}
|
|
if (size !== index - startIndex) {
|
|
if (isArray)
|
|
throw new BSONError('corrupt array bson');
|
|
throw new BSONError('corrupt object bson');
|
|
}
|
|
if (!isPossibleDBRef)
|
|
return object;
|
|
if (isDBRefLike(object)) {
|
|
const copy = Object.assign({}, object);
|
|
delete copy.$ref;
|
|
delete copy.$id;
|
|
delete copy.$db;
|
|
return new DBRef(object.$ref, object.$id, object.$db, copy);
|
|
}
|
|
return object;
|
|
}
|
|
function getValidatedString(buffer, start, end, shouldValidateUtf8) {
|
|
const value = ByteUtils.toUTF8(buffer, start, end);
|
|
if (shouldValidateUtf8) {
|
|
for (let i = 0; i < value.length; i++) {
|
|
if (value.charCodeAt(i) === 0xfffd) {
|
|
if (!validateUtf8(buffer, start, end)) {
|
|
throw new BSONError('Invalid UTF-8 string in BSON document');
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
const regexp = /\x00/;
|
|
const ignoreKeys = new Set(['$db', '$ref', '$id', '$clusterTime']);
|
|
function serializeString(buffer, key, value, index) {
|
|
buffer[index++] = BSON_DATA_STRING;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes + 1;
|
|
buffer[index - 1] = 0;
|
|
const size = ByteUtils.encodeUTF8Into(buffer, value, index + 4);
|
|
buffer[index + 3] = ((size + 1) >> 24) & 0xff;
|
|
buffer[index + 2] = ((size + 1) >> 16) & 0xff;
|
|
buffer[index + 1] = ((size + 1) >> 8) & 0xff;
|
|
buffer[index] = (size + 1) & 0xff;
|
|
index = index + 4 + size;
|
|
buffer[index++] = 0;
|
|
return index;
|
|
}
|
|
const NUMBER_SPACE = new DataView(new ArrayBuffer(8), 0, 8);
|
|
const FOUR_BYTE_VIEW_ON_NUMBER = new Uint8Array(NUMBER_SPACE.buffer, 0, 4);
|
|
const EIGHT_BYTE_VIEW_ON_NUMBER = new Uint8Array(NUMBER_SPACE.buffer, 0, 8);
|
|
function serializeNumber(buffer, key, value, index) {
|
|
const isNegativeZero = Object.is(value, -0);
|
|
const type = !isNegativeZero &&
|
|
Number.isSafeInteger(value) &&
|
|
value <= BSON_INT32_MAX &&
|
|
value >= BSON_INT32_MIN
|
|
? BSON_DATA_INT
|
|
: BSON_DATA_NUMBER;
|
|
if (type === BSON_DATA_INT) {
|
|
NUMBER_SPACE.setInt32(0, value, true);
|
|
}
|
|
else {
|
|
NUMBER_SPACE.setFloat64(0, value, true);
|
|
}
|
|
const bytes = type === BSON_DATA_INT ? FOUR_BYTE_VIEW_ON_NUMBER : EIGHT_BYTE_VIEW_ON_NUMBER;
|
|
buffer[index++] = type;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes;
|
|
buffer[index++] = 0x00;
|
|
buffer.set(bytes, index);
|
|
index += bytes.byteLength;
|
|
return index;
|
|
}
|
|
function serializeBigInt(buffer, key, value, index) {
|
|
buffer[index++] = BSON_DATA_LONG;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index += numberOfWrittenBytes;
|
|
buffer[index++] = 0;
|
|
NUMBER_SPACE.setBigInt64(0, value, true);
|
|
buffer.set(EIGHT_BYTE_VIEW_ON_NUMBER, index);
|
|
index += EIGHT_BYTE_VIEW_ON_NUMBER.byteLength;
|
|
return index;
|
|
}
|
|
function serializeNull(buffer, key, _, index) {
|
|
buffer[index++] = BSON_DATA_NULL;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes;
|
|
buffer[index++] = 0;
|
|
return index;
|
|
}
|
|
function serializeBoolean(buffer, key, value, index) {
|
|
buffer[index++] = BSON_DATA_BOOLEAN;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes;
|
|
buffer[index++] = 0;
|
|
buffer[index++] = value ? 1 : 0;
|
|
return index;
|
|
}
|
|
function serializeDate(buffer, key, value, index) {
|
|
buffer[index++] = BSON_DATA_DATE;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes;
|
|
buffer[index++] = 0;
|
|
const dateInMilis = Long.fromNumber(value.getTime());
|
|
const lowBits = dateInMilis.getLowBits();
|
|
const highBits = dateInMilis.getHighBits();
|
|
buffer[index++] = lowBits & 0xff;
|
|
buffer[index++] = (lowBits >> 8) & 0xff;
|
|
buffer[index++] = (lowBits >> 16) & 0xff;
|
|
buffer[index++] = (lowBits >> 24) & 0xff;
|
|
buffer[index++] = highBits & 0xff;
|
|
buffer[index++] = (highBits >> 8) & 0xff;
|
|
buffer[index++] = (highBits >> 16) & 0xff;
|
|
buffer[index++] = (highBits >> 24) & 0xff;
|
|
return index;
|
|
}
|
|
function serializeRegExp(buffer, key, value, index) {
|
|
buffer[index++] = BSON_DATA_REGEXP;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes;
|
|
buffer[index++] = 0;
|
|
if (value.source && value.source.match(regexp) != null) {
|
|
throw new BSONError('value ' + value.source + ' must not contain null bytes');
|
|
}
|
|
index = index + ByteUtils.encodeUTF8Into(buffer, value.source, index);
|
|
buffer[index++] = 0x00;
|
|
if (value.ignoreCase)
|
|
buffer[index++] = 0x69;
|
|
if (value.global)
|
|
buffer[index++] = 0x73;
|
|
if (value.multiline)
|
|
buffer[index++] = 0x6d;
|
|
buffer[index++] = 0x00;
|
|
return index;
|
|
}
|
|
function serializeBSONRegExp(buffer, key, value, index) {
|
|
buffer[index++] = BSON_DATA_REGEXP;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes;
|
|
buffer[index++] = 0;
|
|
if (value.pattern.match(regexp) != null) {
|
|
throw new BSONError('pattern ' + value.pattern + ' must not contain null bytes');
|
|
}
|
|
index = index + ByteUtils.encodeUTF8Into(buffer, value.pattern, index);
|
|
buffer[index++] = 0x00;
|
|
const sortedOptions = value.options.split('').sort().join('');
|
|
index = index + ByteUtils.encodeUTF8Into(buffer, sortedOptions, index);
|
|
buffer[index++] = 0x00;
|
|
return index;
|
|
}
|
|
function serializeMinMax(buffer, key, value, index) {
|
|
if (value === null) {
|
|
buffer[index++] = BSON_DATA_NULL;
|
|
}
|
|
else if (value._bsontype === 'MinKey') {
|
|
buffer[index++] = BSON_DATA_MIN_KEY;
|
|
}
|
|
else {
|
|
buffer[index++] = BSON_DATA_MAX_KEY;
|
|
}
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes;
|
|
buffer[index++] = 0;
|
|
return index;
|
|
}
|
|
function serializeObjectId(buffer, key, value, index) {
|
|
buffer[index++] = BSON_DATA_OID;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes;
|
|
buffer[index++] = 0;
|
|
const idValue = value.id;
|
|
if (isUint8Array(idValue)) {
|
|
for (let i = 0; i < 12; i++) {
|
|
buffer[index++] = idValue[i];
|
|
}
|
|
}
|
|
else {
|
|
throw new BSONError('object [' + JSON.stringify(value) + '] is not a valid ObjectId');
|
|
}
|
|
return index;
|
|
}
|
|
function serializeBuffer(buffer, key, value, index) {
|
|
buffer[index++] = BSON_DATA_BINARY;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes;
|
|
buffer[index++] = 0;
|
|
const size = value.length;
|
|
buffer[index++] = size & 0xff;
|
|
buffer[index++] = (size >> 8) & 0xff;
|
|
buffer[index++] = (size >> 16) & 0xff;
|
|
buffer[index++] = (size >> 24) & 0xff;
|
|
buffer[index++] = BSON_BINARY_SUBTYPE_DEFAULT;
|
|
buffer.set(value, index);
|
|
index = index + size;
|
|
return index;
|
|
}
|
|
function serializeObject(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path) {
|
|
if (path.has(value)) {
|
|
throw new BSONError('Cannot convert circular structure to BSON');
|
|
}
|
|
path.add(value);
|
|
buffer[index++] = Array.isArray(value) ? BSON_DATA_ARRAY : BSON_DATA_OBJECT;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes;
|
|
buffer[index++] = 0;
|
|
const endIndex = serializeInto(buffer, value, checkKeys, index, depth + 1, serializeFunctions, ignoreUndefined, path);
|
|
path.delete(value);
|
|
return endIndex;
|
|
}
|
|
function serializeDecimal128(buffer, key, value, index) {
|
|
buffer[index++] = BSON_DATA_DECIMAL128;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes;
|
|
buffer[index++] = 0;
|
|
buffer.set(value.bytes.subarray(0, 16), index);
|
|
return index + 16;
|
|
}
|
|
function serializeLong(buffer, key, value, index) {
|
|
buffer[index++] =
|
|
value._bsontype === 'Long' ? BSON_DATA_LONG : BSON_DATA_TIMESTAMP;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes;
|
|
buffer[index++] = 0;
|
|
const lowBits = value.getLowBits();
|
|
const highBits = value.getHighBits();
|
|
buffer[index++] = lowBits & 0xff;
|
|
buffer[index++] = (lowBits >> 8) & 0xff;
|
|
buffer[index++] = (lowBits >> 16) & 0xff;
|
|
buffer[index++] = (lowBits >> 24) & 0xff;
|
|
buffer[index++] = highBits & 0xff;
|
|
buffer[index++] = (highBits >> 8) & 0xff;
|
|
buffer[index++] = (highBits >> 16) & 0xff;
|
|
buffer[index++] = (highBits >> 24) & 0xff;
|
|
return index;
|
|
}
|
|
function serializeInt32(buffer, key, value, index) {
|
|
value = value.valueOf();
|
|
buffer[index++] = BSON_DATA_INT;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes;
|
|
buffer[index++] = 0;
|
|
buffer[index++] = value & 0xff;
|
|
buffer[index++] = (value >> 8) & 0xff;
|
|
buffer[index++] = (value >> 16) & 0xff;
|
|
buffer[index++] = (value >> 24) & 0xff;
|
|
return index;
|
|
}
|
|
function serializeDouble(buffer, key, value, index) {
|
|
buffer[index++] = BSON_DATA_NUMBER;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes;
|
|
buffer[index++] = 0;
|
|
NUMBER_SPACE.setFloat64(0, value.value, true);
|
|
buffer.set(EIGHT_BYTE_VIEW_ON_NUMBER, index);
|
|
index = index + 8;
|
|
return index;
|
|
}
|
|
function serializeFunction(buffer, key, value, index) {
|
|
buffer[index++] = BSON_DATA_CODE;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes;
|
|
buffer[index++] = 0;
|
|
const functionString = value.toString();
|
|
const size = ByteUtils.encodeUTF8Into(buffer, functionString, index + 4) + 1;
|
|
buffer[index] = size & 0xff;
|
|
buffer[index + 1] = (size >> 8) & 0xff;
|
|
buffer[index + 2] = (size >> 16) & 0xff;
|
|
buffer[index + 3] = (size >> 24) & 0xff;
|
|
index = index + 4 + size - 1;
|
|
buffer[index++] = 0;
|
|
return index;
|
|
}
|
|
function serializeCode(buffer, key, value, index, checkKeys = false, depth = 0, serializeFunctions = false, ignoreUndefined = true, path) {
|
|
if (value.scope && typeof value.scope === 'object') {
|
|
buffer[index++] = BSON_DATA_CODE_W_SCOPE;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes;
|
|
buffer[index++] = 0;
|
|
let startIndex = index;
|
|
const functionString = value.code;
|
|
index = index + 4;
|
|
const codeSize = ByteUtils.encodeUTF8Into(buffer, functionString, index + 4) + 1;
|
|
buffer[index] = codeSize & 0xff;
|
|
buffer[index + 1] = (codeSize >> 8) & 0xff;
|
|
buffer[index + 2] = (codeSize >> 16) & 0xff;
|
|
buffer[index + 3] = (codeSize >> 24) & 0xff;
|
|
buffer[index + 4 + codeSize - 1] = 0;
|
|
index = index + codeSize + 4;
|
|
const endIndex = serializeInto(buffer, value.scope, checkKeys, index, depth + 1, serializeFunctions, ignoreUndefined, path);
|
|
index = endIndex - 1;
|
|
const totalSize = endIndex - startIndex;
|
|
buffer[startIndex++] = totalSize & 0xff;
|
|
buffer[startIndex++] = (totalSize >> 8) & 0xff;
|
|
buffer[startIndex++] = (totalSize >> 16) & 0xff;
|
|
buffer[startIndex++] = (totalSize >> 24) & 0xff;
|
|
buffer[index++] = 0;
|
|
}
|
|
else {
|
|
buffer[index++] = BSON_DATA_CODE;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes;
|
|
buffer[index++] = 0;
|
|
const functionString = value.code.toString();
|
|
const size = ByteUtils.encodeUTF8Into(buffer, functionString, index + 4) + 1;
|
|
buffer[index] = size & 0xff;
|
|
buffer[index + 1] = (size >> 8) & 0xff;
|
|
buffer[index + 2] = (size >> 16) & 0xff;
|
|
buffer[index + 3] = (size >> 24) & 0xff;
|
|
index = index + 4 + size - 1;
|
|
buffer[index++] = 0;
|
|
}
|
|
return index;
|
|
}
|
|
function serializeBinary(buffer, key, value, index) {
|
|
buffer[index++] = BSON_DATA_BINARY;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes;
|
|
buffer[index++] = 0;
|
|
const data = value.buffer;
|
|
let size = value.position;
|
|
if (value.sub_type === Binary.SUBTYPE_BYTE_ARRAY)
|
|
size = size + 4;
|
|
buffer[index++] = size & 0xff;
|
|
buffer[index++] = (size >> 8) & 0xff;
|
|
buffer[index++] = (size >> 16) & 0xff;
|
|
buffer[index++] = (size >> 24) & 0xff;
|
|
buffer[index++] = value.sub_type;
|
|
if (value.sub_type === Binary.SUBTYPE_BYTE_ARRAY) {
|
|
size = size - 4;
|
|
buffer[index++] = size & 0xff;
|
|
buffer[index++] = (size >> 8) & 0xff;
|
|
buffer[index++] = (size >> 16) & 0xff;
|
|
buffer[index++] = (size >> 24) & 0xff;
|
|
}
|
|
buffer.set(data, index);
|
|
index = index + value.position;
|
|
return index;
|
|
}
|
|
function serializeSymbol(buffer, key, value, index) {
|
|
buffer[index++] = BSON_DATA_SYMBOL;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes;
|
|
buffer[index++] = 0;
|
|
const size = ByteUtils.encodeUTF8Into(buffer, value.value, index + 4) + 1;
|
|
buffer[index] = size & 0xff;
|
|
buffer[index + 1] = (size >> 8) & 0xff;
|
|
buffer[index + 2] = (size >> 16) & 0xff;
|
|
buffer[index + 3] = (size >> 24) & 0xff;
|
|
index = index + 4 + size - 1;
|
|
buffer[index++] = 0x00;
|
|
return index;
|
|
}
|
|
function serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path) {
|
|
buffer[index++] = BSON_DATA_OBJECT;
|
|
const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
|
|
index = index + numberOfWrittenBytes;
|
|
buffer[index++] = 0;
|
|
let startIndex = index;
|
|
let output = {
|
|
$ref: value.collection || value.namespace,
|
|
$id: value.oid
|
|
};
|
|
if (value.db != null) {
|
|
output.$db = value.db;
|
|
}
|
|
output = Object.assign(output, value.fields);
|
|
const endIndex = serializeInto(buffer, output, false, index, depth + 1, serializeFunctions, true, path);
|
|
const size = endIndex - startIndex;
|
|
buffer[startIndex++] = size & 0xff;
|
|
buffer[startIndex++] = (size >> 8) & 0xff;
|
|
buffer[startIndex++] = (size >> 16) & 0xff;
|
|
buffer[startIndex++] = (size >> 24) & 0xff;
|
|
return endIndex;
|
|
}
|
|
function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializeFunctions, ignoreUndefined, path) {
|
|
if (path == null) {
|
|
if (object == null) {
|
|
buffer[0] = 0x05;
|
|
buffer[1] = 0x00;
|
|
buffer[2] = 0x00;
|
|
buffer[3] = 0x00;
|
|
buffer[4] = 0x00;
|
|
return 5;
|
|
}
|
|
if (Array.isArray(object)) {
|
|
throw new BSONError('serialize does not support an array as the root input');
|
|
}
|
|
if (typeof object !== 'object') {
|
|
throw new BSONError('serialize does not support non-object as the root input');
|
|
}
|
|
else if ('_bsontype' in object && typeof object._bsontype === 'string') {
|
|
throw new BSONError(`BSON types cannot be serialized as a document`);
|
|
}
|
|
else if (isDate(object) ||
|
|
isRegExp(object) ||
|
|
isUint8Array(object) ||
|
|
isAnyArrayBuffer(object)) {
|
|
throw new BSONError(`date, regexp, typedarray, and arraybuffer cannot be BSON documents`);
|
|
}
|
|
path = new Set();
|
|
}
|
|
path.add(object);
|
|
let index = startingIndex + 4;
|
|
if (Array.isArray(object)) {
|
|
for (let i = 0; i < object.length; i++) {
|
|
const key = `${i}`;
|
|
let value = object[i];
|
|
if (typeof value?.toBSON === 'function') {
|
|
value = value.toBSON();
|
|
}
|
|
if (typeof value === 'string') {
|
|
index = serializeString(buffer, key, value, index);
|
|
}
|
|
else if (typeof value === 'number') {
|
|
index = serializeNumber(buffer, key, value, index);
|
|
}
|
|
else if (typeof value === 'bigint') {
|
|
index = serializeBigInt(buffer, key, value, index);
|
|
}
|
|
else if (typeof value === 'boolean') {
|
|
index = serializeBoolean(buffer, key, value, index);
|
|
}
|
|
else if (value instanceof Date || isDate(value)) {
|
|
index = serializeDate(buffer, key, value, index);
|
|
}
|
|
else if (value === undefined) {
|
|
index = serializeNull(buffer, key, value, index);
|
|
}
|
|
else if (value === null) {
|
|
index = serializeNull(buffer, key, value, index);
|
|
}
|
|
else if (isUint8Array(value)) {
|
|
index = serializeBuffer(buffer, key, value, index);
|
|
}
|
|
else if (value instanceof RegExp || isRegExp(value)) {
|
|
index = serializeRegExp(buffer, key, value, index);
|
|
}
|
|
else if (typeof value === 'object' && value._bsontype == null) {
|
|
index = serializeObject(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
|
|
}
|
|
else if (typeof value === 'object' &&
|
|
value[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
|
|
throw new BSONVersionError();
|
|
}
|
|
else if (value._bsontype === 'ObjectId') {
|
|
index = serializeObjectId(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'Decimal128') {
|
|
index = serializeDecimal128(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
|
|
index = serializeLong(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'Double') {
|
|
index = serializeDouble(buffer, key, value, index);
|
|
}
|
|
else if (typeof value === 'function' && serializeFunctions) {
|
|
index = serializeFunction(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'Code') {
|
|
index = serializeCode(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
|
|
}
|
|
else if (value._bsontype === 'Binary') {
|
|
index = serializeBinary(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'BSONSymbol') {
|
|
index = serializeSymbol(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'DBRef') {
|
|
index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
|
|
}
|
|
else if (value._bsontype === 'BSONRegExp') {
|
|
index = serializeBSONRegExp(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'Int32') {
|
|
index = serializeInt32(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
|
|
index = serializeMinMax(buffer, key, value, index);
|
|
}
|
|
else if (typeof value._bsontype !== 'undefined') {
|
|
throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
|
|
}
|
|
}
|
|
}
|
|
else if (object instanceof Map || isMap(object)) {
|
|
const iterator = object.entries();
|
|
let done = false;
|
|
while (!done) {
|
|
const entry = iterator.next();
|
|
done = !!entry.done;
|
|
if (done)
|
|
continue;
|
|
const key = entry.value[0];
|
|
let value = entry.value[1];
|
|
if (typeof value?.toBSON === 'function') {
|
|
value = value.toBSON();
|
|
}
|
|
const type = typeof value;
|
|
if (typeof key === 'string' && !ignoreKeys.has(key)) {
|
|
if (key.match(regexp) != null) {
|
|
throw new BSONError('key ' + key + ' must not contain null bytes');
|
|
}
|
|
if (checkKeys) {
|
|
if ('$' === key[0]) {
|
|
throw new BSONError('key ' + key + " must not start with '$'");
|
|
}
|
|
else if (~key.indexOf('.')) {
|
|
throw new BSONError('key ' + key + " must not contain '.'");
|
|
}
|
|
}
|
|
}
|
|
if (type === 'string') {
|
|
index = serializeString(buffer, key, value, index);
|
|
}
|
|
else if (type === 'number') {
|
|
index = serializeNumber(buffer, key, value, index);
|
|
}
|
|
else if (type === 'bigint') {
|
|
index = serializeBigInt(buffer, key, value, index);
|
|
}
|
|
else if (type === 'boolean') {
|
|
index = serializeBoolean(buffer, key, value, index);
|
|
}
|
|
else if (value instanceof Date || isDate(value)) {
|
|
index = serializeDate(buffer, key, value, index);
|
|
}
|
|
else if (value === null || (value === undefined && ignoreUndefined === false)) {
|
|
index = serializeNull(buffer, key, value, index);
|
|
}
|
|
else if (isUint8Array(value)) {
|
|
index = serializeBuffer(buffer, key, value, index);
|
|
}
|
|
else if (value instanceof RegExp || isRegExp(value)) {
|
|
index = serializeRegExp(buffer, key, value, index);
|
|
}
|
|
else if (type === 'object' && value._bsontype == null) {
|
|
index = serializeObject(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
|
|
}
|
|
else if (typeof value === 'object' &&
|
|
value[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
|
|
throw new BSONVersionError();
|
|
}
|
|
else if (value._bsontype === 'ObjectId') {
|
|
index = serializeObjectId(buffer, key, value, index);
|
|
}
|
|
else if (type === 'object' && value._bsontype === 'Decimal128') {
|
|
index = serializeDecimal128(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
|
|
index = serializeLong(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'Double') {
|
|
index = serializeDouble(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'Code') {
|
|
index = serializeCode(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
|
|
}
|
|
else if (typeof value === 'function' && serializeFunctions) {
|
|
index = serializeFunction(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'Binary') {
|
|
index = serializeBinary(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'BSONSymbol') {
|
|
index = serializeSymbol(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'DBRef') {
|
|
index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
|
|
}
|
|
else if (value._bsontype === 'BSONRegExp') {
|
|
index = serializeBSONRegExp(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'Int32') {
|
|
index = serializeInt32(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
|
|
index = serializeMinMax(buffer, key, value, index);
|
|
}
|
|
else if (typeof value._bsontype !== 'undefined') {
|
|
throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (typeof object?.toBSON === 'function') {
|
|
object = object.toBSON();
|
|
if (object != null && typeof object !== 'object') {
|
|
throw new BSONError('toBSON function did not return an object');
|
|
}
|
|
}
|
|
for (const key of Object.keys(object)) {
|
|
let value = object[key];
|
|
if (typeof value?.toBSON === 'function') {
|
|
value = value.toBSON();
|
|
}
|
|
const type = typeof value;
|
|
if (typeof key === 'string' && !ignoreKeys.has(key)) {
|
|
if (key.match(regexp) != null) {
|
|
throw new BSONError('key ' + key + ' must not contain null bytes');
|
|
}
|
|
if (checkKeys) {
|
|
if ('$' === key[0]) {
|
|
throw new BSONError('key ' + key + " must not start with '$'");
|
|
}
|
|
else if (~key.indexOf('.')) {
|
|
throw new BSONError('key ' + key + " must not contain '.'");
|
|
}
|
|
}
|
|
}
|
|
if (type === 'string') {
|
|
index = serializeString(buffer, key, value, index);
|
|
}
|
|
else if (type === 'number') {
|
|
index = serializeNumber(buffer, key, value, index);
|
|
}
|
|
else if (type === 'bigint') {
|
|
index = serializeBigInt(buffer, key, value, index);
|
|
}
|
|
else if (type === 'boolean') {
|
|
index = serializeBoolean(buffer, key, value, index);
|
|
}
|
|
else if (value instanceof Date || isDate(value)) {
|
|
index = serializeDate(buffer, key, value, index);
|
|
}
|
|
else if (value === undefined) {
|
|
if (ignoreUndefined === false)
|
|
index = serializeNull(buffer, key, value, index);
|
|
}
|
|
else if (value === null) {
|
|
index = serializeNull(buffer, key, value, index);
|
|
}
|
|
else if (isUint8Array(value)) {
|
|
index = serializeBuffer(buffer, key, value, index);
|
|
}
|
|
else if (value instanceof RegExp || isRegExp(value)) {
|
|
index = serializeRegExp(buffer, key, value, index);
|
|
}
|
|
else if (type === 'object' && value._bsontype == null) {
|
|
index = serializeObject(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
|
|
}
|
|
else if (typeof value === 'object' &&
|
|
value[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
|
|
throw new BSONVersionError();
|
|
}
|
|
else if (value._bsontype === 'ObjectId') {
|
|
index = serializeObjectId(buffer, key, value, index);
|
|
}
|
|
else if (type === 'object' && value._bsontype === 'Decimal128') {
|
|
index = serializeDecimal128(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
|
|
index = serializeLong(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'Double') {
|
|
index = serializeDouble(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'Code') {
|
|
index = serializeCode(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
|
|
}
|
|
else if (typeof value === 'function' && serializeFunctions) {
|
|
index = serializeFunction(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'Binary') {
|
|
index = serializeBinary(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'BSONSymbol') {
|
|
index = serializeSymbol(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'DBRef') {
|
|
index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
|
|
}
|
|
else if (value._bsontype === 'BSONRegExp') {
|
|
index = serializeBSONRegExp(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'Int32') {
|
|
index = serializeInt32(buffer, key, value, index);
|
|
}
|
|
else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
|
|
index = serializeMinMax(buffer, key, value, index);
|
|
}
|
|
else if (typeof value._bsontype !== 'undefined') {
|
|
throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
|
|
}
|
|
}
|
|
}
|
|
path.delete(object);
|
|
buffer[index++] = 0x00;
|
|
const size = index - startingIndex;
|
|
buffer[startingIndex++] = size & 0xff;
|
|
buffer[startingIndex++] = (size >> 8) & 0xff;
|
|
buffer[startingIndex++] = (size >> 16) & 0xff;
|
|
buffer[startingIndex++] = (size >> 24) & 0xff;
|
|
return index;
|
|
}
|
|
|
|
function isBSONType(value) {
|
|
return (value != null &&
|
|
typeof value === 'object' &&
|
|
'_bsontype' in value &&
|
|
typeof value._bsontype === 'string');
|
|
}
|
|
const keysToCodecs = {
|
|
$oid: ObjectId,
|
|
$binary: Binary,
|
|
$uuid: Binary,
|
|
$symbol: BSONSymbol,
|
|
$numberInt: Int32,
|
|
$numberDecimal: Decimal128,
|
|
$numberDouble: Double,
|
|
$numberLong: Long,
|
|
$minKey: MinKey,
|
|
$maxKey: MaxKey,
|
|
$regex: BSONRegExp,
|
|
$regularExpression: BSONRegExp,
|
|
$timestamp: Timestamp
|
|
};
|
|
function deserializeValue(value, options = {}) {
|
|
if (typeof value === 'number') {
|
|
const in32BitRange = value <= BSON_INT32_MAX && value >= BSON_INT32_MIN;
|
|
const in64BitRange = value <= BSON_INT64_MAX && value >= BSON_INT64_MIN;
|
|
if (options.relaxed || options.legacy) {
|
|
return value;
|
|
}
|
|
if (Number.isInteger(value) && !Object.is(value, -0)) {
|
|
if (in32BitRange) {
|
|
return new Int32(value);
|
|
}
|
|
if (in64BitRange) {
|
|
if (options.useBigInt64) {
|
|
return BigInt(value);
|
|
}
|
|
return Long.fromNumber(value);
|
|
}
|
|
}
|
|
return new Double(value);
|
|
}
|
|
if (value == null || typeof value !== 'object')
|
|
return value;
|
|
if (value.$undefined)
|
|
return null;
|
|
const keys = Object.keys(value).filter(k => k.startsWith('$') && value[k] != null);
|
|
for (let i = 0; i < keys.length; i++) {
|
|
const c = keysToCodecs[keys[i]];
|
|
if (c)
|
|
return c.fromExtendedJSON(value, options);
|
|
}
|
|
if (value.$date != null) {
|
|
const d = value.$date;
|
|
const date = new Date();
|
|
if (options.legacy) {
|
|
if (typeof d === 'number')
|
|
date.setTime(d);
|
|
else if (typeof d === 'string')
|
|
date.setTime(Date.parse(d));
|
|
else if (typeof d === 'bigint')
|
|
date.setTime(Number(d));
|
|
else
|
|
throw new BSONRuntimeError(`Unrecognized type for EJSON date: ${typeof d}`);
|
|
}
|
|
else {
|
|
if (typeof d === 'string')
|
|
date.setTime(Date.parse(d));
|
|
else if (Long.isLong(d))
|
|
date.setTime(d.toNumber());
|
|
else if (typeof d === 'number' && options.relaxed)
|
|
date.setTime(d);
|
|
else if (typeof d === 'bigint')
|
|
date.setTime(Number(d));
|
|
else
|
|
throw new BSONRuntimeError(`Unrecognized type for EJSON date: ${typeof d}`);
|
|
}
|
|
return date;
|
|
}
|
|
if (value.$code != null) {
|
|
const copy = Object.assign({}, value);
|
|
if (value.$scope) {
|
|
copy.$scope = deserializeValue(value.$scope);
|
|
}
|
|
return Code.fromExtendedJSON(value);
|
|
}
|
|
if (isDBRefLike(value) || value.$dbPointer) {
|
|
const v = value.$ref ? value : value.$dbPointer;
|
|
if (v instanceof DBRef)
|
|
return v;
|
|
const dollarKeys = Object.keys(v).filter(k => k.startsWith('$'));
|
|
let valid = true;
|
|
dollarKeys.forEach(k => {
|
|
if (['$ref', '$id', '$db'].indexOf(k) === -1)
|
|
valid = false;
|
|
});
|
|
if (valid)
|
|
return DBRef.fromExtendedJSON(v);
|
|
}
|
|
return value;
|
|
}
|
|
function serializeArray(array, options) {
|
|
return array.map((v, index) => {
|
|
options.seenObjects.push({ propertyName: `index ${index}`, obj: null });
|
|
try {
|
|
return serializeValue(v, options);
|
|
}
|
|
finally {
|
|
options.seenObjects.pop();
|
|
}
|
|
});
|
|
}
|
|
function getISOString(date) {
|
|
const isoStr = date.toISOString();
|
|
return date.getUTCMilliseconds() !== 0 ? isoStr : isoStr.slice(0, -5) + 'Z';
|
|
}
|
|
function serializeValue(value, options) {
|
|
if (value instanceof Map || isMap(value)) {
|
|
const obj = Object.create(null);
|
|
for (const [k, v] of value) {
|
|
if (typeof k !== 'string') {
|
|
throw new BSONError('Can only serialize maps with string keys');
|
|
}
|
|
obj[k] = v;
|
|
}
|
|
return serializeValue(obj, options);
|
|
}
|
|
if ((typeof value === 'object' || typeof value === 'function') && value !== null) {
|
|
const index = options.seenObjects.findIndex(entry => entry.obj === value);
|
|
if (index !== -1) {
|
|
const props = options.seenObjects.map(entry => entry.propertyName);
|
|
const leadingPart = props
|
|
.slice(0, index)
|
|
.map(prop => `${prop} -> `)
|
|
.join('');
|
|
const alreadySeen = props[index];
|
|
const circularPart = ' -> ' +
|
|
props
|
|
.slice(index + 1, props.length - 1)
|
|
.map(prop => `${prop} -> `)
|
|
.join('');
|
|
const current = props[props.length - 1];
|
|
const leadingSpace = ' '.repeat(leadingPart.length + alreadySeen.length / 2);
|
|
const dashes = '-'.repeat(circularPart.length + (alreadySeen.length + current.length) / 2 - 1);
|
|
throw new BSONError('Converting circular structure to EJSON:\n' +
|
|
` ${leadingPart}${alreadySeen}${circularPart}${current}\n` +
|
|
` ${leadingSpace}\\${dashes}/`);
|
|
}
|
|
options.seenObjects[options.seenObjects.length - 1].obj = value;
|
|
}
|
|
if (Array.isArray(value))
|
|
return serializeArray(value, options);
|
|
if (value === undefined)
|
|
return null;
|
|
if (value instanceof Date || isDate(value)) {
|
|
const dateNum = value.getTime(), inRange = dateNum > -1 && dateNum < 253402318800000;
|
|
if (options.legacy) {
|
|
return options.relaxed && inRange
|
|
? { $date: value.getTime() }
|
|
: { $date: getISOString(value) };
|
|
}
|
|
return options.relaxed && inRange
|
|
? { $date: getISOString(value) }
|
|
: { $date: { $numberLong: value.getTime().toString() } };
|
|
}
|
|
if (typeof value === 'number' && (!options.relaxed || !isFinite(value))) {
|
|
if (Number.isInteger(value) && !Object.is(value, -0)) {
|
|
if (value >= BSON_INT32_MIN && value <= BSON_INT32_MAX) {
|
|
return { $numberInt: value.toString() };
|
|
}
|
|
if (value >= BSON_INT64_MIN && value <= BSON_INT64_MAX) {
|
|
return { $numberLong: value.toString() };
|
|
}
|
|
}
|
|
return { $numberDouble: Object.is(value, -0) ? '-0.0' : value.toString() };
|
|
}
|
|
if (typeof value === 'bigint') {
|
|
if (!options.relaxed) {
|
|
return { $numberLong: BigInt.asIntN(64, value).toString() };
|
|
}
|
|
return Number(BigInt.asIntN(64, value));
|
|
}
|
|
if (value instanceof RegExp || isRegExp(value)) {
|
|
let flags = value.flags;
|
|
if (flags === undefined) {
|
|
const match = value.toString().match(/[gimuy]*$/);
|
|
if (match) {
|
|
flags = match[0];
|
|
}
|
|
}
|
|
const rx = new BSONRegExp(value.source, flags);
|
|
return rx.toExtendedJSON(options);
|
|
}
|
|
if (value != null && typeof value === 'object')
|
|
return serializeDocument(value, options);
|
|
return value;
|
|
}
|
|
const BSON_TYPE_MAPPINGS = {
|
|
Binary: (o) => new Binary(o.value(), o.sub_type),
|
|
Code: (o) => new Code(o.code, o.scope),
|
|
DBRef: (o) => new DBRef(o.collection || o.namespace, o.oid, o.db, o.fields),
|
|
Decimal128: (o) => new Decimal128(o.bytes),
|
|
Double: (o) => new Double(o.value),
|
|
Int32: (o) => new Int32(o.value),
|
|
Long: (o) => Long.fromBits(o.low != null ? o.low : o.low_, o.low != null ? o.high : o.high_, o.low != null ? o.unsigned : o.unsigned_),
|
|
MaxKey: () => new MaxKey(),
|
|
MinKey: () => new MinKey(),
|
|
ObjectId: (o) => new ObjectId(o),
|
|
BSONRegExp: (o) => new BSONRegExp(o.pattern, o.options),
|
|
BSONSymbol: (o) => new BSONSymbol(o.value),
|
|
Timestamp: (o) => Timestamp.fromBits(o.low, o.high)
|
|
};
|
|
function serializeDocument(doc, options) {
|
|
if (doc == null || typeof doc !== 'object')
|
|
throw new BSONError('not an object instance');
|
|
const bsontype = doc._bsontype;
|
|
if (typeof bsontype === 'undefined') {
|
|
const _doc = {};
|
|
for (const name of Object.keys(doc)) {
|
|
options.seenObjects.push({ propertyName: name, obj: null });
|
|
try {
|
|
const value = serializeValue(doc[name], options);
|
|
if (name === '__proto__') {
|
|
Object.defineProperty(_doc, name, {
|
|
value,
|
|
writable: true,
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
}
|
|
else {
|
|
_doc[name] = value;
|
|
}
|
|
}
|
|
finally {
|
|
options.seenObjects.pop();
|
|
}
|
|
}
|
|
return _doc;
|
|
}
|
|
else if (doc != null &&
|
|
typeof doc === 'object' &&
|
|
typeof doc._bsontype === 'string' &&
|
|
doc[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
|
|
throw new BSONVersionError();
|
|
}
|
|
else if (isBSONType(doc)) {
|
|
let outDoc = doc;
|
|
if (typeof outDoc.toExtendedJSON !== 'function') {
|
|
const mapper = BSON_TYPE_MAPPINGS[doc._bsontype];
|
|
if (!mapper) {
|
|
throw new BSONError('Unrecognized or invalid _bsontype: ' + doc._bsontype);
|
|
}
|
|
outDoc = mapper(outDoc);
|
|
}
|
|
if (bsontype === 'Code' && outDoc.scope) {
|
|
outDoc = new Code(outDoc.code, serializeValue(outDoc.scope, options));
|
|
}
|
|
else if (bsontype === 'DBRef' && outDoc.oid) {
|
|
outDoc = new DBRef(serializeValue(outDoc.collection, options), serializeValue(outDoc.oid, options), serializeValue(outDoc.db, options), serializeValue(outDoc.fields, options));
|
|
}
|
|
return outDoc.toExtendedJSON(options);
|
|
}
|
|
else {
|
|
throw new BSONError('_bsontype must be a string, but was: ' + typeof bsontype);
|
|
}
|
|
}
|
|
function parse(text, options) {
|
|
const ejsonOptions = {
|
|
useBigInt64: options?.useBigInt64 ?? false,
|
|
relaxed: options?.relaxed ?? true,
|
|
legacy: options?.legacy ?? false
|
|
};
|
|
return JSON.parse(text, (key, value) => {
|
|
if (key.indexOf('\x00') !== -1) {
|
|
throw new BSONError(`BSON Document field names cannot contain null bytes, found: ${JSON.stringify(key)}`);
|
|
}
|
|
return deserializeValue(value, ejsonOptions);
|
|
});
|
|
}
|
|
function stringify(value, replacer, space, options) {
|
|
if (space != null && typeof space === 'object') {
|
|
options = space;
|
|
space = 0;
|
|
}
|
|
if (replacer != null && typeof replacer === 'object' && !Array.isArray(replacer)) {
|
|
options = replacer;
|
|
replacer = undefined;
|
|
space = 0;
|
|
}
|
|
const serializeOptions = Object.assign({ relaxed: true, legacy: false }, options, {
|
|
seenObjects: [{ propertyName: '(root)', obj: null }]
|
|
});
|
|
const doc = serializeValue(value, serializeOptions);
|
|
return JSON.stringify(doc, replacer, space);
|
|
}
|
|
function EJSONserialize(value, options) {
|
|
options = options || {};
|
|
return JSON.parse(stringify(value, options));
|
|
}
|
|
function EJSONdeserialize(ejson, options) {
|
|
options = options || {};
|
|
return parse(JSON.stringify(ejson), options);
|
|
}
|
|
const EJSON = Object.create(null);
|
|
EJSON.parse = parse;
|
|
EJSON.stringify = stringify;
|
|
EJSON.serialize = EJSONserialize;
|
|
EJSON.deserialize = EJSONdeserialize;
|
|
Object.freeze(EJSON);
|
|
|
|
const MAXSIZE = 1024 * 1024 * 17;
|
|
let buffer = ByteUtils.allocate(MAXSIZE);
|
|
function setInternalBufferSize(size) {
|
|
if (buffer.length < size) {
|
|
buffer = ByteUtils.allocate(size);
|
|
}
|
|
}
|
|
function serialize(object, options = {}) {
|
|
const checkKeys = typeof options.checkKeys === 'boolean' ? options.checkKeys : false;
|
|
const serializeFunctions = typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;
|
|
const ignoreUndefined = typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : true;
|
|
const minInternalBufferSize = typeof options.minInternalBufferSize === 'number' ? options.minInternalBufferSize : MAXSIZE;
|
|
if (buffer.length < minInternalBufferSize) {
|
|
buffer = ByteUtils.allocate(minInternalBufferSize);
|
|
}
|
|
const serializationIndex = serializeInto(buffer, object, checkKeys, 0, 0, serializeFunctions, ignoreUndefined, null);
|
|
const finishedBuffer = ByteUtils.allocate(serializationIndex);
|
|
finishedBuffer.set(buffer.subarray(0, serializationIndex), 0);
|
|
return finishedBuffer;
|
|
}
|
|
function serializeWithBufferAndIndex(object, finalBuffer, options = {}) {
|
|
const checkKeys = typeof options.checkKeys === 'boolean' ? options.checkKeys : false;
|
|
const serializeFunctions = typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;
|
|
const ignoreUndefined = typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : true;
|
|
const startIndex = typeof options.index === 'number' ? options.index : 0;
|
|
const serializationIndex = serializeInto(buffer, object, checkKeys, 0, 0, serializeFunctions, ignoreUndefined, null);
|
|
finalBuffer.set(buffer.subarray(0, serializationIndex), startIndex);
|
|
return startIndex + serializationIndex - 1;
|
|
}
|
|
function deserialize(buffer, options = {}) {
|
|
return internalDeserialize(ByteUtils.toLocalBufferType(buffer), options);
|
|
}
|
|
function calculateObjectSize(object, options = {}) {
|
|
options = options || {};
|
|
const serializeFunctions = typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;
|
|
const ignoreUndefined = typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : true;
|
|
return internalCalculateObjectSize(object, serializeFunctions, ignoreUndefined);
|
|
}
|
|
function deserializeStream(data, startIndex, numberOfDocuments, documents, docStartIndex, options) {
|
|
const internalOptions = Object.assign({ allowObjectSmallerThanBufferSize: true, index: 0 }, options);
|
|
const bufferData = ByteUtils.toLocalBufferType(data);
|
|
let index = startIndex;
|
|
for (let i = 0; i < numberOfDocuments; i++) {
|
|
const size = bufferData[index] |
|
|
(bufferData[index + 1] << 8) |
|
|
(bufferData[index + 2] << 16) |
|
|
(bufferData[index + 3] << 24);
|
|
internalOptions.index = index;
|
|
documents[docStartIndex + i] = internalDeserialize(bufferData, internalOptions);
|
|
index = index + size;
|
|
}
|
|
return index;
|
|
}
|
|
|
|
var bson = /*#__PURE__*/Object.freeze({
|
|
__proto__: null,
|
|
BSONError: BSONError,
|
|
BSONRegExp: BSONRegExp,
|
|
BSONRuntimeError: BSONRuntimeError,
|
|
BSONSymbol: BSONSymbol,
|
|
BSONType: BSONType,
|
|
BSONValue: BSONValue,
|
|
BSONVersionError: BSONVersionError,
|
|
Binary: Binary,
|
|
Code: Code,
|
|
DBRef: DBRef,
|
|
Decimal128: Decimal128,
|
|
Double: Double,
|
|
EJSON: EJSON,
|
|
Int32: Int32,
|
|
Long: Long,
|
|
MaxKey: MaxKey,
|
|
MinKey: MinKey,
|
|
ObjectId: ObjectId,
|
|
Timestamp: Timestamp,
|
|
UUID: UUID,
|
|
calculateObjectSize: calculateObjectSize,
|
|
deserialize: deserialize,
|
|
deserializeStream: deserializeStream,
|
|
serialize: serialize,
|
|
serializeWithBufferAndIndex: serializeWithBufferAndIndex,
|
|
setInternalBufferSize: setInternalBufferSize
|
|
});
|
|
|
|
export { bson as BSON, BSONError, BSONRegExp, BSONRuntimeError, BSONSymbol, BSONType, BSONValue, BSONVersionError, Binary, Code, DBRef, Decimal128, Double, EJSON, Int32, Long, MaxKey, MinKey, ObjectId, Timestamp, UUID, calculateObjectSize, deserialize, deserializeStream, serialize, serializeWithBufferAndIndex, setInternalBufferSize };
|
|
//# sourceMappingURL=bson.mjs.map
|