@tellescope/utilities 1.72.2 → 1.74.0

package/lib/esm/ObjectId/constants.js

@@ -0,0 +1,105 @@
+/** @internal */
+export var BSON_MAJOR_VERSION = 5;
+/** @internal */
+export var BSON_INT32_MAX = 0x7fffffff;
+/** @internal */
+export var BSON_INT32_MIN = -0x80000000;
+/** @internal */
+export var BSON_INT64_MAX = Math.pow(2, 63) - 1;
+/** @internal */
+export var BSON_INT64_MIN = -Math.pow(2, 63);
+/**
+ * Any integer up to 2^53 can be precisely represented by a double.
+ * @internal
+ */
+export var JS_INT_MAX = Math.pow(2, 53);
+/**
+ * Any integer down to -2^53 can be precisely represented by a double.
+ * @internal
+ */
+export var JS_INT_MIN = -Math.pow(2, 53);
+/** Number BSON Type @internal */
+export var BSON_DATA_NUMBER = 1;
+/** String BSON Type @internal */
+export var BSON_DATA_STRING = 2;
+/** Object BSON Type @internal */
+export var BSON_DATA_OBJECT = 3;
+/** Array BSON Type @internal */
+export var BSON_DATA_ARRAY = 4;
+/** Binary BSON Type @internal */
+export var BSON_DATA_BINARY = 5;
+/** Binary BSON Type @internal */
+export var BSON_DATA_UNDEFINED = 6;
+/** ObjectId BSON Type @internal */
+export var BSON_DATA_OID = 7;
+/** Boolean BSON Type @internal */
+export var BSON_DATA_BOOLEAN = 8;
+/** Date BSON Type @internal */
+export var BSON_DATA_DATE = 9;
+/** null BSON Type @internal */
+export var BSON_DATA_NULL = 10;
+/** RegExp BSON Type @internal */
+export var BSON_DATA_REGEXP = 11;
+/** Code BSON Type @internal */
+export var BSON_DATA_DBPOINTER = 12;
+/** Code BSON Type @internal */
+export var BSON_DATA_CODE = 13;
+/** Symbol BSON Type @internal */
+export var BSON_DATA_SYMBOL = 14;
+/** Code with Scope BSON Type @internal */
+export var BSON_DATA_CODE_W_SCOPE = 15;
+/** 32 bit Integer BSON Type @internal */
+export var BSON_DATA_INT = 16;
+/** Timestamp BSON Type @internal */
+export var BSON_DATA_TIMESTAMP = 17;
+/** Long BSON Type @internal */
+export var BSON_DATA_LONG = 18;
+/** Decimal128 BSON Type @internal */
+export var BSON_DATA_DECIMAL128 = 19;
+/** MinKey BSON Type @internal */
+export var BSON_DATA_MIN_KEY = 0xff;
+/** MaxKey BSON Type @internal */
+export var BSON_DATA_MAX_KEY = 0x7f;
+/** Binary Default Type @internal */
+export var BSON_BINARY_SUBTYPE_DEFAULT = 0;
+/** Binary Function Type @internal */
+export var BSON_BINARY_SUBTYPE_FUNCTION = 1;
+/** Binary Byte Array Type @internal */
+export var BSON_BINARY_SUBTYPE_BYTE_ARRAY = 2;
+/** Binary Deprecated UUID Type @deprecated Please use BSON_BINARY_SUBTYPE_UUID_NEW @internal */
+export var BSON_BINARY_SUBTYPE_UUID = 3;
+/** Binary UUID Type @internal */
+export var BSON_BINARY_SUBTYPE_UUID_NEW = 4;
+/** Binary MD5 Type @internal */
+export var BSON_BINARY_SUBTYPE_MD5 = 5;
+/** Encrypted BSON type @internal */
+export var BSON_BINARY_SUBTYPE_ENCRYPTED = 6;
+/** Column BSON type @internal */
+export var BSON_BINARY_SUBTYPE_COLUMN = 7;
+/** Binary User Defined Type @internal */
+export var BSON_BINARY_SUBTYPE_USER_DEFINED = 128;
+/** @public */
+export var 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
+});
+//# sourceMappingURL=constants.js.map

package/lib/esm/ObjectId/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/ObjectId/constants.ts"],"names":[],"mappings":"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"}

package/lib/esm/ObjectId/error.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @public
+ * @category Error
+ *
+ * `BSONError` objects are thrown when BSON ecounters an error.
+ *
+ * This is the parent class for all the other errors thrown by this library.
+ */
+export declare class BSONError extends Error {
+    /**
+     * @internal
+     * The underlying algorithm for isBSONError may change to improve how strict it is
+     * about determining if an input is a BSONError. But it must remain backwards compatible
+     * with previous minors & patches of the current major version.
+     */
+    protected get bsonError(): true;
+    get name(): string;
+    constructor(message: string);
+    /**
+     * @public
+     *
+     * All errors thrown from the BSON library inherit from `BSONError`.
+     * This method can assist with determining if an error originates from the BSON library
+     * even if it does not pass an `instanceof` check against this class' constructor.
+     *
+     * @param value - any javascript value that needs type checking
+     */
+    static isBSONError(value: unknown): value is BSONError;
+}
+/**
+ * @public
+ * @category Error
+ */
+export declare class BSONVersionError extends BSONError {
+    get name(): 'BSONVersionError';
+    constructor();
+}
+/**
+ * @public
+ * @category Error
+ *
+ * An error generated when BSON functions encounter an unexpected input
+ * or reaches an unexpected/invalid internal state
+ *
+ */
+export declare class BSONRuntimeError extends BSONError {
+    get name(): 'BSONRuntimeError';
+    constructor(message: string);
+}
+//# sourceMappingURL=error.d.ts.map

package/lib/esm/ObjectId/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../src/ObjectId/error.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,qBAAa,SAAU,SAAQ,KAAK;IAClC;;;;;OAKG;IACH,SAAS,KAAK,SAAS,IAAI,IAAI,CAE9B;IAED,IAAa,IAAI,IAAI,MAAM,CAE1B;gBAEW,OAAO,EAAE,MAAM;IAI3B;;;;;;;;OAQG;WACW,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS;CAY9D;AAED;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,SAAS;IAC7C,IAAI,IAAI,IAAI,kBAAkB,CAE7B;;CAKF;AAED;;;;;;;GAOG;AACH,qBAAa,gBAAiB,SAAQ,SAAS;IAC7C,IAAI,IAAI,IAAI,kBAAkB,CAE7B;gBAEW,OAAO,EAAE,MAAM;CAG5B"}

package/lib/esm/ObjectId/error.js

@@ -0,0 +1,114 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { BSON_MAJOR_VERSION } from './constants';
+/**
+ * @public
+ * @category Error
+ *
+ * `BSONError` objects are thrown when BSON ecounters an error.
+ *
+ * This is the parent class for all the other errors thrown by this library.
+ */
+var BSONError = /** @class */ (function (_super) {
+    __extends(BSONError, _super);
+    function BSONError(message) {
+        return _super.call(this, message) || this;
+    }
+    Object.defineProperty(BSONError.prototype, "bsonError", {
+        /**
+         * @internal
+         * The underlying algorithm for isBSONError may change to improve how strict it is
+         * about determining if an input is a BSONError. But it must remain backwards compatible
+         * with previous minors & patches of the current major version.
+         */
+        get: function () {
+            return true;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BSONError.prototype, "name", {
+        get: function () {
+            return 'BSONError';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * @public
+     *
+     * All errors thrown from the BSON library inherit from `BSONError`.
+     * This method can assist with determining if an error originates from the BSON library
+     * even if it does not pass an `instanceof` check against this class' constructor.
+     *
+     * @param value - any javascript value that needs type checking
+     */
+    BSONError.isBSONError = function (value) {
+        return (value != null &&
+            typeof value === 'object' &&
+            'bsonError' in value &&
+            value.bsonError === true &&
+            // Do not access the following properties, just check existence
+            'name' in value &&
+            'message' in value &&
+            'stack' in value);
+    };
+    return BSONError;
+}(Error));
+export { BSONError };
+/**
+ * @public
+ * @category Error
+ */
+var BSONVersionError = /** @class */ (function (_super) {
+    __extends(BSONVersionError, _super);
+    function BSONVersionError() {
+        return _super.call(this, "Unsupported BSON version, bson types must be from bson ".concat(BSON_MAJOR_VERSION, ".x.x")) || this;
+    }
+    Object.defineProperty(BSONVersionError.prototype, "name", {
+        get: function () {
+            return 'BSONVersionError';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BSONVersionError;
+}(BSONError));
+export { BSONVersionError };
+/**
+ * @public
+ * @category Error
+ *
+ * An error generated when BSON functions encounter an unexpected input
+ * or reaches an unexpected/invalid internal state
+ *
+ */
+var BSONRuntimeError = /** @class */ (function (_super) {
+    __extends(BSONRuntimeError, _super);
+    function BSONRuntimeError(message) {
+        return _super.call(this, message) || this;
+    }
+    Object.defineProperty(BSONRuntimeError.prototype, "name", {
+        get: function () {
+            return 'BSONRuntimeError';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BSONRuntimeError;
+}(BSONError));
+export { BSONRuntimeError };
+//# sourceMappingURL=error.js.map

package/lib/esm/ObjectId/error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","sourceRoot":"","sources":["../../../src/ObjectId/error.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEjD;;;;;;;GAOG;AACH;IAA+B,6BAAK;IAelC,mBAAY,OAAe;eACzB,kBAAM,OAAO,CAAC;IAChB,CAAC;IAVD,sBAAc,gCAAS;QANvB;;;;;WAKG;aACH;YACE,OAAO,IAAI,CAAC;QACd,CAAC;;;OAAA;IAED,sBAAa,2BAAI;aAAjB;YACE,OAAO,WAAW,CAAC;QACrB,CAAC;;;OAAA;IAMD;;;;;;;;OAQG;IACW,qBAAW,GAAzB,UAA0B,KAAc;QACtC,OAAO,CACL,KAAK,IAAI,IAAI;YACb,OAAO,KAAK,KAAK,QAAQ;YACzB,WAAW,IAAI,KAAK;YACpB,KAAK,CAAC,SAAS,KAAK,IAAI;YACxB,+DAA+D;YAC/D,MAAM,IAAI,KAAK;YACf,SAAS,IAAI,KAAK;YAClB,OAAO,IAAI,KAAK,CACjB,CAAC;IACJ,CAAC;IACH,gBAAC;AAAD,CAAC,AAxCD,CAA+B,KAAK,GAwCnC;;AAED;;;GAGG;AACH;IAAsC,oCAAS;IAK7C;eACE,kBAAM,iEAA0D,kBAAkB,SAAM,CAAC;IAC3F,CAAC;IAND,sBAAI,kCAAI;aAAR;YACE,OAAO,kBAAkB,CAAC;QAC5B,CAAC;;;OAAA;IAKH,uBAAC;AAAD,CAAC,AARD,CAAsC,SAAS,GAQ9C;;AAED;;;;;;;GAOG;AACH;IAAsC,oCAAS;IAK7C,0BAAY,OAAe;eACzB,kBAAM,OAAO,CAAC;IAChB,CAAC;IAND,sBAAI,kCAAI;aAAR;YACE,OAAO,kBAAkB,CAAC;QAC5B,CAAC;;;OAAA;IAKH,uBAAC;AAAD,CAAC,AARD,CAAsC,SAAS,GAQ9C"}

package/lib/esm/ObjectId/objectid.d.ts

@@ -0,0 +1,96 @@
+import { BSONValue } from './bson_value';
+/** @public */
+export interface ObjectIdLike {
+    id: string | Uint8Array;
+    __id?: string;
+    toHexString(): string;
+}
+/** @public */
+export interface ObjectIdExtended {
+    $oid: string;
+}
+declare const kId: unique symbol;
+/**
+ * A class representation of the BSON ObjectId type.
+ * @public
+ * @category BSONType
+ */
+export declare class ObjectId extends BSONValue {
+    get _bsontype(): 'ObjectId';
+    /** @internal */
+    private static index;
+    static cacheHexString: boolean;
+    /** ObjectId Bytes @internal */
+    private [kId];
+    /** ObjectId hexString cache @internal */
+    private __id?;
+    /**
+     * Create an ObjectId type
+     *
+     * @param inputId - Can be a 24 character hex string, 12 byte binary Buffer, or a number.
+     */
+    constructor(inputId?: string | number | ObjectId | ObjectIdLike | Uint8Array);
+    /**
+     * The ObjectId bytes
+     * @readonly
+     */
+    get id(): Uint8Array;
+    set id(value: Uint8Array);
+    /** Returns the ObjectId id as a 24 character hex string representation */
+    toHexString(): string;
+    /**
+     * Update the ObjectId index
+     * @internal
+     */
+    private static getInc;
+    /**
+     * Generate a 12 byte id buffer used in ObjectId's
+     *
+     * @param time - pass in a second based timestamp.
+     */
+    static generate(time?: number): Uint8Array;
+    /**
+     * Converts the id into a 24 character hex string for printing, unless encoding is provided.
+     * @param encoding - hex or base64
+     */
+    toString(encoding?: 'hex' | 'base64'): string;
+    /** Converts to its JSON the 24 character hex string representation. */
+    toJSON(): string;
+    /**
+     * Compares the equality of this ObjectId with `otherID`.
+     *
+     * @param otherId - ObjectId instance to compare against.
+     */
+    equals(otherId: string | ObjectId | ObjectIdLike): boolean;
+    /** Returns the generation date (accurate up to the second) that this ID was generated. */
+    getTimestamp(): Date;
+    /** @internal */
+    static createPk(): ObjectId;
+    /**
+     * Creates an ObjectId from a second based number, with the rest of the ObjectId zeroed out. Used for comparisons or sorting the ObjectId.
+     *
+     * @param time - an integer number representing a number of seconds.
+     */
+    static createFromTime(time: number): ObjectId;
+    /**
+     * Creates an ObjectId from a hex string representation of an ObjectId.
+     *
+     * @param hexString - create a ObjectId from a passed in 24 character hexstring.
+     */
+    static createFromHexString(hexString: string): ObjectId;
+    /** Creates an ObjectId instance from a base64 string */
+    static createFromBase64(base64: string): ObjectId;
+    /**
+     * Checks if a value is a valid bson ObjectId
+     *
+     * @param id - ObjectId instance to validate.
+     */
+    static isValid(id: string | number | ObjectId | ObjectIdLike | Uint8Array): boolean;
+    /** @internal */
+    toExtendedJSON(): ObjectIdExtended;
+    /** @internal */
+    static fromExtendedJSON(doc: ObjectIdExtended): ObjectId;
+    inspect(): string;
+}
+export {};
+//# sourceMappingURL=objectid.d.ts.map

package/lib/esm/ObjectId/objectid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objectid.d.ts","sourceRoot":"","sources":["../../../src/ObjectId/objectid.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAWzC,cAAc;AACd,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,GAAG,UAAU,CAAC;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,IAAI,MAAM,CAAC;CACvB;AAED,cAAc;AACd,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;CACd;AAED,QAAA,MAAM,GAAG,eAAe,CAAC;AAEzB;;;;GAIG;AACH,qBAAa,QAAS,SAAQ,SAAS;IACrC,IAAI,SAAS,IAAI,UAAU,CAE1B;IAED,gBAAgB;IAChB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAwC;IAE5D,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC;IAE/B,+BAA+B;IAC/B,OAAO,CAAC,CAAC,GAAG,CAAC,CAAc;IAC3B,yCAAyC;IACzC,OAAO,CAAC,IAAI,CAAC,CAAS;IAEtB;;;;OAIG;gBACS,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,YAAY,GAAG,UAAU;IAkD5E;;;OAGG;IACH,IAAI,EAAE,IAAI,UAAU,CAEnB;IAED,IAAI,EAAE,CAAC,KAAK,EAAE,UAAU,EAKvB;IAED,0EAA0E;IAC1E,WAAW,IAAI,MAAM;IAcrB;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,MAAM;IAIrB;;;;OAIG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,UAAU;IA+B1C;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM;IAO7C,uEAAuE;IACvE,MAAM,IAAI,MAAM;IAIhB;;;;OAIG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,GAAG,YAAY,GAAG,OAAO;IAuC1D,0FAA0F;IAC1F,YAAY,IAAI,IAAI;IAOpB,gBAAgB;IAChB,MAAM,CAAC,QAAQ,IAAI,QAAQ;IAI3B;;;;OAIG;IACH,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ;IAQ7C;;;;OAIG;IACH,MAAM,CAAC,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,QAAQ;IAQvD,wDAAwD;IACxD,MAAM,CAAC,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ;IAQjD;;;;OAIG;IACH,MAAM,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,YAAY,GAAG,UAAU,GAAG,OAAO;IAWnF,gBAAgB;IAChB,cAAc,IAAI,gBAAgB;IAKlC,gBAAgB;IAChB,MAAM,CAAC,gBAAgB,CAAC,GAAG,EAAE,gBAAgB,GAAG,QAAQ;IAcxD,OAAO,IAAI,MAAM;CAGlB"}

package/lib/esm/ObjectId/objectid.js

@@ -0,0 +1,297 @@
+// 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { BSONValue } from './bson_value';
+import { BSONError } from './error';
+import { isUint8Array } from './parser/utils';
+import { BSONDataView, ByteUtils } from './utils/byte_utils';
+// Regular expression that checks for hex value
+var checkForHexRegExp = new RegExp('^[0-9a-fA-F]{24}$');
+// Unique sequence for the current process (initialized on first use)
+var PROCESS_UNIQUE = null;
+var kId = Symbol('id');
+/**
+ * A class representation of the BSON ObjectId type.
+ * @public
+ * @category BSONType
+ */
+var ObjectId = /** @class */ (function (_super) {
+    __extends(ObjectId, _super);
+    /**
+     * Create an ObjectId type
+     *
+     * @param inputId - Can be a 24 character hex string, 12 byte binary Buffer, or a number.
+     */
+    function ObjectId(inputId) {
+        var _this = _super.call(this) || this;
+        // workingId is set based on type of input and whether valid id exists for the input
+        var 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;
+        }
+        // the following cases use workingId to construct an ObjectId
+        if (workingId == null || typeof workingId === 'number') {
+            // The most common use case (blank id, new objectId instance)
+            // Generate a new id
+            _this[kId] = ObjectId.generate(typeof workingId === 'number' ? workingId : undefined);
+        }
+        else if (ArrayBuffer.isView(workingId) && workingId.byteLength === 12) {
+            // If intstanceof matches we can escape calling ensure buffer in Node.js environments
+            _this[kId] = ByteUtils.toLocalBufferType(workingId);
+        }
+        else if (typeof workingId === 'string') {
+            if (workingId.length === 12) {
+                // TODO(NODE-4361): Remove string of length 12 support
+                var bytes = ByteUtils.fromUTF8(workingId);
+                if (bytes.byteLength === 12) {
+                    _this[kId] = bytes;
+                }
+                else {
+                    throw new BSONError('Argument passed in must be a string of 12 bytes');
+                }
+            }
+            else if (workingId.length === 24 && checkForHexRegExp.test(workingId)) {
+                _this[kId] = ByteUtils.fromHex(workingId);
+            }
+            else {
+                throw new BSONError('Argument passed in must be a string of 12 bytes or a string of 24 hex characters or an integer');
+            }
+        }
+        else {
+            throw new BSONError('Argument passed in does not match the accepted types');
+        }
+        // If we are caching the hex string
+        if (ObjectId.cacheHexString) {
+            _this.__id = ByteUtils.toHex(_this.id);
+        }
+        return _this;
+    }
+    Object.defineProperty(ObjectId.prototype, "_bsontype", {
+        get: function () {
+            return 'ObjectId';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ObjectId.prototype, "id", {
+        /**
+         * The ObjectId bytes
+         * @readonly
+         */
+        get: function () {
+            return this[kId];
+        },
+        set: function (value) {
+            this[kId] = value;
+            if (ObjectId.cacheHexString) {
+                this.__id = ByteUtils.toHex(value);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** Returns the ObjectId id as a 24 character hex string representation */
+    ObjectId.prototype.toHexString = function () {
+        if (ObjectId.cacheHexString && this.__id) {
+            return this.__id;
+        }
+        var hexString = ByteUtils.toHex(this.id);
+        if (ObjectId.cacheHexString && !this.__id) {
+            this.__id = hexString;
+        }
+        return hexString;
+    };
+    /**
+     * Update the ObjectId index
+     * @internal
+     */
+    ObjectId.getInc = function () {
+        return (ObjectId.index = (ObjectId.index + 1) % 0xffffff);
+    };
+    /**
+     * Generate a 12 byte id buffer used in ObjectId's
+     *
+     * @param time - pass in a second based timestamp.
+     */
+    ObjectId.generate = function (time) {
+        if ('number' !== typeof time) {
+            time = Math.floor(Date.now() / 1000);
+        }
+        var inc = ObjectId.getInc();
+        var buffer = ByteUtils.allocate(12);
+        // 4-byte timestamp
+        BSONDataView.fromUint8Array(buffer).setUint32(0, time, false);
+        // set PROCESS_UNIQUE if yet not initialized
+        if (PROCESS_UNIQUE === null) {
+            PROCESS_UNIQUE = ByteUtils.randomBytes(5);
+        }
+        // 5-byte process unique
+        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];
+        // 3-byte counter
+        buffer[11] = inc & 0xff;
+        buffer[10] = (inc >> 8) & 0xff;
+        buffer[9] = (inc >> 16) & 0xff;
+        return buffer;
+    };
+    /**
+     * Converts the id into a 24 character hex string for printing, unless encoding is provided.
+     * @param encoding - hex or base64
+     */
+    ObjectId.prototype.toString = function (encoding) {
+        // Is the id a buffer then use the buffer toString method to return the format
+        if (encoding === 'base64')
+            return ByteUtils.toBase64(this.id);
+        if (encoding === 'hex')
+            return this.toHexString();
+        return this.toHexString();
+    };
+    /** Converts to its JSON the 24 character hex string representation. */
+    ObjectId.prototype.toJSON = function () {
+        return this.toHexString();
+    };
+    /**
+     * Compares the equality of this ObjectId with `otherID`.
+     *
+     * @param otherId - ObjectId instance to compare against.
+     */
+    ObjectId.prototype.equals = function (otherId) {
+        if (otherId === undefined || otherId === null) {
+            return false;
+        }
+        if (otherId instanceof ObjectId) {
+            return this[kId][11] === otherId[kId][11] && ByteUtils.equals(this[kId], otherId[kId]);
+        }
+        if (typeof otherId === 'string' &&
+            ObjectId.isValid(otherId) &&
+            otherId.length === 12 &&
+            isUint8Array(this.id)) {
+            return ByteUtils.equals(this.id, ByteUtils.fromISO88591(otherId));
+        }
+        if (typeof otherId === 'string' && ObjectId.isValid(otherId) && otherId.length === 24) {
+            return otherId.toLowerCase() === this.toHexString();
+        }
+        if (typeof otherId === 'string' && ObjectId.isValid(otherId) && otherId.length === 12) {
+            return ByteUtils.equals(ByteUtils.fromUTF8(otherId), this.id);
+        }
+        if (typeof otherId === 'object' &&
+            'toHexString' in otherId &&
+            typeof otherId.toHexString === 'function') {
+            var otherIdString = otherId.toHexString();
+            var thisIdString = this.toHexString().toLowerCase();
+            return typeof otherIdString === 'string' && otherIdString.toLowerCase() === thisIdString;
+        }
+        return false;
+    };
+    /** Returns the generation date (accurate up to the second) that this ID was generated. */
+    ObjectId.prototype.getTimestamp = function () {
+        var timestamp = new Date();
+        var time = BSONDataView.fromUint8Array(this.id).getUint32(0, false);
+        timestamp.setTime(Math.floor(time) * 1000);
+        return timestamp;
+    };
+    /** @internal */
+    ObjectId.createPk = function () {
+        return new ObjectId();
+    };
+    /**
+     * Creates an ObjectId from a second based number, with the rest of the ObjectId zeroed out. Used for comparisons or sorting the ObjectId.
+     *
+     * @param time - an integer number representing a number of seconds.
+     */
+    ObjectId.createFromTime = function (time) {
+        var buffer = ByteUtils.fromNumberArray([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+        // Encode time into first 4 bytes
+        BSONDataView.fromUint8Array(buffer).setUint32(0, time, false);
+        // Return the new objectId
+        return new ObjectId(buffer);
+    };
+    /**
+     * Creates an ObjectId from a hex string representation of an ObjectId.
+     *
+     * @param hexString - create a ObjectId from a passed in 24 character hexstring.
+     */
+    ObjectId.createFromHexString = function (hexString) {
+        if ((hexString === null || hexString === void 0 ? void 0 : hexString.length) !== 24) {
+            throw new BSONError('hex string must be 24 characters');
+        }
+        return new ObjectId(ByteUtils.fromHex(hexString));
+    };
+    /** Creates an ObjectId instance from a base64 string */
+    ObjectId.createFromBase64 = function (base64) {
+        if ((base64 === null || base64 === void 0 ? void 0 : base64.length) !== 16) {
+            throw new BSONError('base64 string must be 16 characters');
+        }
+        return new ObjectId(ByteUtils.fromBase64(base64));
+    };
+    /**
+     * Checks if a value is a valid bson ObjectId
+     *
+     * @param id - ObjectId instance to validate.
+     */
+    ObjectId.isValid = function (id) {
+        if (id == null)
+            return false;
+        try {
+            new ObjectId(id);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    };
+    /** @internal */
+    ObjectId.prototype.toExtendedJSON = function () {
+        if (this.toHexString)
+            return { $oid: this.toHexString() };
+        return { $oid: this.toString('hex') };
+    };
+    /** @internal */
+    ObjectId.fromExtendedJSON = function (doc) {
+        return new ObjectId(doc.$oid);
+    };
+    /**
+     * Converts to a string representation of this Id.
+     *
+     * @returns return the 24 character hex string representation.
+     * @internal
+     */
+    ObjectId.prototype[Symbol.for('nodejs.util.inspect.custom')] = function () {
+        return this.inspect();
+    };
+    ObjectId.prototype.inspect = function () {
+        return "new ObjectId(\"".concat(this.toHexString(), "\")");
+    };
+    /** @internal */
+    ObjectId.index = Math.floor(Math.random() * 0xffffff);
+    return ObjectId;
+}(BSONValue));
+export { ObjectId };
+//# sourceMappingURL=objectid.js.map