From 29a9fc2264fcc824b14295fcf10c977a39dfb818 Mon Sep 17 00:00:00 2001 From: CounterFire2023 <136581895+CounterFire2023@users.noreply.github.com> Date: Fri, 19 Jan 2024 13:54:32 +0800 Subject: [PATCH] add base code --- README.md | 5 + dist/index.d.ts | 90 + dist/index.js | 4040 +++++++++++++++++++++++++++++++++++ dist/index.js.map | 1 + package.json | 19 +- src/common/AsyncQueue.ts | 107 + src/decorators/dbconn.ts | 14 + src/decorators/nojson.ts | 30 + src/decorators/singleton.ts | 29 + src/index.ts | 5 + src/logger/logger.ts | 19 + src/models/Base.ts | 216 ++ src/models/UserLog.ts | 31 + src/queue/logger.queue.ts | 39 + tsconfig.json | 6 +- tsup.config.ts | 10 + yarn.lock | 1322 +++++++++++- 17 files changed, 5976 insertions(+), 7 deletions(-) create mode 100644 dist/index.d.ts create mode 100644 dist/index.js create mode 100644 dist/index.js.map create mode 100644 src/common/AsyncQueue.ts create mode 100644 src/decorators/dbconn.ts create mode 100644 src/decorators/nojson.ts create mode 100644 src/decorators/singleton.ts create mode 100644 src/index.ts create mode 100644 src/logger/logger.ts create mode 100644 src/models/Base.ts create mode 100644 src/models/UserLog.ts create mode 100644 src/queue/logger.queue.ts create mode 100644 tsup.config.ts diff --git a/README.md b/README.md index 86c6405..a6859fd 100644 --- a/README.md +++ b/README.md @@ -11,6 +11,11 @@ yarn add file:packages/mongobase # or yarn add link:packages/mongobase ``` +db的配置, 请在环境变量中配置 + +```bash +process.env.DB_DBNAME=xxx +``` ```typescript diff --git a/dist/index.d.ts b/dist/index.d.ts new file mode 100644 index 0000000..52e5b22 --- /dev/null +++ b/dist/index.d.ts @@ -0,0 +1,90 @@ +import * as tracer from 'tracer'; +import * as _typegoose_typegoose from '@typegoose/typegoose'; +import { ReturnModelType } from '@typegoose/typegoose'; +import * as _typegoose_typegoose_lib_types from '@typegoose/typegoose/lib/types'; +import { AnyParamConstructor } from '@typegoose/typegoose/lib/types'; +import * as mongoose from 'mongoose'; +import { Connection } from 'mongoose'; + +/** + * 为model指定数据库连接 + * @param {string} name 数据库连接名字， 在config中必须要有对应的配置， 比如main， 则必须要有 db_main + * */ +declare function dbconn(name?: string): (target: any) => void; + +declare class NoJsonClass { + private noJsonPropSet; + addKey(className: string, propertyKey: string): void; + checkExist(className: string, propertyKey: string): boolean; +} +/** + * 在不需要toJson方法输出的字段上加上 @noJson + * @return {{(target: Function): void, (target: Object, propertyKey: (string | symbol)): void}} + */ +declare function noJson(): (target: Object, propertyKey: string) => void; +declare function checkJson(target: any, propertyKey: string): boolean; + +declare const logger: tracer.Tracer.Logger; + +declare abstract class BaseModule { + static db: Connection; + updateFromReq(data: any): void; + /** + * 插入或更新 + * @param condition + * @param data + */ + static insertOrUpdate(this: ReturnModelType>, condition: any, data: any): mongoose.QueryWithHelpers & Omit, "typegooseName"> & _typegoose_typegoose_lib_types.IObjectWithTypegooseFunction>, mongoose.IfAny & Omit, "typegooseName"> & _typegoose_typegoose_lib_types.IObjectWithTypegooseFunction>, _typegoose_typegoose_lib_types.BeAnObject, T, "findOneAndUpdate">; + /** + * 虚拟删除 + * @param {string[]} ids + */ + static deleteVirtual(this: ReturnModelType>, ids: string[]): mongoose.QueryWithHelpers & Omit, "typegooseName"> & _typegoose_typegoose_lib_types.IObjectWithTypegooseFunction>, _typegoose_typegoose_lib_types.BeAnObject, T, "updateMany">; + /** + * 自定义分页查询 + * @param data + * @param {boolean} json + */ + static pageQuery(this: ReturnModelType>, data: any, json?: boolean): Promise<{ + records: mongoose.IfAny & Omit, "typegooseName"> & _typegoose_typegoose_lib_types.IObjectWithTypegooseFunction>[]; + total: number; + start: any; + limit: any; + }>; + toJson(): any; + /** + * 通用的查询条件拼接方法 + * @param {{}} params req.params + * @param options + * sort: 排序 比如: {createdAt: 1} 默认是 {_id: 1} + * opt: 设置一些特殊的过滤条件, 比如{deleted: 0} + * timeKey: 如果需要查询创建时间, 而且创建时间不为 createdAt, 可以用此字段设置 + * matchKey: 指定关键字查询的匹配字段, 可为string或[string] + * + * @return {{opt: any, sort: {_id: number}}} + */ + static parseQueryParam(params: {}, options?: any): { + opt: any; + sort: { + _id: number; + }; + }; + getTimestampOfID(): any; +} + +/** + * 用户操作记录 + */ +declare class UserLogClass extends BaseModule { + user: string; + name: string; + method: string; + path: string; + referer: string; + user_agent: string; + ip: string; + params: any; +} +declare const UserLog: _typegoose_typegoose.ReturnModelType; + +export { BaseModule, NoJsonClass, UserLog, checkJson, dbconn, logger, noJson }; diff --git a/dist/index.js b/dist/index.js new file mode 100644 index 0000000..d6e3e40 --- /dev/null +++ b/dist/index.js @@ -0,0 +1,4040 @@ +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __decorateClass = (decorators, target, key, kind) => { + var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target; + for (var i = decorators.length - 1, decorator; i >= 0; i--) + if (decorator = decorators[i]) + result = (kind ? decorator(target, key, result) : decorator(result)) || result; + if (kind && result) + __defProp(target, key, result); + return result; +}; + +// node_modules/reflect-metadata/Reflect.js +var require_Reflect = __commonJS({ + "node_modules/reflect-metadata/Reflect.js"() { + var Reflect2; + (function(Reflect3) { + (function(factory) { + var root = typeof globalThis === "object" ? globalThis : typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis(); + var exporter = makeExporter(Reflect3); + if (typeof root.Reflect !== "undefined") { + exporter = makeExporter(root.Reflect, exporter); + } + factory(exporter, root); + if (typeof root.Reflect === "undefined") { + root.Reflect = Reflect3; + } + function makeExporter(target, previous) { + return function(key, value) { + Object.defineProperty(target, key, { configurable: true, writable: true, value }); + if (previous) + previous(key, value); + }; + } + function functionThis() { + try { + return Function("return this;")(); + } catch (_) { + } + } + function indirectEvalThis() { + try { + return (void 0, eval)("(function() { return this; })()"); + } catch (_) { + } + } + function sloppyModeThis() { + return functionThis() || indirectEvalThis(); + } + })(function(exporter, root) { + var hasOwn = Object.prototype.hasOwnProperty; + var supportsSymbol = typeof Symbol === "function"; + var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive"; + var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator"; + var supportsCreate = typeof Object.create === "function"; + var supportsProto = { __proto__: [] } instanceof Array; + var downLevel = !supportsCreate && !supportsProto; + var HashMap = { + // create an object in dictionary mode (a.k.a. "slow" mode in v8) + create: supportsCreate ? function() { + return MakeDictionary(/* @__PURE__ */ Object.create(null)); + } : supportsProto ? function() { + return MakeDictionary({ __proto__: null }); + } : function() { + return MakeDictionary({}); + }, + has: downLevel ? function(map, key) { + return hasOwn.call(map, key); + } : function(map, key) { + return key in map; + }, + get: downLevel ? function(map, key) { + return hasOwn.call(map, key) ? map[key] : void 0; + } : function(map, key) { + return map[key]; + } + }; + var functionPrototype = Object.getPrototypeOf(Function); + var _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill(); + var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill(); + var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill(); + var registrySymbol = supportsSymbol ? Symbol.for("@reflect-metadata:registry") : void 0; + var metadataRegistry = GetOrCreateMetadataRegistry(); + var metadataProvider = CreateMetadataProvider(metadataRegistry); + function decorate(decorators, target, propertyKey, attributes) { + if (!IsUndefined(propertyKey)) { + if (!IsArray(decorators)) + throw new TypeError(); + if (!IsObject(target)) + throw new TypeError(); + if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes)) + throw new TypeError(); + if (IsNull(attributes)) + attributes = void 0; + propertyKey = ToPropertyKey(propertyKey); + return DecorateProperty(decorators, target, propertyKey, attributes); + } else { + if (!IsArray(decorators)) + throw new TypeError(); + if (!IsConstructor(target)) + throw new TypeError(); + return DecorateConstructor(decorators, target); + } + } + exporter("decorate", decorate); + function metadata(metadataKey, metadataValue) { + function decorator(target, propertyKey) { + if (!IsObject(target)) + throw new TypeError(); + if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey)) + throw new TypeError(); + OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey); + } + return decorator; + } + exporter("metadata", metadata); + function defineMetadata(metadataKey, metadataValue, target, propertyKey) { + if (!IsObject(target)) + throw new TypeError(); + if (!IsUndefined(propertyKey)) + propertyKey = ToPropertyKey(propertyKey); + return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey); + } + exporter("defineMetadata", defineMetadata); + function hasMetadata(metadataKey, target, propertyKey) { + if (!IsObject(target)) + throw new TypeError(); + if (!IsUndefined(propertyKey)) + propertyKey = ToPropertyKey(propertyKey); + return OrdinaryHasMetadata(metadataKey, target, propertyKey); + } + exporter("hasMetadata", hasMetadata); + function hasOwnMetadata(metadataKey, target, propertyKey) { + if (!IsObject(target)) + throw new TypeError(); + if (!IsUndefined(propertyKey)) + propertyKey = ToPropertyKey(propertyKey); + return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey); + } + exporter("hasOwnMetadata", hasOwnMetadata); + function getMetadata(metadataKey, target, propertyKey) { + if (!IsObject(target)) + throw new TypeError(); + if (!IsUndefined(propertyKey)) + propertyKey = ToPropertyKey(propertyKey); + return OrdinaryGetMetadata(metadataKey, target, propertyKey); + } + exporter("getMetadata", getMetadata); + function getOwnMetadata(metadataKey, target, propertyKey) { + if (!IsObject(target)) + throw new TypeError(); + if (!IsUndefined(propertyKey)) + propertyKey = ToPropertyKey(propertyKey); + return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey); + } + exporter("getOwnMetadata", getOwnMetadata); + function getMetadataKeys(target, propertyKey) { + if (!IsObject(target)) + throw new TypeError(); + if (!IsUndefined(propertyKey)) + propertyKey = ToPropertyKey(propertyKey); + return OrdinaryMetadataKeys(target, propertyKey); + } + exporter("getMetadataKeys", getMetadataKeys); + function getOwnMetadataKeys(target, propertyKey) { + if (!IsObject(target)) + throw new TypeError(); + if (!IsUndefined(propertyKey)) + propertyKey = ToPropertyKey(propertyKey); + return OrdinaryOwnMetadataKeys(target, propertyKey); + } + exporter("getOwnMetadataKeys", getOwnMetadataKeys); + function deleteMetadata(metadataKey, target, propertyKey) { + if (!IsObject(target)) + throw new TypeError(); + if (!IsUndefined(propertyKey)) + propertyKey = ToPropertyKey(propertyKey); + if (!IsObject(target)) + throw new TypeError(); + if (!IsUndefined(propertyKey)) + propertyKey = ToPropertyKey(propertyKey); + var provider = GetMetadataProvider( + target, + propertyKey, + /*Create*/ + false + ); + if (IsUndefined(provider)) + return false; + return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey); + } + exporter("deleteMetadata", deleteMetadata); + function DecorateConstructor(decorators, target) { + for (var i = decorators.length - 1; i >= 0; --i) { + var decorator = decorators[i]; + var decorated = decorator(target); + if (!IsUndefined(decorated) && !IsNull(decorated)) { + if (!IsConstructor(decorated)) + throw new TypeError(); + target = decorated; + } + } + return target; + } + function DecorateProperty(decorators, target, propertyKey, descriptor) { + for (var i = decorators.length - 1; i >= 0; --i) { + var decorator = decorators[i]; + var decorated = decorator(target, propertyKey, descriptor); + if (!IsUndefined(decorated) && !IsNull(decorated)) { + if (!IsObject(decorated)) + throw new TypeError(); + descriptor = decorated; + } + } + return descriptor; + } + function OrdinaryHasMetadata(MetadataKey, O, P) { + var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P); + if (hasOwn2) + return true; + var parent = OrdinaryGetPrototypeOf(O); + if (!IsNull(parent)) + return OrdinaryHasMetadata(MetadataKey, parent, P); + return false; + } + function OrdinaryHasOwnMetadata(MetadataKey, O, P) { + var provider = GetMetadataProvider( + O, + P, + /*Create*/ + false + ); + if (IsUndefined(provider)) + return false; + return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P)); + } + function OrdinaryGetMetadata(MetadataKey, O, P) { + var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P); + if (hasOwn2) + return OrdinaryGetOwnMetadata(MetadataKey, O, P); + var parent = OrdinaryGetPrototypeOf(O); + if (!IsNull(parent)) + return OrdinaryGetMetadata(MetadataKey, parent, P); + return void 0; + } + function OrdinaryGetOwnMetadata(MetadataKey, O, P) { + var provider = GetMetadataProvider( + O, + P, + /*Create*/ + false + ); + if (IsUndefined(provider)) + return; + return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P); + } + function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) { + var provider = GetMetadataProvider( + O, + P, + /*Create*/ + true + ); + provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P); + } + function OrdinaryMetadataKeys(O, P) { + var ownKeys = OrdinaryOwnMetadataKeys(O, P); + var parent = OrdinaryGetPrototypeOf(O); + if (parent === null) + return ownKeys; + var parentKeys = OrdinaryMetadataKeys(parent, P); + if (parentKeys.length <= 0) + return ownKeys; + if (ownKeys.length <= 0) + return parentKeys; + var set = new _Set(); + var keys = []; + for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) { + var key = ownKeys_1[_i]; + var hasKey = set.has(key); + if (!hasKey) { + set.add(key); + keys.push(key); + } + } + for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) { + var key = parentKeys_1[_a]; + var hasKey = set.has(key); + if (!hasKey) { + set.add(key); + keys.push(key); + } + } + return keys; + } + function OrdinaryOwnMetadataKeys(O, P) { + var provider = GetMetadataProvider( + O, + P, + /*create*/ + false + ); + if (!provider) { + return []; + } + return provider.OrdinaryOwnMetadataKeys(O, P); + } + function Type(x) { + if (x === null) + return 1; + switch (typeof x) { + case "undefined": + return 0; + case "boolean": + return 2; + case "string": + return 3; + case "symbol": + return 4; + case "number": + return 5; + case "object": + return x === null ? 1 : 6; + default: + return 6; + } + } + function IsUndefined(x) { + return x === void 0; + } + function IsNull(x) { + return x === null; + } + function IsSymbol(x) { + return typeof x === "symbol"; + } + function IsObject(x) { + return typeof x === "object" ? x !== null : typeof x === "function"; + } + function ToPrimitive(input, PreferredType) { + switch (Type(input)) { + case 0: + return input; + case 1: + return input; + case 2: + return input; + case 3: + return input; + case 4: + return input; + case 5: + return input; + } + var hint = PreferredType === 3 ? "string" : PreferredType === 5 ? "number" : "default"; + var exoticToPrim = GetMethod(input, toPrimitiveSymbol); + if (exoticToPrim !== void 0) { + var result = exoticToPrim.call(input, hint); + if (IsObject(result)) + throw new TypeError(); + return result; + } + return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint); + } + function OrdinaryToPrimitive(O, hint) { + if (hint === "string") { + var toString_1 = O.toString; + if (IsCallable(toString_1)) { + var result = toString_1.call(O); + if (!IsObject(result)) + return result; + } + var valueOf = O.valueOf; + if (IsCallable(valueOf)) { + var result = valueOf.call(O); + if (!IsObject(result)) + return result; + } + } else { + var valueOf = O.valueOf; + if (IsCallable(valueOf)) { + var result = valueOf.call(O); + if (!IsObject(result)) + return result; + } + var toString_2 = O.toString; + if (IsCallable(toString_2)) { + var result = toString_2.call(O); + if (!IsObject(result)) + return result; + } + } + throw new TypeError(); + } + function ToBoolean(argument) { + return !!argument; + } + function ToString(argument) { + return "" + argument; + } + function ToPropertyKey(argument) { + var key = ToPrimitive( + argument, + 3 + /* String */ + ); + if (IsSymbol(key)) + return key; + return ToString(key); + } + function IsArray(argument) { + return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]"; + } + function IsCallable(argument) { + return typeof argument === "function"; + } + function IsConstructor(argument) { + return typeof argument === "function"; + } + function IsPropertyKey(argument) { + switch (Type(argument)) { + case 3: + return true; + case 4: + return true; + default: + return false; + } + } + function SameValueZero(x, y) { + return x === y || x !== x && y !== y; + } + function GetMethod(V, P) { + var func = V[P]; + if (func === void 0 || func === null) + return void 0; + if (!IsCallable(func)) + throw new TypeError(); + return func; + } + function GetIterator(obj) { + var method = GetMethod(obj, iteratorSymbol); + if (!IsCallable(method)) + throw new TypeError(); + var iterator = method.call(obj); + if (!IsObject(iterator)) + throw new TypeError(); + return iterator; + } + function IteratorValue(iterResult) { + return iterResult.value; + } + function IteratorStep(iterator) { + var result = iterator.next(); + return result.done ? false : result; + } + function IteratorClose(iterator) { + var f = iterator["return"]; + if (f) + f.call(iterator); + } + function OrdinaryGetPrototypeOf(O) { + var proto = Object.getPrototypeOf(O); + if (typeof O !== "function" || O === functionPrototype) + return proto; + if (proto !== functionPrototype) + return proto; + var prototype = O.prototype; + var prototypeProto = prototype && Object.getPrototypeOf(prototype); + if (prototypeProto == null || prototypeProto === Object.prototype) + return proto; + var constructor = prototypeProto.constructor; + if (typeof constructor !== "function") + return proto; + if (constructor === O) + return proto; + return constructor; + } + function CreateMetadataRegistry() { + var fallback; + if (!IsUndefined(registrySymbol) && typeof root.Reflect !== "undefined" && !(registrySymbol in root.Reflect) && typeof root.Reflect.defineMetadata === "function") { + fallback = CreateFallbackProvider(root.Reflect); + } + var first; + var second; + var rest; + var targetProviderMap = new _WeakMap(); + var registry = { + registerProvider, + getProvider, + setProvider + }; + return registry; + function registerProvider(provider) { + if (!Object.isExtensible(registry)) { + throw new Error("Cannot add provider to a frozen registry."); + } + switch (true) { + case fallback === provider: + break; + case IsUndefined(first): + first = provider; + break; + case first === provider: + break; + case IsUndefined(second): + second = provider; + break; + case second === provider: + break; + default: + if (rest === void 0) + rest = new _Set(); + rest.add(provider); + break; + } + } + function getProviderNoCache(O, P) { + if (!IsUndefined(first)) { + if (first.isProviderFor(O, P)) + return first; + if (!IsUndefined(second)) { + if (second.isProviderFor(O, P)) + return first; + if (!IsUndefined(rest)) { + var iterator = GetIterator(rest); + while (true) { + var next = IteratorStep(iterator); + if (!next) { + return void 0; + } + var provider = IteratorValue(next); + if (provider.isProviderFor(O, P)) { + IteratorClose(iterator); + return provider; + } + } + } + } + } + if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) { + return fallback; + } + return void 0; + } + function getProvider(O, P) { + var providerMap = targetProviderMap.get(O); + var provider; + if (!IsUndefined(providerMap)) { + provider = providerMap.get(P); + } + if (!IsUndefined(provider)) { + return provider; + } + provider = getProviderNoCache(O, P); + if (!IsUndefined(provider)) { + if (IsUndefined(providerMap)) { + providerMap = new _Map(); + targetProviderMap.set(O, providerMap); + } + providerMap.set(P, provider); + } + return provider; + } + function hasProvider(provider) { + if (IsUndefined(provider)) + throw new TypeError(); + return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider); + } + function setProvider(O, P, provider) { + if (!hasProvider(provider)) { + throw new Error("Metadata provider not registered."); + } + var existingProvider = getProvider(O, P); + if (existingProvider !== provider) { + if (!IsUndefined(existingProvider)) { + return false; + } + var providerMap = targetProviderMap.get(O); + if (IsUndefined(providerMap)) { + providerMap = new _Map(); + targetProviderMap.set(O, providerMap); + } + providerMap.set(P, provider); + } + return true; + } + } + function GetOrCreateMetadataRegistry() { + var metadataRegistry2; + if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) { + metadataRegistry2 = root.Reflect[registrySymbol]; + } + if (IsUndefined(metadataRegistry2)) { + metadataRegistry2 = CreateMetadataRegistry(); + } + if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) { + Object.defineProperty(root.Reflect, registrySymbol, { + enumerable: false, + configurable: false, + writable: false, + value: metadataRegistry2 + }); + } + return metadataRegistry2; + } + function CreateMetadataProvider(registry) { + var metadata2 = new _WeakMap(); + var provider = { + isProviderFor: function(O, P) { + var targetMetadata = metadata2.get(O); + if (IsUndefined(targetMetadata)) + return false; + return targetMetadata.has(P); + }, + OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata2, + OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata2, + OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata2, + OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys2, + OrdinaryDeleteMetadata + }; + metadataRegistry.registerProvider(provider); + return provider; + function GetOrCreateMetadataMap(O, P, Create) { + var targetMetadata = metadata2.get(O); + var createdTargetMetadata = false; + if (IsUndefined(targetMetadata)) { + if (!Create) + return void 0; + targetMetadata = new _Map(); + metadata2.set(O, targetMetadata); + createdTargetMetadata = true; + } + var metadataMap = targetMetadata.get(P); + if (IsUndefined(metadataMap)) { + if (!Create) + return void 0; + metadataMap = new _Map(); + targetMetadata.set(P, metadataMap); + if (!registry.setProvider(O, P, provider)) { + targetMetadata.delete(P); + if (createdTargetMetadata) { + metadata2.delete(O); + } + throw new Error("Wrong provider for target."); + } + } + return metadataMap; + } + function OrdinaryHasOwnMetadata2(MetadataKey, O, P) { + var metadataMap = GetOrCreateMetadataMap( + O, + P, + /*Create*/ + false + ); + if (IsUndefined(metadataMap)) + return false; + return ToBoolean(metadataMap.has(MetadataKey)); + } + function OrdinaryGetOwnMetadata2(MetadataKey, O, P) { + var metadataMap = GetOrCreateMetadataMap( + O, + P, + /*Create*/ + false + ); + if (IsUndefined(metadataMap)) + return void 0; + return metadataMap.get(MetadataKey); + } + function OrdinaryDefineOwnMetadata2(MetadataKey, MetadataValue, O, P) { + var metadataMap = GetOrCreateMetadataMap( + O, + P, + /*Create*/ + true + ); + metadataMap.set(MetadataKey, MetadataValue); + } + function OrdinaryOwnMetadataKeys2(O, P) { + var keys = []; + var metadataMap = GetOrCreateMetadataMap( + O, + P, + /*Create*/ + false + ); + if (IsUndefined(metadataMap)) + return keys; + var keysObj = metadataMap.keys(); + var iterator = GetIterator(keysObj); + var k = 0; + while (true) { + var next = IteratorStep(iterator); + if (!next) { + keys.length = k; + return keys; + } + var nextValue = IteratorValue(next); + try { + keys[k] = nextValue; + } catch (e) { + try { + IteratorClose(iterator); + } finally { + throw e; + } + } + k++; + } + } + function OrdinaryDeleteMetadata(MetadataKey, O, P) { + var metadataMap = GetOrCreateMetadataMap( + O, + P, + /*Create*/ + false + ); + if (IsUndefined(metadataMap)) + return false; + if (!metadataMap.delete(MetadataKey)) + return false; + if (metadataMap.size === 0) { + var targetMetadata = metadata2.get(O); + if (!IsUndefined(targetMetadata)) { + targetMetadata.delete(P); + if (targetMetadata.size === 0) { + metadata2.delete(targetMetadata); + } + } + } + return true; + } + } + function CreateFallbackProvider(reflect) { + var defineMetadata2 = reflect.defineMetadata, hasOwnMetadata2 = reflect.hasOwnMetadata, getOwnMetadata2 = reflect.getOwnMetadata, getOwnMetadataKeys2 = reflect.getOwnMetadataKeys, deleteMetadata2 = reflect.deleteMetadata; + var metadataOwner = new _WeakMap(); + var provider = { + isProviderFor: function(O, P) { + var metadataPropertySet = metadataOwner.get(O); + if (!IsUndefined(metadataPropertySet)) { + return metadataPropertySet.has(P); + } + if (getOwnMetadataKeys2(O, P).length) { + if (IsUndefined(metadataPropertySet)) { + metadataPropertySet = new _Set(); + metadataOwner.set(O, metadataPropertySet); + } + metadataPropertySet.add(P); + return true; + } + return false; + }, + OrdinaryDefineOwnMetadata: defineMetadata2, + OrdinaryHasOwnMetadata: hasOwnMetadata2, + OrdinaryGetOwnMetadata: getOwnMetadata2, + OrdinaryOwnMetadataKeys: getOwnMetadataKeys2, + OrdinaryDeleteMetadata: deleteMetadata2 + }; + return provider; + } + function GetMetadataProvider(O, P, Create) { + var registeredProvider = metadataRegistry.getProvider(O, P); + if (!IsUndefined(registeredProvider)) { + return registeredProvider; + } + if (Create) { + if (metadataRegistry.setProvider(O, P, metadataProvider)) { + return metadataProvider; + } + throw new Error("Illegal state."); + } + return void 0; + } + function CreateMapPolyfill() { + var cacheSentinel = {}; + var arraySentinel = []; + var MapIterator = ( + /** @class */ + function() { + function MapIterator2(keys, values, selector) { + this._index = 0; + this._keys = keys; + this._values = values; + this._selector = selector; + } + MapIterator2.prototype["@@iterator"] = function() { + return this; + }; + MapIterator2.prototype[iteratorSymbol] = function() { + return this; + }; + MapIterator2.prototype.next = function() { + var index2 = this._index; + if (index2 >= 0 && index2 < this._keys.length) { + var result = this._selector(this._keys[index2], this._values[index2]); + if (index2 + 1 >= this._keys.length) { + this._index = -1; + this._keys = arraySentinel; + this._values = arraySentinel; + } else { + this._index++; + } + return { value: result, done: false }; + } + return { value: void 0, done: true }; + }; + MapIterator2.prototype.throw = function(error) { + if (this._index >= 0) { + this._index = -1; + this._keys = arraySentinel; + this._values = arraySentinel; + } + throw error; + }; + MapIterator2.prototype.return = function(value) { + if (this._index >= 0) { + this._index = -1; + this._keys = arraySentinel; + this._values = arraySentinel; + } + return { value, done: true }; + }; + return MapIterator2; + }() + ); + var Map2 = ( + /** @class */ + function() { + function Map3() { + this._keys = []; + this._values = []; + this._cacheKey = cacheSentinel; + this._cacheIndex = -2; + } + Object.defineProperty(Map3.prototype, "size", { + get: function() { + return this._keys.length; + }, + enumerable: true, + configurable: true + }); + Map3.prototype.has = function(key) { + return this._find( + key, + /*insert*/ + false + ) >= 0; + }; + Map3.prototype.get = function(key) { + var index2 = this._find( + key, + /*insert*/ + false + ); + return index2 >= 0 ? this._values[index2] : void 0; + }; + Map3.prototype.set = function(key, value) { + var index2 = this._find( + key, + /*insert*/ + true + ); + this._values[index2] = value; + return this; + }; + Map3.prototype.delete = function(key) { + var index2 = this._find( + key, + /*insert*/ + false + ); + if (index2 >= 0) { + var size = this._keys.length; + for (var i = index2 + 1; i < size; i++) { + this._keys[i - 1] = this._keys[i]; + this._values[i - 1] = this._values[i]; + } + this._keys.length--; + this._values.length--; + if (SameValueZero(key, this._cacheKey)) { + this._cacheKey = cacheSentinel; + this._cacheIndex = -2; + } + return true; + } + return false; + }; + Map3.prototype.clear = function() { + this._keys.length = 0; + this._values.length = 0; + this._cacheKey = cacheSentinel; + this._cacheIndex = -2; + }; + Map3.prototype.keys = function() { + return new MapIterator(this._keys, this._values, getKey); + }; + Map3.prototype.values = function() { + return new MapIterator(this._keys, this._values, getValue); + }; + Map3.prototype.entries = function() { + return new MapIterator(this._keys, this._values, getEntry); + }; + Map3.prototype["@@iterator"] = function() { + return this.entries(); + }; + Map3.prototype[iteratorSymbol] = function() { + return this.entries(); + }; + Map3.prototype._find = function(key, insert) { + if (!SameValueZero(this._cacheKey, key)) { + this._cacheIndex = -1; + for (var i = 0; i < this._keys.length; i++) { + if (SameValueZero(this._keys[i], key)) { + this._cacheIndex = i; + break; + } + } + } + if (this._cacheIndex < 0 && insert) { + this._cacheIndex = this._keys.length; + this._keys.push(key); + this._values.push(void 0); + } + return this._cacheIndex; + }; + return Map3; + }() + ); + return Map2; + function getKey(key, _) { + return key; + } + function getValue(_, value) { + return value; + } + function getEntry(key, value) { + return [key, value]; + } + } + function CreateSetPolyfill() { + var Set2 = ( + /** @class */ + function() { + function Set3() { + this._map = new _Map(); + } + Object.defineProperty(Set3.prototype, "size", { + get: function() { + return this._map.size; + }, + enumerable: true, + configurable: true + }); + Set3.prototype.has = function(value) { + return this._map.has(value); + }; + Set3.prototype.add = function(value) { + return this._map.set(value, value), this; + }; + Set3.prototype.delete = function(value) { + return this._map.delete(value); + }; + Set3.prototype.clear = function() { + this._map.clear(); + }; + Set3.prototype.keys = function() { + return this._map.keys(); + }; + Set3.prototype.values = function() { + return this._map.keys(); + }; + Set3.prototype.entries = function() { + return this._map.entries(); + }; + Set3.prototype["@@iterator"] = function() { + return this.keys(); + }; + Set3.prototype[iteratorSymbol] = function() { + return this.keys(); + }; + return Set3; + }() + ); + return Set2; + } + function CreateWeakMapPolyfill() { + var UUID_SIZE = 16; + var keys = HashMap.create(); + var rootKey = CreateUniqueKey(); + return ( + /** @class */ + function() { + function WeakMap2() { + this._key = CreateUniqueKey(); + } + WeakMap2.prototype.has = function(target) { + var table = GetOrCreateWeakMapTable( + target, + /*create*/ + false + ); + return table !== void 0 ? HashMap.has(table, this._key) : false; + }; + WeakMap2.prototype.get = function(target) { + var table = GetOrCreateWeakMapTable( + target, + /*create*/ + false + ); + return table !== void 0 ? HashMap.get(table, this._key) : void 0; + }; + WeakMap2.prototype.set = function(target, value) { + var table = GetOrCreateWeakMapTable( + target, + /*create*/ + true + ); + table[this._key] = value; + return this; + }; + WeakMap2.prototype.delete = function(target) { + var table = GetOrCreateWeakMapTable( + target, + /*create*/ + false + ); + return table !== void 0 ? delete table[this._key] : false; + }; + WeakMap2.prototype.clear = function() { + this._key = CreateUniqueKey(); + }; + return WeakMap2; + }() + ); + function CreateUniqueKey() { + var key; + do + key = "@@WeakMap@@" + CreateUUID(); + while (HashMap.has(keys, key)); + keys[key] = true; + return key; + } + function GetOrCreateWeakMapTable(target, create) { + if (!hasOwn.call(target, rootKey)) { + if (!create) + return void 0; + Object.defineProperty(target, rootKey, { value: HashMap.create() }); + } + return target[rootKey]; + } + function FillRandomBytes(buffer2, size) { + for (var i = 0; i < size; ++i) + buffer2[i] = Math.random() * 255 | 0; + return buffer2; + } + function GenRandomBytes(size) { + if (typeof Uint8Array === "function") { + if (typeof crypto !== "undefined") + return crypto.getRandomValues(new Uint8Array(size)); + if (typeof msCrypto !== "undefined") + return msCrypto.getRandomValues(new Uint8Array(size)); + return FillRandomBytes(new Uint8Array(size), size); + } + return FillRandomBytes(new Array(size), size); + } + function CreateUUID() { + var data = GenRandomBytes(UUID_SIZE); + data[6] = data[6] & 79 | 64; + data[8] = data[8] & 191 | 128; + var result = ""; + for (var offset = 0; offset < UUID_SIZE; ++offset) { + var byte = data[offset]; + if (offset === 4 || offset === 6 || offset === 8) + result += "-"; + if (byte < 16) + result += "0"; + result += byte.toString(16).toLowerCase(); + } + return result; + } + } + function MakeDictionary(obj) { + obj.__ = void 0; + delete obj.__; + return obj; + } + }); + })(Reflect2 || (Reflect2 = {})); + } +}); + +// src/decorators/dbconn.ts +import { mongoose } from "@typegoose/typegoose"; +function dbconn(name) { + return (target) => { + name = name || "main"; + const dbName = ("db_" + name).toUpperCase(); + const url = process.env[dbName]; + target["db"] = mongoose.createConnection(url, {}); + }; +} + +// src/decorators/nojson.ts +var import_reflect_metadata = __toESM(require_Reflect(), 1); + +// src/decorators/singleton.ts +var SINGLETON_KEY = Symbol(); +var singleton = (classTarget) => new Proxy(classTarget, { + construct(target, argumentsList, newTarget) { + if (target.prototype !== newTarget.prototype) { + return Reflect.construct(target, argumentsList, newTarget); + } + if (!target[SINGLETON_KEY]) { + target[SINGLETON_KEY] = Reflect.construct(target, argumentsList, newTarget); + } + return target[SINGLETON_KEY]; + } +}); + +// src/decorators/nojson.ts +var NoJsonClass = class { + noJsonPropSet = /* @__PURE__ */ new Set(); + addKey(className, propertyKey) { + this.noJsonPropSet.add(className + "_" + propertyKey); + } + checkExist(className, propertyKey) { + return this.noJsonPropSet.has(className + "_" + propertyKey); + } +}; +NoJsonClass = __decorateClass([ + singleton +], NoJsonClass); +function noJson() { + return function(target, propertyKey) { + new NoJsonClass().addKey(target.constructor.name, propertyKey); + }; +} +function checkJson(target, propertyKey) { + return !new NoJsonClass().checkExist(target.constructor.modelName, propertyKey); +} + +// src/common/AsyncQueue.ts +function createAsyncQueue(opts = { dedupeConcurrent: false }) { + const { dedupeConcurrent } = opts; + let queue = []; + let running; + let nextPromise = new DeferredPromise(); + const push = (task) => { + let taskPromise = new DeferredPromise(); + if (dedupeConcurrent) { + queue = []; + if (nextPromise.started) + nextPromise = new DeferredPromise(); + taskPromise = nextPromise; + } + queue.push(() => { + taskPromise.started = true; + task().then(taskPromise.resolve).catch(taskPromise.reject); + return taskPromise.promise; + }); + if (!running) + running = start(); + return taskPromise.promise; + }; + const start = async () => { + while (queue.length) { + const task = queue.shift(); + await task().catch(() => { + }); + } + running = void 0; + }; + return { + push, + flush: () => running || Promise.resolve(), + get size() { + return queue.length; + } + }; +} +var DeferredPromise = class { + started = false; + resolve = () => { + }; + reject = () => { + }; + promise; + constructor() { + this.promise = new Promise((res, rej) => { + this.resolve = res; + this.reject = rej; + }); + } +}; + +// src/models/UserLog.ts +import { getModelForClass, index, modelOptions, mongoose as mongoose2, prop } from "@typegoose/typegoose"; +import { Severity } from "@typegoose/typegoose/lib/internal/constants"; + +// node_modules/bson/lib/bson.mjs +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; + } +} +var BSON_MAJOR_VERSION = 6; +var BSON_INT32_MAX = 2147483647; +var BSON_INT32_MIN = -2147483648; +var BSON_INT64_MAX = Math.pow(2, 63) - 1; +var BSON_INT64_MIN = -Math.pow(2, 63); +var JS_INT_MAX = Math.pow(2, 53); +var JS_INT_MIN = -Math.pow(2, 53); +var BSON_BINARY_SUBTYPE_UUID_NEW = 4; +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 +}); +var BSONError = class 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; + } +}; +var BSONVersionError = class extends BSONError { + get name() { + return "BSONVersionError"; + } + constructor() { + super(`Unsupported BSON version, bson types must be from bson ${BSON_MAJOR_VERSION}.x.x`); + } +}; +var BSONRuntimeError = class 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))); +} +var nodejsRandomBytes = await (async () => { + try { + return (await import("crypto")).randomBytes; + } catch { + return nodejsMathRandomBytes; + } +})(); +var 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(buffer2) { + return nodeJsByteUtils.toLocalBufferType(buffer2).toString("base64"); + }, + fromISO88591(codePoints) { + return Buffer.from(codePoints, "binary"); + }, + toISO88591(buffer2) { + return nodeJsByteUtils.toLocalBufferType(buffer2).toString("binary"); + }, + fromHex(hex) { + return Buffer.from(hex, "hex"); + }, + toHex(buffer2) { + return nodeJsByteUtils.toLocalBufferType(buffer2).toString("hex"); + }, + fromUTF8(text) { + return Buffer.from(text, "utf8"); + }, + toUTF8(buffer2, start, end) { + return nodeJsByteUtils.toLocalBufferType(buffer2).toString("utf8", start, end); + }, + utf8ByteLength(input) { + return Buffer.byteLength(input, "utf8"); + }, + encodeUTF8Into(buffer2, source, byteOffset) { + return nodeJsByteUtils.toLocalBufferType(buffer2).write(source, byteOffset, void 0, "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))); +} +var webRandomBytes = (() => { + const { crypto: crypto2 } = globalThis; + if (crypto2 != null && typeof crypto2.getRandomValues === "function") { + return (byteLength) => { + return crypto2.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; + } +})(); +var HEX_DIGIT = /(\d|[a-f])/i; +var 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) & 255); + }, + 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 buffer2 = []; + 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); + buffer2.push(hexDigit); + } + return Uint8Array.from(buffer2); + }, + 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(buffer2, source, byteOffset) { + const bytes = webByteUtils.fromUTF8(source); + buffer2.set(bytes, byteOffset); + return bytes.byteLength; + }, + randomBytes: webRandomBytes +}; +var hasGlobalBuffer = typeof Buffer === "function" && Buffer.prototype?._isBuffer !== true; +var ByteUtils = hasGlobalBuffer ? nodeJsByteUtils : webByteUtils; +var BSONDataView = class extends DataView { + static fromUint8Array(input) { + return new DataView(input.buffer, input.byteOffset, input.byteLength); + } +}; +var BSONValue = class { + 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); + } +}; +var Binary = class _Binary extends BSONValue { + get _bsontype() { + return "Binary"; + } + constructor(buffer2, subType) { + super(); + if (!(buffer2 == null) && typeof buffer2 === "string" && !ArrayBuffer.isView(buffer2) && !isAnyArrayBuffer(buffer2) && !Array.isArray(buffer2)) { + throw new BSONError("Binary can only be constructed from Uint8Array or number[]"); + } + this.sub_type = subType ?? _Binary.BSON_BINARY_SUBTYPE_DEFAULT; + if (buffer2 == null) { + this.buffer = ByteUtils.allocate(_Binary.BUFFER_SIZE); + this.position = 0; + } else { + this.buffer = Array.isArray(buffer2) ? ByteUtils.fromNumberArray(buffer2) : ByteUtils.toLocalBufferType(buffer2); + 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; +var UUID_BYTE_LENGTH = 16; +var UUID_WITHOUT_DASHES = /^[0-9A-F]{32}$/i; +var UUID_WITH_DASHES = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i; +var UUID = 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] & 15 | 64; + bytes[8] = bytes[8] & 63 | 128; + 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 buffer2 = _UUID.bytesFromString(hexString); + return new _UUID(buffer2); + } + 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)})`; + } +}; +var Code = 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"); +} +var DBRef = 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(", ")})`; + } +}; +var wasm = void 0; +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 { +} +var TWO_PWR_16_DBL = 1 << 16; +var TWO_PWR_24_DBL = 1 << 24; +var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL; +var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL; +var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2; +var INT_CACHE = {}; +var UINT_CACHE = {}; +var MAX_INT64_STRING_LENGTH = 20; +var DECIMAL_REG_EX = /^(\+?0|(\+|-)?[1-9][0-9]*)$/; +var Long = 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 & 65535; + const a16 = this.low >>> 16; + const a00 = this.low & 65535; + const b48 = addend.high >>> 16; + const b32 = addend.high & 65535; + const b16 = addend.low >>> 16; + const b00 = addend.low & 65535; + let c48 = 0, c32 = 0, c16 = 0, c00 = 0; + c00 += a00 + b00; + c16 += c00 >>> 16; + c00 &= 65535; + c16 += a16 + b16; + c32 += c16 >>> 16; + c16 &= 65535; + c32 += a32 + b32; + c48 += c32 >>> 16; + c32 &= 65535; + c48 += a48 + b48; + c48 &= 65535; + 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 === -2147483648 && 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 & 65535; + const a16 = this.low >>> 16; + const a00 = this.low & 65535; + const b48 = multiplier.high >>> 16; + const b32 = multiplier.high & 65535; + const b16 = multiplier.low >>> 16; + const b00 = multiplier.low & 65535; + let c48 = 0, c32 = 0, c16 = 0, c00 = 0; + c00 += a00 * b00; + c16 += c00 >>> 16; + c00 &= 65535; + c16 += a16 * b00; + c32 += c16 >>> 16; + c16 &= 65535; + c16 += a00 * b16; + c32 += c16 >>> 16; + c16 &= 65535; + c32 += a32 * b00; + c48 += c32 >>> 16; + c32 &= 65535; + c32 += a16 * b16; + c48 += c32 >>> 16; + c32 &= 65535; + c32 += a00 * b32; + c48 += c32 >>> 16; + c32 &= 65535; + c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48; + c48 &= 65535; + 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 & 255, + lo >>> 8 & 255, + lo >>> 16 & 255, + lo >>> 24, + hi & 255, + hi >>> 8 & 255, + hi >>> 16 & 255, + hi >>> 24 + ]; + } + toBytesBE() { + const hi = this.high, lo = this.low; + return [ + hi >>> 24, + hi >>> 16 & 255, + hi >>> 8 & 255, + hi & 255, + lo >>> 24, + lo >>> 16 & 255, + lo >>> 8 & 255, + lo & 255 + ]; + } + 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(4294967295 | 0, 4294967295 | 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(4294967295 | 0, 2147483647 | 0, false); +Long.MIN_VALUE = Long.fromBits(0, 2147483648 | 0, false); +var PARSE_STRING_REGEXP = /^(\+|-)?(\d+|(\d*\.\d*))?(E|e)?([-+])?(\d+)?$/; +var PARSE_INF_REGEXP = /^(\+|-)?(Infinity|inf)$/i; +var PARSE_NAN_REGEXP = /^(\+|-)?NaN$/i; +var EXPONENT_MAX = 6111; +var EXPONENT_MIN = -6176; +var EXPONENT_BIAS = 6176; +var MAX_DIGITS = 34; +var NAN_BUFFER = ByteUtils.fromNumberArray([ + 124, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 +].reverse()); +var INF_NEGATIVE_BUFFER = ByteUtils.fromNumberArray([ + 248, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 +].reverse()); +var INF_POSITIVE_BUFFER = ByteUtils.fromNumberArray([ + 120, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 +].reverse()); +var EXPONENT_REGEX = /^([-+])?(\d+)?$/; +var COMBINATION_MASK = 31; +var EXPONENT_MASK = 16383; +var COMBINATION_INFINITY = 30; +var COMBINATION_NAN = 31; +function isDigit(value) { + return !isNaN(parseInt(value, 10)); +} +function divideu128(value) { + const DIVISOR = Long.fromNumber(1e3 * 1e3 * 1e3); + 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}`); +} +var Decimal128 = 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 index2 = 0; + if (representation.length >= 7e3) { + 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 === void 0) + invalidErr(representation, "missing exponent power"); + if (e && unsignedNumber === void 0) + invalidErr(representation, "missing exponent base"); + if (e === void 0 && (expSign || expNumber)) { + invalidErr(representation, "missing e before exponent"); + } + } + if (representation[index2] === "+" || representation[index2] === "-") { + sawSign = true; + isNegative = representation[index2++] === "-"; + } + if (!isDigit(representation[index2]) && representation[index2] !== ".") { + if (representation[index2] === "i" || representation[index2] === "I") { + return new _Decimal128(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER); + } else if (representation[index2] === "N") { + return new _Decimal128(NAN_BUFFER); + } + } + while (isDigit(representation[index2]) || representation[index2] === ".") { + if (representation[index2] === ".") { + if (sawRadix) + invalidErr(representation, "contains multiple periods"); + sawRadix = true; + index2 = index2 + 1; + continue; + } + if (nDigitsStored < MAX_DIGITS) { + if (representation[index2] !== "0" || foundNonZero) { + if (!foundNonZero) { + firstNonZero = nDigitsRead; + } + foundNonZero = true; + digits[digitsInsert++] = parseInt(representation[index2], 10); + nDigitsStored = nDigitsStored + 1; + } + } + if (foundNonZero) + nDigits = nDigits + 1; + if (sawRadix) + radixPosition = radixPosition + 1; + nDigitsRead = nDigitsRead + 1; + index2 = index2 + 1; + } + if (sawRadix && !nDigitsRead) + throw new BSONError("" + representation + " not a valid Decimal128 string"); + if (representation[index2] === "e" || representation[index2] === "E") { + const match = representation.substr(++index2).match(EXPONENT_REGEX); + if (!match || !match[2]) + return new _Decimal128(NAN_BUFFER); + exponent = parseInt(match[0], 10); + index2 = index2 + match[0].length; + } + if (representation[index2]) + 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(3).shiftLeft(61)); + dec.high = dec.high.or(Long.fromNumber(biasedExponent).and(Long.fromNumber(16383).shiftLeft(47))); + dec.high = dec.high.or(significand.high.and(Long.fromNumber(140737488355327))); + } else { + dec.high = dec.high.or(Long.fromNumber(biasedExponent & 16383).shiftLeft(49)); + dec.high = dec.high.or(significand.high.and(Long.fromNumber(562949953421311))); + } + dec.low = significand.low; + if (isNegative) { + dec.high = dec.high.or(Long.fromString("9223372036854775808")); + } + const buffer2 = ByteUtils.allocate(16); + index2 = 0; + buffer2[index2++] = dec.low.low & 255; + buffer2[index2++] = dec.low.low >> 8 & 255; + buffer2[index2++] = dec.low.low >> 16 & 255; + buffer2[index2++] = dec.low.low >> 24 & 255; + buffer2[index2++] = dec.low.high & 255; + buffer2[index2++] = dec.low.high >> 8 & 255; + buffer2[index2++] = dec.low.high >> 16 & 255; + buffer2[index2++] = dec.low.high >> 24 & 255; + buffer2[index2++] = dec.high.low & 255; + buffer2[index2++] = dec.high.low >> 8 & 255; + buffer2[index2++] = dec.high.low >> 16 & 255; + buffer2[index2++] = dec.high.low >> 24 & 255; + buffer2[index2++] = dec.high.high & 255; + buffer2[index2++] = dec.high.high >> 8 & 255; + buffer2[index2++] = dec.high.high >> 16 & 255; + buffer2[index2++] = dec.high.high >> 24 & 255; + return new _Decimal128(buffer2); + } + 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 index2 = 0; + let is_zero = false; + let significand_msb; + let significand128 = { parts: [0, 0, 0, 0] }; + let j, k; + const string = []; + index2 = 0; + const buffer2 = this.bytes; + const low = buffer2[index2++] | buffer2[index2++] << 8 | buffer2[index2++] << 16 | buffer2[index2++] << 24; + const midl = buffer2[index2++] | buffer2[index2++] << 8 | buffer2[index2++] << 16 | buffer2[index2++] << 24; + const midh = buffer2[index2++] | buffer2[index2++] << 8 | buffer2[index2++] << 16 | buffer2[index2++] << 24; + const high = buffer2[index2++] | buffer2[index2++] << 8 | buffer2[index2++] << 16 | buffer2[index2++] << 24; + index2 = 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 = 8 + (high >> 14 & 1); + } + } else { + significand_msb = high >> 14 & 7; + biased_exponent = high >> 17 & EXPONENT_MASK; + } + const exponent = biased_exponent - EXPONENT_BIAS; + significand128.parts[0] = (high & 16383) + ((significand_msb & 15) << 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[index2] = 0; + } else { + significand_digits = 36; + while (!significand[index2]) { + significand_digits = significand_digits - 1; + index2 = index2 + 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[index2++]}`); + significand_digits = significand_digits - 1; + if (significand_digits) { + string.push("."); + } + for (let i = 0; i < significand_digits; i++) { + string.push(`${significand[index2++]}`); + } + 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[index2++]}`); + } + } else { + let radix_position = significand_digits + exponent; + if (radix_position > 0) { + for (let i = 0; i < radix_position; i++) { + string.push(`${significand[index2++]}`); + } + } 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[index2++]}`); + } + } + } + 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})`; + } +}; +var Double = 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)})`; + } +}; +var Int32 = 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)})`; + } +}; +var MaxKey = class _MaxKey extends BSONValue { + get _bsontype() { + return "MaxKey"; + } + toExtendedJSON() { + return { $maxKey: 1 }; + } + static fromExtendedJSON() { + return new _MaxKey(); + } + inspect() { + return "new MaxKey()"; + } +}; +var MinKey = class _MinKey extends BSONValue { + get _bsontype() { + return "MinKey"; + } + toExtendedJSON() { + return { $minKey: 1 }; + } + static fromExtendedJSON() { + return new _MinKey(); + } + inspect() { + return "new MinKey()"; + } +}; +var checkForHexRegExp = new RegExp("^[0-9a-fA-F]{24}$"); +var PROCESS_UNIQUE = null; +var kId = Symbol("id"); +var ObjectId = 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 : void 0); + } 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) % 16777215; + } + static generate(time) { + if ("number" !== typeof time) { + time = Math.floor(Date.now() / 1e3); + } + const inc = _ObjectId.getInc(); + const buffer2 = ByteUtils.allocate(12); + BSONDataView.fromUint8Array(buffer2).setUint32(0, time, false); + if (PROCESS_UNIQUE === null) { + PROCESS_UNIQUE = ByteUtils.randomBytes(5); + } + buffer2[4] = PROCESS_UNIQUE[0]; + buffer2[5] = PROCESS_UNIQUE[1]; + buffer2[6] = PROCESS_UNIQUE[2]; + buffer2[7] = PROCESS_UNIQUE[3]; + buffer2[8] = PROCESS_UNIQUE[4]; + buffer2[11] = inc & 255; + buffer2[10] = inc >> 8 & 255; + buffer2[9] = inc >> 16 & 255; + return buffer2; + } + 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 === void 0 || 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 = /* @__PURE__ */ new Date(); + const time = BSONDataView.fromUint8Array(this.id).getUint32(0, false); + timestamp.setTime(Math.floor(time) * 1e3); + return timestamp; + } + static createPk() { + return new _ObjectId(); + } + static createFromTime(time) { + const buffer2 = ByteUtils.fromNumberArray([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); + BSONDataView.fromUint8Array(buffer2).setUint32(0, time, false); + return new _ObjectId(buffer2); + } + 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() * 16777215); +function alphabetize(str) { + return str.split("").sort().join(""); +} +var BSONRegExp = class _BSONRegExp extends BSONValue { + get _bsontype() { + return "BSONRegExp"; + } + constructor(pattern, options) { + super(); + this.pattern = pattern; + this.options = alphabetize(options ?? ""); + if (this.pattern.indexOf("\0") !== -1) { + throw new BSONError(`BSON Regex patterns cannot contain null bytes, found: ${JSON.stringify(this.pattern)}`); + } + if (this.options.indexOf("\0") !== -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})`; + } +}; +var BSONSymbol = 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)})`; + } +}; +var LongWithoutOverridesClass = Long; +var Timestamp = 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; +var JS_INT_MAX_LONG = Long.fromNumber(JS_INT_MAX); +var JS_INT_MIN_LONG = Long.fromNumber(JS_INT_MIN); +var NUMBER_SPACE = new DataView(new ArrayBuffer(8), 0, 8); +var FOUR_BYTE_VIEW_ON_NUMBER = new Uint8Array(NUMBER_SPACE.buffer, 0, 4); +var EIGHT_BYTE_VIEW_ON_NUMBER = new Uint8Array(NUMBER_SPACE.buffer, 0, 8); +function isBSONType(value) { + return value != null && typeof value === "object" && "_bsontype" in value && typeof value._bsontype === "string"; +} +var 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 = /* @__PURE__ */ 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, index2) => { + options.seenObjects.push({ propertyName: `index ${index2}`, 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 = /* @__PURE__ */ 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 index2 = options.seenObjects.findIndex((entry) => entry.obj === value); + if (index2 !== -1) { + const props = options.seenObjects.map((entry) => entry.propertyName); + const leadingPart = props.slice(0, index2).map((prop2) => `${prop2} -> `).join(""); + const alreadySeen = props[index2]; + const circularPart = " -> " + props.slice(index2 + 1, props.length - 1).map((prop2) => `${prop2} -> `).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: + ${leadingPart}${alreadySeen}${circularPart}${current} + ${leadingSpace}\\${dashes}/`); + } + options.seenObjects[options.seenObjects.length - 1].obj = value; + } + if (Array.isArray(value)) + return serializeArray(value, options); + if (value === void 0) + return null; + if (value instanceof Date || isDate(value)) { + const dateNum = value.getTime(), inRange = dateNum > -1 && dateNum < 2534023188e5; + 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 === void 0) { + 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; +} +var 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("\0") !== -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 = void 0; + 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); +} +var EJSON = /* @__PURE__ */ Object.create(null); +EJSON.parse = parse; +EJSON.stringify = stringify; +EJSON.serialize = EJSONserialize; +EJSON.deserialize = EJSONdeserialize; +Object.freeze(EJSON); +var MAXSIZE = 1024 * 1024 * 17; +var buffer = ByteUtils.allocate(MAXSIZE); + +// src/models/Base.ts +var jsonExcludeKeys = ["updatedAt", "__v"]; +var saveExcludeKeys = ["createdAt", "updatedAt", "__v", "_id"]; +var isTrue = (obj) => { + return obj === "true" || obj === "TRUE" || obj === "True" || obj === "on" || obj === "ON" || obj === true || obj === 1 || obj === "1" || obj === "YES" || obj === "yes"; +}; +var BaseModule = class { + static db; + updateFromReq(data) { + for (let key in data) { + if (saveExcludeKeys.indexOf(key) == -1) { + this[key] = data[key]; + } + } + } + /** + * 插入或更新 + * @param condition + * @param data + */ + static insertOrUpdate(condition, data) { + return this.findOneAndUpdate(condition, data, { upsert: true, new: true, setDefaultsOnInsert: true }); + } + /** + * 虚拟删除 + * @param {string[]} ids + */ + static deleteVirtual(ids) { + return this.updateMany( + // @ts-ignore + { + _id: { $in: ids } + }, + { + $set: { + deleted: true, + deleteTime: /* @__PURE__ */ new Date() + } + } + ); + } + /** + * 自定义分页查询 + * @param data + * @param {boolean} json + */ + static async pageQuery(data, json = false) { + let { start, limit, page } = data; + limit = +limit || 10; + start = +start || (+page - 1) * limit || 0; + let { opt, sort } = this.parseQueryParam(data); + let records = await this.find(opt).sort(sort).skip(start).limit(limit); + let total = await this.countDocuments(opt); + if (json) { + records.map((o) => o.toJson()); + } + return { records, total, start, limit }; + } + toJson() { + let result = {}; + for (let key in this._doc) { + if (checkJson(this, key + "") && jsonExcludeKeys.indexOf(key) == -1) { + result[key] = this[key]; + } + } + return result; + } + /** + * 通用的查询条件拼接方法 + * @param {{}} params req.params + * @param options + * sort: 排序 比如: {createdAt: 1} 默认是 {_id: 1} + * opt: 设置一些特殊的过滤条件, 比如{deleted: 0} + * timeKey: 如果需要查询创建时间, 而且创建时间不为 createdAt, 可以用此字段设置 + * matchKey: 指定关键字查询的匹配字段, 可为string或[string] + * + * @return {{opt: any, sort: {_id: number}}} + */ + static parseQueryParam(params, options) { + const opt = { deleted: { $ne: true } }; + let obj = this.schema.paths; + for (let key in params) { + if (key !== "sort" && obj.hasOwnProperty(key)) { + switch (obj[key].instance) { + case "String": + opt[key] = { $regex: params[key], $options: "i" }; + break; + case "Number": + opt[key] = params[key]; + break; + case "Array": + if (Array.isArray(params[key])) { + opt[key] = { $in: params[key] }; + } else { + opt[key] = params[key]; + } + break; + case "Date": + break; + case "Boolean": + opt[key] = isTrue(params[key]); + break; + case "ObjectID": + if (/^[0-9a-fA-F]{24}$/.test(params[key])) { + opt[key] = new ObjectId(params[key]); + } + break; + } + } + } + if (params.hasOwnProperty("key") && params["key"]) { + let orArr = []; + if (options?.matchKey) { + if (Array.isArray(options?.matchKey)) { + for (let key in options?.matchKey) { + let _tmp = {}; + _tmp[key] = { $regex: params["key"], $options: "i" }; + orArr.push(_tmp); + } + } else { + let _tmp = {}; + _tmp[options.matchKey] = { $regex: params["key"], $options: "i" }; + orArr.push(_tmp); + } + } else { + for (let key in obj) { + if (obj[key].instance === "String") { + let _tmp = {}; + _tmp[key] = { $regex: params["key"], $options: "i" }; + orArr.push(_tmp); + } + } + } + Object.assign(opt, { $or: orArr }); + } + let timeKey = options?.timeKey ? options.timeKey : "createdAt"; + if (params.hasOwnProperty("timeBegin") && !params.hasOwnProperty("timeEnd")) { + let timeBegin = params["timeBegin"]; + if (!(timeBegin instanceof Date)) { + timeBegin = new Date(parseInt(timeBegin)); + } + opt[timeKey] = { $gte: timeBegin }; + } else if (params.hasOwnProperty("timeBegin") && params.hasOwnProperty("timeEnd")) { + let timeBegin = params["timeBegin"]; + if (!(timeBegin instanceof Date)) { + timeBegin = new Date(parseInt(timeBegin)); + } + let timeEnd = params["timeEnd"]; + if (!(timeEnd instanceof Date)) { + timeEnd = new Date(parseInt(timeEnd)); + } + let tmpB = {}; + tmpB[timeKey] = { $gte: timeBegin }; + let tmpE = {}; + tmpE[timeKey] = { $lte: timeEnd }; + opt["$and"] = [tmpB, tmpE]; + } else if (!params.hasOwnProperty("timeBegin") && params.hasOwnProperty("timeEnd")) { + let timeEnd = params["timeEnd"]; + if (!(timeEnd instanceof Date)) { + timeEnd = new Date(parseInt(timeEnd)); + } + opt[timeKey] = { $lte: timeEnd }; + } + if (options?.opt) { + Object.assign(opt, options.opt); + } + let sort = { _id: 1 }; + if (params.hasOwnProperty("sort")) { + sort = params["sort"]; + } + return { opt, sort }; + } + getTimestampOfID() { + return this._id.getTimestamp(); + } +}; + +// src/models/UserLog.ts +var UserLogClass = class extends BaseModule { + user; + name; + method; + path; + referer; + user_agent; + ip; + params; +}; +__decorateClass([ + prop() +], UserLogClass.prototype, "user", 2); +__decorateClass([ + prop() +], UserLogClass.prototype, "name", 2); +__decorateClass([ + prop() +], UserLogClass.prototype, "method", 2); +__decorateClass([ + prop() +], UserLogClass.prototype, "path", 2); +__decorateClass([ + prop() +], UserLogClass.prototype, "referer", 2); +__decorateClass([ + prop() +], UserLogClass.prototype, "user_agent", 2); +__decorateClass([ + prop() +], UserLogClass.prototype, "ip", 2); +__decorateClass([ + prop({ type: mongoose2.Schema.Types.Mixed }) +], UserLogClass.prototype, "params", 2); +UserLogClass = __decorateClass([ + dbconn(), + index({ user: 1 }, { unique: false }), + index({ name: 1 }, { unique: false }), + modelOptions({ schemaOptions: { collection: "user_log", timestamps: true }, options: { allowMixed: Severity.ALLOW } }) +], UserLogClass); +var UserLog = getModelForClass(UserLogClass, { existingConnection: UserLogClass["db"] }); + +// src/queue/logger.queue.ts +var LoggerQueue = class { + queue; + constructor() { + this.queue = createAsyncQueue(); + } + addLog(name, req, logObj = {}) { + this.queue.push(async () => { + const user = req.user; + const ip = req.headers["x-forwarded-for"] || req.ip; + const path = req.url; + const params = req.method === "GET" ? req.query : req.body; + const dataObj = JSON.stringify(logObj) === "{}" ? params : logObj; + try { + const history = new UserLog({ + user: user ? user.id : "", + path, + method: req.method, + params: dataObj, + referer: req.headers["referer"], + user_agent: req.headers["user-agent"], + ip, + name + }); + await history.save(); + } catch (err) { + logger.error("error add user log: "); + logger.error(err); + } + }); + } +}; +LoggerQueue = __decorateClass([ + singleton +], LoggerQueue); + +// src/logger/logger.ts +import { colorConsole } from "tracer"; +var level = process.env.NODE_ENV === "production" ? "info" : "log"; +var _logger = colorConsole({ dateformat: "yyyy-mm-dd HH:MM:ss.L", level }); +Object.assign(_logger, { + db: (name, req, logObj) => { + logObj = logObj || {}; + new LoggerQueue().addLog(name, req, logObj); + } +}); +var logger = _logger; +export { + BaseModule, + NoJsonClass, + UserLog, + checkJson, + dbconn, + logger, + noJson +}; +/*! Bundled license information: + +reflect-metadata/Reflect.js: + (*! ***************************************************************************** + Copyright (C) Microsoft. All rights reserved. + Licensed under the Apache License, Version 2.0 (the "License"); you may not use + this file except in compliance with the License. You may obtain a copy of the + License at http://www.apache.org/licenses/LICENSE-2.0 + + THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED + WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, + MERCHANTABLITY OR NON-INFRINGEMENT. + + See the Apache Version 2.0 License for specific language governing permissions + and limitations under the License. + ***************************************************************************** *) +*/ +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/dist/index.js.map b/dist/index.js.map new file mode 100644 index 0000000..231bc6b --- /dev/null +++ b/dist/index.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["../node_modules/reflect-metadata/Reflect.js","../src/decorators/dbconn.ts","../src/decorators/nojson.ts","../src/decorators/singleton.ts","../src/common/AsyncQueue.ts","../src/models/UserLog.ts","../node_modules/bson/src/parser/utils.ts","../node_modules/bson/src/constants.ts","../node_modules/bson/src/error.ts","../node_modules/bson/src/utils/node_byte_utils.ts","../node_modules/bson/src/utils/web_byte_utils.ts","../node_modules/bson/src/utils/byte_utils.ts","../node_modules/bson/src/bson_value.ts","../node_modules/bson/src/binary.ts","../node_modules/bson/src/code.ts","../node_modules/bson/src/db_ref.ts","../node_modules/bson/src/long.ts","../node_modules/bson/src/decimal128.ts","../node_modules/bson/src/double.ts","../node_modules/bson/src/int_32.ts","../node_modules/bson/src/max_key.ts","../node_modules/bson/src/min_key.ts","../node_modules/bson/src/objectid.ts","../node_modules/bson/src/parser/calculate_size.ts","../node_modules/bson/src/regexp.ts","../node_modules/bson/src/symbol.ts","../node_modules/bson/src/timestamp.ts","../node_modules/bson/src/validate_utf8.ts","../node_modules/bson/src/parser/deserializer.ts","../node_modules/bson/src/parser/serializer.ts","../node_modules/bson/src/extended_json.ts","../node_modules/bson/src/bson.ts","../src/models/Base.ts","../src/queue/logger.queue.ts","../src/logger/logger.ts"],"sourcesContent":["/*! *****************************************************************************\nCopyright (C) Microsoft. All rights reserved.\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\nthis file except in compliance with the License. You may obtain a copy of the\nLicense at http://www.apache.org/licenses/LICENSE-2.0\n\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\nMERCHANTABLITY OR NON-INFRINGEMENT.\n\nSee the Apache Version 2.0 License for specific language governing permissions\nand limitations under the License.\n***************************************************************************** */\nvar Reflect;\n(function (Reflect) {\n // Metadata Proposal\n // https://rbuckton.github.io/reflect-metadata/\n (function (factory) {\n var root = typeof globalThis === \"object\" ? globalThis :\n typeof global === \"object\" ? global :\n typeof self === \"object\" ? self :\n typeof this === \"object\" ? this :\n sloppyModeThis();\n var exporter = makeExporter(Reflect);\n if (typeof root.Reflect !== \"undefined\") {\n exporter = makeExporter(root.Reflect, exporter);\n }\n factory(exporter, root);\n if (typeof root.Reflect === \"undefined\") {\n root.Reflect = Reflect;\n }\n function makeExporter(target, previous) {\n return function (key, value) {\n Object.defineProperty(target, key, { configurable: true, writable: true, value: value });\n if (previous)\n previous(key, value);\n };\n }\n function functionThis() {\n try {\n return Function(\"return this;\")();\n }\n catch (_) { }\n }\n function indirectEvalThis() {\n try {\n return (void 0, eval)(\"(function() { return this; })()\");\n }\n catch (_) { }\n }\n function sloppyModeThis() {\n return functionThis() || indirectEvalThis();\n }\n })(function (exporter, root) {\n var hasOwn = Object.prototype.hasOwnProperty;\n // feature test for Symbol support\n var supportsSymbol = typeof Symbol === \"function\";\n var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== \"undefined\" ? Symbol.toPrimitive : \"@@toPrimitive\";\n var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== \"undefined\" ? Symbol.iterator : \"@@iterator\";\n var supportsCreate = typeof Object.create === \"function\"; // feature test for Object.create support\n var supportsProto = { __proto__: [] } instanceof Array; // feature test for __proto__ support\n var downLevel = !supportsCreate && !supportsProto;\n var HashMap = {\n // create an object in dictionary mode (a.k.a. \"slow\" mode in v8)\n create: supportsCreate\n ? function () { return MakeDictionary(Object.create(null)); }\n : supportsProto\n ? function () { return MakeDictionary({ __proto__: null }); }\n : function () { return MakeDictionary({}); },\n has: downLevel\n ? function (map, key) { return hasOwn.call(map, key); }\n : function (map, key) { return key in map; },\n get: downLevel\n ? function (map, key) { return hasOwn.call(map, key) ? map[key] : undefined; }\n : function (map, key) { return map[key]; },\n };\n // Load global or shim versions of Map, Set, and WeakMap\n var functionPrototype = Object.getPrototypeOf(Function);\n var _Map = typeof Map === \"function\" && typeof Map.prototype.entries === \"function\" ? Map : CreateMapPolyfill();\n var _Set = typeof Set === \"function\" && typeof Set.prototype.entries === \"function\" ? Set : CreateSetPolyfill();\n var _WeakMap = typeof WeakMap === \"function\" ? WeakMap : CreateWeakMapPolyfill();\n var registrySymbol = supportsSymbol ? Symbol.for(\"@reflect-metadata:registry\") : undefined;\n var metadataRegistry = GetOrCreateMetadataRegistry();\n var metadataProvider = CreateMetadataProvider(metadataRegistry);\n /**\n * Applies a set of decorators to a property of a target object.\n * @param decorators An array of decorators.\n * @param target The target object.\n * @param propertyKey (Optional) The property key to decorate.\n * @param attributes (Optional) The property descriptor for the target key.\n * @remarks Decorators are applied in reverse order.\n * @example\n *\n * class Example {\n * // property declarations are not part of ES6, though they are valid in TypeScript:\n * // static staticProperty;\n * // property;\n *\n * constructor(p) { }\n * static staticMethod(p) { }\n * method(p) { }\n * }\n *\n * // constructor\n * Example = Reflect.decorate(decoratorsArray, Example);\n *\n * // property (on constructor)\n * Reflect.decorate(decoratorsArray, Example, \"staticProperty\");\n *\n * // property (on prototype)\n * Reflect.decorate(decoratorsArray, Example.prototype, \"property\");\n *\n * // method (on constructor)\n * Object.defineProperty(Example, \"staticMethod\",\n * Reflect.decorate(decoratorsArray, Example, \"staticMethod\",\n * Object.getOwnPropertyDescriptor(Example, \"staticMethod\")));\n *\n * // method (on prototype)\n * Object.defineProperty(Example.prototype, \"method\",\n * Reflect.decorate(decoratorsArray, Example.prototype, \"method\",\n * Object.getOwnPropertyDescriptor(Example.prototype, \"method\")));\n *\n */\n function decorate(decorators, target, propertyKey, attributes) {\n if (!IsUndefined(propertyKey)) {\n if (!IsArray(decorators))\n throw new TypeError();\n if (!IsObject(target))\n throw new TypeError();\n if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))\n throw new TypeError();\n if (IsNull(attributes))\n attributes = undefined;\n propertyKey = ToPropertyKey(propertyKey);\n return DecorateProperty(decorators, target, propertyKey, attributes);\n }\n else {\n if (!IsArray(decorators))\n throw new TypeError();\n if (!IsConstructor(target))\n throw new TypeError();\n return DecorateConstructor(decorators, target);\n }\n }\n exporter(\"decorate\", decorate);\n // 4.1.2 Reflect.metadata(metadataKey, metadataValue)\n // https://rbuckton.github.io/reflect-metadata/#reflect.metadata\n /**\n * A default metadata decorator factory that can be used on a class, class member, or parameter.\n * @param metadataKey The key for the metadata entry.\n * @param metadataValue The value for the metadata entry.\n * @returns A decorator function.\n * @remarks\n * If `metadataKey` is already defined for the target and target key, the\n * metadataValue for that key will be overwritten.\n * @example\n *\n * // constructor\n * @Reflect.metadata(key, value)\n * class Example {\n * }\n *\n * // property (on constructor, TypeScript only)\n * class Example {\n * @Reflect.metadata(key, value)\n * static staticProperty;\n * }\n *\n * // property (on prototype, TypeScript only)\n * class Example {\n * @Reflect.metadata(key, value)\n * property;\n * }\n *\n * // method (on constructor)\n * class Example {\n * @Reflect.metadata(key, value)\n * static staticMethod() { }\n * }\n *\n * // method (on prototype)\n * class Example {\n * @Reflect.metadata(key, value)\n * method() { }\n * }\n *\n */\n function metadata(metadataKey, metadataValue) {\n function decorator(target, propertyKey) {\n if (!IsObject(target))\n throw new TypeError();\n if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))\n throw new TypeError();\n OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);\n }\n return decorator;\n }\n exporter(\"metadata\", metadata);\n /**\n * Define a unique metadata entry on the target.\n * @param metadataKey A key used to store and retrieve metadata.\n * @param metadataValue A value that contains attached metadata.\n * @param target The target object on which to define metadata.\n * @param propertyKey (Optional) The property key for the target.\n * @example\n *\n * class Example {\n * // property declarations are not part of ES6, though they are valid in TypeScript:\n * // static staticProperty;\n * // property;\n *\n * constructor(p) { }\n * static staticMethod(p) { }\n * method(p) { }\n * }\n *\n * // constructor\n * Reflect.defineMetadata(\"custom:annotation\", options, Example);\n *\n * // property (on constructor)\n * Reflect.defineMetadata(\"custom:annotation\", options, Example, \"staticProperty\");\n *\n * // property (on prototype)\n * Reflect.defineMetadata(\"custom:annotation\", options, Example.prototype, \"property\");\n *\n * // method (on constructor)\n * Reflect.defineMetadata(\"custom:annotation\", options, Example, \"staticMethod\");\n *\n * // method (on prototype)\n * Reflect.defineMetadata(\"custom:annotation\", options, Example.prototype, \"method\");\n *\n * // decorator factory as metadata-producing annotation.\n * function MyAnnotation(options): Decorator {\n * return (target, key?) => Reflect.defineMetadata(\"custom:annotation\", options, target, key);\n * }\n *\n */\n function defineMetadata(metadataKey, metadataValue, target, propertyKey) {\n if (!IsObject(target))\n throw new TypeError();\n if (!IsUndefined(propertyKey))\n propertyKey = ToPropertyKey(propertyKey);\n return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);\n }\n exporter(\"defineMetadata\", defineMetadata);\n /**\n * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.\n * @param metadataKey A key used to store and retrieve metadata.\n * @param target The target object on which the metadata is defined.\n * @param propertyKey (Optional) The property key for the target.\n * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.\n * @example\n *\n * class Example {\n * // property declarations are not part of ES6, though they are valid in TypeScript:\n * // static staticProperty;\n * // property;\n *\n * constructor(p) { }\n * static staticMethod(p) { }\n * method(p) { }\n * }\n *\n * // constructor\n * result = Reflect.hasMetadata(\"custom:annotation\", Example);\n *\n * // property (on constructor)\n * result = Reflect.hasMetadata(\"custom:annotation\", Example, \"staticProperty\");\n *\n * // property (on prototype)\n * result = Reflect.hasMetadata(\"custom:annotation\", Example.prototype, \"property\");\n *\n * // method (on constructor)\n * result = Reflect.hasMetadata(\"custom:annotation\", Example, \"staticMethod\");\n *\n * // method (on prototype)\n * result = Reflect.hasMetadata(\"custom:annotation\", Example.prototype, \"method\");\n *\n */\n function hasMetadata(metadataKey, target, propertyKey) {\n if (!IsObject(target))\n throw new TypeError();\n if (!IsUndefined(propertyKey))\n propertyKey = ToPropertyKey(propertyKey);\n return OrdinaryHasMetadata(metadataKey, target, propertyKey);\n }\n exporter(\"hasMetadata\", hasMetadata);\n /**\n * Gets a value indicating whether the target object has the provided metadata key defined.\n * @param metadataKey A key used to store and retrieve metadata.\n * @param target The target object on which the metadata is defined.\n * @param propertyKey (Optional) The property key for the target.\n * @returns `true` if the metadata key was defined on the target object; otherwise, `false`.\n * @example\n *\n * class Example {\n * // property declarations are not part of ES6, though they are valid in TypeScript:\n * // static staticProperty;\n * // property;\n *\n * constructor(p) { }\n * static staticMethod(p) { }\n * method(p) { }\n * }\n *\n * // constructor\n * result = Reflect.hasOwnMetadata(\"custom:annotation\", Example);\n *\n * // property (on constructor)\n * result = Reflect.hasOwnMetadata(\"custom:annotation\", Example, \"staticProperty\");\n *\n * // property (on prototype)\n * result = Reflect.hasOwnMetadata(\"custom:annotation\", Example.prototype, \"property\");\n *\n * // method (on constructor)\n * result = Reflect.hasOwnMetadata(\"custom:annotation\", Example, \"staticMethod\");\n *\n * // method (on prototype)\n * result = Reflect.hasOwnMetadata(\"custom:annotation\", Example.prototype, \"method\");\n *\n */\n function hasOwnMetadata(metadataKey, target, propertyKey) {\n if (!IsObject(target))\n throw new TypeError();\n if (!IsUndefined(propertyKey))\n propertyKey = ToPropertyKey(propertyKey);\n return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);\n }\n exporter(\"hasOwnMetadata\", hasOwnMetadata);\n /**\n * Gets the metadata value for the provided metadata key on the target object or its prototype chain.\n * @param metadataKey A key used to store and retrieve metadata.\n * @param target The target object on which the metadata is defined.\n * @param propertyKey (Optional) The property key for the target.\n * @returns The metadata value for the metadata key if found; otherwise, `undefined`.\n * @example\n *\n * class Example {\n * // property declarations are not part of ES6, though they are valid in TypeScript:\n * // static staticProperty;\n * // property;\n *\n * constructor(p) { }\n * static staticMethod(p) { }\n * method(p) { }\n * }\n *\n * // constructor\n * result = Reflect.getMetadata(\"custom:annotation\", Example);\n *\n * // property (on constructor)\n * result = Reflect.getMetadata(\"custom:annotation\", Example, \"staticProperty\");\n *\n * // property (on prototype)\n * result = Reflect.getMetadata(\"custom:annotation\", Example.prototype, \"property\");\n *\n * // method (on constructor)\n * result = Reflect.getMetadata(\"custom:annotation\", Example, \"staticMethod\");\n *\n * // method (on prototype)\n * result = Reflect.getMetadata(\"custom:annotation\", Example.prototype, \"method\");\n *\n */\n function getMetadata(metadataKey, target, propertyKey) {\n if (!IsObject(target))\n throw new TypeError();\n if (!IsUndefined(propertyKey))\n propertyKey = ToPropertyKey(propertyKey);\n return OrdinaryGetMetadata(metadataKey, target, propertyKey);\n }\n exporter(\"getMetadata\", getMetadata);\n /**\n * Gets the metadata value for the provided metadata key on the target object.\n * @param metadataKey A key used to store and retrieve metadata.\n * @param target The target object on which the metadata is defined.\n * @param propertyKey (Optional) The property key for the target.\n * @returns The metadata value for the metadata key if found; otherwise, `undefined`.\n * @example\n *\n * class Example {\n * // property declarations are not part of ES6, though they are valid in TypeScript:\n * // static staticProperty;\n * // property;\n *\n * constructor(p) { }\n * static staticMethod(p) { }\n * method(p) { }\n * }\n *\n * // constructor\n * result = Reflect.getOwnMetadata(\"custom:annotation\", Example);\n *\n * // property (on constructor)\n * result = Reflect.getOwnMetadata(\"custom:annotation\", Example, \"staticProperty\");\n *\n * // property (on prototype)\n * result = Reflect.getOwnMetadata(\"custom:annotation\", Example.prototype, \"property\");\n *\n * // method (on constructor)\n * result = Reflect.getOwnMetadata(\"custom:annotation\", Example, \"staticMethod\");\n *\n * // method (on prototype)\n * result = Reflect.getOwnMetadata(\"custom:annotation\", Example.prototype, \"method\");\n *\n */\n function getOwnMetadata(metadataKey, target, propertyKey) {\n if (!IsObject(target))\n throw new TypeError();\n if (!IsUndefined(propertyKey))\n propertyKey = ToPropertyKey(propertyKey);\n return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);\n }\n exporter(\"getOwnMetadata\", getOwnMetadata);\n /**\n * Gets the metadata keys defined on the target object or its prototype chain.\n * @param target The target object on which the metadata is defined.\n * @param propertyKey (Optional) The property key for the target.\n * @returns An array of unique metadata keys.\n * @example\n *\n * class Example {\n * // property declarations are not part of ES6, though they are valid in TypeScript:\n * // static staticProperty;\n * // property;\n *\n * constructor(p) { }\n * static staticMethod(p) { }\n * method(p) { }\n * }\n *\n * // constructor\n * result = Reflect.getMetadataKeys(Example);\n *\n * // property (on constructor)\n * result = Reflect.getMetadataKeys(Example, \"staticProperty\");\n *\n * // property (on prototype)\n * result = Reflect.getMetadataKeys(Example.prototype, \"property\");\n *\n * // method (on constructor)\n * result = Reflect.getMetadataKeys(Example, \"staticMethod\");\n *\n * // method (on prototype)\n * result = Reflect.getMetadataKeys(Example.prototype, \"method\");\n *\n */\n function getMetadataKeys(target, propertyKey) {\n if (!IsObject(target))\n throw new TypeError();\n if (!IsUndefined(propertyKey))\n propertyKey = ToPropertyKey(propertyKey);\n return OrdinaryMetadataKeys(target, propertyKey);\n }\n exporter(\"getMetadataKeys\", getMetadataKeys);\n /**\n * Gets the unique metadata keys defined on the target object.\n * @param target The target object on which the metadata is defined.\n * @param propertyKey (Optional) The property key for the target.\n * @returns An array of unique metadata keys.\n * @example\n *\n * class Example {\n * // property declarations are not part of ES6, though they are valid in TypeScript:\n * // static staticProperty;\n * // property;\n *\n * constructor(p) { }\n * static staticMethod(p) { }\n * method(p) { }\n * }\n *\n * // constructor\n * result = Reflect.getOwnMetadataKeys(Example);\n *\n * // property (on constructor)\n * result = Reflect.getOwnMetadataKeys(Example, \"staticProperty\");\n *\n * // property (on prototype)\n * result = Reflect.getOwnMetadataKeys(Example.prototype, \"property\");\n *\n * // method (on constructor)\n * result = Reflect.getOwnMetadataKeys(Example, \"staticMethod\");\n *\n * // method (on prototype)\n * result = Reflect.getOwnMetadataKeys(Example.prototype, \"method\");\n *\n */\n function getOwnMetadataKeys(target, propertyKey) {\n if (!IsObject(target))\n throw new TypeError();\n if (!IsUndefined(propertyKey))\n propertyKey = ToPropertyKey(propertyKey);\n return OrdinaryOwnMetadataKeys(target, propertyKey);\n }\n exporter(\"getOwnMetadataKeys\", getOwnMetadataKeys);\n /**\n * Deletes the metadata entry from the target object with the provided key.\n * @param metadataKey A key used to store and retrieve metadata.\n * @param target The target object on which the metadata is defined.\n * @param propertyKey (Optional) The property key for the target.\n * @returns `true` if the metadata entry was found and deleted; otherwise, false.\n * @example\n *\n * class Example {\n * // property declarations are not part of ES6, though they are valid in TypeScript:\n * // static staticProperty;\n * // property;\n *\n * constructor(p) { }\n * static staticMethod(p) { }\n * method(p) { }\n * }\n *\n * // constructor\n * result = Reflect.deleteMetadata(\"custom:annotation\", Example);\n *\n * // property (on constructor)\n * result = Reflect.deleteMetadata(\"custom:annotation\", Example, \"staticProperty\");\n *\n * // property (on prototype)\n * result = Reflect.deleteMetadata(\"custom:annotation\", Example.prototype, \"property\");\n *\n * // method (on constructor)\n * result = Reflect.deleteMetadata(\"custom:annotation\", Example, \"staticMethod\");\n *\n * // method (on prototype)\n * result = Reflect.deleteMetadata(\"custom:annotation\", Example.prototype, \"method\");\n *\n */\n function deleteMetadata(metadataKey, target, propertyKey) {\n if (!IsObject(target))\n throw new TypeError();\n if (!IsUndefined(propertyKey))\n propertyKey = ToPropertyKey(propertyKey);\n if (!IsObject(target))\n throw new TypeError();\n if (!IsUndefined(propertyKey))\n propertyKey = ToPropertyKey(propertyKey);\n var provider = GetMetadataProvider(target, propertyKey, /*Create*/ false);\n if (IsUndefined(provider))\n return false;\n return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);\n }\n exporter(\"deleteMetadata\", deleteMetadata);\n function DecorateConstructor(decorators, target) {\n for (var i = decorators.length - 1; i >= 0; --i) {\n var decorator = decorators[i];\n var decorated = decorator(target);\n if (!IsUndefined(decorated) && !IsNull(decorated)) {\n if (!IsConstructor(decorated))\n throw new TypeError();\n target = decorated;\n }\n }\n return target;\n }\n function DecorateProperty(decorators, target, propertyKey, descriptor) {\n for (var i = decorators.length - 1; i >= 0; --i) {\n var decorator = decorators[i];\n var decorated = decorator(target, propertyKey, descriptor);\n if (!IsUndefined(decorated) && !IsNull(decorated)) {\n if (!IsObject(decorated))\n throw new TypeError();\n descriptor = decorated;\n }\n }\n return descriptor;\n }\n // 3.1.1.1 OrdinaryHasMetadata(MetadataKey, O, P)\n // https://rbuckton.github.io/reflect-metadata/#ordinaryhasmetadata\n function OrdinaryHasMetadata(MetadataKey, O, P) {\n var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);\n if (hasOwn)\n return true;\n var parent = OrdinaryGetPrototypeOf(O);\n if (!IsNull(parent))\n return OrdinaryHasMetadata(MetadataKey, parent, P);\n return false;\n }\n // 3.1.2.1 OrdinaryHasOwnMetadata(MetadataKey, O, P)\n // https://rbuckton.github.io/reflect-metadata/#ordinaryhasownmetadata\n function OrdinaryHasOwnMetadata(MetadataKey, O, P) {\n var provider = GetMetadataProvider(O, P, /*Create*/ false);\n if (IsUndefined(provider))\n return false;\n return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));\n }\n // 3.1.3.1 OrdinaryGetMetadata(MetadataKey, O, P)\n // https://rbuckton.github.io/reflect-metadata/#ordinarygetmetadata\n function OrdinaryGetMetadata(MetadataKey, O, P) {\n var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);\n if (hasOwn)\n return OrdinaryGetOwnMetadata(MetadataKey, O, P);\n var parent = OrdinaryGetPrototypeOf(O);\n if (!IsNull(parent))\n return OrdinaryGetMetadata(MetadataKey, parent, P);\n return undefined;\n }\n // 3.1.4.1 OrdinaryGetOwnMetadata(MetadataKey, O, P)\n // https://rbuckton.github.io/reflect-metadata/#ordinarygetownmetadata\n function OrdinaryGetOwnMetadata(MetadataKey, O, P) {\n var provider = GetMetadataProvider(O, P, /*Create*/ false);\n if (IsUndefined(provider))\n return;\n return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);\n }\n // 3.1.5.1 OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P)\n // https://rbuckton.github.io/reflect-metadata/#ordinarydefineownmetadata\n function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {\n var provider = GetMetadataProvider(O, P, /*Create*/ true);\n provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);\n }\n // 3.1.6.1 OrdinaryMetadataKeys(O, P)\n // https://rbuckton.github.io/reflect-metadata/#ordinarymetadatakeys\n function OrdinaryMetadataKeys(O, P) {\n var ownKeys = OrdinaryOwnMetadataKeys(O, P);\n var parent = OrdinaryGetPrototypeOf(O);\n if (parent === null)\n return ownKeys;\n var parentKeys = OrdinaryMetadataKeys(parent, P);\n if (parentKeys.length <= 0)\n return ownKeys;\n if (ownKeys.length <= 0)\n return parentKeys;\n var set = new _Set();\n var keys = [];\n for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) {\n var key = ownKeys_1[_i];\n var hasKey = set.has(key);\n if (!hasKey) {\n set.add(key);\n keys.push(key);\n }\n }\n for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) {\n var key = parentKeys_1[_a];\n var hasKey = set.has(key);\n if (!hasKey) {\n set.add(key);\n keys.push(key);\n }\n }\n return keys;\n }\n // 3.1.7.1 OrdinaryOwnMetadataKeys(O, P)\n // https://rbuckton.github.io/reflect-metadata/#ordinaryownmetadatakeys\n function OrdinaryOwnMetadataKeys(O, P) {\n var provider = GetMetadataProvider(O, P, /*create*/ false);\n if (!provider) {\n return [];\n }\n return provider.OrdinaryOwnMetadataKeys(O, P);\n }\n // 6 ECMAScript Data Typ0es and Values\n // https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values\n function Type(x) {\n if (x === null)\n return 1 /* Null */;\n switch (typeof x) {\n case \"undefined\": return 0 /* Undefined */;\n case \"boolean\": return 2 /* Boolean */;\n case \"string\": return 3 /* String */;\n case \"symbol\": return 4 /* Symbol */;\n case \"number\": return 5 /* Number */;\n case \"object\": return x === null ? 1 /* Null */ : 6 /* Object */;\n default: return 6 /* Object */;\n }\n }\n // 6.1.1 The Undefined Type\n // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-undefined-type\n function IsUndefined(x) {\n return x === undefined;\n }\n // 6.1.2 The Null Type\n // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-null-type\n function IsNull(x) {\n return x === null;\n }\n // 6.1.5 The Symbol Type\n // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-symbol-type\n function IsSymbol(x) {\n return typeof x === \"symbol\";\n }\n // 6.1.7 The Object Type\n // https://tc39.github.io/ecma262/#sec-object-type\n function IsObject(x) {\n return typeof x === \"object\" ? x !== null : typeof x === \"function\";\n }\n // 7.1 Type Conversion\n // https://tc39.github.io/ecma262/#sec-type-conversion\n // 7.1.1 ToPrimitive(input [, PreferredType])\n // https://tc39.github.io/ecma262/#sec-toprimitive\n function ToPrimitive(input, PreferredType) {\n switch (Type(input)) {\n case 0 /* Undefined */: return input;\n case 1 /* Null */: return input;\n case 2 /* Boolean */: return input;\n case 3 /* String */: return input;\n case 4 /* Symbol */: return input;\n case 5 /* Number */: return input;\n }\n var hint = PreferredType === 3 /* String */ ? \"string\" : PreferredType === 5 /* Number */ ? \"number\" : \"default\";\n var exoticToPrim = GetMethod(input, toPrimitiveSymbol);\n if (exoticToPrim !== undefined) {\n var result = exoticToPrim.call(input, hint);\n if (IsObject(result))\n throw new TypeError();\n return result;\n }\n return OrdinaryToPrimitive(input, hint === \"default\" ? \"number\" : hint);\n }\n // 7.1.1.1 OrdinaryToPrimitive(O, hint)\n // https://tc39.github.io/ecma262/#sec-ordinarytoprimitive\n function OrdinaryToPrimitive(O, hint) {\n if (hint === \"string\") {\n var toString_1 = O.toString;\n if (IsCallable(toString_1)) {\n var result = toString_1.call(O);\n if (!IsObject(result))\n return result;\n }\n var valueOf = O.valueOf;\n if (IsCallable(valueOf)) {\n var result = valueOf.call(O);\n if (!IsObject(result))\n return result;\n }\n }\n else {\n var valueOf = O.valueOf;\n if (IsCallable(valueOf)) {\n var result = valueOf.call(O);\n if (!IsObject(result))\n return result;\n }\n var toString_2 = O.toString;\n if (IsCallable(toString_2)) {\n var result = toString_2.call(O);\n if (!IsObject(result))\n return result;\n }\n }\n throw new TypeError();\n }\n // 7.1.2 ToBoolean(argument)\n // https://tc39.github.io/ecma262/2016/#sec-toboolean\n function ToBoolean(argument) {\n return !!argument;\n }\n // 7.1.12 ToString(argument)\n // https://tc39.github.io/ecma262/#sec-tostring\n function ToString(argument) {\n return \"\" + argument;\n }\n // 7.1.14 ToPropertyKey(argument)\n // https://tc39.github.io/ecma262/#sec-topropertykey\n function ToPropertyKey(argument) {\n var key = ToPrimitive(argument, 3 /* String */);\n if (IsSymbol(key))\n return key;\n return ToString(key);\n }\n // 7.2 Testing and Comparison Operations\n // https://tc39.github.io/ecma262/#sec-testing-and-comparison-operations\n // 7.2.2 IsArray(argument)\n // https://tc39.github.io/ecma262/#sec-isarray\n function IsArray(argument) {\n return Array.isArray\n ? Array.isArray(argument)\n : argument instanceof Object\n ? argument instanceof Array\n : Object.prototype.toString.call(argument) === \"[object Array]\";\n }\n // 7.2.3 IsCallable(argument)\n // https://tc39.github.io/ecma262/#sec-iscallable\n function IsCallable(argument) {\n // NOTE: This is an approximation as we cannot check for [[Call]] internal method.\n return typeof argument === \"function\";\n }\n // 7.2.4 IsConstructor(argument)\n // https://tc39.github.io/ecma262/#sec-isconstructor\n function IsConstructor(argument) {\n // NOTE: This is an approximation as we cannot check for [[Construct]] internal method.\n return typeof argument === \"function\";\n }\n // 7.2.7 IsPropertyKey(argument)\n // https://tc39.github.io/ecma262/#sec-ispropertykey\n function IsPropertyKey(argument) {\n switch (Type(argument)) {\n case 3 /* String */: return true;\n case 4 /* Symbol */: return true;\n default: return false;\n }\n }\n function SameValueZero(x, y) {\n return x === y || x !== x && y !== y;\n }\n // 7.3 Operations on Objects\n // https://tc39.github.io/ecma262/#sec-operations-on-objects\n // 7.3.9 GetMethod(V, P)\n // https://tc39.github.io/ecma262/#sec-getmethod\n function GetMethod(V, P) {\n var func = V[P];\n if (func === undefined || func === null)\n return undefined;\n if (!IsCallable(func))\n throw new TypeError();\n return func;\n }\n // 7.4 Operations on Iterator Objects\n // https://tc39.github.io/ecma262/#sec-operations-on-iterator-objects\n function GetIterator(obj) {\n var method = GetMethod(obj, iteratorSymbol);\n if (!IsCallable(method))\n throw new TypeError(); // from Call\n var iterator = method.call(obj);\n if (!IsObject(iterator))\n throw new TypeError();\n return iterator;\n }\n // 7.4.4 IteratorValue(iterResult)\n // https://tc39.github.io/ecma262/2016/#sec-iteratorvalue\n function IteratorValue(iterResult) {\n return iterResult.value;\n }\n // 7.4.5 IteratorStep(iterator)\n // https://tc39.github.io/ecma262/#sec-iteratorstep\n function IteratorStep(iterator) {\n var result = iterator.next();\n return result.done ? false : result;\n }\n // 7.4.6 IteratorClose(iterator, completion)\n // https://tc39.github.io/ecma262/#sec-iteratorclose\n function IteratorClose(iterator) {\n var f = iterator[\"return\"];\n if (f)\n f.call(iterator);\n }\n // 9.1 Ordinary Object Internal Methods and Internal Slots\n // https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots\n // 9.1.1.1 OrdinaryGetPrototypeOf(O)\n // https://tc39.github.io/ecma262/#sec-ordinarygetprototypeof\n function OrdinaryGetPrototypeOf(O) {\n var proto = Object.getPrototypeOf(O);\n if (typeof O !== \"function\" || O === functionPrototype)\n return proto;\n // TypeScript doesn't set __proto__ in ES5, as it's non-standard.\n // Try to determine the superclass constructor. Compatible implementations\n // must either set __proto__ on a subclass constructor to the superclass constructor,\n // or ensure each class has a valid `constructor` property on its prototype that\n // points back to the constructor.\n // If this is not the same as Function.[[Prototype]], then this is definately inherited.\n // This is the case when in ES6 or when using __proto__ in a compatible browser.\n if (proto !== functionPrototype)\n return proto;\n // If the super prototype is Object.prototype, null, or undefined, then we cannot determine the heritage.\n var prototype = O.prototype;\n var prototypeProto = prototype && Object.getPrototypeOf(prototype);\n if (prototypeProto == null || prototypeProto === Object.prototype)\n return proto;\n // If the constructor was not a function, then we cannot determine the heritage.\n var constructor = prototypeProto.constructor;\n if (typeof constructor !== \"function\")\n return proto;\n // If we have some kind of self-reference, then we cannot determine the heritage.\n if (constructor === O)\n return proto;\n // we have a pretty good guess at the heritage.\n return constructor;\n }\n // Global metadata registry\n // - Allows `import \"reflect-metadata\"` and `import \"reflect-metadata/no-conflict\"` to interoperate.\n // - Uses isolated metadata if `Reflect` is frozen before the registry can be installed.\n /**\n * Creates a registry used to allow multiple `reflect-metadata` providers.\n */\n function CreateMetadataRegistry() {\n var fallback;\n if (!IsUndefined(registrySymbol) &&\n typeof root.Reflect !== \"undefined\" &&\n !(registrySymbol in root.Reflect) &&\n typeof root.Reflect.defineMetadata === \"function\") {\n // interoperate with older version of `reflect-metadata` that did not support a registry.\n fallback = CreateFallbackProvider(root.Reflect);\n }\n var first;\n var second;\n var rest;\n var targetProviderMap = new _WeakMap();\n var registry = {\n registerProvider: registerProvider,\n getProvider: getProvider,\n setProvider: setProvider,\n };\n return registry;\n function registerProvider(provider) {\n if (!Object.isExtensible(registry)) {\n throw new Error(\"Cannot add provider to a frozen registry.\");\n }\n switch (true) {\n case fallback === provider: break;\n case IsUndefined(first):\n first = provider;\n break;\n case first === provider: break;\n case IsUndefined(second):\n second = provider;\n break;\n case second === provider: break;\n default:\n if (rest === undefined)\n rest = new _Set();\n rest.add(provider);\n break;\n }\n }\n function getProviderNoCache(O, P) {\n if (!IsUndefined(first)) {\n if (first.isProviderFor(O, P))\n return first;\n if (!IsUndefined(second)) {\n if (second.isProviderFor(O, P))\n return first;\n if (!IsUndefined(rest)) {\n var iterator = GetIterator(rest);\n while (true) {\n var next = IteratorStep(iterator);\n if (!next) {\n return undefined;\n }\n var provider = IteratorValue(next);\n if (provider.isProviderFor(O, P)) {\n IteratorClose(iterator);\n return provider;\n }\n }\n }\n }\n }\n if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) {\n return fallback;\n }\n return undefined;\n }\n function getProvider(O, P) {\n var providerMap = targetProviderMap.get(O);\n var provider;\n if (!IsUndefined(providerMap)) {\n provider = providerMap.get(P);\n }\n if (!IsUndefined(provider)) {\n return provider;\n }\n provider = getProviderNoCache(O, P);\n if (!IsUndefined(provider)) {\n if (IsUndefined(providerMap)) {\n providerMap = new _Map();\n targetProviderMap.set(O, providerMap);\n }\n providerMap.set(P, provider);\n }\n return provider;\n }\n function hasProvider(provider) {\n if (IsUndefined(provider))\n throw new TypeError();\n return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider);\n }\n function setProvider(O, P, provider) {\n if (!hasProvider(provider)) {\n throw new Error(\"Metadata provider not registered.\");\n }\n var existingProvider = getProvider(O, P);\n if (existingProvider !== provider) {\n if (!IsUndefined(existingProvider)) {\n return false;\n }\n var providerMap = targetProviderMap.get(O);\n if (IsUndefined(providerMap)) {\n providerMap = new _Map();\n targetProviderMap.set(O, providerMap);\n }\n providerMap.set(P, provider);\n }\n return true;\n }\n }\n /**\n * Gets or creates the shared registry of metadata providers.\n */\n function GetOrCreateMetadataRegistry() {\n var metadataRegistry;\n if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {\n metadataRegistry = root.Reflect[registrySymbol];\n }\n if (IsUndefined(metadataRegistry)) {\n metadataRegistry = CreateMetadataRegistry();\n }\n if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {\n Object.defineProperty(root.Reflect, registrySymbol, {\n enumerable: false,\n configurable: false,\n writable: false,\n value: metadataRegistry\n });\n }\n return metadataRegistry;\n }\n function CreateMetadataProvider(registry) {\n // [[Metadata]] internal slot\n // https://rbuckton.github.io/reflect-metadata/#ordinary-object-internal-methods-and-internal-slots\n var metadata = new _WeakMap();\n var provider = {\n isProviderFor: function (O, P) {\n var targetMetadata = metadata.get(O);\n if (IsUndefined(targetMetadata))\n return false;\n return targetMetadata.has(P);\n },\n OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata,\n OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata,\n OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata,\n OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys,\n OrdinaryDeleteMetadata: OrdinaryDeleteMetadata,\n };\n metadataRegistry.registerProvider(provider);\n return provider;\n function GetOrCreateMetadataMap(O, P, Create) {\n var targetMetadata = metadata.get(O);\n var createdTargetMetadata = false;\n if (IsUndefined(targetMetadata)) {\n if (!Create)\n return undefined;\n targetMetadata = new _Map();\n metadata.set(O, targetMetadata);\n createdTargetMetadata = true;\n }\n var metadataMap = targetMetadata.get(P);\n if (IsUndefined(metadataMap)) {\n if (!Create)\n return undefined;\n metadataMap = new _Map();\n targetMetadata.set(P, metadataMap);\n if (!registry.setProvider(O, P, provider)) {\n targetMetadata.delete(P);\n if (createdTargetMetadata) {\n metadata.delete(O);\n }\n throw new Error(\"Wrong provider for target.\");\n }\n }\n return metadataMap;\n }\n // 3.1.2.1 OrdinaryHasOwnMetadata(MetadataKey, O, P)\n // https://rbuckton.github.io/reflect-metadata/#ordinaryhasownmetadata\n function OrdinaryHasOwnMetadata(MetadataKey, O, P) {\n var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);\n if (IsUndefined(metadataMap))\n return false;\n return ToBoolean(metadataMap.has(MetadataKey));\n }\n // 3.1.4.1 OrdinaryGetOwnMetadata(MetadataKey, O, P)\n // https://rbuckton.github.io/reflect-metadata/#ordinarygetownmetadata\n function OrdinaryGetOwnMetadata(MetadataKey, O, P) {\n var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);\n if (IsUndefined(metadataMap))\n return undefined;\n return metadataMap.get(MetadataKey);\n }\n // 3.1.5.1 OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P)\n // https://rbuckton.github.io/reflect-metadata/#ordinarydefineownmetadata\n function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {\n var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ true);\n metadataMap.set(MetadataKey, MetadataValue);\n }\n // 3.1.7.1 OrdinaryOwnMetadataKeys(O, P)\n // https://rbuckton.github.io/reflect-metadata/#ordinaryownmetadatakeys\n function OrdinaryOwnMetadataKeys(O, P) {\n var keys = [];\n var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);\n if (IsUndefined(metadataMap))\n return keys;\n var keysObj = metadataMap.keys();\n var iterator = GetIterator(keysObj);\n var k = 0;\n while (true) {\n var next = IteratorStep(iterator);\n if (!next) {\n keys.length = k;\n return keys;\n }\n var nextValue = IteratorValue(next);\n try {\n keys[k] = nextValue;\n }\n catch (e) {\n try {\n IteratorClose(iterator);\n }\n finally {\n throw e;\n }\n }\n k++;\n }\n }\n function OrdinaryDeleteMetadata(MetadataKey, O, P) {\n var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);\n if (IsUndefined(metadataMap))\n return false;\n if (!metadataMap.delete(MetadataKey))\n return false;\n if (metadataMap.size === 0) {\n var targetMetadata = metadata.get(O);\n if (!IsUndefined(targetMetadata)) {\n targetMetadata.delete(P);\n if (targetMetadata.size === 0) {\n metadata.delete(targetMetadata);\n }\n }\n }\n return true;\n }\n }\n function CreateFallbackProvider(reflect) {\n var defineMetadata = reflect.defineMetadata, hasOwnMetadata = reflect.hasOwnMetadata, getOwnMetadata = reflect.getOwnMetadata, getOwnMetadataKeys = reflect.getOwnMetadataKeys, deleteMetadata = reflect.deleteMetadata;\n var metadataOwner = new _WeakMap();\n var provider = {\n isProviderFor: function (O, P) {\n var metadataPropertySet = metadataOwner.get(O);\n if (!IsUndefined(metadataPropertySet)) {\n return metadataPropertySet.has(P);\n }\n if (getOwnMetadataKeys(O, P).length) {\n if (IsUndefined(metadataPropertySet)) {\n metadataPropertySet = new _Set();\n metadataOwner.set(O, metadataPropertySet);\n }\n metadataPropertySet.add(P);\n return true;\n }\n return false;\n },\n OrdinaryDefineOwnMetadata: defineMetadata,\n OrdinaryHasOwnMetadata: hasOwnMetadata,\n OrdinaryGetOwnMetadata: getOwnMetadata,\n OrdinaryOwnMetadataKeys: getOwnMetadataKeys,\n OrdinaryDeleteMetadata: deleteMetadata,\n };\n return provider;\n }\n /**\n * Gets the metadata provider for an object. If the object has no metadata provider and this is for a create operation,\n * then this module's metadata provider is assigned to the object.\n */\n function GetMetadataProvider(O, P, Create) {\n var registeredProvider = metadataRegistry.getProvider(O, P);\n if (!IsUndefined(registeredProvider)) {\n return registeredProvider;\n }\n if (Create) {\n if (metadataRegistry.setProvider(O, P, metadataProvider)) {\n return metadataProvider;\n }\n throw new Error(\"Illegal state.\");\n }\n return undefined;\n }\n // naive Map shim\n function CreateMapPolyfill() {\n var cacheSentinel = {};\n var arraySentinel = [];\n var MapIterator = /** @class */ (function () {\n function MapIterator(keys, values, selector) {\n this._index = 0;\n this._keys = keys;\n this._values = values;\n this._selector = selector;\n }\n MapIterator.prototype[\"@@iterator\"] = function () { return this; };\n MapIterator.prototype[iteratorSymbol] = function () { return this; };\n MapIterator.prototype.next = function () {\n var index = this._index;\n if (index >= 0 && index < this._keys.length) {\n var result = this._selector(this._keys[index], this._values[index]);\n if (index + 1 >= this._keys.length) {\n this._index = -1;\n this._keys = arraySentinel;\n this._values = arraySentinel;\n }\n else {\n this._index++;\n }\n return { value: result, done: false };\n }\n return { value: undefined, done: true };\n };\n MapIterator.prototype.throw = function (error) {\n if (this._index >= 0) {\n this._index = -1;\n this._keys = arraySentinel;\n this._values = arraySentinel;\n }\n throw error;\n };\n MapIterator.prototype.return = function (value) {\n if (this._index >= 0) {\n this._index = -1;\n this._keys = arraySentinel;\n this._values = arraySentinel;\n }\n return { value: value, done: true };\n };\n return MapIterator;\n }());\n var Map = /** @class */ (function () {\n function Map() {\n this._keys = [];\n this._values = [];\n this._cacheKey = cacheSentinel;\n this._cacheIndex = -2;\n }\n Object.defineProperty(Map.prototype, \"size\", {\n get: function () { return this._keys.length; },\n enumerable: true,\n configurable: true\n });\n Map.prototype.has = function (key) { return this._find(key, /*insert*/ false) >= 0; };\n Map.prototype.get = function (key) {\n var index = this._find(key, /*insert*/ false);\n return index >= 0 ? this._values[index] : undefined;\n };\n Map.prototype.set = function (key, value) {\n var index = this._find(key, /*insert*/ true);\n this._values[index] = value;\n return this;\n };\n Map.prototype.delete = function (key) {\n var index = this._find(key, /*insert*/ false);\n if (index >= 0) {\n var size = this._keys.length;\n for (var i = index + 1; i < size; i++) {\n this._keys[i - 1] = this._keys[i];\n this._values[i - 1] = this._values[i];\n }\n this._keys.length--;\n this._values.length--;\n if (SameValueZero(key, this._cacheKey)) {\n this._cacheKey = cacheSentinel;\n this._cacheIndex = -2;\n }\n return true;\n }\n return false;\n };\n Map.prototype.clear = function () {\n this._keys.length = 0;\n this._values.length = 0;\n this._cacheKey = cacheSentinel;\n this._cacheIndex = -2;\n };\n Map.prototype.keys = function () { return new MapIterator(this._keys, this._values, getKey); };\n Map.prototype.values = function () { return new MapIterator(this._keys, this._values, getValue); };\n Map.prototype.entries = function () { return new MapIterator(this._keys, this._values, getEntry); };\n Map.prototype[\"@@iterator\"] = function () { return this.entries(); };\n Map.prototype[iteratorSymbol] = function () { return this.entries(); };\n Map.prototype._find = function (key, insert) {\n if (!SameValueZero(this._cacheKey, key)) {\n this._cacheIndex = -1;\n for (var i = 0; i < this._keys.length; i++) {\n if (SameValueZero(this._keys[i], key)) {\n this._cacheIndex = i;\n break;\n }\n }\n }\n if (this._cacheIndex < 0 && insert) {\n this._cacheIndex = this._keys.length;\n this._keys.push(key);\n this._values.push(undefined);\n }\n return this._cacheIndex;\n };\n return Map;\n }());\n return Map;\n function getKey(key, _) {\n return key;\n }\n function getValue(_, value) {\n return value;\n }\n function getEntry(key, value) {\n return [key, value];\n }\n }\n // naive Set shim\n function CreateSetPolyfill() {\n var Set = /** @class */ (function () {\n function Set() {\n this._map = new _Map();\n }\n Object.defineProperty(Set.prototype, \"size\", {\n get: function () { return this._map.size; },\n enumerable: true,\n configurable: true\n });\n Set.prototype.has = function (value) { return this._map.has(value); };\n Set.prototype.add = function (value) { return this._map.set(value, value), this; };\n Set.prototype.delete = function (value) { return this._map.delete(value); };\n Set.prototype.clear = function () { this._map.clear(); };\n Set.prototype.keys = function () { return this._map.keys(); };\n Set.prototype.values = function () { return this._map.keys(); };\n Set.prototype.entries = function () { return this._map.entries(); };\n Set.prototype[\"@@iterator\"] = function () { return this.keys(); };\n Set.prototype[iteratorSymbol] = function () { return this.keys(); };\n return Set;\n }());\n return Set;\n }\n // naive WeakMap shim\n function CreateWeakMapPolyfill() {\n var UUID_SIZE = 16;\n var keys = HashMap.create();\n var rootKey = CreateUniqueKey();\n return /** @class */ (function () {\n function WeakMap() {\n this._key = CreateUniqueKey();\n }\n WeakMap.prototype.has = function (target) {\n var table = GetOrCreateWeakMapTable(target, /*create*/ false);\n return table !== undefined ? HashMap.has(table, this._key) : false;\n };\n WeakMap.prototype.get = function (target) {\n var table = GetOrCreateWeakMapTable(target, /*create*/ false);\n return table !== undefined ? HashMap.get(table, this._key) : undefined;\n };\n WeakMap.prototype.set = function (target, value) {\n var table = GetOrCreateWeakMapTable(target, /*create*/ true);\n table[this._key] = value;\n return this;\n };\n WeakMap.prototype.delete = function (target) {\n var table = GetOrCreateWeakMapTable(target, /*create*/ false);\n return table !== undefined ? delete table[this._key] : false;\n };\n WeakMap.prototype.clear = function () {\n // NOTE: not a real clear, just makes the previous data unreachable\n this._key = CreateUniqueKey();\n };\n return WeakMap;\n }());\n function CreateUniqueKey() {\n var key;\n do\n key = \"@@WeakMap@@\" + CreateUUID();\n while (HashMap.has(keys, key));\n keys[key] = true;\n return key;\n }\n function GetOrCreateWeakMapTable(target, create) {\n if (!hasOwn.call(target, rootKey)) {\n if (!create)\n return undefined;\n Object.defineProperty(target, rootKey, { value: HashMap.create() });\n }\n return target[rootKey];\n }\n function FillRandomBytes(buffer, size) {\n for (var i = 0; i < size; ++i)\n buffer[i] = Math.random() * 0xff | 0;\n return buffer;\n }\n function GenRandomBytes(size) {\n if (typeof Uint8Array === \"function\") {\n if (typeof crypto !== \"undefined\")\n return crypto.getRandomValues(new Uint8Array(size));\n if (typeof msCrypto !== \"undefined\")\n return msCrypto.getRandomValues(new Uint8Array(size));\n return FillRandomBytes(new Uint8Array(size), size);\n }\n return FillRandomBytes(new Array(size), size);\n }\n function CreateUUID() {\n var data = GenRandomBytes(UUID_SIZE);\n // mark as random - RFC 4122 § 4.4\n data[6] = data[6] & 0x4f | 0x40;\n data[8] = data[8] & 0xbf | 0x80;\n var result = \"\";\n for (var offset = 0; offset < UUID_SIZE; ++offset) {\n var byte = data[offset];\n if (offset === 4 || offset === 6 || offset === 8)\n result += \"-\";\n if (byte < 16)\n result += \"0\";\n result += byte.toString(16).toLowerCase();\n }\n return result;\n }\n }\n // uses a heuristic used by v8 and chakra to force an object into dictionary mode.\n function MakeDictionary(obj) {\n obj.__ = undefined;\n delete obj.__;\n return obj;\n }\n });\n})(Reflect || (Reflect = {}));\n","import { mongoose } from '@typegoose/typegoose'\n\n/**\n * 为model指定数据库连接\n * @param {string} name 数据库连接名字， 在config中必须要有对应的配置， 比如main， 则必须要有 db_main\n * */\nexport function dbconn(name?: string) {\n return target => {\n name = name || 'main'\n const dbName = ('db_' + name).toUpperCase()\n const url = process.env[dbName]\n target['db'] = mongoose.createConnection(url, {})\n }\n}\n","import 'reflect-metadata'\nimport { singleton } from './singleton'\n\n\n@singleton\nexport class NoJsonClass {\n private noJsonPropSet: Set = new Set()\n\n public addKey(className: string, propertyKey: string) {\n this.noJsonPropSet.add(className + '_' + propertyKey)\n }\n\n public checkExist(className: string, propertyKey: string) {\n return this.noJsonPropSet.has(className + '_' + propertyKey)\n }\n}\n/**\n * 在不需要toJson方法输出的字段上加上 @noJson\n * @return {{(target: Function): void, (target: Object, propertyKey: (string | symbol)): void}}\n */\nexport function noJson() {\n // return Reflect.metadata(noJsonMetadataKey, !0)\n return function (target: Object, propertyKey: string) {\n new NoJsonClass().addKey(target.constructor.name, propertyKey)\n }\n}\n\nexport function checkJson(target: any, propertyKey: string) {\n return !new NoJsonClass().checkExist(target.constructor.modelName, propertyKey)\n}\n","/**\n * 单例化一个class\n * 使用方法:\n * @singleton\n * class Test {}\n * new Test() === new Test() // returns `true`\n * 也可以不使用 decorator\n * const TestSingleton = singleton(Test)\n * new TestSingleton() === new TestSingleton() //returns 'true'\n */\n\nexport const SINGLETON_KEY = Symbol()\n\nexport type Singleton any> = T & {\n [SINGLETON_KEY]: T extends new (...args: any[]) => infer I ? I : never\n}\nexport const singleton = any>(classTarget: T) =>\n new Proxy(classTarget, {\n construct(target: Singleton, argumentsList, newTarget) {\n // Skip proxy for children\n if (target.prototype !== newTarget.prototype) {\n return Reflect.construct(target, argumentsList, newTarget)\n }\n if (!target[SINGLETON_KEY]) {\n target[SINGLETON_KEY] = Reflect.construct(target, argumentsList, newTarget)\n }\n return target[SINGLETON_KEY]\n },\n })\n","type Callback = () => Promise\n\nexport type AsyncQueue = {\n push: (task: Callback) => Promise\n flush: () => Promise\n size: number\n}\n\n/**\n * Ensures that each callback pushed onto the queue is executed in series.\n * Such a quetie 😻\n * @param opts.dedupeConcurrent If dedupeConcurrent is `true` it ensures that if multiple\n * tasks are pushed onto the queue while there is an active task, only the\n * last one will be executed, once the active task has completed.\n * e.g. in the below example, only 0 and 3 will be executed.\n * ```\n * const queue = createAsyncQueue({ dedupeConcurrent: true })\n * queue.push(async () => console.log(0)) // returns 0\n * queue.push(async () => console.log(1)) // returns 3\n * queue.push(async () => console.log(2)) // returns 3\n * queue.push(async () => console.log(3)) // returns 3\n * ```\n * */\nexport function createAsyncQueue(opts = { dedupeConcurrent: false }): AsyncQueue {\n const { dedupeConcurrent } = opts\n let queue: Callback[] = []\n let running: Promise | undefined\n let nextPromise = new DeferredPromise()\n const push = (task: Callback) => {\n let taskPromise = new DeferredPromise()\n if (dedupeConcurrent) {\n queue = []\n if (nextPromise.started) nextPromise = new DeferredPromise()\n taskPromise = nextPromise\n }\n queue.push(() => {\n taskPromise.started = true\n task().then(taskPromise.resolve).catch(taskPromise.reject)\n return taskPromise.promise\n })\n if (!running) running = start()\n return taskPromise.promise\n }\n const start = async () => {\n while (queue.length) {\n const task = queue.shift()!\n await task().catch(() => {})\n }\n running = undefined\n }\n return {\n push,\n flush: () => running || Promise.resolve(),\n get size() {\n return queue.length\n },\n }\n}\n\nexport const createAsyncQueues = (opts = { dedupeConcurrent: false }) => {\n const queues: { [queueId: string]: AsyncQueue } = {}\n const push = (queueId: string, task: Callback) => {\n if (!queues[queueId]) queues[queueId] = createAsyncQueue(opts)\n return queues[queueId].push(task)\n }\n const flush = (queueId: string) => {\n if (!queues[queueId]) queues[queueId] = createAsyncQueue(opts)\n return queues[queueId].flush()\n }\n return { push, flush }\n}\n\nclass DeferredPromise {\n started = false\n resolve: (x: T | PromiseLike) => void = () => {}\n reject: (x: E) => void = () => {}\n promise: Promise\n\n constructor() {\n this.promise = new Promise((res, rej) => {\n this.resolve = res\n this.reject = rej\n })\n }\n}\n\n// function main() {\n// const queue = createAsyncQueue()\n// queue.push(async () => {\n// console.log(0)\n// }) // returns 0\n// queue.push(async () => {\n// console.log(1)\n\n// return new Promise((resolve, reject) => {\n// setTimeout(() => {\n// console.log('12')\n// resolve()\n// }, 1000)\n// })\n// }) // returns 3\n// queue.push(async () => console.log(2)) // returns 3\n// queue.push(async () => console.log(3)) // returns 3\n// console.log('hi')\n// }\n\n// main()\n","import { dbconn } from 'decorators/dbconn'\nimport { getModelForClass, index, modelOptions, mongoose, prop } from '@typegoose/typegoose'\nimport { Severity } from '@typegoose/typegoose/lib/internal/constants'\nimport { BaseModule } from './Base'\n\n/**\n * 用户操作记录\n */\n@dbconn()\n@index({ user: 1 }, { unique: false })\n@index({ name: 1 }, { unique: false })\n@modelOptions({ schemaOptions: { collection: 'user_log', timestamps: true }, options: { allowMixed: Severity.ALLOW } })\nclass UserLogClass extends BaseModule {\n @prop()\n public user: string\n @prop()\n public name: string\n @prop()\n public method: string\n @prop()\n public path: string\n @prop()\n public referer: string\n @prop()\n public user_agent: string\n @prop()\n public ip: string\n @prop({ type: mongoose.Schema.Types.Mixed })\n public params: any\n}\nexport const UserLog = getModelForClass(UserLogClass, { existingConnection: UserLogClass['db'] })\n","export function isAnyArrayBuffer(value: unknown): value is ArrayBuffer {\n return ['[object ArrayBuffer]', '[object SharedArrayBuffer]'].includes(\n Object.prototype.toString.call(value)\n );\n}\n\nexport function isUint8Array(value: unknown): value is Uint8Array {\n return Object.prototype.toString.call(value) === '[object Uint8Array]';\n}\n\nexport function isBigInt64Array(value: unknown): value is BigInt64Array {\n return Object.prototype.toString.call(value) === '[object BigInt64Array]';\n}\n\nexport function isBigUInt64Array(value: unknown): value is BigUint64Array {\n return Object.prototype.toString.call(value) === '[object BigUint64Array]';\n}\n\nexport function isRegExp(d: unknown): d is RegExp {\n return Object.prototype.toString.call(d) === '[object RegExp]';\n}\n\nexport function isMap(d: unknown): d is Map {\n return Object.prototype.toString.call(d) === '[object Map]';\n}\n\nexport function isDate(d: unknown): d is Date {\n return Object.prototype.toString.call(d) === '[object Date]';\n}\n\nexport type InspectFn = (x: unknown, options?: unknown) => string;\nexport function defaultInspect(x: unknown, _options?: unknown): string {\n return JSON.stringify(x, (k: string, v: unknown) => {\n if (typeof v === 'bigint') {\n return { $numberLong: `${v}` };\n } else if (isMap(v)) {\n return Object.fromEntries(v);\n }\n return v;\n });\n}\n\n/** @internal */\ntype StylizeFunction = (x: string, style: string) => string;\n/** @internal */\nexport function getStylizeFunction(options?: unknown): StylizeFunction | undefined {\n const stylizeExists =\n options != null &&\n typeof options === 'object' &&\n 'stylize' in options &&\n typeof options.stylize === 'function';\n\n if (stylizeExists) {\n return options.stylize as StylizeFunction;\n }\n}\n","/** @internal */\nexport const BSON_MAJOR_VERSION = 6 as const;\n\n/** @internal */\nexport const BSON_INT32_MAX = 0x7fffffff;\n/** @internal */\nexport const BSON_INT32_MIN = -0x80000000;\n/** @internal */\nexport const BSON_INT64_MAX = Math.pow(2, 63) - 1;\n/** @internal */\nexport const BSON_INT64_MIN = -Math.pow(2, 63);\n\n/**\n * Any integer up to 2^53 can be precisely represented by a double.\n * @internal\n */\nexport const JS_INT_MAX = Math.pow(2, 53);\n\n/**\n * Any integer down to -2^53 can be precisely represented by a double.\n * @internal\n */\nexport const JS_INT_MIN = -Math.pow(2, 53);\n\n/** Number BSON Type @internal */\nexport const BSON_DATA_NUMBER = 1;\n\n/** String BSON Type @internal */\nexport const BSON_DATA_STRING = 2;\n\n/** Object BSON Type @internal */\nexport const BSON_DATA_OBJECT = 3;\n\n/** Array BSON Type @internal */\nexport const BSON_DATA_ARRAY = 4;\n\n/** Binary BSON Type @internal */\nexport const BSON_DATA_BINARY = 5;\n\n/** Binary BSON Type @internal */\nexport const BSON_DATA_UNDEFINED = 6;\n\n/** ObjectId BSON Type @internal */\nexport const BSON_DATA_OID = 7;\n\n/** Boolean BSON Type @internal */\nexport const BSON_DATA_BOOLEAN = 8;\n\n/** Date BSON Type @internal */\nexport const BSON_DATA_DATE = 9;\n\n/** null BSON Type @internal */\nexport const BSON_DATA_NULL = 10;\n\n/** RegExp BSON Type @internal */\nexport const BSON_DATA_REGEXP = 11;\n\n/** Code BSON Type @internal */\nexport const BSON_DATA_DBPOINTER = 12;\n\n/** Code BSON Type @internal */\nexport const BSON_DATA_CODE = 13;\n\n/** Symbol BSON Type @internal */\nexport const BSON_DATA_SYMBOL = 14;\n\n/** Code with Scope BSON Type @internal */\nexport const BSON_DATA_CODE_W_SCOPE = 15;\n\n/** 32 bit Integer BSON Type @internal */\nexport const BSON_DATA_INT = 16;\n\n/** Timestamp BSON Type @internal */\nexport const BSON_DATA_TIMESTAMP = 17;\n\n/** Long BSON Type @internal */\nexport const BSON_DATA_LONG = 18;\n\n/** Decimal128 BSON Type @internal */\nexport const BSON_DATA_DECIMAL128 = 19;\n\n/** MinKey BSON Type @internal */\nexport const BSON_DATA_MIN_KEY = 0xff;\n\n/** MaxKey BSON Type @internal */\nexport const BSON_DATA_MAX_KEY = 0x7f;\n\n/** Binary Default Type @internal */\nexport const BSON_BINARY_SUBTYPE_DEFAULT = 0;\n\n/** Binary Function Type @internal */\nexport const BSON_BINARY_SUBTYPE_FUNCTION = 1;\n\n/** Binary Byte Array Type @internal */\nexport const BSON_BINARY_SUBTYPE_BYTE_ARRAY = 2;\n\n/** Binary Deprecated UUID Type @deprecated Please use BSON_BINARY_SUBTYPE_UUID_NEW @internal */\nexport const BSON_BINARY_SUBTYPE_UUID = 3;\n\n/** Binary UUID Type @internal */\nexport const BSON_BINARY_SUBTYPE_UUID_NEW = 4;\n\n/** Binary MD5 Type @internal */\nexport const BSON_BINARY_SUBTYPE_MD5 = 5;\n\n/** Encrypted BSON type @internal */\nexport const BSON_BINARY_SUBTYPE_ENCRYPTED = 6;\n\n/** Column BSON type @internal */\nexport const BSON_BINARY_SUBTYPE_COLUMN = 7;\n\n/** Binary User Defined Type @internal */\nexport const BSON_BINARY_SUBTYPE_USER_DEFINED = 128;\n\n/** @public */\nexport const BSONType = Object.freeze({\n double: 1,\n string: 2,\n object: 3,\n array: 4,\n binData: 5,\n undefined: 6,\n objectId: 7,\n bool: 8,\n date: 9,\n null: 10,\n regex: 11,\n dbPointer: 12,\n javascript: 13,\n symbol: 14,\n javascriptWithScope: 15,\n int: 16,\n timestamp: 17,\n long: 18,\n decimal: 19,\n minKey: -1,\n maxKey: 127\n} as const);\n\n/** @public */\nexport type BSONType = (typeof BSONType)[keyof typeof BSONType];\n","import { BSON_MAJOR_VERSION } from './constants';\n\n/**\n * @public\n * @category Error\n *\n * `BSONError` objects are thrown when BSON ecounters an error.\n *\n * This is the parent class for all the other errors thrown by this library.\n */\nexport class BSONError extends Error {\n /**\n * @internal\n * The underlying algorithm for isBSONError may change to improve how strict it is\n * about determining if an input is a BSONError. But it must remain backwards compatible\n * with previous minors & patches of the current major version.\n */\n protected get bsonError(): true {\n return true;\n }\n\n override get name(): string {\n return 'BSONError';\n }\n\n constructor(message: string) {\n super(message);\n }\n\n /**\n * @public\n *\n * All errors thrown from the BSON library inherit from `BSONError`.\n * This method can assist with determining if an error originates from the BSON library\n * even if it does not pass an `instanceof` check against this class' constructor.\n *\n * @param value - any javascript value that needs type checking\n */\n public static isBSONError(value: unknown): value is BSONError {\n return (\n value != null &&\n typeof value === 'object' &&\n 'bsonError' in value &&\n value.bsonError === true &&\n // Do not access the following properties, just check existence\n 'name' in value &&\n 'message' in value &&\n 'stack' in value\n );\n }\n}\n\n/**\n * @public\n * @category Error\n */\nexport class BSONVersionError extends BSONError {\n get name(): 'BSONVersionError' {\n return 'BSONVersionError';\n }\n\n constructor() {\n super(`Unsupported BSON version, bson types must be from bson ${BSON_MAJOR_VERSION}.x.x`);\n }\n}\n\n/**\n * @public\n * @category Error\n *\n * An error generated when BSON functions encounter an unexpected input\n * or reaches an unexpected/invalid internal state\n *\n */\nexport class BSONRuntimeError extends BSONError {\n get name(): 'BSONRuntimeError' {\n return 'BSONRuntimeError';\n }\n\n constructor(message: string) {\n super(message);\n }\n}\n","import { BSONError } from '../error';\n\ntype NodeJsEncoding = 'base64' | 'hex' | 'utf8' | 'binary';\ntype NodeJsBuffer = ArrayBufferView &\n Uint8Array & {\n write(string: string, offset: number, length: undefined, encoding: 'utf8'): number;\n copy(target: Uint8Array, targetStart: number, sourceStart: number, sourceEnd: number): number;\n toString: (this: Uint8Array, encoding: NodeJsEncoding, start?: number, end?: number) => string;\n equals: (this: Uint8Array, other: Uint8Array) => boolean;\n };\ntype NodeJsBufferConstructor = Omit & {\n alloc: (size: number) => NodeJsBuffer;\n from(array: number[]): NodeJsBuffer;\n from(array: Uint8Array): NodeJsBuffer;\n from(array: ArrayBuffer): NodeJsBuffer;\n from(array: ArrayBuffer, byteOffset: number, byteLength: number): NodeJsBuffer;\n from(base64: string, encoding: NodeJsEncoding): NodeJsBuffer;\n byteLength(input: string, encoding: 'utf8'): number;\n isBuffer(value: unknown): value is NodeJsBuffer;\n};\n\n// This can be nullish, but we gate the nodejs functions on being exported whether or not this exists\n// Node.js global\ndeclare const Buffer: NodeJsBufferConstructor;\ndeclare const require: (mod: 'crypto') => { randomBytes: (byteLength: number) => Uint8Array };\n\n/** @internal */\nexport function nodejsMathRandomBytes(byteLength: number) {\n return nodeJsByteUtils.fromNumberArray(\n Array.from({ length: byteLength }, () => Math.floor(Math.random() * 256))\n );\n}\n\n/**\n * @internal\n * WARNING: REQUIRE WILL BE REWRITTEN\n *\n * This code is carefully used by require_rewriter.mjs any modifications must be reflected in the plugin.\n *\n * @remarks\n * \"crypto\" is the only dependency BSON needs. This presents a problem for creating a bundle of the BSON library\n * in an es module format that can be used both on the browser and in Node.js. In Node.js when BSON is imported as\n * an es module, there will be no global require function defined, making the code below fallback to the much less desireable math.random bytes.\n * In order to make our es module bundle work as expected on Node.js we need to change this `require()` to a dynamic import, and the dynamic\n * import must be top-level awaited since es modules are async. So we rely on a custom rollup plugin to seek out the following lines of code\n * and replace `require` with `await import` and the IIFE line (`nodejsRandomBytes = (() => { ... })()`) with `nodejsRandomBytes = await (async () => { ... })()`\n * when generating an es module bundle.\n */\nconst nodejsRandomBytes: (byteLength: number) => Uint8Array = (() => {\n try {\n return require('crypto').randomBytes;\n } catch {\n return nodejsMathRandomBytes;\n }\n})();\n\n/** @internal */\nexport const nodeJsByteUtils = {\n toLocalBufferType(potentialBuffer: Uint8Array | NodeJsBuffer | ArrayBuffer): NodeJsBuffer {\n if (Buffer.isBuffer(potentialBuffer)) {\n return potentialBuffer;\n }\n\n if (ArrayBuffer.isView(potentialBuffer)) {\n return Buffer.from(\n potentialBuffer.buffer,\n potentialBuffer.byteOffset,\n potentialBuffer.byteLength\n );\n }\n\n const stringTag =\n potentialBuffer?.[Symbol.toStringTag] ?? Object.prototype.toString.call(potentialBuffer);\n if (\n stringTag === 'ArrayBuffer' ||\n stringTag === 'SharedArrayBuffer' ||\n stringTag === '[object ArrayBuffer]' ||\n stringTag === '[object SharedArrayBuffer]'\n ) {\n return Buffer.from(potentialBuffer);\n }\n\n throw new BSONError(`Cannot create Buffer from ${String(potentialBuffer)}`);\n },\n\n allocate(size: number): NodeJsBuffer {\n return Buffer.alloc(size);\n },\n\n equals(a: Uint8Array, b: Uint8Array): boolean {\n return nodeJsByteUtils.toLocalBufferType(a).equals(b);\n },\n\n fromNumberArray(array: number[]): NodeJsBuffer {\n return Buffer.from(array);\n },\n\n fromBase64(base64: string): NodeJsBuffer {\n return Buffer.from(base64, 'base64');\n },\n\n toBase64(buffer: Uint8Array): string {\n return nodeJsByteUtils.toLocalBufferType(buffer).toString('base64');\n },\n\n /** **Legacy** binary strings are an outdated method of data transfer. Do not add public API support for interpreting this format */\n fromISO88591(codePoints: string): NodeJsBuffer {\n return Buffer.from(codePoints, 'binary');\n },\n\n /** **Legacy** binary strings are an outdated method of data transfer. Do not add public API support for interpreting this format */\n toISO88591(buffer: Uint8Array): string {\n return nodeJsByteUtils.toLocalBufferType(buffer).toString('binary');\n },\n\n fromHex(hex: string): NodeJsBuffer {\n return Buffer.from(hex, 'hex');\n },\n\n toHex(buffer: Uint8Array): string {\n return nodeJsByteUtils.toLocalBufferType(buffer).toString('hex');\n },\n\n fromUTF8(text: string): NodeJsBuffer {\n return Buffer.from(text, 'utf8');\n },\n\n toUTF8(buffer: Uint8Array, start: number, end: number): string {\n return nodeJsByteUtils.toLocalBufferType(buffer).toString('utf8', start, end);\n },\n\n utf8ByteLength(input: string): number {\n return Buffer.byteLength(input, 'utf8');\n },\n\n encodeUTF8Into(buffer: Uint8Array, source: string, byteOffset: number): number {\n return nodeJsByteUtils.toLocalBufferType(buffer).write(source, byteOffset, undefined, 'utf8');\n },\n\n randomBytes: nodejsRandomBytes\n};\n","import { BSONError } from '../error';\n\ntype TextDecoder = {\n readonly encoding: string;\n readonly fatal: boolean;\n readonly ignoreBOM: boolean;\n decode(input?: Uint8Array): string;\n};\ntype TextDecoderConstructor = {\n new (label: 'utf8', options: { fatal: boolean; ignoreBOM?: boolean }): TextDecoder;\n};\n\ntype TextEncoder = {\n readonly encoding: string;\n encode(input?: string): Uint8Array;\n};\ntype TextEncoderConstructor = {\n new (): TextEncoder;\n};\n\n// Web global\ndeclare const TextDecoder: TextDecoderConstructor;\ndeclare const TextEncoder: TextEncoderConstructor;\ndeclare const atob: (base64: string) => string;\ndeclare const btoa: (binary: string) => string;\n\ntype ArrayBufferViewWithTag = ArrayBufferView & {\n [Symbol.toStringTag]?: string;\n};\n\nfunction isReactNative() {\n const { navigator } = globalThis as { navigator?: { product?: string } };\n return typeof navigator === 'object' && navigator.product === 'ReactNative';\n}\n\n/** @internal */\nexport function webMathRandomBytes(byteLength: number) {\n if (byteLength < 0) {\n throw new RangeError(`The argument 'byteLength' is invalid. Received ${byteLength}`);\n }\n return webByteUtils.fromNumberArray(\n Array.from({ length: byteLength }, () => Math.floor(Math.random() * 256))\n );\n}\n\n/** @internal */\nconst webRandomBytes: (byteLength: number) => Uint8Array = (() => {\n const { crypto } = globalThis as {\n crypto?: { getRandomValues?: (space: Uint8Array) => Uint8Array };\n };\n if (crypto != null && typeof crypto.getRandomValues === 'function') {\n return (byteLength: number) => {\n // @ts-expect-error: crypto.getRandomValues cannot actually be null here\n // You cannot separate getRandomValues from crypto (need to have this === crypto)\n return crypto.getRandomValues(webByteUtils.allocate(byteLength));\n };\n } else {\n if (isReactNative()) {\n const { console } = globalThis as { console?: { warn?: (message: string) => void } };\n console?.warn?.(\n 'BSON: For React Native please polyfill crypto.getRandomValues, e.g. using: https://www.npmjs.com/package/react-native-get-random-values.'\n );\n }\n return webMathRandomBytes;\n }\n})();\n\nconst HEX_DIGIT = /(\\d|[a-f])/i;\n\n/** @internal */\nexport const webByteUtils = {\n toLocalBufferType(\n potentialUint8array: Uint8Array | ArrayBufferViewWithTag | ArrayBuffer\n ): Uint8Array {\n const stringTag =\n potentialUint8array?.[Symbol.toStringTag] ??\n Object.prototype.toString.call(potentialUint8array);\n\n if (stringTag === 'Uint8Array') {\n return potentialUint8array as Uint8Array;\n }\n\n if (ArrayBuffer.isView(potentialUint8array)) {\n return new Uint8Array(\n potentialUint8array.buffer.slice(\n potentialUint8array.byteOffset,\n potentialUint8array.byteOffset + potentialUint8array.byteLength\n )\n );\n }\n\n if (\n stringTag === 'ArrayBuffer' ||\n stringTag === 'SharedArrayBuffer' ||\n stringTag === '[object ArrayBuffer]' ||\n stringTag === '[object SharedArrayBuffer]'\n ) {\n return new Uint8Array(potentialUint8array);\n }\n\n throw new BSONError(`Cannot make a Uint8Array from ${String(potentialUint8array)}`);\n },\n\n allocate(size: number): Uint8Array {\n if (typeof size !== 'number') {\n throw new TypeError(`The \"size\" argument must be of type number. Received ${String(size)}`);\n }\n return new Uint8Array(size);\n },\n\n equals(a: Uint8Array, b: Uint8Array): boolean {\n if (a.byteLength !== b.byteLength) {\n return false;\n }\n for (let i = 0; i < a.byteLength; i++) {\n if (a[i] !== b[i]) {\n return false;\n }\n }\n return true;\n },\n\n fromNumberArray(array: number[]): Uint8Array {\n return Uint8Array.from(array);\n },\n\n fromBase64(base64: string): Uint8Array {\n return Uint8Array.from(atob(base64), c => c.charCodeAt(0));\n },\n\n toBase64(uint8array: Uint8Array): string {\n return btoa(webByteUtils.toISO88591(uint8array));\n },\n\n /** **Legacy** binary strings are an outdated method of data transfer. Do not add public API support for interpreting this format */\n fromISO88591(codePoints: string): Uint8Array {\n return Uint8Array.from(codePoints, c => c.charCodeAt(0) & 0xff);\n },\n\n /** **Legacy** binary strings are an outdated method of data transfer. Do not add public API support for interpreting this format */\n toISO88591(uint8array: Uint8Array): string {\n return Array.from(Uint16Array.from(uint8array), b => String.fromCharCode(b)).join('');\n },\n\n fromHex(hex: string): Uint8Array {\n const evenLengthHex = hex.length % 2 === 0 ? hex : hex.slice(0, hex.length - 1);\n const buffer = [];\n\n for (let i = 0; i < evenLengthHex.length; i += 2) {\n const firstDigit = evenLengthHex[i];\n const secondDigit = evenLengthHex[i + 1];\n\n if (!HEX_DIGIT.test(firstDigit)) {\n break;\n }\n if (!HEX_DIGIT.test(secondDigit)) {\n break;\n }\n\n const hexDigit = Number.parseInt(`${firstDigit}${secondDigit}`, 16);\n buffer.push(hexDigit);\n }\n\n return Uint8Array.from(buffer);\n },\n\n toHex(uint8array: Uint8Array): string {\n return Array.from(uint8array, byte => byte.toString(16).padStart(2, '0')).join('');\n },\n\n fromUTF8(text: string): Uint8Array {\n return new TextEncoder().encode(text);\n },\n\n toUTF8(uint8array: Uint8Array, start: number, end: number): string {\n return new TextDecoder('utf8', { fatal: false }).decode(uint8array.slice(start, end));\n },\n\n utf8ByteLength(input: string): number {\n return webByteUtils.fromUTF8(input).byteLength;\n },\n\n encodeUTF8Into(buffer: Uint8Array, source: string, byteOffset: number): number {\n const bytes = webByteUtils.fromUTF8(source);\n buffer.set(bytes, byteOffset);\n return bytes.byteLength;\n },\n\n randomBytes: webRandomBytes\n};\n","import { nodeJsByteUtils } from './node_byte_utils';\nimport { webByteUtils } from './web_byte_utils';\n\n/** @internal */\nexport type ByteUtils = {\n /** Transforms the input to an instance of Buffer if running on node, otherwise Uint8Array */\n toLocalBufferType(buffer: Uint8Array | ArrayBufferView | ArrayBuffer): Uint8Array;\n /** Create empty space of size */\n allocate: (size: number) => Uint8Array;\n /** Check if two Uint8Arrays are deep equal */\n equals: (a: Uint8Array, b: Uint8Array) => boolean;\n /** Check if two Uint8Arrays are deep equal */\n fromNumberArray: (array: number[]) => Uint8Array;\n /** Create a Uint8Array from a base64 string */\n fromBase64: (base64: string) => Uint8Array;\n /** Create a base64 string from bytes */\n toBase64: (buffer: Uint8Array) => string;\n /** **Legacy** binary strings are an outdated method of data transfer. Do not add public API support for interpreting this format */\n fromISO88591: (codePoints: string) => Uint8Array;\n /** **Legacy** binary strings are an outdated method of data transfer. Do not add public API support for interpreting this format */\n toISO88591: (buffer: Uint8Array) => string;\n /** Create a Uint8Array from a hex string */\n fromHex: (hex: string) => Uint8Array;\n /** Create a lowercase hex string from bytes */\n toHex: (buffer: Uint8Array) => string;\n /** Create a Uint8Array containing utf8 code units from a string */\n fromUTF8: (text: string) => Uint8Array;\n /** Create a string from utf8 code units */\n toUTF8: (buffer: Uint8Array, start: number, end: number) => string;\n /** Get the utf8 code unit count from a string if it were to be transformed to utf8 */\n utf8ByteLength: (input: string) => number;\n /** Encode UTF8 bytes generated from `source` string into `destination` at byteOffset. Returns the number of bytes encoded. */\n encodeUTF8Into(destination: Uint8Array, source: string, byteOffset: number): number;\n /** Generate a Uint8Array filled with random bytes with byteLength */\n randomBytes(byteLength: number): Uint8Array;\n};\n\ndeclare const Buffer: { new (): unknown; prototype?: { _isBuffer?: boolean } } | undefined;\n\n/**\n * Check that a global Buffer exists that is a function and\n * does not have a '_isBuffer' property defined on the prototype\n * (this is to prevent using the npm buffer)\n */\nconst hasGlobalBuffer = typeof Buffer === 'function' && Buffer.prototype?._isBuffer !== true;\n\n/**\n * This is the only ByteUtils that should be used across the rest of the BSON library.\n *\n * The type annotation is important here, it asserts that each of the platform specific\n * utils implementations are compatible with the common one.\n *\n * @internal\n */\nexport const ByteUtils: ByteUtils = hasGlobalBuffer ? nodeJsByteUtils : webByteUtils;\n\nexport class BSONDataView extends DataView {\n static fromUint8Array(input: Uint8Array) {\n return new DataView(input.buffer, input.byteOffset, input.byteLength);\n }\n}\n","import { BSON_MAJOR_VERSION } from './constants';\nimport { type InspectFn } from './parser/utils';\n\n/** @public */\nexport abstract class BSONValue {\n /** @public */\n public abstract get _bsontype(): string;\n\n /** @internal */\n get [Symbol.for('@@mdb.bson.version')](): typeof BSON_MAJOR_VERSION {\n return BSON_MAJOR_VERSION;\n }\n\n [Symbol.for('nodejs.util.inspect.custom')](\n depth?: number,\n options?: unknown,\n inspect?: InspectFn\n ): string {\n return this.inspect(depth, options, inspect);\n }\n\n /**\n * @public\n * Prints a human-readable string of BSON value information\n * If invoked manually without node.js.inspect function, this will default to a modified JSON.stringify\n */\n public abstract inspect(depth?: number, options?: unknown, inspect?: InspectFn): string;\n\n /** @internal */\n abstract toExtendedJSON(): unknown;\n}\n","import { type InspectFn, defaultInspect, isAnyArrayBuffer, isUint8Array } from './parser/utils';\nimport type { EJSONOptions } from './extended_json';\nimport { BSONError } from './error';\nimport { BSON_BINARY_SUBTYPE_UUID_NEW } from './constants';\nimport { ByteUtils } from './utils/byte_utils';\nimport { BSONValue } from './bson_value';\n\n/** @public */\nexport type BinarySequence = Uint8Array | number[];\n\n/** @public */\nexport interface BinaryExtendedLegacy {\n $type: string;\n $binary: string;\n}\n\n/** @public */\nexport interface BinaryExtended {\n $binary: {\n subType: string;\n base64: string;\n };\n}\n\n/**\n * A class representation of the BSON Binary type.\n * @public\n * @category BSONType\n */\nexport class Binary extends BSONValue {\n get _bsontype(): 'Binary' {\n return 'Binary';\n }\n\n /**\n * Binary default subtype\n * @internal\n */\n private static readonly BSON_BINARY_SUBTYPE_DEFAULT = 0;\n\n /** Initial buffer default size */\n static readonly BUFFER_SIZE = 256;\n /** Default BSON type */\n static readonly SUBTYPE_DEFAULT = 0;\n /** Function BSON type */\n static readonly SUBTYPE_FUNCTION = 1;\n /** Byte Array BSON type */\n static readonly SUBTYPE_BYTE_ARRAY = 2;\n /** Deprecated UUID BSON type @deprecated Please use SUBTYPE_UUID */\n static readonly SUBTYPE_UUID_OLD = 3;\n /** UUID BSON type */\n static readonly SUBTYPE_UUID = 4;\n /** MD5 BSON type */\n static readonly SUBTYPE_MD5 = 5;\n /** Encrypted BSON type */\n static readonly SUBTYPE_ENCRYPTED = 6;\n /** Column BSON type */\n static readonly SUBTYPE_COLUMN = 7;\n /** User BSON type */\n static readonly SUBTYPE_USER_DEFINED = 128;\n\n buffer!: Uint8Array;\n sub_type!: number;\n position!: number;\n\n /**\n * Create a new Binary instance.\n * @param buffer - a buffer object containing the binary data.\n * @param subType - the option binary type.\n */\n constructor(buffer?: BinarySequence, subType?: number) {\n super();\n if (\n !(buffer == null) &&\n typeof buffer === 'string' &&\n !ArrayBuffer.isView(buffer) &&\n !isAnyArrayBuffer(buffer) &&\n !Array.isArray(buffer)\n ) {\n throw new BSONError('Binary can only be constructed from Uint8Array or number[]');\n }\n\n this.sub_type = subType ?? Binary.BSON_BINARY_SUBTYPE_DEFAULT;\n\n if (buffer == null) {\n // create an empty binary buffer\n this.buffer = ByteUtils.allocate(Binary.BUFFER_SIZE);\n this.position = 0;\n } else {\n this.buffer = Array.isArray(buffer)\n ? ByteUtils.fromNumberArray(buffer)\n : ByteUtils.toLocalBufferType(buffer);\n this.position = this.buffer.byteLength;\n }\n }\n\n /**\n * Updates this binary with byte_value.\n *\n * @param byteValue - a single byte we wish to write.\n */\n put(byteValue: string | number | Uint8Array | number[]): void {\n // If it's a string and a has more than one character throw an error\n if (typeof byteValue === 'string' && byteValue.length !== 1) {\n throw new BSONError('only accepts single character String');\n } else if (typeof byteValue !== 'number' && byteValue.length !== 1)\n throw new BSONError('only accepts single character Uint8Array or Array');\n\n // Decode the byte value once\n let decodedByte: number;\n if (typeof byteValue === 'string') {\n decodedByte = byteValue.charCodeAt(0);\n } else if (typeof byteValue === 'number') {\n decodedByte = byteValue;\n } else {\n decodedByte = byteValue[0];\n }\n\n if (decodedByte < 0 || decodedByte > 255) {\n throw new BSONError('only accepts number in a valid unsigned byte range 0-255');\n }\n\n if (this.buffer.byteLength > this.position) {\n this.buffer[this.position++] = decodedByte;\n } else {\n const newSpace = ByteUtils.allocate(Binary.BUFFER_SIZE + this.buffer.length);\n newSpace.set(this.buffer, 0);\n this.buffer = newSpace;\n this.buffer[this.position++] = decodedByte;\n }\n }\n\n /**\n * Writes a buffer to the binary.\n *\n * @param sequence - a string or buffer to be written to the Binary BSON object.\n * @param offset - specify the binary of where to write the content.\n */\n write(sequence: BinarySequence, offset: number): void {\n offset = typeof offset === 'number' ? offset : this.position;\n\n // If the buffer is to small let's extend the buffer\n if (this.buffer.byteLength < offset + sequence.length) {\n const newSpace = ByteUtils.allocate(this.buffer.byteLength + sequence.length);\n newSpace.set(this.buffer, 0);\n\n // Assign the new buffer\n this.buffer = newSpace;\n }\n\n if (ArrayBuffer.isView(sequence)) {\n this.buffer.set(ByteUtils.toLocalBufferType(sequence), offset);\n this.position =\n offset + sequence.byteLength > this.position ? offset + sequence.length : this.position;\n } else if (typeof sequence === 'string') {\n throw new BSONError('input cannot be string');\n }\n }\n\n /**\n * Reads **length** bytes starting at **position**.\n *\n * @param position - read from the given position in the Binary.\n * @param length - the number of bytes to read.\n */\n read(position: number, length: number): BinarySequence {\n length = length && length > 0 ? length : this.position;\n\n // Let's return the data based on the type we have\n return this.buffer.slice(position, position + length);\n }\n\n /** returns a view of the binary value as a Uint8Array */\n value(): Uint8Array {\n // Optimize to serialize for the situation where the data == size of buffer\n return this.buffer.length === this.position\n ? this.buffer\n : this.buffer.subarray(0, this.position);\n }\n\n /** the length of the binary sequence */\n length(): number {\n return this.position;\n }\n\n toJSON(): string {\n return ByteUtils.toBase64(this.buffer);\n }\n\n toString(encoding?: 'hex' | 'base64' | 'utf8' | 'utf-8'): string {\n if (encoding === 'hex') return ByteUtils.toHex(this.buffer);\n if (encoding === 'base64') return ByteUtils.toBase64(this.buffer);\n if (encoding === 'utf8' || encoding === 'utf-8')\n return ByteUtils.toUTF8(this.buffer, 0, this.buffer.byteLength);\n return ByteUtils.toUTF8(this.buffer, 0, this.buffer.byteLength);\n }\n\n /** @internal */\n toExtendedJSON(options?: EJSONOptions): BinaryExtendedLegacy | BinaryExtended {\n options = options || {};\n const base64String = ByteUtils.toBase64(this.buffer);\n\n const subType = Number(this.sub_type).toString(16);\n if (options.legacy) {\n return {\n $binary: base64String,\n $type: subType.length === 1 ? '0' + subType : subType\n };\n }\n return {\n $binary: {\n base64: base64String,\n subType: subType.length === 1 ? '0' + subType : subType\n }\n };\n }\n\n toUUID(): UUID {\n if (this.sub_type === Binary.SUBTYPE_UUID) {\n return new UUID(this.buffer.slice(0, this.position));\n }\n\n throw new BSONError(\n `Binary sub_type \"${this.sub_type}\" is not supported for converting to UUID. Only \"${Binary.SUBTYPE_UUID}\" is currently supported.`\n );\n }\n\n /** Creates an Binary instance from a hex digit string */\n static createFromHexString(hex: string, subType?: number): Binary {\n return new Binary(ByteUtils.fromHex(hex), subType);\n }\n\n /** Creates an Binary instance from a base64 string */\n static createFromBase64(base64: string, subType?: number): Binary {\n return new Binary(ByteUtils.fromBase64(base64), subType);\n }\n\n /** @internal */\n static fromExtendedJSON(\n doc: BinaryExtendedLegacy | BinaryExtended | UUIDExtended,\n options?: EJSONOptions\n ): Binary {\n options = options || {};\n let data: Uint8Array | undefined;\n let type;\n if ('$binary' in doc) {\n if (options.legacy && typeof doc.$binary === 'string' && '$type' in doc) {\n type = doc.$type ? parseInt(doc.$type, 16) : 0;\n data = ByteUtils.fromBase64(doc.$binary);\n } else {\n if (typeof doc.$binary !== 'string') {\n type = doc.$binary.subType ? parseInt(doc.$binary.subType, 16) : 0;\n data = ByteUtils.fromBase64(doc.$binary.base64);\n }\n }\n } else if ('$uuid' in doc) {\n type = 4;\n data = UUID.bytesFromString(doc.$uuid);\n }\n if (!data) {\n throw new BSONError(`Unexpected Binary Extended JSON format ${JSON.stringify(doc)}`);\n }\n return type === BSON_BINARY_SUBTYPE_UUID_NEW ? new UUID(data) : new Binary(data, type);\n }\n\n inspect(depth?: number, options?: unknown, inspect?: InspectFn): string {\n inspect ??= defaultInspect;\n const base64 = ByteUtils.toBase64(this.buffer.subarray(0, this.position));\n const base64Arg = inspect(base64, options);\n const subTypeArg = inspect(this.sub_type, options);\n return `Binary.createFromBase64(${base64Arg}, ${subTypeArg})`;\n }\n}\n\n/** @public */\nexport type UUIDExtended = {\n $uuid: string;\n};\n\nconst UUID_BYTE_LENGTH = 16;\nconst UUID_WITHOUT_DASHES = /^[0-9A-F]{32}$/i;\nconst UUID_WITH_DASHES = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i;\n\n/**\n * A class representation of the BSON UUID type.\n * @public\n */\nexport class UUID extends Binary {\n /**\n * Create a UUID type\n *\n * When the argument to the constructor is omitted a random v4 UUID will be generated.\n *\n * @param input - Can be a 32 or 36 character hex string (dashes excluded/included) or a 16 byte binary Buffer.\n */\n constructor(input?: string | Uint8Array | UUID) {\n let bytes: Uint8Array;\n if (input == null) {\n bytes = UUID.generate();\n } else if (input instanceof UUID) {\n bytes = ByteUtils.toLocalBufferType(new Uint8Array(input.buffer));\n } else if (ArrayBuffer.isView(input) && input.byteLength === UUID_BYTE_LENGTH) {\n bytes = ByteUtils.toLocalBufferType(input);\n } else if (typeof input === 'string') {\n bytes = UUID.bytesFromString(input);\n } else {\n throw new BSONError(\n '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).'\n );\n }\n super(bytes, BSON_BINARY_SUBTYPE_UUID_NEW);\n }\n\n /**\n * The UUID bytes\n * @readonly\n */\n get id(): Uint8Array {\n return this.buffer;\n }\n\n set id(value: Uint8Array) {\n this.buffer = value;\n }\n\n /**\n * Returns the UUID id as a 32 or 36 character hex string representation, excluding/including dashes (defaults to 36 character dash separated)\n * @param includeDashes - should the string exclude dash-separators.\n */\n toHexString(includeDashes = true): string {\n if (includeDashes) {\n return [\n ByteUtils.toHex(this.buffer.subarray(0, 4)),\n ByteUtils.toHex(this.buffer.subarray(4, 6)),\n ByteUtils.toHex(this.buffer.subarray(6, 8)),\n ByteUtils.toHex(this.buffer.subarray(8, 10)),\n ByteUtils.toHex(this.buffer.subarray(10, 16))\n ].join('-');\n }\n return ByteUtils.toHex(this.buffer);\n }\n\n /**\n * Converts the id into a 36 character (dashes included) hex string, unless a encoding is specified.\n */\n toString(encoding?: 'hex' | 'base64'): string {\n if (encoding === 'hex') return ByteUtils.toHex(this.id);\n if (encoding === 'base64') return ByteUtils.toBase64(this.id);\n return this.toHexString();\n }\n\n /**\n * Converts the id into its JSON string representation.\n * A 36 character (dashes included) hex string in the format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\n */\n toJSON(): string {\n return this.toHexString();\n }\n\n /**\n * Compares the equality of this UUID with `otherID`.\n *\n * @param otherId - UUID instance to compare against.\n */\n equals(otherId: string | Uint8Array | UUID): boolean {\n if (!otherId) {\n return false;\n }\n\n if (otherId instanceof UUID) {\n return ByteUtils.equals(otherId.id, this.id);\n }\n\n try {\n return ByteUtils.equals(new UUID(otherId).id, this.id);\n } catch {\n return false;\n }\n }\n\n /**\n * Creates a Binary instance from the current UUID.\n */\n toBinary(): Binary {\n return new Binary(this.id, Binary.SUBTYPE_UUID);\n }\n\n /**\n * Generates a populated buffer containing a v4 uuid\n */\n static generate(): Uint8Array {\n const bytes = ByteUtils.randomBytes(UUID_BYTE_LENGTH);\n\n // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n // Kindly borrowed from https://github.com/uuidjs/uuid/blob/master/src/v4.js\n bytes[6] = (bytes[6] & 0x0f) | 0x40;\n bytes[8] = (bytes[8] & 0x3f) | 0x80;\n\n return bytes;\n }\n\n /**\n * Checks if a value is a valid bson UUID\n * @param input - UUID, string or Buffer to validate.\n */\n static isValid(input: string | Uint8Array | UUID | Binary): boolean {\n if (!input) {\n return false;\n }\n\n if (typeof input === 'string') {\n return UUID.isValidUUIDString(input);\n }\n\n if (isUint8Array(input)) {\n return input.byteLength === UUID_BYTE_LENGTH;\n }\n\n return (\n input._bsontype === 'Binary' &&\n input.sub_type === this.SUBTYPE_UUID &&\n input.buffer.byteLength === 16\n );\n }\n\n /**\n * Creates an UUID from a hex string representation of an UUID.\n * @param hexString - 32 or 36 character hex string (dashes excluded/included).\n */\n static override createFromHexString(hexString: string): UUID {\n const buffer = UUID.bytesFromString(hexString);\n return new UUID(buffer);\n }\n\n /** Creates an UUID from a base64 string representation of an UUID. */\n static override createFromBase64(base64: string): UUID {\n return new UUID(ByteUtils.fromBase64(base64));\n }\n\n /** @internal */\n static bytesFromString(representation: string) {\n if (!UUID.isValidUUIDString(representation)) {\n throw new BSONError(\n 'UUID string representation must be 32 hex digits or canonical hyphenated representation'\n );\n }\n return ByteUtils.fromHex(representation.replace(/-/g, ''));\n }\n\n /**\n * @internal\n *\n * Validates a string to be a hex digit sequence with or without dashes.\n * The canonical hyphenated representation of a uuid is hex in 8-4-4-4-12 groups.\n */\n static isValidUUIDString(representation: string) {\n return UUID_WITHOUT_DASHES.test(representation) || UUID_WITH_DASHES.test(representation);\n }\n\n /**\n * Converts to a string representation of this Id.\n *\n * @returns return the 36 character hex string representation.\n *\n */\n inspect(depth?: number, options?: unknown, inspect?: InspectFn): string {\n inspect ??= defaultInspect;\n return `new UUID(${inspect(this.toHexString(), options)})`;\n }\n}\n","import type { Document } from './bson';\nimport { BSONValue } from './bson_value';\nimport { type InspectFn, defaultInspect } from './parser/utils';\n\n/** @public */\nexport interface CodeExtended {\n $code: string;\n $scope?: Document;\n}\n\n/**\n * A class representation of the BSON Code type.\n * @public\n * @category BSONType\n */\nexport class Code extends BSONValue {\n get _bsontype(): 'Code' {\n return 'Code';\n }\n\n code: string;\n\n // a code instance having a null scope is what determines whether\n // it is BSONType 0x0D (just code) / 0x0F (code with scope)\n scope: Document | null;\n\n /**\n * @param code - a string or function.\n * @param scope - an optional scope for the function.\n */\n constructor(code: string | Function, scope?: Document | null) {\n super();\n this.code = code.toString();\n this.scope = scope ?? null;\n }\n\n toJSON(): { code: string; scope?: Document } {\n if (this.scope != null) {\n return { code: this.code, scope: this.scope };\n }\n\n return { code: this.code };\n }\n\n /** @internal */\n toExtendedJSON(): CodeExtended {\n if (this.scope) {\n return { $code: this.code, $scope: this.scope };\n }\n\n return { $code: this.code };\n }\n\n /** @internal */\n static fromExtendedJSON(doc: CodeExtended): Code {\n return new Code(doc.$code, doc.$scope);\n }\n\n inspect(depth?: number, options?: unknown, inspect?: InspectFn): string {\n inspect ??= defaultInspect;\n let parametersString = inspect(this.code, options);\n const multiLineFn = parametersString.includes('\\n');\n if (this.scope != null) {\n parametersString += `,${multiLineFn ? '\\n' : ' '}${inspect(this.scope, options)}`;\n }\n const endingNewline = multiLineFn && this.scope === null;\n return `new Code(${multiLineFn ? '\\n' : ''}${parametersString}${endingNewline ? '\\n' : ''})`;\n }\n}\n","import type { Document } from './bson';\nimport { BSONValue } from './bson_value';\nimport type { EJSONOptions } from './extended_json';\nimport type { ObjectId } from './objectid';\nimport { type InspectFn, defaultInspect } from './parser/utils';\n\n/** @public */\nexport interface DBRefLike {\n $ref: string;\n $id: ObjectId;\n $db?: string;\n}\n\n/** @internal */\nexport function isDBRefLike(value: unknown): value is DBRefLike {\n return (\n value != null &&\n typeof value === 'object' &&\n '$id' in value &&\n value.$id != null &&\n '$ref' in value &&\n typeof value.$ref === 'string' &&\n // If '$db' is defined it MUST be a string, otherwise it should be absent\n (!('$db' in value) || ('$db' in value && typeof value.$db === 'string'))\n );\n}\n\n/**\n * A class representation of the BSON DBRef type.\n * @public\n * @category BSONType\n */\nexport class DBRef extends BSONValue {\n get _bsontype(): 'DBRef' {\n return 'DBRef';\n }\n\n collection!: string;\n oid!: ObjectId;\n db?: string;\n fields!: Document;\n\n /**\n * @param collection - the collection name.\n * @param oid - the reference ObjectId.\n * @param db - optional db name, if omitted the reference is local to the current db.\n */\n constructor(collection: string, oid: ObjectId, db?: string, fields?: Document) {\n super();\n // check if namespace has been provided\n const parts = collection.split('.');\n if (parts.length === 2) {\n db = parts.shift();\n // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n collection = parts.shift()!;\n }\n\n this.collection = collection;\n this.oid = oid;\n this.db = db;\n this.fields = fields || {};\n }\n\n // Property provided for compatibility with the 1.x parser\n // the 1.x parser used a \"namespace\" property, while 4.x uses \"collection\"\n\n /** @internal */\n get namespace(): string {\n return this.collection;\n }\n\n set namespace(value: string) {\n this.collection = value;\n }\n\n toJSON(): DBRefLike & Document {\n const o = Object.assign(\n {\n $ref: this.collection,\n $id: this.oid\n },\n this.fields\n );\n\n if (this.db != null) o.$db = this.db;\n return o;\n }\n\n /** @internal */\n toExtendedJSON(options?: EJSONOptions): DBRefLike {\n options = options || {};\n let o: DBRefLike = {\n $ref: this.collection,\n $id: this.oid\n };\n\n if (options.legacy) {\n return o;\n }\n\n if (this.db) o.$db = this.db;\n o = Object.assign(o, this.fields);\n return o;\n }\n\n /** @internal */\n static fromExtendedJSON(doc: DBRefLike): DBRef {\n const copy = Object.assign({}, doc) as Partial;\n delete copy.$ref;\n delete copy.$id;\n delete copy.$db;\n return new DBRef(doc.$ref, doc.$id, doc.$db, copy);\n }\n\n inspect(depth?: number, options?: unknown, inspect?: InspectFn): string {\n inspect ??= defaultInspect;\n\n const args = [\n inspect(this.namespace, options),\n inspect(this.oid, options),\n ...(this.db ? [inspect(this.db, options)] : []),\n ...(Object.keys(this.fields).length > 0 ? [inspect(this.fields, options)] : [])\n ];\n\n args[1] = inspect === defaultInspect ? `new ObjectId(${args[1]})` : args[1];\n\n return `new DBRef(${args.join(', ')})`;\n }\n}\n","import { BSONValue } from './bson_value';\nimport { BSONError } from './error';\nimport type { EJSONOptions } from './extended_json';\nimport { type InspectFn, defaultInspect } from './parser/utils';\nimport type { Timestamp } from './timestamp';\n\ninterface LongWASMHelpers {\n /** Gets the high bits of the last operation performed */\n get_high(this: void): number;\n div_u(\n this: void,\n lowBits: number,\n highBits: number,\n lowBitsDivisor: number,\n highBitsDivisor: number\n ): number;\n div_s(\n this: void,\n lowBits: number,\n highBits: number,\n lowBitsDivisor: number,\n highBitsDivisor: number\n ): number;\n rem_u(\n this: void,\n lowBits: number,\n highBits: number,\n lowBitsDivisor: number,\n highBitsDivisor: number\n ): number;\n rem_s(\n this: void,\n lowBits: number,\n highBits: number,\n lowBitsDivisor: number,\n highBitsDivisor: number\n ): number;\n mul(\n this: void,\n lowBits: number,\n highBits: number,\n lowBitsMultiplier: number,\n highBitsMultiplier: number\n ): number;\n}\n\n/**\n * wasm optimizations, to do native i64 multiplication and divide\n */\nlet wasm: LongWASMHelpers | undefined = undefined;\n\n/* We do not want to have to include DOM types just for this check */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ndeclare const WebAssembly: any;\n\ntry {\n wasm = new WebAssembly.Instance(\n new WebAssembly.Module(\n // prettier-ignore\n 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])\n ),\n {}\n ).exports as unknown as LongWASMHelpers;\n} catch {\n // no wasm support\n}\n\nconst TWO_PWR_16_DBL = 1 << 16;\nconst TWO_PWR_24_DBL = 1 << 24;\nconst TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;\nconst TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;\nconst TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;\n\n/** A cache of the Long representations of small integer values. */\nconst INT_CACHE: { [key: number]: Long } = {};\n\n/** A cache of the Long representations of small unsigned integer values. */\nconst UINT_CACHE: { [key: number]: Long } = {};\n\nconst MAX_INT64_STRING_LENGTH = 20;\n\nconst DECIMAL_REG_EX = /^(\\+?0|(\\+|-)?[1-9][0-9]*)$/;\n\n/** @public */\nexport interface LongExtended {\n $numberLong: string;\n}\n\n/**\n * A class representing a 64-bit integer\n * @public\n * @category BSONType\n * @remarks\n * The internal representation of a long is the two given signed, 32-bit values.\n * We use 32-bit pieces because these are the size of integers on which\n * Javascript performs bit-operations. For operations like addition and\n * multiplication, we split each number into 16 bit pieces, which can easily be\n * multiplied within Javascript's floating-point representation without overflow\n * or change in sign.\n * In the algorithms below, we frequently reduce the negative case to the\n * positive case by negating the input(s) and then post-processing the result.\n * Note that we must ALWAYS check specially whether those values are MIN_VALUE\n * (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as\n * a positive number, it overflows back into a negative). Not handling this\n * case would often result in infinite recursion.\n * Common constant values ZERO, ONE, NEG_ONE, etc. are found as static properties on this class.\n */\nexport class Long extends BSONValue {\n get _bsontype(): 'Long' {\n return 'Long';\n }\n\n /** An indicator used to reliably determine if an object is a Long or not. */\n get __isLong__(): boolean {\n return true;\n }\n\n /**\n * The high 32 bits as a signed value.\n */\n high!: number;\n\n /**\n * The low 32 bits as a signed value.\n */\n low!: number;\n\n /**\n * Whether unsigned or not.\n */\n unsigned!: boolean;\n\n /**\n * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.\n * See the from* functions below for more convenient ways of constructing Longs.\n *\n * Acceptable signatures are:\n * - Long(low, high, unsigned?)\n * - Long(bigint, unsigned?)\n * - Long(string, unsigned?)\n *\n * @param low - The low (signed) 32 bits of the long\n * @param high - The high (signed) 32 bits of the long\n * @param unsigned - Whether unsigned or not, defaults to signed\n */\n constructor(low: number | bigint | string = 0, high?: number | boolean, unsigned?: boolean) {\n super();\n if (typeof low === 'bigint') {\n Object.assign(this, Long.fromBigInt(low, !!high));\n } else if (typeof low === 'string') {\n Object.assign(this, Long.fromString(low, !!high));\n } else {\n this.low = low | 0;\n this.high = (high as number) | 0;\n this.unsigned = !!unsigned;\n }\n }\n\n static TWO_PWR_24 = Long.fromInt(TWO_PWR_24_DBL);\n\n /** Maximum unsigned value. */\n static MAX_UNSIGNED_VALUE = Long.fromBits(0xffffffff | 0, 0xffffffff | 0, true);\n /** Signed zero */\n static ZERO = Long.fromInt(0);\n /** Unsigned zero. */\n static UZERO = Long.fromInt(0, true);\n /** Signed one. */\n static ONE = Long.fromInt(1);\n /** Unsigned one. */\n static UONE = Long.fromInt(1, true);\n /** Signed negative one. */\n static NEG_ONE = Long.fromInt(-1);\n /** Maximum signed value. */\n static MAX_VALUE = Long.fromBits(0xffffffff | 0, 0x7fffffff | 0, false);\n /** Minimum signed value. */\n static MIN_VALUE = Long.fromBits(0, 0x80000000 | 0, false);\n\n /**\n * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits.\n * Each is assumed to use 32 bits.\n * @param lowBits - The low 32 bits\n * @param highBits - The high 32 bits\n * @param unsigned - Whether unsigned or not, defaults to signed\n * @returns The corresponding Long value\n */\n static fromBits(lowBits: number, highBits: number, unsigned?: boolean): Long {\n return new Long(lowBits, highBits, unsigned);\n }\n\n /**\n * Returns a Long representing the given 32 bit integer value.\n * @param value - The 32 bit integer in question\n * @param unsigned - Whether unsigned or not, defaults to signed\n * @returns The corresponding Long value\n */\n static fromInt(value: number, unsigned?: boolean): Long {\n let obj, cachedObj, cache;\n if (unsigned) {\n value >>>= 0;\n if ((cache = 0 <= value && value < 256)) {\n cachedObj = UINT_CACHE[value];\n if (cachedObj) return cachedObj;\n }\n obj = Long.fromBits(value, (value | 0) < 0 ? -1 : 0, true);\n if (cache) UINT_CACHE[value] = obj;\n return obj;\n } else {\n value |= 0;\n if ((cache = -128 <= value && value < 128)) {\n cachedObj = INT_CACHE[value];\n if (cachedObj) return cachedObj;\n }\n obj = Long.fromBits(value, value < 0 ? -1 : 0, false);\n if (cache) INT_CACHE[value] = obj;\n return obj;\n }\n }\n\n /**\n * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.\n * @param value - The number in question\n * @param unsigned - Whether unsigned or not, defaults to signed\n * @returns The corresponding Long value\n */\n static fromNumber(value: number, unsigned?: boolean): Long {\n if (isNaN(value)) return unsigned ? Long.UZERO : Long.ZERO;\n if (unsigned) {\n if (value < 0) return Long.UZERO;\n if (value >= TWO_PWR_64_DBL) return Long.MAX_UNSIGNED_VALUE;\n } else {\n if (value <= -TWO_PWR_63_DBL) return Long.MIN_VALUE;\n if (value + 1 >= TWO_PWR_63_DBL) return Long.MAX_VALUE;\n }\n if (value < 0) return Long.fromNumber(-value, unsigned).neg();\n return Long.fromBits(value % TWO_PWR_32_DBL | 0, (value / TWO_PWR_32_DBL) | 0, unsigned);\n }\n\n /**\n * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.\n * @param value - The number in question\n * @param unsigned - Whether unsigned or not, defaults to signed\n * @returns The corresponding Long value\n */\n static fromBigInt(value: bigint, unsigned?: boolean): Long {\n return Long.fromString(value.toString(), unsigned);\n }\n\n /**\n * Returns a Long representation of the given string, written using the specified radix.\n * @param str - The textual representation of the Long\n * @param unsigned - Whether unsigned or not, defaults to signed\n * @param radix - The radix in which the text is written (2-36), defaults to 10\n * @returns The corresponding Long value\n */\n static fromString(str: string, unsigned?: boolean, radix?: number): Long {\n if (str.length === 0) throw new BSONError('empty string');\n if (str === 'NaN' || str === 'Infinity' || str === '+Infinity' || str === '-Infinity')\n return Long.ZERO;\n if (typeof unsigned === 'number') {\n // For goog.math.long compatibility\n (radix = unsigned), (unsigned = false);\n } else {\n unsigned = !!unsigned;\n }\n radix = radix || 10;\n if (radix < 2 || 36 < radix) throw new BSONError('radix');\n\n let p;\n if ((p = str.indexOf('-')) > 0) throw new BSONError('interior hyphen');\n else if (p === 0) {\n return Long.fromString(str.substring(1), unsigned, radix).neg();\n }\n\n // Do several (8) digits each time through the loop, so as to\n // minimize the calls to the very expensive emulated div.\n const radixToPower = Long.fromNumber(Math.pow(radix, 8));\n\n let result = Long.ZERO;\n for (let i = 0; i < str.length; i += 8) {\n const size = Math.min(8, str.length - i),\n value = parseInt(str.substring(i, i + size), radix);\n if (size < 8) {\n const power = Long.fromNumber(Math.pow(radix, size));\n result = result.mul(power).add(Long.fromNumber(value));\n } else {\n result = result.mul(radixToPower);\n result = result.add(Long.fromNumber(value));\n }\n }\n result.unsigned = unsigned;\n return result;\n }\n\n /**\n * Creates a Long from its byte representation.\n * @param bytes - Byte representation\n * @param unsigned - Whether unsigned or not, defaults to signed\n * @param le - Whether little or big endian, defaults to big endian\n * @returns The corresponding Long value\n */\n static fromBytes(bytes: number[], unsigned?: boolean, le?: boolean): Long {\n return le ? Long.fromBytesLE(bytes, unsigned) : Long.fromBytesBE(bytes, unsigned);\n }\n\n /**\n * Creates a Long from its little endian byte representation.\n * @param bytes - Little endian byte representation\n * @param unsigned - Whether unsigned or not, defaults to signed\n * @returns The corresponding Long value\n */\n static fromBytesLE(bytes: number[], unsigned?: boolean): Long {\n return new Long(\n bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24),\n bytes[4] | (bytes[5] << 8) | (bytes[6] << 16) | (bytes[7] << 24),\n unsigned\n );\n }\n\n /**\n * Creates a Long from its big endian byte representation.\n * @param bytes - Big endian byte representation\n * @param unsigned - Whether unsigned or not, defaults to signed\n * @returns The corresponding Long value\n */\n static fromBytesBE(bytes: number[], unsigned?: boolean): Long {\n return new Long(\n (bytes[4] << 24) | (bytes[5] << 16) | (bytes[6] << 8) | bytes[7],\n (bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3],\n unsigned\n );\n }\n\n /**\n * Tests if the specified object is a Long.\n */\n static isLong(value: unknown): value is Long {\n return (\n value != null &&\n typeof value === 'object' &&\n '__isLong__' in value &&\n value.__isLong__ === true\n );\n }\n\n /**\n * Converts the specified value to a Long.\n * @param unsigned - Whether unsigned or not, defaults to signed\n */\n static fromValue(\n val: number | string | { low: number; high: number; unsigned?: boolean },\n unsigned?: boolean\n ): Long {\n if (typeof val === 'number') return Long.fromNumber(val, unsigned);\n if (typeof val === 'string') return Long.fromString(val, unsigned);\n // Throws for non-objects, converts non-instanceof Long:\n return Long.fromBits(\n val.low,\n val.high,\n typeof unsigned === 'boolean' ? unsigned : val.unsigned\n );\n }\n\n /** Returns the sum of this and the specified Long. */\n add(addend: string | number | Long | Timestamp): Long {\n if (!Long.isLong(addend)) addend = Long.fromValue(addend);\n\n // Divide each number into 4 chunks of 16 bits, and then sum the chunks.\n\n const a48 = this.high >>> 16;\n const a32 = this.high & 0xffff;\n const a16 = this.low >>> 16;\n const a00 = this.low & 0xffff;\n\n const b48 = addend.high >>> 16;\n const b32 = addend.high & 0xffff;\n const b16 = addend.low >>> 16;\n const b00 = addend.low & 0xffff;\n\n let c48 = 0,\n c32 = 0,\n c16 = 0,\n c00 = 0;\n c00 += a00 + b00;\n c16 += c00 >>> 16;\n c00 &= 0xffff;\n c16 += a16 + b16;\n c32 += c16 >>> 16;\n c16 &= 0xffff;\n c32 += a32 + b32;\n c48 += c32 >>> 16;\n c32 &= 0xffff;\n c48 += a48 + b48;\n c48 &= 0xffff;\n return Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);\n }\n\n /**\n * Returns the sum of this and the specified Long.\n * @returns Sum\n */\n and(other: string | number | Long | Timestamp): Long {\n if (!Long.isLong(other)) other = Long.fromValue(other);\n return Long.fromBits(this.low & other.low, this.high & other.high, this.unsigned);\n }\n\n /**\n * Compares this Long's value with the specified's.\n * @returns 0 if they are the same, 1 if the this is greater and -1 if the given one is greater\n */\n compare(other: string | number | Long | Timestamp): 0 | 1 | -1 {\n if (!Long.isLong(other)) other = Long.fromValue(other);\n if (this.eq(other)) return 0;\n const thisNeg = this.isNegative(),\n otherNeg = other.isNegative();\n if (thisNeg && !otherNeg) return -1;\n if (!thisNeg && otherNeg) return 1;\n // At this point the sign bits are the same\n if (!this.unsigned) return this.sub(other).isNegative() ? -1 : 1;\n // Both are positive if at least one is unsigned\n return other.high >>> 0 > this.high >>> 0 ||\n (other.high === this.high && other.low >>> 0 > this.low >>> 0)\n ? -1\n : 1;\n }\n\n /** This is an alias of {@link Long.compare} */\n comp(other: string | number | Long | Timestamp): 0 | 1 | -1 {\n return this.compare(other);\n }\n\n /**\n * Returns this Long divided by the specified. The result is signed if this Long is signed or unsigned if this Long is unsigned.\n * @returns Quotient\n */\n divide(divisor: string | number | Long | Timestamp): Long {\n if (!Long.isLong(divisor)) divisor = Long.fromValue(divisor);\n if (divisor.isZero()) throw new BSONError('division by zero');\n\n // use wasm support if present\n if (wasm) {\n // guard against signed division overflow: the largest\n // negative number / -1 would be 1 larger than the largest\n // positive number, due to two's complement.\n if (\n !this.unsigned &&\n this.high === -0x80000000 &&\n divisor.low === -1 &&\n divisor.high === -1\n ) {\n // be consistent with non-wasm code path\n return this;\n }\n const low = (this.unsigned ? wasm.div_u : wasm.div_s)(\n this.low,\n this.high,\n divisor.low,\n divisor.high\n );\n return Long.fromBits(low, wasm.get_high(), this.unsigned);\n }\n\n if (this.isZero()) return this.unsigned ? Long.UZERO : Long.ZERO;\n let approx, rem, res;\n if (!this.unsigned) {\n // This section is only relevant for signed longs and is derived from the\n // closure library as a whole.\n if (this.eq(Long.MIN_VALUE)) {\n if (divisor.eq(Long.ONE) || divisor.eq(Long.NEG_ONE)) return Long.MIN_VALUE;\n // recall that -MIN_VALUE == MIN_VALUE\n else if (divisor.eq(Long.MIN_VALUE)) return Long.ONE;\n else {\n // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.\n const halfThis = this.shr(1);\n approx = halfThis.div(divisor).shl(1);\n if (approx.eq(Long.ZERO)) {\n return divisor.isNegative() ? Long.ONE : Long.NEG_ONE;\n } else {\n rem = this.sub(divisor.mul(approx));\n res = approx.add(rem.div(divisor));\n return res;\n }\n }\n } else if (divisor.eq(Long.MIN_VALUE)) return this.unsigned ? Long.UZERO : Long.ZERO;\n if (this.isNegative()) {\n if (divisor.isNegative()) return this.neg().div(divisor.neg());\n return this.neg().div(divisor).neg();\n } else if (divisor.isNegative()) return this.div(divisor.neg()).neg();\n res = Long.ZERO;\n } else {\n // The algorithm below has not been made for unsigned longs. It's therefore\n // required to take special care of the MSB prior to running it.\n if (!divisor.unsigned) divisor = divisor.toUnsigned();\n if (divisor.gt(this)) return Long.UZERO;\n if (divisor.gt(this.shru(1)))\n // 15 >>> 1 = 7 ; with divisor = 8 ; true\n return Long.UONE;\n res = Long.UZERO;\n }\n\n // Repeat the following until the remainder is less than other: find a\n // floating-point that approximates remainder / other *from below*, add this\n // into the result, and subtract it from the remainder. It is critical that\n // the approximate value is less than or equal to the real value so that the\n // remainder never becomes negative.\n // eslint-disable-next-line @typescript-eslint/no-this-alias\n rem = this;\n while (rem.gte(divisor)) {\n // Approximate the result of division. This may be a little greater or\n // smaller than the actual value.\n approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));\n\n // We will tweak the approximate result by changing it in the 48-th digit or\n // the smallest non-fractional digit, whichever is larger.\n const log2 = Math.ceil(Math.log(approx) / Math.LN2);\n const delta = log2 <= 48 ? 1 : Math.pow(2, log2 - 48);\n // Decrease the approximation until it is smaller than the remainder. Note\n // that if it is too large, the product overflows and is negative.\n let approxRes = Long.fromNumber(approx);\n let approxRem = approxRes.mul(divisor);\n while (approxRem.isNegative() || approxRem.gt(rem)) {\n approx -= delta;\n approxRes = Long.fromNumber(approx, this.unsigned);\n approxRem = approxRes.mul(divisor);\n }\n\n // We know the answer can't be zero... and actually, zero would cause\n // infinite recursion since we would make no progress.\n if (approxRes.isZero()) approxRes = Long.ONE;\n\n res = res.add(approxRes);\n rem = rem.sub(approxRem);\n }\n return res;\n }\n\n /**This is an alias of {@link Long.divide} */\n div(divisor: string | number | Long | Timestamp): Long {\n return this.divide(divisor);\n }\n\n /**\n * Tests if this Long's value equals the specified's.\n * @param other - Other value\n */\n equals(other: string | number | Long | Timestamp): boolean {\n if (!Long.isLong(other)) other = Long.fromValue(other);\n if (this.unsigned !== other.unsigned && this.high >>> 31 === 1 && other.high >>> 31 === 1)\n return false;\n return this.high === other.high && this.low === other.low;\n }\n\n /** This is an alias of {@link Long.equals} */\n eq(other: string | number | Long | Timestamp): boolean {\n return this.equals(other);\n }\n\n /** Gets the high 32 bits as a signed integer. */\n getHighBits(): number {\n return this.high;\n }\n\n /** Gets the high 32 bits as an unsigned integer. */\n getHighBitsUnsigned(): number {\n return this.high >>> 0;\n }\n\n /** Gets the low 32 bits as a signed integer. */\n getLowBits(): number {\n return this.low;\n }\n\n /** Gets the low 32 bits as an unsigned integer. */\n getLowBitsUnsigned(): number {\n return this.low >>> 0;\n }\n\n /** Gets the number of bits needed to represent the absolute value of this Long. */\n getNumBitsAbs(): number {\n if (this.isNegative()) {\n // Unsigned Longs are never negative\n return this.eq(Long.MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();\n }\n const val = this.high !== 0 ? this.high : this.low;\n let bit: number;\n for (bit = 31; bit > 0; bit--) if ((val & (1 << bit)) !== 0) break;\n return this.high !== 0 ? bit + 33 : bit + 1;\n }\n\n /** Tests if this Long's value is greater than the specified's. */\n greaterThan(other: string | number | Long | Timestamp): boolean {\n return this.comp(other) > 0;\n }\n\n /** This is an alias of {@link Long.greaterThan} */\n gt(other: string | number | Long | Timestamp): boolean {\n return this.greaterThan(other);\n }\n\n /** Tests if this Long's value is greater than or equal the specified's. */\n greaterThanOrEqual(other: string | number | Long | Timestamp): boolean {\n return this.comp(other) >= 0;\n }\n\n /** This is an alias of {@link Long.greaterThanOrEqual} */\n gte(other: string | number | Long | Timestamp): boolean {\n return this.greaterThanOrEqual(other);\n }\n /** This is an alias of {@link Long.greaterThanOrEqual} */\n ge(other: string | number | Long | Timestamp): boolean {\n return this.greaterThanOrEqual(other);\n }\n\n /** Tests if this Long's value is even. */\n isEven(): boolean {\n return (this.low & 1) === 0;\n }\n\n /** Tests if this Long's value is negative. */\n isNegative(): boolean {\n return !this.unsigned && this.high < 0;\n }\n\n /** Tests if this Long's value is odd. */\n isOdd(): boolean {\n return (this.low & 1) === 1;\n }\n\n /** Tests if this Long's value is positive. */\n isPositive(): boolean {\n return this.unsigned || this.high >= 0;\n }\n\n /** Tests if this Long's value equals zero. */\n isZero(): boolean {\n return this.high === 0 && this.low === 0;\n }\n\n /** Tests if this Long's value is less than the specified's. */\n lessThan(other: string | number | Long | Timestamp): boolean {\n return this.comp(other) < 0;\n }\n\n /** This is an alias of {@link Long#lessThan}. */\n lt(other: string | number | Long | Timestamp): boolean {\n return this.lessThan(other);\n }\n\n /** Tests if this Long's value is less than or equal the specified's. */\n lessThanOrEqual(other: string | number | Long | Timestamp): boolean {\n return this.comp(other) <= 0;\n }\n\n /** This is an alias of {@link Long.lessThanOrEqual} */\n lte(other: string | number | Long | Timestamp): boolean {\n return this.lessThanOrEqual(other);\n }\n\n /** Returns this Long modulo the specified. */\n modulo(divisor: string | number | Long | Timestamp): Long {\n if (!Long.isLong(divisor)) divisor = Long.fromValue(divisor);\n\n // use wasm support if present\n if (wasm) {\n const low = (this.unsigned ? wasm.rem_u : wasm.rem_s)(\n this.low,\n this.high,\n divisor.low,\n divisor.high\n );\n return Long.fromBits(low, wasm.get_high(), this.unsigned);\n }\n\n return this.sub(this.div(divisor).mul(divisor));\n }\n\n /** This is an alias of {@link Long.modulo} */\n mod(divisor: string | number | Long | Timestamp): Long {\n return this.modulo(divisor);\n }\n /** This is an alias of {@link Long.modulo} */\n rem(divisor: string | number | Long | Timestamp): Long {\n return this.modulo(divisor);\n }\n\n /**\n * Returns the product of this and the specified Long.\n * @param multiplier - Multiplier\n * @returns Product\n */\n multiply(multiplier: string | number | Long | Timestamp): Long {\n if (this.isZero()) return Long.ZERO;\n if (!Long.isLong(multiplier)) multiplier = Long.fromValue(multiplier);\n\n // use wasm support if present\n if (wasm) {\n const low = wasm.mul(this.low, this.high, multiplier.low, multiplier.high);\n return Long.fromBits(low, wasm.get_high(), this.unsigned);\n }\n\n if (multiplier.isZero()) return Long.ZERO;\n if (this.eq(Long.MIN_VALUE)) return multiplier.isOdd() ? Long.MIN_VALUE : Long.ZERO;\n if (multiplier.eq(Long.MIN_VALUE)) return this.isOdd() ? Long.MIN_VALUE : Long.ZERO;\n\n if (this.isNegative()) {\n if (multiplier.isNegative()) return this.neg().mul(multiplier.neg());\n else return this.neg().mul(multiplier).neg();\n } else if (multiplier.isNegative()) return this.mul(multiplier.neg()).neg();\n\n // If both longs are small, use float multiplication\n if (this.lt(Long.TWO_PWR_24) && multiplier.lt(Long.TWO_PWR_24))\n return Long.fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);\n\n // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.\n // We can skip products that would overflow.\n\n const a48 = this.high >>> 16;\n const a32 = this.high & 0xffff;\n const a16 = this.low >>> 16;\n const a00 = this.low & 0xffff;\n\n const b48 = multiplier.high >>> 16;\n const b32 = multiplier.high & 0xffff;\n const b16 = multiplier.low >>> 16;\n const b00 = multiplier.low & 0xffff;\n\n let c48 = 0,\n c32 = 0,\n c16 = 0,\n c00 = 0;\n c00 += a00 * b00;\n c16 += c00 >>> 16;\n c00 &= 0xffff;\n c16 += a16 * b00;\n c32 += c16 >>> 16;\n c16 &= 0xffff;\n c16 += a00 * b16;\n c32 += c16 >>> 16;\n c16 &= 0xffff;\n c32 += a32 * b00;\n c48 += c32 >>> 16;\n c32 &= 0xffff;\n c32 += a16 * b16;\n c48 += c32 >>> 16;\n c32 &= 0xffff;\n c32 += a00 * b32;\n c48 += c32 >>> 16;\n c32 &= 0xffff;\n c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;\n c48 &= 0xffff;\n return Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);\n }\n\n /** This is an alias of {@link Long.multiply} */\n mul(multiplier: string | number | Long | Timestamp): Long {\n return this.multiply(multiplier);\n }\n\n /** Returns the Negation of this Long's value. */\n negate(): Long {\n if (!this.unsigned && this.eq(Long.MIN_VALUE)) return Long.MIN_VALUE;\n return this.not().add(Long.ONE);\n }\n\n /** This is an alias of {@link Long.negate} */\n neg(): Long {\n return this.negate();\n }\n\n /** Returns the bitwise NOT of this Long. */\n not(): Long {\n return Long.fromBits(~this.low, ~this.high, this.unsigned);\n }\n\n /** Tests if this Long's value differs from the specified's. */\n notEquals(other: string | number | Long | Timestamp): boolean {\n return !this.equals(other);\n }\n\n /** This is an alias of {@link Long.notEquals} */\n neq(other: string | number | Long | Timestamp): boolean {\n return this.notEquals(other);\n }\n /** This is an alias of {@link Long.notEquals} */\n ne(other: string | number | Long | Timestamp): boolean {\n return this.notEquals(other);\n }\n\n /**\n * Returns the bitwise OR of this Long and the specified.\n */\n or(other: number | string | Long): Long {\n if (!Long.isLong(other)) other = Long.fromValue(other);\n return Long.fromBits(this.low | other.low, this.high | other.high, this.unsigned);\n }\n\n /**\n * Returns this Long with bits shifted to the left by the given amount.\n * @param numBits - Number of bits\n * @returns Shifted Long\n */\n shiftLeft(numBits: number | Long): Long {\n if (Long.isLong(numBits)) numBits = numBits.toInt();\n if ((numBits &= 63) === 0) return this;\n else if (numBits < 32)\n return Long.fromBits(\n this.low << numBits,\n (this.high << numBits) | (this.low >>> (32 - numBits)),\n this.unsigned\n );\n else return Long.fromBits(0, this.low << (numBits - 32), this.unsigned);\n }\n\n /** This is an alias of {@link Long.shiftLeft} */\n shl(numBits: number | Long): Long {\n return this.shiftLeft(numBits);\n }\n\n /**\n * Returns this Long with bits arithmetically shifted to the right by the given amount.\n * @param numBits - Number of bits\n * @returns Shifted Long\n */\n shiftRight(numBits: number | Long): Long {\n if (Long.isLong(numBits)) numBits = numBits.toInt();\n if ((numBits &= 63) === 0) return this;\n else if (numBits < 32)\n return Long.fromBits(\n (this.low >>> numBits) | (this.high << (32 - numBits)),\n this.high >> numBits,\n this.unsigned\n );\n else return Long.fromBits(this.high >> (numBits - 32), this.high >= 0 ? 0 : -1, this.unsigned);\n }\n\n /** This is an alias of {@link Long.shiftRight} */\n shr(numBits: number | Long): Long {\n return this.shiftRight(numBits);\n }\n\n /**\n * Returns this Long with bits logically shifted to the right by the given amount.\n * @param numBits - Number of bits\n * @returns Shifted Long\n */\n shiftRightUnsigned(numBits: Long | number): Long {\n if (Long.isLong(numBits)) numBits = numBits.toInt();\n numBits &= 63;\n if (numBits === 0) return this;\n else {\n const high = this.high;\n if (numBits < 32) {\n const low = this.low;\n return Long.fromBits(\n (low >>> numBits) | (high << (32 - numBits)),\n high >>> numBits,\n this.unsigned\n );\n } else if (numBits === 32) return Long.fromBits(high, 0, this.unsigned);\n else return Long.fromBits(high >>> (numBits - 32), 0, this.unsigned);\n }\n }\n\n /** This is an alias of {@link Long.shiftRightUnsigned} */\n shr_u(numBits: number | Long): Long {\n return this.shiftRightUnsigned(numBits);\n }\n /** This is an alias of {@link Long.shiftRightUnsigned} */\n shru(numBits: number | Long): Long {\n return this.shiftRightUnsigned(numBits);\n }\n\n /**\n * Returns the difference of this and the specified Long.\n * @param subtrahend - Subtrahend\n * @returns Difference\n */\n subtract(subtrahend: string | number | Long | Timestamp): Long {\n if (!Long.isLong(subtrahend)) subtrahend = Long.fromValue(subtrahend);\n return this.add(subtrahend.neg());\n }\n\n /** This is an alias of {@link Long.subtract} */\n sub(subtrahend: string | number | Long | Timestamp): Long {\n return this.subtract(subtrahend);\n }\n\n /** Converts the Long to a 32 bit integer, assuming it is a 32 bit integer. */\n toInt(): number {\n return this.unsigned ? this.low >>> 0 : this.low;\n }\n\n /** Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa). */\n toNumber(): number {\n if (this.unsigned) return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0);\n return this.high * TWO_PWR_32_DBL + (this.low >>> 0);\n }\n\n /** Converts the Long to a BigInt (arbitrary precision). */\n toBigInt(): bigint {\n // eslint-disable-next-line no-restricted-globals -- This is allowed here as it is explicitly requesting a bigint\n return BigInt(this.toString());\n }\n\n /**\n * Converts this Long to its byte representation.\n * @param le - Whether little or big endian, defaults to big endian\n * @returns Byte representation\n */\n toBytes(le?: boolean): number[] {\n return le ? this.toBytesLE() : this.toBytesBE();\n }\n\n /**\n * Converts this Long to its little endian byte representation.\n * @returns Little endian byte representation\n */\n toBytesLE(): number[] {\n const hi = this.high,\n lo = this.low;\n return [\n lo & 0xff,\n (lo >>> 8) & 0xff,\n (lo >>> 16) & 0xff,\n lo >>> 24,\n hi & 0xff,\n (hi >>> 8) & 0xff,\n (hi >>> 16) & 0xff,\n hi >>> 24\n ];\n }\n\n /**\n * Converts this Long to its big endian byte representation.\n * @returns Big endian byte representation\n */\n toBytesBE(): number[] {\n const hi = this.high,\n lo = this.low;\n return [\n hi >>> 24,\n (hi >>> 16) & 0xff,\n (hi >>> 8) & 0xff,\n hi & 0xff,\n lo >>> 24,\n (lo >>> 16) & 0xff,\n (lo >>> 8) & 0xff,\n lo & 0xff\n ];\n }\n\n /**\n * Converts this Long to signed.\n */\n toSigned(): Long {\n if (!this.unsigned) return this;\n return Long.fromBits(this.low, this.high, false);\n }\n\n /**\n * Converts the Long to a string written in the specified radix.\n * @param radix - Radix (2-36), defaults to 10\n * @throws RangeError If `radix` is out of range\n */\n toString(radix?: number): string {\n radix = radix || 10;\n if (radix < 2 || 36 < radix) throw new BSONError('radix');\n if (this.isZero()) return '0';\n if (this.isNegative()) {\n // Unsigned Longs are never negative\n if (this.eq(Long.MIN_VALUE)) {\n // We need to change the Long value before it can be negated, so we remove\n // the bottom-most digit in this base and then recurse to do the rest.\n const radixLong = Long.fromNumber(radix),\n div = this.div(radixLong),\n rem1 = div.mul(radixLong).sub(this);\n return div.toString(radix) + rem1.toInt().toString(radix);\n } else return '-' + this.neg().toString(radix);\n }\n\n // Do several (6) digits each time through the loop, so as to\n // minimize the calls to the very expensive emulated div.\n const radixToPower = Long.fromNumber(Math.pow(radix, 6), this.unsigned);\n // eslint-disable-next-line @typescript-eslint/no-this-alias\n let rem: Long = this;\n let result = '';\n // eslint-disable-next-line no-constant-condition\n while (true) {\n const remDiv = rem.div(radixToPower);\n const intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0;\n let digits = intval.toString(radix);\n rem = remDiv;\n if (rem.isZero()) {\n return digits + result;\n } else {\n while (digits.length < 6) digits = '0' + digits;\n result = '' + digits + result;\n }\n }\n }\n\n /** Converts this Long to unsigned. */\n toUnsigned(): Long {\n if (this.unsigned) return this;\n return Long.fromBits(this.low, this.high, true);\n }\n\n /** Returns the bitwise XOR of this Long and the given one. */\n xor(other: Long | number | string): Long {\n if (!Long.isLong(other)) other = Long.fromValue(other);\n return Long.fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);\n }\n\n /** This is an alias of {@link Long.isZero} */\n eqz(): boolean {\n return this.isZero();\n }\n\n /** This is an alias of {@link Long.lessThanOrEqual} */\n le(other: string | number | Long | Timestamp): boolean {\n return this.lessThanOrEqual(other);\n }\n\n /*\n ****************************************************************\n * BSON SPECIFIC ADDITIONS *\n ****************************************************************\n */\n toExtendedJSON(options?: EJSONOptions): number | LongExtended {\n if (options && options.relaxed) return this.toNumber();\n return { $numberLong: this.toString() };\n }\n static fromExtendedJSON(\n doc: { $numberLong: string },\n options?: EJSONOptions\n ): number | Long | bigint {\n const { useBigInt64 = false, relaxed = true } = { ...options };\n\n if (doc.$numberLong.length > MAX_INT64_STRING_LENGTH) {\n throw new BSONError('$numberLong string is too long');\n }\n\n if (!DECIMAL_REG_EX.test(doc.$numberLong)) {\n throw new BSONError(`$numberLong string \"${doc.$numberLong}\" is in an invalid format`);\n }\n\n if (useBigInt64) {\n /* eslint-disable no-restricted-globals -- Can use BigInt here as useBigInt64=true */\n const bigIntResult = BigInt(doc.$numberLong);\n return BigInt.asIntN(64, bigIntResult);\n /* eslint-enable */\n }\n\n const longResult = Long.fromString(doc.$numberLong);\n if (relaxed) {\n return longResult.toNumber();\n }\n return longResult;\n }\n\n inspect(depth?: number, options?: unknown, inspect?: InspectFn): string {\n inspect ??= defaultInspect;\n const longVal = inspect(this.toString(), options);\n const unsignedVal = this.unsigned ? `, ${inspect(this.unsigned, options)}` : '';\n return `new Long(${longVal}${unsignedVal})`;\n }\n}\n","import { BSONValue } from './bson_value';\nimport { BSONError } from './error';\nimport { Long } from './long';\nimport { type InspectFn, defaultInspect, isUint8Array } from './parser/utils';\nimport { ByteUtils } from './utils/byte_utils';\n\nconst PARSE_STRING_REGEXP = /^(\\+|-)?(\\d+|(\\d*\\.\\d*))?(E|e)?([-+])?(\\d+)?$/;\nconst PARSE_INF_REGEXP = /^(\\+|-)?(Infinity|inf)$/i;\nconst PARSE_NAN_REGEXP = /^(\\+|-)?NaN$/i;\n\nconst EXPONENT_MAX = 6111;\nconst EXPONENT_MIN = -6176;\nconst EXPONENT_BIAS = 6176;\nconst MAX_DIGITS = 34;\n\n// Nan value bits as 32 bit values (due to lack of longs)\nconst NAN_BUFFER = ByteUtils.fromNumberArray(\n [\n 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00\n ].reverse()\n);\n// Infinity value bits 32 bit values (due to lack of longs)\nconst INF_NEGATIVE_BUFFER = ByteUtils.fromNumberArray(\n [\n 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00\n ].reverse()\n);\nconst INF_POSITIVE_BUFFER = ByteUtils.fromNumberArray(\n [\n 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00\n ].reverse()\n);\n\nconst EXPONENT_REGEX = /^([-+])?(\\d+)?$/;\n\n// Extract least significant 5 bits\nconst COMBINATION_MASK = 0x1f;\n// Extract least significant 14 bits\nconst EXPONENT_MASK = 0x3fff;\n// Value of combination field for Inf\nconst COMBINATION_INFINITY = 30;\n// Value of combination field for NaN\nconst COMBINATION_NAN = 31;\n\n// Detect if the value is a digit\nfunction isDigit(value: string): boolean {\n return !isNaN(parseInt(value, 10));\n}\n\n// Divide two uint128 values\nfunction divideu128(value: { parts: [number, number, number, number] }) {\n const DIVISOR = Long.fromNumber(1000 * 1000 * 1000);\n let _rem = Long.fromNumber(0);\n\n if (!value.parts[0] && !value.parts[1] && !value.parts[2] && !value.parts[3]) {\n return { quotient: value, rem: _rem };\n }\n\n for (let i = 0; i <= 3; i++) {\n // Adjust remainder to match value of next dividend\n _rem = _rem.shiftLeft(32);\n // Add the divided to _rem\n _rem = _rem.add(new Long(value.parts[i], 0));\n value.parts[i] = _rem.div(DIVISOR).low;\n _rem = _rem.modulo(DIVISOR);\n }\n\n return { quotient: value, rem: _rem };\n}\n\n// Multiply two Long values and return the 128 bit value\nfunction multiply64x2(left: Long, right: Long): { high: Long; low: Long } {\n if (!left && !right) {\n return { high: Long.fromNumber(0), low: Long.fromNumber(0) };\n }\n\n const leftHigh = left.shiftRightUnsigned(32);\n const leftLow = new Long(left.getLowBits(), 0);\n const rightHigh = right.shiftRightUnsigned(32);\n const rightLow = new Long(right.getLowBits(), 0);\n\n let productHigh = leftHigh.multiply(rightHigh);\n let productMid = leftHigh.multiply(rightLow);\n const productMid2 = leftLow.multiply(rightHigh);\n let productLow = leftLow.multiply(rightLow);\n\n productHigh = productHigh.add(productMid.shiftRightUnsigned(32));\n productMid = new Long(productMid.getLowBits(), 0)\n .add(productMid2)\n .add(productLow.shiftRightUnsigned(32));\n\n productHigh = productHigh.add(productMid.shiftRightUnsigned(32));\n productLow = productMid.shiftLeft(32).add(new Long(productLow.getLowBits(), 0));\n\n // Return the 128 bit result\n return { high: productHigh, low: productLow };\n}\n\nfunction lessThan(left: Long, right: Long): boolean {\n // Make values unsigned\n const uhleft = left.high >>> 0;\n const uhright = right.high >>> 0;\n\n // Compare high bits first\n if (uhleft < uhright) {\n return true;\n } else if (uhleft === uhright) {\n const ulleft = left.low >>> 0;\n const ulright = right.low >>> 0;\n if (ulleft < ulright) return true;\n }\n\n return false;\n}\n\nfunction invalidErr(string: string, message: string) {\n throw new BSONError(`\"${string}\" is not a valid Decimal128 string - ${message}`);\n}\n\n/** @public */\nexport interface Decimal128Extended {\n $numberDecimal: string;\n}\n\n/**\n * A class representation of the BSON Decimal128 type.\n * @public\n * @category BSONType\n */\nexport class Decimal128 extends BSONValue {\n get _bsontype(): 'Decimal128' {\n return 'Decimal128';\n }\n\n readonly bytes!: Uint8Array;\n\n /**\n * @param bytes - a buffer containing the raw Decimal128 bytes in little endian order,\n * or a string representation as returned by .toString()\n */\n constructor(bytes: Uint8Array | string) {\n super();\n if (typeof bytes === 'string') {\n this.bytes = Decimal128.fromString(bytes).bytes;\n } else if (isUint8Array(bytes)) {\n if (bytes.byteLength !== 16) {\n throw new BSONError('Decimal128 must take a Buffer of 16 bytes');\n }\n this.bytes = bytes;\n } else {\n throw new BSONError('Decimal128 must take a Buffer or string');\n }\n }\n\n /**\n * Create a Decimal128 instance from a string representation\n *\n * @param representation - a numeric string representation.\n */\n static fromString(representation: string): Decimal128 {\n return Decimal128._fromString(representation, { allowRounding: false });\n }\n\n /**\n * Create a Decimal128 instance from a string representation, allowing for rounding to 34\n * significant digits\n *\n * @example Example of a number that will be rounded\n * ```ts\n * > let d = Decimal128.fromString('37.499999999999999196428571428571375')\n * Uncaught:\n * BSONError: \"37.499999999999999196428571428571375\" is not a valid Decimal128 string - inexact rounding\n * at invalidErr (/home/wajames/js-bson/lib/bson.cjs:1402:11)\n * at Decimal128.fromStringInternal (/home/wajames/js-bson/lib/bson.cjs:1633:25)\n * at Decimal128.fromString (/home/wajames/js-bson/lib/bson.cjs:1424:27)\n *\n * > d = Decimal128.fromStringWithRounding('37.499999999999999196428571428571375')\n * new Decimal128(\"37.49999999999999919642857142857138\")\n * ```\n * @param representation - a numeric string representation.\n */\n static fromStringWithRounding(representation: string): Decimal128 {\n return Decimal128._fromString(representation, { allowRounding: true });\n }\n\n private static _fromString(representation: string, options: { allowRounding: boolean }) {\n // Parse state tracking\n let isNegative = false;\n let sawSign = false;\n let sawRadix = false;\n let foundNonZero = false;\n\n // Total number of significant digits (no leading or trailing zero)\n let significantDigits = 0;\n // Total number of significand digits read\n let nDigitsRead = 0;\n // Total number of digits (no leading zeros)\n let nDigits = 0;\n // The number of the digits after radix\n let radixPosition = 0;\n // The index of the first non-zero in *str*\n let firstNonZero = 0;\n\n // Digits Array\n const digits = [0];\n // The number of digits in digits\n let nDigitsStored = 0;\n // Insertion pointer for digits\n let digitsInsert = 0;\n // The index of the last digit\n let lastDigit = 0;\n\n // Exponent\n let exponent = 0;\n // The high 17 digits of the significand\n let significandHigh = new Long(0, 0);\n // The low 17 digits of the significand\n let significandLow = new Long(0, 0);\n // The biased exponent\n let biasedExponent = 0;\n\n // Read index\n let index = 0;\n\n // Naively prevent against REDOS attacks.\n // TODO: implementing a custom parsing for this, or refactoring the regex would yield\n // further gains.\n if (representation.length >= 7000) {\n throw new BSONError('' + representation + ' not a valid Decimal128 string');\n }\n\n // Results\n const stringMatch = representation.match(PARSE_STRING_REGEXP);\n const infMatch = representation.match(PARSE_INF_REGEXP);\n const nanMatch = representation.match(PARSE_NAN_REGEXP);\n\n // Validate the string\n if ((!stringMatch && !infMatch && !nanMatch) || representation.length === 0) {\n throw new BSONError('' + representation + ' not a valid Decimal128 string');\n }\n\n if (stringMatch) {\n // full_match = stringMatch[0]\n // sign = stringMatch[1]\n\n const unsignedNumber = stringMatch[2];\n // stringMatch[3] is undefined if a whole number (ex \"1\", 12\")\n // but defined if a number w/ decimal in it (ex \"1.0, 12.2\")\n\n const e = stringMatch[4];\n const expSign = stringMatch[5];\n const expNumber = stringMatch[6];\n\n // they provided e, but didn't give an exponent number. for ex \"1e\"\n if (e && expNumber === undefined) invalidErr(representation, 'missing exponent power');\n\n // they provided e, but didn't give a number before it. for ex \"e1\"\n if (e && unsignedNumber === undefined) invalidErr(representation, 'missing exponent base');\n\n if (e === undefined && (expSign || expNumber)) {\n invalidErr(representation, 'missing e before exponent');\n }\n }\n\n // Get the negative or positive sign\n if (representation[index] === '+' || representation[index] === '-') {\n sawSign = true;\n isNegative = representation[index++] === '-';\n }\n\n // Check if user passed Infinity or NaN\n if (!isDigit(representation[index]) && representation[index] !== '.') {\n if (representation[index] === 'i' || representation[index] === 'I') {\n return new Decimal128(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER);\n } else if (representation[index] === 'N') {\n return new Decimal128(NAN_BUFFER);\n }\n }\n\n // Read all the digits\n while (isDigit(representation[index]) || representation[index] === '.') {\n if (representation[index] === '.') {\n if (sawRadix) invalidErr(representation, 'contains multiple periods');\n\n sawRadix = true;\n index = index + 1;\n continue;\n }\n\n if (nDigitsStored < MAX_DIGITS) {\n if (representation[index] !== '0' || foundNonZero) {\n if (!foundNonZero) {\n firstNonZero = nDigitsRead;\n }\n\n foundNonZero = true;\n\n // Only store 34 digits\n digits[digitsInsert++] = parseInt(representation[index], 10);\n nDigitsStored = nDigitsStored + 1;\n }\n }\n\n if (foundNonZero) nDigits = nDigits + 1;\n if (sawRadix) radixPosition = radixPosition + 1;\n\n nDigitsRead = nDigitsRead + 1;\n index = index + 1;\n }\n\n if (sawRadix && !nDigitsRead)\n throw new BSONError('' + representation + ' not a valid Decimal128 string');\n\n // Read exponent if exists\n if (representation[index] === 'e' || representation[index] === 'E') {\n // Read exponent digits\n const match = representation.substr(++index).match(EXPONENT_REGEX);\n\n // No digits read\n if (!match || !match[2]) return new Decimal128(NAN_BUFFER);\n\n // Get exponent\n exponent = parseInt(match[0], 10);\n\n // Adjust the index\n index = index + match[0].length;\n }\n\n // Return not a number\n if (representation[index]) return new Decimal128(NAN_BUFFER);\n\n // Done reading input\n // Find first non-zero digit in digits\n if (!nDigitsStored) {\n digits[0] = 0;\n nDigits = 1;\n nDigitsStored = 1;\n significantDigits = 0;\n } else {\n lastDigit = nDigitsStored - 1;\n significantDigits = nDigits;\n if (significantDigits !== 1) {\n while (\n representation[\n firstNonZero + significantDigits - 1 + Number(sawSign) + Number(sawRadix)\n ] === '0'\n ) {\n significantDigits = significantDigits - 1;\n }\n }\n }\n\n // Normalization of exponent\n // Correct exponent based on radix position, and shift significand as needed\n // to represent user input\n\n // Overflow prevention\n if (exponent <= radixPosition && radixPosition > exponent + (1 << 14)) {\n exponent = EXPONENT_MIN;\n } else {\n exponent = exponent - radixPosition;\n }\n\n // Attempt to normalize the exponent\n while (exponent > EXPONENT_MAX) {\n // Shift exponent to significand and decrease\n lastDigit = lastDigit + 1;\n if (lastDigit >= MAX_DIGITS) {\n // Check if we have a zero then just hard clamp, otherwise fail\n if (significantDigits === 0) {\n exponent = EXPONENT_MAX;\n break;\n }\n\n invalidErr(representation, 'overflow');\n }\n exponent = exponent - 1;\n }\n\n if (options.allowRounding) {\n while (exponent < EXPONENT_MIN || nDigitsStored < nDigits) {\n // Shift last digit. can only do this if < significant digits than # stored.\n if (lastDigit === 0 && significantDigits < nDigitsStored) {\n exponent = EXPONENT_MIN;\n significantDigits = 0;\n break;\n }\n\n if (nDigitsStored < nDigits) {\n // adjust to match digits not stored\n nDigits = nDigits - 1;\n } else {\n // adjust to round\n lastDigit = lastDigit - 1;\n }\n\n if (exponent < EXPONENT_MAX) {\n exponent = exponent + 1;\n } else {\n // Check if we have a zero then just hard clamp, otherwise fail\n const digitsString = digits.join('');\n if (digitsString.match(/^0+$/)) {\n exponent = EXPONENT_MAX;\n break;\n }\n invalidErr(representation, 'overflow');\n }\n }\n\n // Round\n // We've normalized the exponent, but might still need to round.\n if (lastDigit + 1 < significantDigits) {\n let endOfString = nDigitsRead;\n\n // If we have seen a radix point, 'string' is 1 longer than we have\n // documented with ndigits_read, so inc the position of the first nonzero\n // digit and the position that digits are read to.\n if (sawRadix) {\n firstNonZero = firstNonZero + 1;\n endOfString = endOfString + 1;\n }\n // if negative, we need to increment again to account for - sign at start.\n if (sawSign) {\n firstNonZero = firstNonZero + 1;\n endOfString = endOfString + 1;\n }\n\n const roundDigit = parseInt(representation[firstNonZero + lastDigit + 1], 10);\n let roundBit = 0;\n\n if (roundDigit >= 5) {\n roundBit = 1;\n if (roundDigit === 5) {\n roundBit = digits[lastDigit] % 2 === 1 ? 1 : 0;\n for (let i = firstNonZero + lastDigit + 2; i < endOfString; i++) {\n if (parseInt(representation[i], 10)) {\n roundBit = 1;\n break;\n }\n }\n }\n }\n\n if (roundBit) {\n let dIdx = lastDigit;\n\n for (; dIdx >= 0; dIdx--) {\n if (++digits[dIdx] > 9) {\n digits[dIdx] = 0;\n\n // overflowed most significant digit\n if (dIdx === 0) {\n if (exponent < EXPONENT_MAX) {\n exponent = exponent + 1;\n digits[dIdx] = 1;\n } else {\n return new Decimal128(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER);\n }\n }\n } else {\n break;\n }\n }\n }\n }\n } else {\n while (exponent < EXPONENT_MIN || nDigitsStored < nDigits) {\n // Shift last digit. can only do this if < significant digits than # stored.\n if (lastDigit === 0) {\n if (significantDigits === 0) {\n exponent = EXPONENT_MIN;\n break;\n }\n\n invalidErr(representation, 'exponent underflow');\n }\n\n if (nDigitsStored < nDigits) {\n if (\n representation[nDigits - 1 + Number(sawSign) + Number(sawRadix)] !== '0' &&\n significantDigits !== 0\n ) {\n invalidErr(representation, 'inexact rounding');\n }\n // adjust to match digits not stored\n nDigits = nDigits - 1;\n } else {\n if (digits[lastDigit] !== 0) {\n invalidErr(representation, 'inexact rounding');\n }\n // adjust to round\n lastDigit = lastDigit - 1;\n }\n\n if (exponent < EXPONENT_MAX) {\n exponent = exponent + 1;\n } else {\n invalidErr(representation, 'overflow');\n }\n }\n\n // Round\n // We've normalized the exponent, but might still need to round.\n if (lastDigit + 1 < significantDigits) {\n // If we have seen a radix point, 'string' is 1 longer than we have\n // documented with ndigits_read, so inc the position of the first nonzero\n // digit and the position that digits are read to.\n if (sawRadix) {\n firstNonZero = firstNonZero + 1;\n }\n // if saw sign, we need to increment again to account for - or + sign at start.\n if (sawSign) {\n firstNonZero = firstNonZero + 1;\n }\n\n const roundDigit = parseInt(representation[firstNonZero + lastDigit + 1], 10);\n\n if (roundDigit !== 0) {\n invalidErr(representation, 'inexact rounding');\n }\n }\n }\n\n // Encode significand\n // The high 17 digits of the significand\n significandHigh = Long.fromNumber(0);\n // The low 17 digits of the significand\n significandLow = Long.fromNumber(0);\n\n // read a zero\n if (significantDigits === 0) {\n significandHigh = Long.fromNumber(0);\n significandLow = Long.fromNumber(0);\n } else if (lastDigit < 17) {\n let dIdx = 0;\n significandLow = Long.fromNumber(digits[dIdx++]);\n significandHigh = new Long(0, 0);\n\n for (; dIdx <= lastDigit; dIdx++) {\n significandLow = significandLow.multiply(Long.fromNumber(10));\n significandLow = significandLow.add(Long.fromNumber(digits[dIdx]));\n }\n } else {\n let dIdx = 0;\n significandHigh = Long.fromNumber(digits[dIdx++]);\n\n for (; dIdx <= lastDigit - 17; dIdx++) {\n significandHigh = significandHigh.multiply(Long.fromNumber(10));\n significandHigh = significandHigh.add(Long.fromNumber(digits[dIdx]));\n }\n\n significandLow = Long.fromNumber(digits[dIdx++]);\n\n for (; dIdx <= lastDigit; dIdx++) {\n significandLow = significandLow.multiply(Long.fromNumber(10));\n significandLow = significandLow.add(Long.fromNumber(digits[dIdx]));\n }\n }\n\n const significand = multiply64x2(significandHigh, Long.fromString('100000000000000000'));\n significand.low = significand.low.add(significandLow);\n\n if (lessThan(significand.low, significandLow)) {\n significand.high = significand.high.add(Long.fromNumber(1));\n }\n\n // Biased exponent\n biasedExponent = exponent + EXPONENT_BIAS;\n const dec = { low: Long.fromNumber(0), high: Long.fromNumber(0) };\n\n // Encode combination, exponent, and significand.\n if (\n significand.high.shiftRightUnsigned(49).and(Long.fromNumber(1)).equals(Long.fromNumber(1))\n ) {\n // Encode '11' into bits 1 to 3\n dec.high = dec.high.or(Long.fromNumber(0x3).shiftLeft(61));\n dec.high = dec.high.or(\n Long.fromNumber(biasedExponent).and(Long.fromNumber(0x3fff).shiftLeft(47))\n );\n dec.high = dec.high.or(significand.high.and(Long.fromNumber(0x7fffffffffff)));\n } else {\n dec.high = dec.high.or(Long.fromNumber(biasedExponent & 0x3fff).shiftLeft(49));\n dec.high = dec.high.or(significand.high.and(Long.fromNumber(0x1ffffffffffff)));\n }\n\n dec.low = significand.low;\n\n // Encode sign\n if (isNegative) {\n dec.high = dec.high.or(Long.fromString('9223372036854775808'));\n }\n\n // Encode into a buffer\n const buffer = ByteUtils.allocate(16);\n index = 0;\n\n // Encode the low 64 bits of the decimal\n // Encode low bits\n buffer[index++] = dec.low.low & 0xff;\n buffer[index++] = (dec.low.low >> 8) & 0xff;\n buffer[index++] = (dec.low.low >> 16) & 0xff;\n buffer[index++] = (dec.low.low >> 24) & 0xff;\n // Encode high bits\n buffer[index++] = dec.low.high & 0xff;\n buffer[index++] = (dec.low.high >> 8) & 0xff;\n buffer[index++] = (dec.low.high >> 16) & 0xff;\n buffer[index++] = (dec.low.high >> 24) & 0xff;\n\n // Encode the high 64 bits of the decimal\n // Encode low bits\n buffer[index++] = dec.high.low & 0xff;\n buffer[index++] = (dec.high.low >> 8) & 0xff;\n buffer[index++] = (dec.high.low >> 16) & 0xff;\n buffer[index++] = (dec.high.low >> 24) & 0xff;\n // Encode high bits\n buffer[index++] = dec.high.high & 0xff;\n buffer[index++] = (dec.high.high >> 8) & 0xff;\n buffer[index++] = (dec.high.high >> 16) & 0xff;\n buffer[index++] = (dec.high.high >> 24) & 0xff;\n\n // Return the new Decimal128\n return new Decimal128(buffer);\n }\n /** Create a string representation of the raw Decimal128 value */\n toString(): string {\n // Note: bits in this routine are referred to starting at 0,\n // from the sign bit, towards the coefficient.\n\n // decoded biased exponent (14 bits)\n let biased_exponent;\n // the number of significand digits\n let significand_digits = 0;\n // the base-10 digits in the significand\n const significand = new Array(36);\n for (let i = 0; i < significand.length; i++) significand[i] = 0;\n // read pointer into significand\n let index = 0;\n\n // true if the number is zero\n let is_zero = false;\n\n // the most significant significand bits (50-46)\n let significand_msb;\n // temporary storage for significand decoding\n let significand128: { parts: [number, number, number, number] } = { parts: [0, 0, 0, 0] };\n // indexing variables\n let j, k;\n\n // Output string\n const string: string[] = [];\n\n // Unpack index\n index = 0;\n\n // Buffer reference\n const buffer = this.bytes;\n\n // Unpack the low 64bits into a long\n // bits 96 - 127\n const low =\n buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);\n // bits 64 - 95\n const midl =\n buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);\n\n // Unpack the high 64bits into a long\n // bits 32 - 63\n const midh =\n buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);\n // bits 0 - 31\n const high =\n buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);\n\n // Unpack index\n index = 0;\n\n // Create the state of the decimal\n const dec = {\n low: new Long(low, midl),\n high: new Long(midh, high)\n };\n\n if (dec.high.lessThan(Long.ZERO)) {\n string.push('-');\n }\n\n // Decode combination field and exponent\n // bits 1 - 5\n const combination = (high >> 26) & COMBINATION_MASK;\n\n if (combination >> 3 === 3) {\n // Check for 'special' values\n if (combination === COMBINATION_INFINITY) {\n return string.join('') + 'Infinity';\n } else if (combination === COMBINATION_NAN) {\n return 'NaN';\n } else {\n biased_exponent = (high >> 15) & EXPONENT_MASK;\n significand_msb = 0x08 + ((high >> 14) & 0x01);\n }\n } else {\n significand_msb = (high >> 14) & 0x07;\n biased_exponent = (high >> 17) & EXPONENT_MASK;\n }\n\n // unbiased exponent\n const exponent = biased_exponent - EXPONENT_BIAS;\n\n // Create string of significand digits\n\n // Convert the 114-bit binary number represented by\n // (significand_high, significand_low) to at most 34 decimal\n // digits through modulo and division.\n significand128.parts[0] = (high & 0x3fff) + ((significand_msb & 0xf) << 14);\n significand128.parts[1] = midh;\n significand128.parts[2] = midl;\n significand128.parts[3] = low;\n\n if (\n significand128.parts[0] === 0 &&\n significand128.parts[1] === 0 &&\n significand128.parts[2] === 0 &&\n significand128.parts[3] === 0\n ) {\n is_zero = true;\n } else {\n for (k = 3; k >= 0; k--) {\n let least_digits = 0;\n // Perform the divide\n const result = divideu128(significand128);\n significand128 = result.quotient;\n least_digits = result.rem.low;\n\n // We now have the 9 least significant digits (in base 2).\n // Convert and output to string.\n if (!least_digits) continue;\n\n for (j = 8; j >= 0; j--) {\n // significand[k * 9 + j] = Math.round(least_digits % 10);\n significand[k * 9 + j] = least_digits % 10;\n // least_digits = Math.round(least_digits / 10);\n least_digits = Math.floor(least_digits / 10);\n }\n }\n }\n\n // Output format options:\n // Scientific - [-]d.dddE(+/-)dd or [-]dE(+/-)dd\n // Regular - ddd.ddd\n\n if (is_zero) {\n significand_digits = 1;\n significand[index] = 0;\n } else {\n significand_digits = 36;\n while (!significand[index]) {\n significand_digits = significand_digits - 1;\n index = index + 1;\n }\n }\n\n // the exponent if scientific notation is used\n const scientific_exponent = significand_digits - 1 + exponent;\n\n // The scientific exponent checks are dictated by the string conversion\n // specification and are somewhat arbitrary cutoffs.\n //\n // We must check exponent > 0, because if this is the case, the number\n // has trailing zeros. However, we *cannot* output these trailing zeros,\n // because doing so would change the precision of the value, and would\n // change stored data if the string converted number is round tripped.\n if (scientific_exponent >= 34 || scientific_exponent <= -7 || exponent > 0) {\n // Scientific format\n\n // if there are too many significant digits, we should just be treating numbers\n // as + or - 0 and using the non-scientific exponent (this is for the \"invalid\n // representation should be treated as 0/-0\" spec cases in decimal128-1.json)\n if (significand_digits > 34) {\n string.push(`${0}`);\n if (exponent > 0) string.push(`E+${exponent}`);\n else if (exponent < 0) string.push(`E${exponent}`);\n return string.join('');\n }\n\n string.push(`${significand[index++]}`);\n significand_digits = significand_digits - 1;\n\n if (significand_digits) {\n string.push('.');\n }\n\n for (let i = 0; i < significand_digits; i++) {\n string.push(`${significand[index++]}`);\n }\n\n // Exponent\n string.push('E');\n if (scientific_exponent > 0) {\n string.push(`+${scientific_exponent}`);\n } else {\n string.push(`${scientific_exponent}`);\n }\n } else {\n // Regular format with no decimal place\n if (exponent >= 0) {\n for (let i = 0; i < significand_digits; i++) {\n string.push(`${significand[index++]}`);\n }\n } else {\n let radix_position = significand_digits + exponent;\n\n // non-zero digits before radix\n if (radix_position > 0) {\n for (let i = 0; i < radix_position; i++) {\n string.push(`${significand[index++]}`);\n }\n } else {\n string.push('0');\n }\n\n string.push('.');\n // add leading zeros after radix\n while (radix_position++ < 0) {\n string.push('0');\n }\n\n for (let i = 0; i < significand_digits - Math.max(radix_position - 1, 0); i++) {\n string.push(`${significand[index++]}`);\n }\n }\n }\n\n return string.join('');\n }\n\n toJSON(): Decimal128Extended {\n return { $numberDecimal: this.toString() };\n }\n\n /** @internal */\n toExtendedJSON(): Decimal128Extended {\n return { $numberDecimal: this.toString() };\n }\n\n /** @internal */\n static fromExtendedJSON(doc: Decimal128Extended): Decimal128 {\n return Decimal128.fromString(doc.$numberDecimal);\n }\n\n inspect(depth?: number, options?: unknown, inspect?: InspectFn): string {\n inspect ??= defaultInspect;\n const d128string = inspect(this.toString(), options);\n return `new Decimal128(${d128string})`;\n }\n}\n","import { BSONValue } from './bson_value';\nimport type { EJSONOptions } from './extended_json';\nimport { type InspectFn, defaultInspect } from './parser/utils';\n\n/** @public */\nexport interface DoubleExtended {\n $numberDouble: string;\n}\n\n/**\n * A class representation of the BSON Double type.\n * @public\n * @category BSONType\n */\nexport class Double extends BSONValue {\n get _bsontype(): 'Double' {\n return 'Double';\n }\n\n value!: number;\n /**\n * Create a Double type\n *\n * @param value - the number we want to represent as a double.\n */\n constructor(value: number) {\n super();\n if ((value as unknown) instanceof Number) {\n value = value.valueOf();\n }\n\n this.value = +value;\n }\n\n /**\n * Access the number value.\n *\n * @returns returns the wrapped double number.\n */\n valueOf(): number {\n return this.value;\n }\n\n toJSON(): number {\n return this.value;\n }\n\n toString(radix?: number): string {\n return this.value.toString(radix);\n }\n\n /** @internal */\n toExtendedJSON(options?: EJSONOptions): number | DoubleExtended {\n if (options && (options.legacy || (options.relaxed && isFinite(this.value)))) {\n return this.value;\n }\n\n if (Object.is(Math.sign(this.value), -0)) {\n // NOTE: JavaScript has +0 and -0, apparently to model limit calculations. If a user\n // explicitly provided `-0` then we need to ensure the sign makes it into the output\n return { $numberDouble: '-0.0' };\n }\n\n return {\n $numberDouble: Number.isInteger(this.value) ? this.value.toFixed(1) : this.value.toString()\n };\n }\n\n /** @internal */\n static fromExtendedJSON(doc: DoubleExtended, options?: EJSONOptions): number | Double {\n const doubleValue = parseFloat(doc.$numberDouble);\n return options && options.relaxed ? doubleValue : new Double(doubleValue);\n }\n\n inspect(depth?: number, options?: unknown, inspect?: InspectFn): string {\n inspect ??= defaultInspect;\n return `new Double(${inspect(this.value, options)})`;\n }\n}\n","import { BSONValue } from './bson_value';\nimport type { EJSONOptions } from './extended_json';\nimport { type InspectFn, defaultInspect } from './parser/utils';\n\n/** @public */\nexport interface Int32Extended {\n $numberInt: string;\n}\n\n/**\n * A class representation of a BSON Int32 type.\n * @public\n * @category BSONType\n */\nexport class Int32 extends BSONValue {\n get _bsontype(): 'Int32' {\n return 'Int32';\n }\n\n value!: number;\n /**\n * Create an Int32 type\n *\n * @param value - the number we want to represent as an int32.\n */\n constructor(value: number | string) {\n super();\n if ((value as unknown) instanceof Number) {\n value = value.valueOf();\n }\n\n this.value = +value | 0;\n }\n\n /**\n * Access the number value.\n *\n * @returns returns the wrapped int32 number.\n */\n valueOf(): number {\n return this.value;\n }\n\n toString(radix?: number): string {\n return this.value.toString(radix);\n }\n\n toJSON(): number {\n return this.value;\n }\n\n /** @internal */\n toExtendedJSON(options?: EJSONOptions): number | Int32Extended {\n if (options && (options.relaxed || options.legacy)) return this.value;\n return { $numberInt: this.value.toString() };\n }\n\n /** @internal */\n static fromExtendedJSON(doc: Int32Extended, options?: EJSONOptions): number | Int32 {\n return options && options.relaxed ? parseInt(doc.$numberInt, 10) : new Int32(doc.$numberInt);\n }\n\n inspect(depth?: number, options?: unknown, inspect?: InspectFn): string {\n inspect ??= defaultInspect;\n return `new Int32(${inspect(this.value, options)})`;\n }\n}\n","import { BSONValue } from './bson_value';\n\n/** @public */\nexport interface MaxKeyExtended {\n $maxKey: 1;\n}\n\n/**\n * A class representation of the BSON MaxKey type.\n * @public\n * @category BSONType\n */\nexport class MaxKey extends BSONValue {\n get _bsontype(): 'MaxKey' {\n return 'MaxKey';\n }\n\n /** @internal */\n toExtendedJSON(): MaxKeyExtended {\n return { $maxKey: 1 };\n }\n\n /** @internal */\n static fromExtendedJSON(): MaxKey {\n return new MaxKey();\n }\n\n inspect(): string {\n return 'new MaxKey()';\n }\n}\n","import { BSONValue } from './bson_value';\n\n/** @public */\nexport interface MinKeyExtended {\n $minKey: 1;\n}\n\n/**\n * A class representation of the BSON MinKey type.\n * @public\n * @category BSONType\n */\nexport class MinKey extends BSONValue {\n get _bsontype(): 'MinKey' {\n return 'MinKey';\n }\n\n /** @internal */\n toExtendedJSON(): MinKeyExtended {\n return { $minKey: 1 };\n }\n\n /** @internal */\n static fromExtendedJSON(): MinKey {\n return new MinKey();\n }\n\n inspect(): string {\n return 'new MinKey()';\n }\n}\n","import { BSONValue } from './bson_value';\nimport { BSONError } from './error';\nimport { type InspectFn, defaultInspect } from './parser/utils';\nimport { BSONDataView, ByteUtils } from './utils/byte_utils';\n\n// Regular expression that checks for hex value\nconst checkForHexRegExp = new RegExp('^[0-9a-fA-F]{24}$');\n\n// Unique sequence for the current process (initialized on first use)\nlet PROCESS_UNIQUE: Uint8Array | null = null;\n\n/** @public */\nexport interface ObjectIdLike {\n id: string | Uint8Array;\n __id?: string;\n toHexString(): string;\n}\n\n/** @public */\nexport interface ObjectIdExtended {\n $oid: string;\n}\n\nconst kId = Symbol('id');\n\n/**\n * A class representation of the BSON ObjectId type.\n * @public\n * @category BSONType\n */\nexport class ObjectId extends BSONValue {\n get _bsontype(): 'ObjectId' {\n return 'ObjectId';\n }\n\n /** @internal */\n private static index = Math.floor(Math.random() * 0xffffff);\n\n static cacheHexString: boolean;\n\n /** ObjectId Bytes @internal */\n private [kId]!: Uint8Array;\n /** ObjectId hexString cache @internal */\n private __id?: string;\n\n /**\n * Create an ObjectId type\n *\n * @param inputId - Can be a 24 character hex string, 12 byte binary Buffer, or a number.\n */\n constructor(inputId?: string | number | ObjectId | ObjectIdLike | Uint8Array) {\n super();\n // workingId is set based on type of input and whether valid id exists for the input\n let workingId;\n if (typeof inputId === 'object' && inputId && 'id' in inputId) {\n if (typeof inputId.id !== 'string' && !ArrayBuffer.isView(inputId.id)) {\n throw new BSONError('Argument passed in must have an id that is of type string or Buffer');\n }\n if ('toHexString' in inputId && typeof inputId.toHexString === 'function') {\n workingId = ByteUtils.fromHex(inputId.toHexString());\n } else {\n workingId = inputId.id;\n }\n } else {\n workingId = inputId;\n }\n\n // the following cases use workingId to construct an ObjectId\n if (workingId == null || typeof workingId === 'number') {\n // The most common use case (blank id, new objectId instance)\n // Generate a new id\n this[kId] = ObjectId.generate(typeof workingId === 'number' ? workingId : undefined);\n } else if (ArrayBuffer.isView(workingId) && workingId.byteLength === 12) {\n // If intstanceof matches we can escape calling ensure buffer in Node.js environments\n this[kId] = ByteUtils.toLocalBufferType(workingId);\n } else if (typeof workingId === 'string') {\n if (workingId.length === 24 && checkForHexRegExp.test(workingId)) {\n this[kId] = ByteUtils.fromHex(workingId);\n } else {\n throw new BSONError(\n 'input must be a 24 character hex string, 12 byte Uint8Array, or an integer'\n );\n }\n } else {\n throw new BSONError('Argument passed in does not match the accepted types');\n }\n // If we are caching the hex string\n if (ObjectId.cacheHexString) {\n this.__id = ByteUtils.toHex(this.id);\n }\n }\n\n /**\n * The ObjectId bytes\n * @readonly\n */\n get id(): Uint8Array {\n return this[kId];\n }\n\n set id(value: Uint8Array) {\n this[kId] = value;\n if (ObjectId.cacheHexString) {\n this.__id = ByteUtils.toHex(value);\n }\n }\n\n /** Returns the ObjectId id as a 24 lowercase character hex string representation */\n toHexString(): string {\n if (ObjectId.cacheHexString && this.__id) {\n return this.__id;\n }\n\n const hexString = ByteUtils.toHex(this.id);\n\n if (ObjectId.cacheHexString && !this.__id) {\n this.__id = hexString;\n }\n\n return hexString;\n }\n\n /**\n * Update the ObjectId index\n * @internal\n */\n private static getInc(): number {\n return (ObjectId.index = (ObjectId.index + 1) % 0xffffff);\n }\n\n /**\n * Generate a 12 byte id buffer used in ObjectId's\n *\n * @param time - pass in a second based timestamp.\n */\n static generate(time?: number): Uint8Array {\n if ('number' !== typeof time) {\n time = Math.floor(Date.now() / 1000);\n }\n\n const inc = ObjectId.getInc();\n const buffer = ByteUtils.allocate(12);\n\n // 4-byte timestamp\n BSONDataView.fromUint8Array(buffer).setUint32(0, time, false);\n\n // set PROCESS_UNIQUE if yet not initialized\n if (PROCESS_UNIQUE === null) {\n PROCESS_UNIQUE = ByteUtils.randomBytes(5);\n }\n\n // 5-byte process unique\n buffer[4] = PROCESS_UNIQUE[0];\n buffer[5] = PROCESS_UNIQUE[1];\n buffer[6] = PROCESS_UNIQUE[2];\n buffer[7] = PROCESS_UNIQUE[3];\n buffer[8] = PROCESS_UNIQUE[4];\n\n // 3-byte counter\n buffer[11] = inc & 0xff;\n buffer[10] = (inc >> 8) & 0xff;\n buffer[9] = (inc >> 16) & 0xff;\n\n return buffer;\n }\n\n /**\n * Converts the id into a 24 character hex string for printing, unless encoding is provided.\n * @param encoding - hex or base64\n */\n toString(encoding?: 'hex' | 'base64'): string {\n // Is the id a buffer then use the buffer toString method to return the format\n if (encoding === 'base64') return ByteUtils.toBase64(this.id);\n if (encoding === 'hex') return this.toHexString();\n return this.toHexString();\n }\n\n /** Converts to its JSON the 24 character hex string representation. */\n toJSON(): string {\n return this.toHexString();\n }\n\n /** @internal */\n private static is(variable: unknown): variable is ObjectId {\n return (\n variable != null &&\n typeof variable === 'object' &&\n '_bsontype' in variable &&\n variable._bsontype === 'ObjectId'\n );\n }\n\n /**\n * Compares the equality of this ObjectId with `otherID`.\n *\n * @param otherId - ObjectId instance to compare against.\n */\n equals(otherId: string | ObjectId | ObjectIdLike | undefined | null): boolean {\n if (otherId === undefined || otherId === null) {\n return false;\n }\n\n if (ObjectId.is(otherId)) {\n return this[kId][11] === otherId[kId][11] && ByteUtils.equals(this[kId], otherId[kId]);\n }\n\n if (typeof otherId === 'string') {\n return otherId.toLowerCase() === this.toHexString();\n }\n\n if (typeof otherId === 'object' && typeof otherId.toHexString === 'function') {\n const otherIdString = otherId.toHexString();\n const thisIdString = this.toHexString();\n return typeof otherIdString === 'string' && otherIdString.toLowerCase() === thisIdString;\n }\n\n return false;\n }\n\n /** Returns the generation date (accurate up to the second) that this ID was generated. */\n getTimestamp(): Date {\n const timestamp = new Date();\n const time = BSONDataView.fromUint8Array(this.id).getUint32(0, false);\n timestamp.setTime(Math.floor(time) * 1000);\n return timestamp;\n }\n\n /** @internal */\n static createPk(): ObjectId {\n return new ObjectId();\n }\n\n /**\n * Creates an ObjectId from a second based number, with the rest of the ObjectId zeroed out. Used for comparisons or sorting the ObjectId.\n *\n * @param time - an integer number representing a number of seconds.\n */\n static createFromTime(time: number): ObjectId {\n const buffer = ByteUtils.fromNumberArray([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);\n // Encode time into first 4 bytes\n BSONDataView.fromUint8Array(buffer).setUint32(0, time, false);\n // Return the new objectId\n return new ObjectId(buffer);\n }\n\n /**\n * Creates an ObjectId from a hex string representation of an ObjectId.\n *\n * @param hexString - create a ObjectId from a passed in 24 character hexstring.\n */\n static createFromHexString(hexString: string): ObjectId {\n if (hexString?.length !== 24) {\n throw new BSONError('hex string must be 24 characters');\n }\n\n return new ObjectId(ByteUtils.fromHex(hexString));\n }\n\n /** Creates an ObjectId instance from a base64 string */\n static createFromBase64(base64: string): ObjectId {\n if (base64?.length !== 16) {\n throw new BSONError('base64 string must be 16 characters');\n }\n\n return new ObjectId(ByteUtils.fromBase64(base64));\n }\n\n /**\n * Checks if a value can be used to create a valid bson ObjectId\n * @param id - any JS value\n */\n static isValid(id: string | number | ObjectId | ObjectIdLike | Uint8Array): boolean {\n if (id == null) return false;\n\n try {\n new ObjectId(id);\n return true;\n } catch {\n return false;\n }\n }\n\n /** @internal */\n toExtendedJSON(): ObjectIdExtended {\n if (this.toHexString) return { $oid: this.toHexString() };\n return { $oid: this.toString('hex') };\n }\n\n /** @internal */\n static fromExtendedJSON(doc: ObjectIdExtended): ObjectId {\n return new ObjectId(doc.$oid);\n }\n\n /**\n * Converts to a string representation of this Id.\n *\n * @returns return the 24 character hex string representation.\n */\n inspect(depth?: number, options?: unknown, inspect?: InspectFn): string {\n inspect ??= defaultInspect;\n return `new ObjectId(${inspect(this.toHexString(), options)})`;\n }\n}\n","import { Binary } from '../binary';\nimport type { Document } from '../bson';\nimport { BSONVersionError } from '../error';\nimport * as constants from '../constants';\nimport { ByteUtils } from '../utils/byte_utils';\nimport { isAnyArrayBuffer, isDate, isRegExp } from './utils';\n\nexport function internalCalculateObjectSize(\n object: Document,\n serializeFunctions?: boolean,\n ignoreUndefined?: boolean\n): number {\n let totalLength = 4 + 1;\n\n if (Array.isArray(object)) {\n for (let i = 0; i < object.length; i++) {\n totalLength += calculateElement(\n i.toString(),\n object[i],\n serializeFunctions,\n true,\n ignoreUndefined\n );\n }\n } else {\n // If we have toBSON defined, override the current object\n\n if (typeof object?.toBSON === 'function') {\n object = object.toBSON();\n }\n\n // Calculate size\n for (const key of Object.keys(object)) {\n totalLength += calculateElement(key, object[key], serializeFunctions, false, ignoreUndefined);\n }\n }\n\n return totalLength;\n}\n\n/** @internal */\nfunction calculateElement(\n name: string,\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n value: any,\n serializeFunctions = false,\n isArray = false,\n ignoreUndefined = false\n) {\n // If we have toBSON defined, override the current object\n if (typeof value?.toBSON === 'function') {\n value = value.toBSON();\n }\n\n switch (typeof value) {\n case 'string':\n return 1 + ByteUtils.utf8ByteLength(name) + 1 + 4 + ByteUtils.utf8ByteLength(value) + 1;\n case 'number':\n if (\n Math.floor(value) === value &&\n value >= constants.JS_INT_MIN &&\n value <= constants.JS_INT_MAX\n ) {\n if (value >= constants.BSON_INT32_MIN && value <= constants.BSON_INT32_MAX) {\n // 32 bit\n return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (4 + 1);\n } else {\n return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (8 + 1);\n }\n } else {\n // 64 bit\n return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (8 + 1);\n }\n case 'undefined':\n if (isArray || !ignoreUndefined)\n return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + 1;\n return 0;\n case 'boolean':\n return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (1 + 1);\n case 'object':\n if (\n value != null &&\n typeof value._bsontype === 'string' &&\n value[Symbol.for('@@mdb.bson.version')] !== constants.BSON_MAJOR_VERSION\n ) {\n throw new BSONVersionError();\n } else if (value == null || value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {\n return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + 1;\n } else if (value._bsontype === 'ObjectId') {\n return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (12 + 1);\n } else if (value instanceof Date || isDate(value)) {\n return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (8 + 1);\n } else if (\n ArrayBuffer.isView(value) ||\n value instanceof ArrayBuffer ||\n isAnyArrayBuffer(value)\n ) {\n return (\n (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (1 + 4 + 1) + value.byteLength\n );\n } else if (\n value._bsontype === 'Long' ||\n value._bsontype === 'Double' ||\n value._bsontype === 'Timestamp'\n ) {\n return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (8 + 1);\n } else if (value._bsontype === 'Decimal128') {\n return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (16 + 1);\n } else if (value._bsontype === 'Code') {\n // Calculate size depending on the availability of a scope\n if (value.scope != null && Object.keys(value.scope).length > 0) {\n return (\n (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +\n 1 +\n 4 +\n 4 +\n ByteUtils.utf8ByteLength(value.code.toString()) +\n 1 +\n internalCalculateObjectSize(value.scope, serializeFunctions, ignoreUndefined)\n );\n } else {\n return (\n (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +\n 1 +\n 4 +\n ByteUtils.utf8ByteLength(value.code.toString()) +\n 1\n );\n }\n } else if (value._bsontype === 'Binary') {\n const binary: Binary = value;\n // Check what kind of subtype we have\n if (binary.sub_type === Binary.SUBTYPE_BYTE_ARRAY) {\n return (\n (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +\n (binary.position + 1 + 4 + 1 + 4)\n );\n } else {\n return (\n (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (binary.position + 1 + 4 + 1)\n );\n }\n } else if (value._bsontype === 'Symbol') {\n return (\n (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +\n ByteUtils.utf8ByteLength(value.value) +\n 4 +\n 1 +\n 1\n );\n } else if (value._bsontype === 'DBRef') {\n // Set up correct object for serialization\n const ordered_values = Object.assign(\n {\n $ref: value.collection,\n $id: value.oid\n },\n value.fields\n );\n\n // Add db reference if it exists\n if (value.db != null) {\n ordered_values['$db'] = value.db;\n }\n\n return (\n (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +\n 1 +\n internalCalculateObjectSize(ordered_values, serializeFunctions, ignoreUndefined)\n );\n } else if (value instanceof RegExp || isRegExp(value)) {\n return (\n (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +\n 1 +\n ByteUtils.utf8ByteLength(value.source) +\n 1 +\n (value.global ? 1 : 0) +\n (value.ignoreCase ? 1 : 0) +\n (value.multiline ? 1 : 0) +\n 1\n );\n } else if (value._bsontype === 'BSONRegExp') {\n return (\n (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +\n 1 +\n ByteUtils.utf8ByteLength(value.pattern) +\n 1 +\n ByteUtils.utf8ByteLength(value.options) +\n 1\n );\n } else {\n return (\n (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +\n internalCalculateObjectSize(value, serializeFunctions, ignoreUndefined) +\n 1\n );\n }\n case 'function':\n if (serializeFunctions) {\n return (\n (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +\n 1 +\n 4 +\n ByteUtils.utf8ByteLength(value.toString()) +\n 1\n );\n }\n }\n\n return 0;\n}\n","import { BSONValue } from './bson_value';\nimport { BSONError } from './error';\nimport type { EJSONOptions } from './extended_json';\nimport { type InspectFn, defaultInspect, getStylizeFunction } from './parser/utils';\n\nfunction alphabetize(str: string): string {\n return str.split('').sort().join('');\n}\n\n/** @public */\nexport interface BSONRegExpExtendedLegacy {\n $regex: string | BSONRegExp;\n $options: string;\n}\n\n/** @public */\nexport interface BSONRegExpExtended {\n $regularExpression: {\n pattern: string;\n options: string;\n };\n}\n\n/**\n * A class representation of the BSON RegExp type.\n * @public\n * @category BSONType\n */\nexport class BSONRegExp extends BSONValue {\n get _bsontype(): 'BSONRegExp' {\n return 'BSONRegExp';\n }\n\n pattern!: string;\n options!: string;\n /**\n * @param pattern - The regular expression pattern to match\n * @param options - The regular expression options\n */\n constructor(pattern: string, options?: string) {\n super();\n this.pattern = pattern;\n this.options = alphabetize(options ?? '');\n\n if (this.pattern.indexOf('\\x00') !== -1) {\n throw new BSONError(\n `BSON Regex patterns cannot contain null bytes, found: ${JSON.stringify(this.pattern)}`\n );\n }\n if (this.options.indexOf('\\x00') !== -1) {\n throw new BSONError(\n `BSON Regex options cannot contain null bytes, found: ${JSON.stringify(this.options)}`\n );\n }\n\n // Validate options\n for (let i = 0; i < this.options.length; i++) {\n if (\n !(\n this.options[i] === 'i' ||\n this.options[i] === 'm' ||\n this.options[i] === 'x' ||\n this.options[i] === 'l' ||\n this.options[i] === 's' ||\n this.options[i] === 'u'\n )\n ) {\n throw new BSONError(`The regular expression option [${this.options[i]}] is not supported`);\n }\n }\n }\n\n static parseOptions(options?: string): string {\n return options ? options.split('').sort().join('') : '';\n }\n\n /** @internal */\n toExtendedJSON(options?: EJSONOptions): BSONRegExpExtendedLegacy | BSONRegExpExtended {\n options = options || {};\n if (options.legacy) {\n return { $regex: this.pattern, $options: this.options };\n }\n return { $regularExpression: { pattern: this.pattern, options: this.options } };\n }\n\n /** @internal */\n static fromExtendedJSON(doc: BSONRegExpExtendedLegacy | BSONRegExpExtended): BSONRegExp {\n if ('$regex' in doc) {\n if (typeof doc.$regex !== 'string') {\n // This is for $regex query operators that have extended json values.\n if (doc.$regex._bsontype === 'BSONRegExp') {\n return doc as unknown as BSONRegExp;\n }\n } else {\n return new BSONRegExp(doc.$regex, BSONRegExp.parseOptions(doc.$options));\n }\n }\n if ('$regularExpression' in doc) {\n return new BSONRegExp(\n doc.$regularExpression.pattern,\n BSONRegExp.parseOptions(doc.$regularExpression.options)\n );\n }\n throw new BSONError(`Unexpected BSONRegExp EJSON object form: ${JSON.stringify(doc)}`);\n }\n\n inspect(depth?: number, options?: unknown, inspect?: InspectFn): string {\n const stylize = getStylizeFunction(options) ?? (v => v);\n inspect ??= defaultInspect;\n const pattern = stylize(inspect(this.pattern), 'regexp');\n const flags = stylize(inspect(this.options), 'regexp');\n return `new BSONRegExp(${pattern}, ${flags})`;\n }\n}\n","import { BSONValue } from './bson_value';\nimport { type InspectFn, defaultInspect } from './parser/utils';\n\n/** @public */\nexport interface BSONSymbolExtended {\n $symbol: string;\n}\n\n/**\n * A class representation of the BSON Symbol type.\n * @public\n * @category BSONType\n */\nexport class BSONSymbol extends BSONValue {\n get _bsontype(): 'BSONSymbol' {\n return 'BSONSymbol';\n }\n\n value!: string;\n /**\n * @param value - the string representing the symbol.\n */\n constructor(value: string) {\n super();\n this.value = value;\n }\n\n /** Access the wrapped string value. */\n valueOf(): string {\n return this.value;\n }\n\n toString(): string {\n return this.value;\n }\n\n toJSON(): string {\n return this.value;\n }\n\n /** @internal */\n toExtendedJSON(): BSONSymbolExtended {\n return { $symbol: this.value };\n }\n\n /** @internal */\n static fromExtendedJSON(doc: BSONSymbolExtended): BSONSymbol {\n return new BSONSymbol(doc.$symbol);\n }\n\n inspect(depth?: number, options?: unknown, inspect?: InspectFn): string {\n inspect ??= defaultInspect;\n return `new BSONSymbol(${inspect(this.value, options)})`;\n }\n}\n","import { BSONError } from './error';\nimport type { Int32 } from './int_32';\nimport { Long } from './long';\nimport { type InspectFn, defaultInspect } from './parser/utils';\n\n/** @public */\nexport type TimestampOverrides = '_bsontype' | 'toExtendedJSON' | 'fromExtendedJSON' | 'inspect';\n/** @public */\nexport type LongWithoutOverrides = new (\n low: unknown,\n high?: number | boolean,\n unsigned?: boolean\n) => {\n [P in Exclude]: Long[P];\n};\n/** @public */\nexport const LongWithoutOverridesClass: LongWithoutOverrides =\n Long as unknown as LongWithoutOverrides;\n\n/** @public */\nexport interface TimestampExtended {\n $timestamp: {\n t: number;\n i: number;\n };\n}\n\n/**\n * @public\n * @category BSONType\n */\nexport class Timestamp extends LongWithoutOverridesClass {\n get _bsontype(): 'Timestamp' {\n return 'Timestamp';\n }\n\n static readonly MAX_VALUE = Long.MAX_UNSIGNED_VALUE;\n\n /**\n * @param int - A 64-bit bigint representing the Timestamp.\n */\n constructor(int: bigint);\n /**\n * @param long - A 64-bit Long representing the Timestamp.\n */\n constructor(long: Long);\n /**\n * @param value - A pair of two values indicating timestamp and increment.\n */\n constructor(value: { t: number; i: number });\n constructor(low?: bigint | Long | { t: number | Int32; i: number | Int32 }) {\n if (low == null) {\n super(0, 0, true);\n } else if (typeof low === 'bigint') {\n super(low, true);\n } else if (Long.isLong(low)) {\n super(low.low, low.high, true);\n } else if (typeof low === 'object' && 't' in low && 'i' in low) {\n if (typeof low.t !== 'number' && (typeof low.t !== 'object' || low.t._bsontype !== 'Int32')) {\n throw new BSONError('Timestamp constructed from { t, i } must provide t as a number');\n }\n if (typeof low.i !== 'number' && (typeof low.i !== 'object' || low.i._bsontype !== 'Int32')) {\n throw new BSONError('Timestamp constructed from { t, i } must provide i as a number');\n }\n const t = Number(low.t);\n const i = Number(low.i);\n if (t < 0 || Number.isNaN(t)) {\n throw new BSONError('Timestamp constructed from { t, i } must provide a positive t');\n }\n if (i < 0 || Number.isNaN(i)) {\n throw new BSONError('Timestamp constructed from { t, i } must provide a positive i');\n }\n if (t > 0xffff_ffff) {\n throw new BSONError(\n 'Timestamp constructed from { t, i } must provide t equal or less than uint32 max'\n );\n }\n if (i > 0xffff_ffff) {\n throw new BSONError(\n 'Timestamp constructed from { t, i } must provide i equal or less than uint32 max'\n );\n }\n\n super(i, t, true);\n } else {\n throw new BSONError(\n 'A Timestamp can only be constructed with: bigint, Long, or { t: number; i: number }'\n );\n }\n }\n\n toJSON(): { $timestamp: string } {\n return {\n $timestamp: this.toString()\n };\n }\n\n /** Returns a Timestamp represented by the given (32-bit) integer value. */\n static fromInt(value: number): Timestamp {\n return new Timestamp(Long.fromInt(value, true));\n }\n\n /** Returns a Timestamp representing the given number value, provided that it is a finite number. Otherwise, zero is returned. */\n static fromNumber(value: number): Timestamp {\n return new Timestamp(Long.fromNumber(value, true));\n }\n\n /**\n * Returns a Timestamp for the given high and low bits. Each is assumed to use 32 bits.\n *\n * @param lowBits - the low 32-bits.\n * @param highBits - the high 32-bits.\n */\n static fromBits(lowBits: number, highBits: number): Timestamp {\n return new Timestamp({ i: lowBits, t: highBits });\n }\n\n /**\n * Returns a Timestamp from the given string, optionally using the given radix.\n *\n * @param str - the textual representation of the Timestamp.\n * @param optRadix - the radix in which the text is written.\n */\n static fromString(str: string, optRadix: number): Timestamp {\n return new Timestamp(Long.fromString(str, true, optRadix));\n }\n\n /** @internal */\n toExtendedJSON(): TimestampExtended {\n return { $timestamp: { t: this.high >>> 0, i: this.low >>> 0 } };\n }\n\n /** @internal */\n static fromExtendedJSON(doc: TimestampExtended): Timestamp {\n // The Long check is necessary because extended JSON has different behavior given the size of the input number\n const i = Long.isLong(doc.$timestamp.i)\n ? doc.$timestamp.i.getLowBitsUnsigned() // Need to fetch the least significant 32 bits\n : doc.$timestamp.i;\n const t = Long.isLong(doc.$timestamp.t)\n ? doc.$timestamp.t.getLowBitsUnsigned() // Need to fetch the least significant 32 bits\n : doc.$timestamp.t;\n return new Timestamp({ t, i });\n }\n\n inspect(depth?: number, options?: unknown, inspect?: InspectFn): string {\n inspect ??= defaultInspect;\n const t = inspect(this.high >>> 0, options);\n const i = inspect(this.low >>> 0, options);\n return `new Timestamp({ t: ${t}, i: ${i} })`;\n }\n}\n","const FIRST_BIT = 0x80;\nconst FIRST_TWO_BITS = 0xc0;\nconst FIRST_THREE_BITS = 0xe0;\nconst FIRST_FOUR_BITS = 0xf0;\nconst FIRST_FIVE_BITS = 0xf8;\n\nconst TWO_BIT_CHAR = 0xc0;\nconst THREE_BIT_CHAR = 0xe0;\nconst FOUR_BIT_CHAR = 0xf0;\nconst CONTINUING_CHAR = 0x80;\n\n/**\n * Determines if the passed in bytes are valid utf8\n * @param bytes - An array of 8-bit bytes. Must be indexable and have length property\n * @param start - The index to start validating\n * @param end - The index to end validating\n */\nexport function validateUtf8(\n bytes: { [index: number]: number },\n start: number,\n end: number\n): boolean {\n let continuation = 0;\n\n for (let i = start; i < end; i += 1) {\n const byte = bytes[i];\n\n if (continuation) {\n if ((byte & FIRST_TWO_BITS) !== CONTINUING_CHAR) {\n return false;\n }\n continuation -= 1;\n } else if (byte & FIRST_BIT) {\n if ((byte & FIRST_THREE_BITS) === TWO_BIT_CHAR) {\n continuation = 1;\n } else if ((byte & FIRST_FOUR_BITS) === THREE_BIT_CHAR) {\n continuation = 2;\n } else if ((byte & FIRST_FIVE_BITS) === FOUR_BIT_CHAR) {\n continuation = 3;\n } else {\n return false;\n }\n }\n }\n\n return !continuation;\n}\n","import { Binary, UUID } from '../binary';\nimport type { Document } from '../bson';\nimport { Code } from '../code';\nimport * as constants from '../constants';\nimport { DBRef, type DBRefLike, isDBRefLike } from '../db_ref';\nimport { Decimal128 } from '../decimal128';\nimport { Double } from '../double';\nimport { BSONError } from '../error';\nimport { Int32 } from '../int_32';\nimport { Long } from '../long';\nimport { MaxKey } from '../max_key';\nimport { MinKey } from '../min_key';\nimport { ObjectId } from '../objectid';\nimport { BSONRegExp } from '../regexp';\nimport { BSONSymbol } from '../symbol';\nimport { Timestamp } from '../timestamp';\nimport { BSONDataView, ByteUtils } from '../utils/byte_utils';\nimport { validateUtf8 } from '../validate_utf8';\n\n/** @public */\nexport interface DeserializeOptions {\n /**\n * when deserializing a Long return as a BigInt.\n * @defaultValue `false`\n */\n useBigInt64?: boolean;\n /**\n * when deserializing a Long will fit it into a Number if it's smaller than 53 bits.\n * @defaultValue `true`\n */\n promoteLongs?: boolean;\n /**\n * when deserializing a Binary will return it as a node.js Buffer instance.\n * @defaultValue `false`\n */\n promoteBuffers?: boolean;\n /**\n * when deserializing will promote BSON values to their Node.js closest equivalent types.\n * @defaultValue `true`\n */\n promoteValues?: boolean;\n /**\n * allow to specify if there what fields we wish to return as unserialized raw buffer.\n * @defaultValue `null`\n */\n fieldsAsRaw?: Document;\n /**\n * return BSON regular expressions as BSONRegExp instances.\n * @defaultValue `false`\n */\n bsonRegExp?: boolean;\n /**\n * allows the buffer to be larger than the parsed BSON object.\n * @defaultValue `false`\n */\n allowObjectSmallerThanBufferSize?: boolean;\n /**\n * Offset into buffer to begin reading document from\n * @defaultValue `0`\n */\n index?: number;\n\n raw?: boolean;\n /** Allows for opt-out utf-8 validation for all keys or\n * specified keys. Must be all true or all false.\n *\n * @example\n * ```js\n * // disables validation on all keys\n * validation: { utf8: false }\n *\n * // enables validation only on specified keys a, b, and c\n * validation: { utf8: { a: true, b: true, c: true } }\n *\n * // disables validation only on specified keys a, b\n * validation: { utf8: { a: false, b: false } }\n * ```\n */\n validation?: { utf8: boolean | Record | Record };\n}\n\n// Internal long versions\nconst JS_INT_MAX_LONG = Long.fromNumber(constants.JS_INT_MAX);\nconst JS_INT_MIN_LONG = Long.fromNumber(constants.JS_INT_MIN);\n\nexport function internalDeserialize(\n buffer: Uint8Array,\n options: DeserializeOptions,\n isArray?: boolean\n): Document {\n options = options == null ? {} : options;\n const index = options && options.index ? options.index : 0;\n // Read the document size\n const size =\n buffer[index] |\n (buffer[index + 1] << 8) |\n (buffer[index + 2] << 16) |\n (buffer[index + 3] << 24);\n\n if (size < 5) {\n throw new BSONError(`bson size must be >= 5, is ${size}`);\n }\n\n if (options.allowObjectSmallerThanBufferSize && buffer.length < size) {\n throw new BSONError(`buffer length ${buffer.length} must be >= bson size ${size}`);\n }\n\n if (!options.allowObjectSmallerThanBufferSize && buffer.length !== size) {\n throw new BSONError(`buffer length ${buffer.length} must === bson size ${size}`);\n }\n\n if (size + index > buffer.byteLength) {\n throw new BSONError(\n `(bson size ${size} + options.index ${index} must be <= buffer length ${buffer.byteLength})`\n );\n }\n\n // Illegal end value\n if (buffer[index + size - 1] !== 0) {\n throw new BSONError(\n \"One object, sized correctly, with a spot for an EOO, but the EOO isn't 0x00\"\n );\n }\n\n // Start deserialization\n return deserializeObject(buffer, index, options, isArray);\n}\n\nconst allowedDBRefKeys = /^\\$ref$|^\\$id$|^\\$db$/;\n\nfunction deserializeObject(\n buffer: Uint8Array,\n index: number,\n options: DeserializeOptions,\n isArray = false\n) {\n const fieldsAsRaw = options['fieldsAsRaw'] == null ? null : options['fieldsAsRaw'];\n\n // Return raw bson buffer instead of parsing it\n const raw = options['raw'] == null ? false : options['raw'];\n\n // Return BSONRegExp objects instead of native regular expressions\n const bsonRegExp = typeof options['bsonRegExp'] === 'boolean' ? options['bsonRegExp'] : false;\n\n // Controls the promotion of values vs wrapper classes\n const promoteBuffers = options.promoteBuffers ?? false;\n const promoteLongs = options.promoteLongs ?? true;\n const promoteValues = options.promoteValues ?? true;\n const useBigInt64 = options.useBigInt64 ?? false;\n\n if (useBigInt64 && !promoteValues) {\n throw new BSONError('Must either request bigint or Long for int64 deserialization');\n }\n\n if (useBigInt64 && !promoteLongs) {\n throw new BSONError('Must either request bigint or Long for int64 deserialization');\n }\n\n // Ensures default validation option if none given\n const validation = options.validation == null ? { utf8: true } : options.validation;\n\n // Shows if global utf-8 validation is enabled or disabled\n let globalUTFValidation = true;\n // Reflects utf-8 validation setting regardless of global or specific key validation\n let validationSetting: boolean;\n // Set of keys either to enable or disable validation on\n const utf8KeysSet = new Set();\n\n // Check for boolean uniformity and empty validation option\n const utf8ValidatedKeys = validation.utf8;\n if (typeof utf8ValidatedKeys === 'boolean') {\n validationSetting = utf8ValidatedKeys;\n } else {\n globalUTFValidation = false;\n const utf8ValidationValues = Object.keys(utf8ValidatedKeys).map(function (key) {\n return utf8ValidatedKeys[key];\n });\n if (utf8ValidationValues.length === 0) {\n throw new BSONError('UTF-8 validation setting cannot be empty');\n }\n if (typeof utf8ValidationValues[0] !== 'boolean') {\n throw new BSONError('Invalid UTF-8 validation option, must specify boolean values');\n }\n validationSetting = utf8ValidationValues[0];\n // Ensures boolean uniformity in utf-8 validation (all true or all false)\n if (!utf8ValidationValues.every(item => item === validationSetting)) {\n throw new BSONError('Invalid UTF-8 validation option - keys must be all true or all false');\n }\n }\n\n // Add keys to set that will either be validated or not based on validationSetting\n if (!globalUTFValidation) {\n for (const key of Object.keys(utf8ValidatedKeys)) {\n utf8KeysSet.add(key);\n }\n }\n\n // Set the start index\n const startIndex = index;\n\n // Validate that we have at least 4 bytes of buffer\n if (buffer.length < 5) throw new BSONError('corrupt bson message < 5 bytes long');\n\n // Read the document size\n const size =\n buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);\n\n // Ensure buffer is valid size\n if (size < 5 || size > buffer.length) throw new BSONError('corrupt bson message');\n\n // Create holding object\n const object: Document = isArray ? [] : {};\n // Used for arrays to skip having to perform utf8 decoding\n let arrayIndex = 0;\n const done = false;\n\n let isPossibleDBRef = isArray ? false : null;\n\n // While we have more left data left keep parsing\n const dataview = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);\n while (!done) {\n // Read the type\n const elementType = buffer[index++];\n\n // If we get a zero it's the last byte, exit\n if (elementType === 0) break;\n\n // Get the start search index\n let i = index;\n // Locate the end of the c string\n while (buffer[i] !== 0x00 && i < buffer.length) {\n i++;\n }\n\n // If are at the end of the buffer there is a problem with the document\n if (i >= buffer.byteLength) throw new BSONError('Bad BSON Document: illegal CString');\n\n // Represents the key\n const name = isArray ? arrayIndex++ : ByteUtils.toUTF8(buffer, index, i);\n\n // shouldValidateKey is true if the key should be validated, false otherwise\n let shouldValidateKey = true;\n if (globalUTFValidation || utf8KeysSet.has(name)) {\n shouldValidateKey = validationSetting;\n } else {\n shouldValidateKey = !validationSetting;\n }\n\n if (isPossibleDBRef !== false && (name as string)[0] === '$') {\n isPossibleDBRef = allowedDBRefKeys.test(name as string);\n }\n let value;\n\n index = i + 1;\n\n if (elementType === constants.BSON_DATA_STRING) {\n const stringSize =\n buffer[index++] |\n (buffer[index++] << 8) |\n (buffer[index++] << 16) |\n (buffer[index++] << 24);\n if (\n stringSize <= 0 ||\n stringSize > buffer.length - index ||\n buffer[index + stringSize - 1] !== 0\n ) {\n throw new BSONError('bad string length in bson');\n }\n value = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);\n index = index + stringSize;\n } else if (elementType === constants.BSON_DATA_OID) {\n const oid = ByteUtils.allocate(12);\n oid.set(buffer.subarray(index, index + 12));\n value = new ObjectId(oid);\n index = index + 12;\n } else if (elementType === constants.BSON_DATA_INT && promoteValues === false) {\n value = new Int32(\n buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24)\n );\n } else if (elementType === constants.BSON_DATA_INT) {\n value =\n buffer[index++] |\n (buffer[index++] << 8) |\n (buffer[index++] << 16) |\n (buffer[index++] << 24);\n } else if (elementType === constants.BSON_DATA_NUMBER && promoteValues === false) {\n value = new Double(dataview.getFloat64(index, true));\n index = index + 8;\n } else if (elementType === constants.BSON_DATA_NUMBER) {\n value = dataview.getFloat64(index, true);\n index = index + 8;\n } else if (elementType === constants.BSON_DATA_DATE) {\n const lowBits =\n buffer[index++] |\n (buffer[index++] << 8) |\n (buffer[index++] << 16) |\n (buffer[index++] << 24);\n const highBits =\n buffer[index++] |\n (buffer[index++] << 8) |\n (buffer[index++] << 16) |\n (buffer[index++] << 24);\n value = new Date(new Long(lowBits, highBits).toNumber());\n } else if (elementType === constants.BSON_DATA_BOOLEAN) {\n if (buffer[index] !== 0 && buffer[index] !== 1)\n throw new BSONError('illegal boolean type value');\n value = buffer[index++] === 1;\n } else if (elementType === constants.BSON_DATA_OBJECT) {\n const _index = index;\n const objectSize =\n buffer[index] |\n (buffer[index + 1] << 8) |\n (buffer[index + 2] << 16) |\n (buffer[index + 3] << 24);\n if (objectSize <= 0 || objectSize > buffer.length - index)\n throw new BSONError('bad embedded document length in bson');\n\n // We have a raw value\n if (raw) {\n value = buffer.slice(index, index + objectSize);\n } else {\n let objectOptions = options;\n if (!globalUTFValidation) {\n objectOptions = { ...options, validation: { utf8: shouldValidateKey } };\n }\n value = deserializeObject(buffer, _index, objectOptions, false);\n }\n\n index = index + objectSize;\n } else if (elementType === constants.BSON_DATA_ARRAY) {\n const _index = index;\n const objectSize =\n buffer[index] |\n (buffer[index + 1] << 8) |\n (buffer[index + 2] << 16) |\n (buffer[index + 3] << 24);\n let arrayOptions: DeserializeOptions = options;\n\n // Stop index\n const stopIndex = index + objectSize;\n\n // All elements of array to be returned as raw bson\n if (fieldsAsRaw && fieldsAsRaw[name]) {\n arrayOptions = { ...options, raw: true };\n }\n\n if (!globalUTFValidation) {\n arrayOptions = { ...arrayOptions, validation: { utf8: shouldValidateKey } };\n }\n value = deserializeObject(buffer, _index, arrayOptions, true);\n index = index + objectSize;\n\n if (buffer[index - 1] !== 0) throw new BSONError('invalid array terminator byte');\n if (index !== stopIndex) throw new BSONError('corrupted array bson');\n } else if (elementType === constants.BSON_DATA_UNDEFINED) {\n value = undefined;\n } else if (elementType === constants.BSON_DATA_NULL) {\n value = null;\n } else if (elementType === constants.BSON_DATA_LONG) {\n // Unpack the low and high bits\n const dataview = BSONDataView.fromUint8Array(buffer.subarray(index, index + 8));\n\n const lowBits =\n buffer[index++] |\n (buffer[index++] << 8) |\n (buffer[index++] << 16) |\n (buffer[index++] << 24);\n const highBits =\n buffer[index++] |\n (buffer[index++] << 8) |\n (buffer[index++] << 16) |\n (buffer[index++] << 24);\n const long = new Long(lowBits, highBits);\n if (useBigInt64) {\n value = dataview.getBigInt64(0, true);\n } else if (promoteLongs && promoteValues === true) {\n // Promote the long if possible\n value =\n long.lessThanOrEqual(JS_INT_MAX_LONG) && long.greaterThanOrEqual(JS_INT_MIN_LONG)\n ? long.toNumber()\n : long;\n } else {\n value = long;\n }\n } else if (elementType === constants.BSON_DATA_DECIMAL128) {\n // Buffer to contain the decimal bytes\n const bytes = ByteUtils.allocate(16);\n // Copy the next 16 bytes into the bytes buffer\n bytes.set(buffer.subarray(index, index + 16), 0);\n // Update index\n index = index + 16;\n // Assign the new Decimal128 value\n value = new Decimal128(bytes);\n } else if (elementType === constants.BSON_DATA_BINARY) {\n let binarySize =\n buffer[index++] |\n (buffer[index++] << 8) |\n (buffer[index++] << 16) |\n (buffer[index++] << 24);\n const totalBinarySize = binarySize;\n const subType = buffer[index++];\n\n // Did we have a negative binary size, throw\n if (binarySize < 0) throw new BSONError('Negative binary type element size found');\n\n // Is the length longer than the document\n if (binarySize > buffer.byteLength)\n throw new BSONError('Binary type size larger than document size');\n\n // Decode as raw Buffer object if options specifies it\n if (buffer['slice'] != null) {\n // If we have subtype 2 skip the 4 bytes for the size\n if (subType === Binary.SUBTYPE_BYTE_ARRAY) {\n binarySize =\n buffer[index++] |\n (buffer[index++] << 8) |\n (buffer[index++] << 16) |\n (buffer[index++] << 24);\n if (binarySize < 0)\n throw new BSONError('Negative binary type element size found for subtype 0x02');\n if (binarySize > totalBinarySize - 4)\n throw new BSONError('Binary type with subtype 0x02 contains too long binary size');\n if (binarySize < totalBinarySize - 4)\n throw new BSONError('Binary type with subtype 0x02 contains too short binary size');\n }\n\n if (promoteBuffers && promoteValues) {\n value = ByteUtils.toLocalBufferType(buffer.slice(index, index + binarySize));\n } else {\n value = new Binary(buffer.slice(index, index + binarySize), subType);\n if (subType === constants.BSON_BINARY_SUBTYPE_UUID_NEW && UUID.isValid(value)) {\n value = value.toUUID();\n }\n }\n } else {\n const _buffer = ByteUtils.allocate(binarySize);\n // If we have subtype 2 skip the 4 bytes for the size\n if (subType === Binary.SUBTYPE_BYTE_ARRAY) {\n binarySize =\n buffer[index++] |\n (buffer[index++] << 8) |\n (buffer[index++] << 16) |\n (buffer[index++] << 24);\n if (binarySize < 0)\n throw new BSONError('Negative binary type element size found for subtype 0x02');\n if (binarySize > totalBinarySize - 4)\n throw new BSONError('Binary type with subtype 0x02 contains too long binary size');\n if (binarySize < totalBinarySize - 4)\n throw new BSONError('Binary type with subtype 0x02 contains too short binary size');\n }\n\n // Copy the data\n for (i = 0; i < binarySize; i++) {\n _buffer[i] = buffer[index + i];\n }\n\n if (promoteBuffers && promoteValues) {\n value = _buffer;\n } else {\n value = new Binary(buffer.slice(index, index + binarySize), subType);\n if (subType === constants.BSON_BINARY_SUBTYPE_UUID_NEW && UUID.isValid(value)) {\n value = value.toUUID();\n }\n }\n }\n\n // Update the index\n index = index + binarySize;\n } else if (elementType === constants.BSON_DATA_REGEXP && bsonRegExp === false) {\n // Get the start search index\n i = index;\n // Locate the end of the c string\n while (buffer[i] !== 0x00 && i < buffer.length) {\n i++;\n }\n // If are at the end of the buffer there is a problem with the document\n if (i >= buffer.length) throw new BSONError('Bad BSON Document: illegal CString');\n // Return the C string\n const source = ByteUtils.toUTF8(buffer, index, i);\n // Create the regexp\n index = i + 1;\n\n // Get the start search index\n i = index;\n // Locate the end of the c string\n while (buffer[i] !== 0x00 && i < buffer.length) {\n i++;\n }\n // If are at the end of the buffer there is a problem with the document\n if (i >= buffer.length) throw new BSONError('Bad BSON Document: illegal CString');\n // Return the C string\n const regExpOptions = ByteUtils.toUTF8(buffer, index, i);\n index = i + 1;\n\n // For each option add the corresponding one for javascript\n const optionsArray = new Array(regExpOptions.length);\n\n // Parse options\n for (i = 0; i < regExpOptions.length; i++) {\n switch (regExpOptions[i]) {\n case 'm':\n optionsArray[i] = 'm';\n break;\n case 's':\n optionsArray[i] = 'g';\n break;\n case 'i':\n optionsArray[i] = 'i';\n break;\n }\n }\n\n value = new RegExp(source, optionsArray.join(''));\n } else if (elementType === constants.BSON_DATA_REGEXP && bsonRegExp === true) {\n // Get the start search index\n i = index;\n // Locate the end of the c string\n while (buffer[i] !== 0x00 && i < buffer.length) {\n i++;\n }\n // If are at the end of the buffer there is a problem with the document\n if (i >= buffer.length) throw new BSONError('Bad BSON Document: illegal CString');\n // Return the C string\n const source = ByteUtils.toUTF8(buffer, index, i);\n index = i + 1;\n\n // Get the start search index\n i = index;\n // Locate the end of the c string\n while (buffer[i] !== 0x00 && i < buffer.length) {\n i++;\n }\n // If are at the end of the buffer there is a problem with the document\n if (i >= buffer.length) throw new BSONError('Bad BSON Document: illegal CString');\n // Return the C string\n const regExpOptions = ByteUtils.toUTF8(buffer, index, i);\n index = i + 1;\n\n // Set the object\n value = new BSONRegExp(source, regExpOptions);\n } else if (elementType === constants.BSON_DATA_SYMBOL) {\n const stringSize =\n buffer[index++] |\n (buffer[index++] << 8) |\n (buffer[index++] << 16) |\n (buffer[index++] << 24);\n if (\n stringSize <= 0 ||\n stringSize > buffer.length - index ||\n buffer[index + stringSize - 1] !== 0\n ) {\n throw new BSONError('bad string length in bson');\n }\n const symbol = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);\n value = promoteValues ? symbol : new BSONSymbol(symbol);\n index = index + stringSize;\n } else if (elementType === constants.BSON_DATA_TIMESTAMP) {\n // We intentionally **do not** use bit shifting here\n // Bit shifting in javascript coerces numbers to **signed** int32s\n // We need to keep i, and t unsigned\n const i =\n buffer[index++] +\n buffer[index++] * (1 << 8) +\n buffer[index++] * (1 << 16) +\n buffer[index++] * (1 << 24);\n const t =\n buffer[index++] +\n buffer[index++] * (1 << 8) +\n buffer[index++] * (1 << 16) +\n buffer[index++] * (1 << 24);\n\n value = new Timestamp({ i, t });\n } else if (elementType === constants.BSON_DATA_MIN_KEY) {\n value = new MinKey();\n } else if (elementType === constants.BSON_DATA_MAX_KEY) {\n value = new MaxKey();\n } else if (elementType === constants.BSON_DATA_CODE) {\n const stringSize =\n buffer[index++] |\n (buffer[index++] << 8) |\n (buffer[index++] << 16) |\n (buffer[index++] << 24);\n if (\n stringSize <= 0 ||\n stringSize > buffer.length - index ||\n buffer[index + stringSize - 1] !== 0\n ) {\n throw new BSONError('bad string length in bson');\n }\n const functionString = getValidatedString(\n buffer,\n index,\n index + stringSize - 1,\n shouldValidateKey\n );\n\n value = new Code(functionString);\n\n // Update parse index position\n index = index + stringSize;\n } else if (elementType === constants.BSON_DATA_CODE_W_SCOPE) {\n const totalSize =\n buffer[index++] |\n (buffer[index++] << 8) |\n (buffer[index++] << 16) |\n (buffer[index++] << 24);\n\n // Element cannot be shorter than totalSize + stringSize + documentSize + terminator\n if (totalSize < 4 + 4 + 4 + 1) {\n throw new BSONError('code_w_scope total size shorter minimum expected length');\n }\n\n // Get the code string size\n const stringSize =\n buffer[index++] |\n (buffer[index++] << 8) |\n (buffer[index++] << 16) |\n (buffer[index++] << 24);\n // Check if we have a valid string\n if (\n stringSize <= 0 ||\n stringSize > buffer.length - index ||\n buffer[index + stringSize - 1] !== 0\n ) {\n throw new BSONError('bad string length in bson');\n }\n\n // Javascript function\n const functionString = getValidatedString(\n buffer,\n index,\n index + stringSize - 1,\n shouldValidateKey\n );\n // Update parse index position\n index = index + stringSize;\n // Parse the element\n const _index = index;\n // Decode the size of the object document\n const objectSize =\n buffer[index] |\n (buffer[index + 1] << 8) |\n (buffer[index + 2] << 16) |\n (buffer[index + 3] << 24);\n // Decode the scope object\n const scopeObject = deserializeObject(buffer, _index, options, false);\n // Adjust the index\n index = index + objectSize;\n\n // Check if field length is too short\n if (totalSize < 4 + 4 + objectSize + stringSize) {\n throw new BSONError('code_w_scope total size is too short, truncating scope');\n }\n\n // Check if totalSize field is too long\n if (totalSize > 4 + 4 + objectSize + stringSize) {\n throw new BSONError('code_w_scope total size is too long, clips outer document');\n }\n\n value = new Code(functionString, scopeObject);\n } else if (elementType === constants.BSON_DATA_DBPOINTER) {\n // Get the code string size\n const stringSize =\n buffer[index++] |\n (buffer[index++] << 8) |\n (buffer[index++] << 16) |\n (buffer[index++] << 24);\n // Check if we have a valid string\n if (\n stringSize <= 0 ||\n stringSize > buffer.length - index ||\n buffer[index + stringSize - 1] !== 0\n )\n throw new BSONError('bad string length in bson');\n // Namespace\n if (validation != null && validation.utf8) {\n if (!validateUtf8(buffer, index, index + stringSize - 1)) {\n throw new BSONError('Invalid UTF-8 string in BSON document');\n }\n }\n const namespace = ByteUtils.toUTF8(buffer, index, index + stringSize - 1);\n // Update parse index position\n index = index + stringSize;\n\n // Read the oid\n const oidBuffer = ByteUtils.allocate(12);\n oidBuffer.set(buffer.subarray(index, index + 12), 0);\n const oid = new ObjectId(oidBuffer);\n\n // Update the index\n index = index + 12;\n\n // Upgrade to DBRef type\n value = new DBRef(namespace, oid);\n } else {\n throw new BSONError(\n `Detected unknown BSON type ${elementType.toString(16)} for fieldname \"${name}\"`\n );\n }\n if (name === '__proto__') {\n Object.defineProperty(object, name, {\n value,\n writable: true,\n enumerable: true,\n configurable: true\n });\n } else {\n object[name] = value;\n }\n }\n\n // Check if the deserialization was against a valid array/object\n if (size !== index - startIndex) {\n if (isArray) throw new BSONError('corrupt array bson');\n throw new BSONError('corrupt object bson');\n }\n\n // if we did not find \"$ref\", \"$id\", \"$db\", or found an extraneous $key, don't make a DBRef\n if (!isPossibleDBRef) return object;\n\n if (isDBRefLike(object)) {\n const copy = Object.assign({}, object) as Partial;\n delete copy.$ref;\n delete copy.$id;\n delete copy.$db;\n return new DBRef(object.$ref, object.$id, object.$db, copy);\n }\n\n return object;\n}\n\nfunction getValidatedString(\n buffer: Uint8Array,\n start: number,\n end: number,\n shouldValidateUtf8: boolean\n) {\n const value = ByteUtils.toUTF8(buffer, start, end);\n // if utf8 validation is on, do the check\n if (shouldValidateUtf8) {\n for (let i = 0; i < value.length; i++) {\n if (value.charCodeAt(i) === 0xfffd) {\n if (!validateUtf8(buffer, start, end)) {\n throw new BSONError('Invalid UTF-8 string in BSON document');\n }\n break;\n }\n }\n }\n return value;\n}\n","import { Binary } from '../binary';\nimport type { BSONSymbol, DBRef, Document, MaxKey } from '../bson';\nimport type { Code } from '../code';\nimport * as constants from '../constants';\nimport type { DBRefLike } from '../db_ref';\nimport type { Decimal128 } from '../decimal128';\nimport type { Double } from '../double';\nimport { BSONError, BSONVersionError } from '../error';\nimport type { Int32 } from '../int_32';\nimport { Long } from '../long';\nimport type { MinKey } from '../min_key';\nimport type { ObjectId } from '../objectid';\nimport type { BSONRegExp } from '../regexp';\nimport { ByteUtils } from '../utils/byte_utils';\nimport { isAnyArrayBuffer, isDate, isMap, isRegExp, isUint8Array } from './utils';\n\n/** @public */\nexport interface SerializeOptions {\n /**\n * the serializer will check if keys are valid.\n * @defaultValue `false`\n */\n checkKeys?: boolean;\n /**\n * serialize the javascript functions\n * @defaultValue `false`\n */\n serializeFunctions?: boolean;\n /**\n * serialize will not emit undefined fields\n * note that the driver sets this to `false`\n * @defaultValue `true`\n */\n ignoreUndefined?: boolean;\n /** @internal Resize internal buffer */\n minInternalBufferSize?: number;\n /**\n * the index in the buffer where we wish to start serializing into\n * @defaultValue `0`\n */\n index?: number;\n}\n\nconst regexp = /\\x00/; // eslint-disable-line no-control-regex\nconst ignoreKeys = new Set(['$db', '$ref', '$id', '$clusterTime']);\n\n/*\n * isArray indicates if we are writing to a BSON array (type 0x04)\n * which forces the \"key\" which really an array index as a string to be written as ascii\n * This will catch any errors in index as a string generation\n */\n\nfunction serializeString(buffer: Uint8Array, key: string, value: string, index: number) {\n // Encode String type\n buffer[index++] = constants.BSON_DATA_STRING;\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n // Encode the name\n index = index + numberOfWrittenBytes + 1;\n buffer[index - 1] = 0;\n // Write the string\n const size = ByteUtils.encodeUTF8Into(buffer, value, index + 4);\n // Write the size of the string to buffer\n buffer[index + 3] = ((size + 1) >> 24) & 0xff;\n buffer[index + 2] = ((size + 1) >> 16) & 0xff;\n buffer[index + 1] = ((size + 1) >> 8) & 0xff;\n buffer[index] = (size + 1) & 0xff;\n // Update index\n index = index + 4 + size;\n // Write zero\n buffer[index++] = 0;\n return index;\n}\n\nconst NUMBER_SPACE = new DataView(new ArrayBuffer(8), 0, 8);\nconst FOUR_BYTE_VIEW_ON_NUMBER = new Uint8Array(NUMBER_SPACE.buffer, 0, 4);\nconst EIGHT_BYTE_VIEW_ON_NUMBER = new Uint8Array(NUMBER_SPACE.buffer, 0, 8);\n\nfunction serializeNumber(buffer: Uint8Array, key: string, value: number, index: number) {\n const isNegativeZero = Object.is(value, -0);\n\n const type =\n !isNegativeZero &&\n Number.isSafeInteger(value) &&\n value <= constants.BSON_INT32_MAX &&\n value >= constants.BSON_INT32_MIN\n ? constants.BSON_DATA_INT\n : constants.BSON_DATA_NUMBER;\n\n if (type === constants.BSON_DATA_INT) {\n NUMBER_SPACE.setInt32(0, value, true);\n } else {\n NUMBER_SPACE.setFloat64(0, value, true);\n }\n\n const bytes =\n type === constants.BSON_DATA_INT ? FOUR_BYTE_VIEW_ON_NUMBER : EIGHT_BYTE_VIEW_ON_NUMBER;\n\n buffer[index++] = type;\n\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n index = index + numberOfWrittenBytes;\n buffer[index++] = 0x00;\n\n buffer.set(bytes, index);\n index += bytes.byteLength;\n\n return index;\n}\n\nfunction serializeBigInt(buffer: Uint8Array, key: string, value: bigint, index: number) {\n buffer[index++] = constants.BSON_DATA_LONG;\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n // Encode the name\n index += numberOfWrittenBytes;\n buffer[index++] = 0;\n NUMBER_SPACE.setBigInt64(0, value, true);\n // Write BigInt value\n buffer.set(EIGHT_BYTE_VIEW_ON_NUMBER, index);\n index += EIGHT_BYTE_VIEW_ON_NUMBER.byteLength;\n return index;\n}\n\nfunction serializeNull(buffer: Uint8Array, key: string, _: unknown, index: number) {\n // Set long type\n buffer[index++] = constants.BSON_DATA_NULL;\n\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n\n // Encode the name\n index = index + numberOfWrittenBytes;\n buffer[index++] = 0;\n return index;\n}\n\nfunction serializeBoolean(buffer: Uint8Array, key: string, value: boolean, index: number) {\n // Write the type\n buffer[index++] = constants.BSON_DATA_BOOLEAN;\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n // Encode the name\n index = index + numberOfWrittenBytes;\n buffer[index++] = 0;\n // Encode the boolean value\n buffer[index++] = value ? 1 : 0;\n return index;\n}\n\nfunction serializeDate(buffer: Uint8Array, key: string, value: Date, index: number) {\n // Write the type\n buffer[index++] = constants.BSON_DATA_DATE;\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n // Encode the name\n index = index + numberOfWrittenBytes;\n buffer[index++] = 0;\n\n // Write the date\n const dateInMilis = Long.fromNumber(value.getTime());\n const lowBits = dateInMilis.getLowBits();\n const highBits = dateInMilis.getHighBits();\n // Encode low bits\n buffer[index++] = lowBits & 0xff;\n buffer[index++] = (lowBits >> 8) & 0xff;\n buffer[index++] = (lowBits >> 16) & 0xff;\n buffer[index++] = (lowBits >> 24) & 0xff;\n // Encode high bits\n buffer[index++] = highBits & 0xff;\n buffer[index++] = (highBits >> 8) & 0xff;\n buffer[index++] = (highBits >> 16) & 0xff;\n buffer[index++] = (highBits >> 24) & 0xff;\n return index;\n}\n\nfunction serializeRegExp(buffer: Uint8Array, key: string, value: RegExp, index: number) {\n // Write the type\n buffer[index++] = constants.BSON_DATA_REGEXP;\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n\n // Encode the name\n index = index + numberOfWrittenBytes;\n buffer[index++] = 0;\n if (value.source && value.source.match(regexp) != null) {\n throw new BSONError('value ' + value.source + ' must not contain null bytes');\n }\n // Adjust the index\n index = index + ByteUtils.encodeUTF8Into(buffer, value.source, index);\n // Write zero\n buffer[index++] = 0x00;\n // Write the parameters\n if (value.ignoreCase) buffer[index++] = 0x69; // i\n if (value.global) buffer[index++] = 0x73; // s\n if (value.multiline) buffer[index++] = 0x6d; // m\n\n // Add ending zero\n buffer[index++] = 0x00;\n return index;\n}\n\nfunction serializeBSONRegExp(buffer: Uint8Array, key: string, value: BSONRegExp, index: number) {\n // Write the type\n buffer[index++] = constants.BSON_DATA_REGEXP;\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n // Encode the name\n index = index + numberOfWrittenBytes;\n buffer[index++] = 0;\n\n // Check the pattern for 0 bytes\n if (value.pattern.match(regexp) != null) {\n // The BSON spec doesn't allow keys with null bytes because keys are\n // null-terminated.\n throw new BSONError('pattern ' + value.pattern + ' must not contain null bytes');\n }\n\n // Adjust the index\n index = index + ByteUtils.encodeUTF8Into(buffer, value.pattern, index);\n // Write zero\n buffer[index++] = 0x00;\n // Write the options\n const sortedOptions = value.options.split('').sort().join('');\n index = index + ByteUtils.encodeUTF8Into(buffer, sortedOptions, index);\n // Add ending zero\n buffer[index++] = 0x00;\n return index;\n}\n\nfunction serializeMinMax(buffer: Uint8Array, key: string, value: MinKey | MaxKey, index: number) {\n // Write the type of either min or max key\n if (value === null) {\n buffer[index++] = constants.BSON_DATA_NULL;\n } else if (value._bsontype === 'MinKey') {\n buffer[index++] = constants.BSON_DATA_MIN_KEY;\n } else {\n buffer[index++] = constants.BSON_DATA_MAX_KEY;\n }\n\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n // Encode the name\n index = index + numberOfWrittenBytes;\n buffer[index++] = 0;\n return index;\n}\n\nfunction serializeObjectId(buffer: Uint8Array, key: string, value: ObjectId, index: number) {\n // Write the type\n buffer[index++] = constants.BSON_DATA_OID;\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n\n // Encode the name\n index = index + numberOfWrittenBytes;\n buffer[index++] = 0;\n\n // Write the objectId into the shared buffer\n const idValue = value.id;\n\n if (isUint8Array(idValue)) {\n for (let i = 0; i < 12; i++) {\n buffer[index++] = idValue[i];\n }\n } else {\n throw new BSONError('object [' + JSON.stringify(value) + '] is not a valid ObjectId');\n }\n\n // Adjust index\n return index;\n}\n\nfunction serializeBuffer(buffer: Uint8Array, key: string, value: Uint8Array, index: number) {\n // Write the type\n buffer[index++] = constants.BSON_DATA_BINARY;\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n // Encode the name\n index = index + numberOfWrittenBytes;\n buffer[index++] = 0;\n // Get size of the buffer (current write point)\n const size = value.length;\n // Write the size of the string to buffer\n buffer[index++] = size & 0xff;\n buffer[index++] = (size >> 8) & 0xff;\n buffer[index++] = (size >> 16) & 0xff;\n buffer[index++] = (size >> 24) & 0xff;\n // Write the default subtype\n buffer[index++] = constants.BSON_BINARY_SUBTYPE_DEFAULT;\n // Copy the content form the binary field to the buffer\n buffer.set(value, index);\n // Adjust the index\n index = index + size;\n return index;\n}\n\nfunction serializeObject(\n buffer: Uint8Array,\n key: string,\n value: Document,\n index: number,\n checkKeys: boolean,\n depth: number,\n serializeFunctions: boolean,\n ignoreUndefined: boolean,\n path: Set\n) {\n if (path.has(value)) {\n throw new BSONError('Cannot convert circular structure to BSON');\n }\n\n path.add(value);\n\n // Write the type\n buffer[index++] = Array.isArray(value) ? constants.BSON_DATA_ARRAY : constants.BSON_DATA_OBJECT;\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n // Encode the name\n index = index + numberOfWrittenBytes;\n buffer[index++] = 0;\n const endIndex = serializeInto(\n buffer,\n value,\n checkKeys,\n index,\n depth + 1,\n serializeFunctions,\n ignoreUndefined,\n path\n );\n\n path.delete(value);\n\n return endIndex;\n}\n\nfunction serializeDecimal128(buffer: Uint8Array, key: string, value: Decimal128, index: number) {\n buffer[index++] = constants.BSON_DATA_DECIMAL128;\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n // Encode the name\n index = index + numberOfWrittenBytes;\n buffer[index++] = 0;\n // Write the data from the value\n buffer.set(value.bytes.subarray(0, 16), index);\n return index + 16;\n}\n\nfunction serializeLong(buffer: Uint8Array, key: string, value: Long, index: number) {\n // Write the type\n buffer[index++] =\n value._bsontype === 'Long' ? constants.BSON_DATA_LONG : constants.BSON_DATA_TIMESTAMP;\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n // Encode the name\n index = index + numberOfWrittenBytes;\n buffer[index++] = 0;\n // Write the date\n const lowBits = value.getLowBits();\n const highBits = value.getHighBits();\n // Encode low bits\n buffer[index++] = lowBits & 0xff;\n buffer[index++] = (lowBits >> 8) & 0xff;\n buffer[index++] = (lowBits >> 16) & 0xff;\n buffer[index++] = (lowBits >> 24) & 0xff;\n // Encode high bits\n buffer[index++] = highBits & 0xff;\n buffer[index++] = (highBits >> 8) & 0xff;\n buffer[index++] = (highBits >> 16) & 0xff;\n buffer[index++] = (highBits >> 24) & 0xff;\n return index;\n}\n\nfunction serializeInt32(buffer: Uint8Array, key: string, value: Int32 | number, index: number) {\n value = value.valueOf();\n // Set int type 32 bits or less\n buffer[index++] = constants.BSON_DATA_INT;\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n // Encode the name\n index = index + numberOfWrittenBytes;\n buffer[index++] = 0;\n // Write the int value\n buffer[index++] = value & 0xff;\n buffer[index++] = (value >> 8) & 0xff;\n buffer[index++] = (value >> 16) & 0xff;\n buffer[index++] = (value >> 24) & 0xff;\n return index;\n}\n\nfunction serializeDouble(buffer: Uint8Array, key: string, value: Double, index: number) {\n // Encode as double\n buffer[index++] = constants.BSON_DATA_NUMBER;\n\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n\n // Encode the name\n index = index + numberOfWrittenBytes;\n buffer[index++] = 0;\n\n // Write float\n NUMBER_SPACE.setFloat64(0, value.value, true);\n buffer.set(EIGHT_BYTE_VIEW_ON_NUMBER, index);\n\n // Adjust index\n index = index + 8;\n return index;\n}\n\nfunction serializeFunction(buffer: Uint8Array, key: string, value: Function, index: number) {\n buffer[index++] = constants.BSON_DATA_CODE;\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n // Encode the name\n index = index + numberOfWrittenBytes;\n buffer[index++] = 0;\n // Function string\n const functionString = value.toString();\n\n // Write the string\n const size = ByteUtils.encodeUTF8Into(buffer, functionString, index + 4) + 1;\n // Write the size of the string to buffer\n buffer[index] = size & 0xff;\n buffer[index + 1] = (size >> 8) & 0xff;\n buffer[index + 2] = (size >> 16) & 0xff;\n buffer[index + 3] = (size >> 24) & 0xff;\n // Update index\n index = index + 4 + size - 1;\n // Write zero\n buffer[index++] = 0;\n return index;\n}\n\nfunction serializeCode(\n buffer: Uint8Array,\n key: string,\n value: Code,\n index: number,\n checkKeys = false,\n depth = 0,\n serializeFunctions = false,\n ignoreUndefined = true,\n path: Set\n) {\n if (value.scope && typeof value.scope === 'object') {\n // Write the type\n buffer[index++] = constants.BSON_DATA_CODE_W_SCOPE;\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n // Encode the name\n index = index + numberOfWrittenBytes;\n buffer[index++] = 0;\n\n // Starting index\n let startIndex = index;\n\n // Serialize the function\n // Get the function string\n const functionString = value.code;\n // Index adjustment\n index = index + 4;\n // Write string into buffer\n const codeSize = ByteUtils.encodeUTF8Into(buffer, functionString, index + 4) + 1;\n // Write the size of the string to buffer\n buffer[index] = codeSize & 0xff;\n buffer[index + 1] = (codeSize >> 8) & 0xff;\n buffer[index + 2] = (codeSize >> 16) & 0xff;\n buffer[index + 3] = (codeSize >> 24) & 0xff;\n // Write end 0\n buffer[index + 4 + codeSize - 1] = 0;\n // Write the\n index = index + codeSize + 4;\n\n // Serialize the scope value\n const endIndex = serializeInto(\n buffer,\n value.scope,\n checkKeys,\n index,\n depth + 1,\n serializeFunctions,\n ignoreUndefined,\n path\n );\n index = endIndex - 1;\n\n // Writ the total\n const totalSize = endIndex - startIndex;\n\n // Write the total size of the object\n buffer[startIndex++] = totalSize & 0xff;\n buffer[startIndex++] = (totalSize >> 8) & 0xff;\n buffer[startIndex++] = (totalSize >> 16) & 0xff;\n buffer[startIndex++] = (totalSize >> 24) & 0xff;\n // Write trailing zero\n buffer[index++] = 0;\n } else {\n buffer[index++] = constants.BSON_DATA_CODE;\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n // Encode the name\n index = index + numberOfWrittenBytes;\n buffer[index++] = 0;\n // Function string\n const functionString = value.code.toString();\n // Write the string\n const size = ByteUtils.encodeUTF8Into(buffer, functionString, index + 4) + 1;\n // Write the size of the string to buffer\n buffer[index] = size & 0xff;\n buffer[index + 1] = (size >> 8) & 0xff;\n buffer[index + 2] = (size >> 16) & 0xff;\n buffer[index + 3] = (size >> 24) & 0xff;\n // Update index\n index = index + 4 + size - 1;\n // Write zero\n buffer[index++] = 0;\n }\n\n return index;\n}\n\nfunction serializeBinary(buffer: Uint8Array, key: string, value: Binary, index: number) {\n // Write the type\n buffer[index++] = constants.BSON_DATA_BINARY;\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n // Encode the name\n index = index + numberOfWrittenBytes;\n buffer[index++] = 0;\n // Extract the buffer\n const data = value.buffer;\n // Calculate size\n let size = value.position;\n // Add the deprecated 02 type 4 bytes of size to total\n if (value.sub_type === Binary.SUBTYPE_BYTE_ARRAY) size = size + 4;\n // Write the size of the string to buffer\n buffer[index++] = size & 0xff;\n buffer[index++] = (size >> 8) & 0xff;\n buffer[index++] = (size >> 16) & 0xff;\n buffer[index++] = (size >> 24) & 0xff;\n // Write the subtype to the buffer\n buffer[index++] = value.sub_type;\n\n // If we have binary type 2 the 4 first bytes are the size\n if (value.sub_type === Binary.SUBTYPE_BYTE_ARRAY) {\n size = size - 4;\n buffer[index++] = size & 0xff;\n buffer[index++] = (size >> 8) & 0xff;\n buffer[index++] = (size >> 16) & 0xff;\n buffer[index++] = (size >> 24) & 0xff;\n }\n\n // Write the data to the object\n buffer.set(data, index);\n // Adjust the index\n index = index + value.position;\n return index;\n}\n\nfunction serializeSymbol(buffer: Uint8Array, key: string, value: BSONSymbol, index: number) {\n // Write the type\n buffer[index++] = constants.BSON_DATA_SYMBOL;\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n // Encode the name\n index = index + numberOfWrittenBytes;\n buffer[index++] = 0;\n // Write the string\n const size = ByteUtils.encodeUTF8Into(buffer, value.value, index + 4) + 1;\n // Write the size of the string to buffer\n buffer[index] = size & 0xff;\n buffer[index + 1] = (size >> 8) & 0xff;\n buffer[index + 2] = (size >> 16) & 0xff;\n buffer[index + 3] = (size >> 24) & 0xff;\n // Update index\n index = index + 4 + size - 1;\n // Write zero\n buffer[index++] = 0x00;\n return index;\n}\n\nfunction serializeDBRef(\n buffer: Uint8Array,\n key: string,\n value: DBRef,\n index: number,\n depth: number,\n serializeFunctions: boolean,\n path: Set\n) {\n // Write the type\n buffer[index++] = constants.BSON_DATA_OBJECT;\n // Number of written bytes\n const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);\n\n // Encode the name\n index = index + numberOfWrittenBytes;\n buffer[index++] = 0;\n\n let startIndex = index;\n let output: DBRefLike = {\n $ref: value.collection || value.namespace, // \"namespace\" was what library 1.x called \"collection\"\n $id: value.oid\n };\n\n if (value.db != null) {\n output.$db = value.db;\n }\n\n output = Object.assign(output, value.fields);\n const endIndex = serializeInto(\n buffer,\n output,\n false,\n index,\n depth + 1,\n serializeFunctions,\n true,\n path\n );\n\n // Calculate object size\n const size = endIndex - startIndex;\n // Write the size\n buffer[startIndex++] = size & 0xff;\n buffer[startIndex++] = (size >> 8) & 0xff;\n buffer[startIndex++] = (size >> 16) & 0xff;\n buffer[startIndex++] = (size >> 24) & 0xff;\n // Set index\n return endIndex;\n}\n\nexport function serializeInto(\n buffer: Uint8Array,\n object: Document,\n checkKeys: boolean,\n startingIndex: number,\n depth: number,\n serializeFunctions: boolean,\n ignoreUndefined: boolean,\n path: Set | null\n): number {\n if (path == null) {\n // We are at the root input\n if (object == null) {\n // ONLY the root should turn into an empty document\n // BSON Empty document has a size of 5 (LE)\n buffer[0] = 0x05;\n buffer[1] = 0x00;\n buffer[2] = 0x00;\n buffer[3] = 0x00;\n // All documents end with null terminator\n buffer[4] = 0x00;\n return 5;\n }\n\n if (Array.isArray(object)) {\n throw new BSONError('serialize does not support an array as the root input');\n }\n if (typeof object !== 'object') {\n throw new BSONError('serialize does not support non-object as the root input');\n } else if ('_bsontype' in object && typeof object._bsontype === 'string') {\n throw new BSONError(`BSON types cannot be serialized as a document`);\n } else if (\n isDate(object) ||\n isRegExp(object) ||\n isUint8Array(object) ||\n isAnyArrayBuffer(object)\n ) {\n throw new BSONError(`date, regexp, typedarray, and arraybuffer cannot be BSON documents`);\n }\n\n path = new Set();\n }\n\n // Push the object to the path\n path.add(object);\n\n // Start place to serialize into\n let index = startingIndex + 4;\n\n // Special case isArray\n if (Array.isArray(object)) {\n // Get object keys\n for (let i = 0; i < object.length; i++) {\n const key = `${i}`;\n let value = object[i];\n\n // Is there an override value\n if (typeof value?.toBSON === 'function') {\n value = value.toBSON();\n }\n\n if (typeof value === 'string') {\n index = serializeString(buffer, key, value, index);\n } else if (typeof value === 'number') {\n index = serializeNumber(buffer, key, value, index);\n } else if (typeof value === 'bigint') {\n index = serializeBigInt(buffer, key, value, index);\n } else if (typeof value === 'boolean') {\n index = serializeBoolean(buffer, key, value, index);\n } else if (value instanceof Date || isDate(value)) {\n index = serializeDate(buffer, key, value, index);\n } else if (value === undefined) {\n index = serializeNull(buffer, key, value, index);\n } else if (value === null) {\n index = serializeNull(buffer, key, value, index);\n } else if (isUint8Array(value)) {\n index = serializeBuffer(buffer, key, value, index);\n } else if (value instanceof RegExp || isRegExp(value)) {\n index = serializeRegExp(buffer, key, value, index);\n } else if (typeof value === 'object' && value._bsontype == null) {\n index = serializeObject(\n buffer,\n key,\n value,\n index,\n checkKeys,\n depth,\n serializeFunctions,\n ignoreUndefined,\n path\n );\n } else if (\n typeof value === 'object' &&\n value[Symbol.for('@@mdb.bson.version')] !== constants.BSON_MAJOR_VERSION\n ) {\n throw new BSONVersionError();\n } else if (value._bsontype === 'ObjectId') {\n index = serializeObjectId(buffer, key, value, index);\n } else if (value._bsontype === 'Decimal128') {\n index = serializeDecimal128(buffer, key, value, index);\n } else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {\n index = serializeLong(buffer, key, value, index);\n } else if (value._bsontype === 'Double') {\n index = serializeDouble(buffer, key, value, index);\n } else if (typeof value === 'function' && serializeFunctions) {\n index = serializeFunction(buffer, key, value, index);\n } else if (value._bsontype === 'Code') {\n index = serializeCode(\n buffer,\n key,\n value,\n index,\n checkKeys,\n depth,\n serializeFunctions,\n ignoreUndefined,\n path\n );\n } else if (value._bsontype === 'Binary') {\n index = serializeBinary(buffer, key, value, index);\n } else if (value._bsontype === 'BSONSymbol') {\n index = serializeSymbol(buffer, key, value, index);\n } else if (value._bsontype === 'DBRef') {\n index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);\n } else if (value._bsontype === 'BSONRegExp') {\n index = serializeBSONRegExp(buffer, key, value, index);\n } else if (value._bsontype === 'Int32') {\n index = serializeInt32(buffer, key, value, index);\n } else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {\n index = serializeMinMax(buffer, key, value, index);\n } else if (typeof value._bsontype !== 'undefined') {\n throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);\n }\n }\n } else if (object instanceof Map || isMap(object)) {\n const iterator = object.entries();\n let done = false;\n\n while (!done) {\n // Unpack the next entry\n const entry = iterator.next();\n done = !!entry.done;\n // Are we done, then skip and terminate\n if (done) continue;\n\n // Get the entry values\n const key = entry.value[0];\n let value = entry.value[1];\n\n if (typeof value?.toBSON === 'function') {\n value = value.toBSON();\n }\n\n // Check the type of the value\n const type = typeof value;\n\n // Check the key and throw error if it's illegal\n if (typeof key === 'string' && !ignoreKeys.has(key)) {\n if (key.match(regexp) != null) {\n // The BSON spec doesn't allow keys with null bytes because keys are\n // null-terminated.\n throw new BSONError('key ' + key + ' must not contain null bytes');\n }\n\n if (checkKeys) {\n if ('$' === key[0]) {\n throw new BSONError('key ' + key + \" must not start with '$'\");\n } else if (~key.indexOf('.')) {\n throw new BSONError('key ' + key + \" must not contain '.'\");\n }\n }\n }\n\n if (type === 'string') {\n index = serializeString(buffer, key, value, index);\n } else if (type === 'number') {\n index = serializeNumber(buffer, key, value, index);\n } else if (type === 'bigint') {\n index = serializeBigInt(buffer, key, value, index);\n } else if (type === 'boolean') {\n index = serializeBoolean(buffer, key, value, index);\n } else if (value instanceof Date || isDate(value)) {\n index = serializeDate(buffer, key, value, index);\n } else if (value === null || (value === undefined && ignoreUndefined === false)) {\n index = serializeNull(buffer, key, value, index);\n } else if (isUint8Array(value)) {\n index = serializeBuffer(buffer, key, value, index);\n } else if (value instanceof RegExp || isRegExp(value)) {\n index = serializeRegExp(buffer, key, value, index);\n } else if (type === 'object' && value._bsontype == null) {\n index = serializeObject(\n buffer,\n key,\n value,\n index,\n checkKeys,\n depth,\n serializeFunctions,\n ignoreUndefined,\n path\n );\n } else if (\n typeof value === 'object' &&\n value[Symbol.for('@@mdb.bson.version')] !== constants.BSON_MAJOR_VERSION\n ) {\n throw new BSONVersionError();\n } else if (value._bsontype === 'ObjectId') {\n index = serializeObjectId(buffer, key, value, index);\n } else if (type === 'object' && value._bsontype === 'Decimal128') {\n index = serializeDecimal128(buffer, key, value, index);\n } else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {\n index = serializeLong(buffer, key, value, index);\n } else if (value._bsontype === 'Double') {\n index = serializeDouble(buffer, key, value, index);\n } else if (value._bsontype === 'Code') {\n index = serializeCode(\n buffer,\n key,\n value,\n index,\n checkKeys,\n depth,\n serializeFunctions,\n ignoreUndefined,\n path\n );\n } else if (typeof value === 'function' && serializeFunctions) {\n index = serializeFunction(buffer, key, value, index);\n } else if (value._bsontype === 'Binary') {\n index = serializeBinary(buffer, key, value, index);\n } else if (value._bsontype === 'BSONSymbol') {\n index = serializeSymbol(buffer, key, value, index);\n } else if (value._bsontype === 'DBRef') {\n index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);\n } else if (value._bsontype === 'BSONRegExp') {\n index = serializeBSONRegExp(buffer, key, value, index);\n } else if (value._bsontype === 'Int32') {\n index = serializeInt32(buffer, key, value, index);\n } else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {\n index = serializeMinMax(buffer, key, value, index);\n } else if (typeof value._bsontype !== 'undefined') {\n throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);\n }\n }\n } else {\n if (typeof object?.toBSON === 'function') {\n // Provided a custom serialization method\n object = object.toBSON();\n if (object != null && typeof object !== 'object') {\n throw new BSONError('toBSON function did not return an object');\n }\n }\n\n // Iterate over all the keys\n for (const key of Object.keys(object)) {\n let value = object[key];\n // Is there an override value\n if (typeof value?.toBSON === 'function') {\n value = value.toBSON();\n }\n\n // Check the type of the value\n const type = typeof value;\n\n // Check the key and throw error if it's illegal\n if (typeof key === 'string' && !ignoreKeys.has(key)) {\n if (key.match(regexp) != null) {\n // The BSON spec doesn't allow keys with null bytes because keys are\n // null-terminated.\n throw new BSONError('key ' + key + ' must not contain null bytes');\n }\n\n if (checkKeys) {\n if ('$' === key[0]) {\n throw new BSONError('key ' + key + \" must not start with '$'\");\n } else if (~key.indexOf('.')) {\n throw new BSONError('key ' + key + \" must not contain '.'\");\n }\n }\n }\n\n if (type === 'string') {\n index = serializeString(buffer, key, value, index);\n } else if (type === 'number') {\n index = serializeNumber(buffer, key, value, index);\n } else if (type === 'bigint') {\n index = serializeBigInt(buffer, key, value, index);\n } else if (type === 'boolean') {\n index = serializeBoolean(buffer, key, value, index);\n } else if (value instanceof Date || isDate(value)) {\n index = serializeDate(buffer, key, value, index);\n } else if (value === undefined) {\n if (ignoreUndefined === false) index = serializeNull(buffer, key, value, index);\n } else if (value === null) {\n index = serializeNull(buffer, key, value, index);\n } else if (isUint8Array(value)) {\n index = serializeBuffer(buffer, key, value, index);\n } else if (value instanceof RegExp || isRegExp(value)) {\n index = serializeRegExp(buffer, key, value, index);\n } else if (type === 'object' && value._bsontype == null) {\n index = serializeObject(\n buffer,\n key,\n value,\n index,\n checkKeys,\n depth,\n serializeFunctions,\n ignoreUndefined,\n path\n );\n } else if (\n typeof value === 'object' &&\n value[Symbol.for('@@mdb.bson.version')] !== constants.BSON_MAJOR_VERSION\n ) {\n throw new BSONVersionError();\n } else if (value._bsontype === 'ObjectId') {\n index = serializeObjectId(buffer, key, value, index);\n } else if (type === 'object' && value._bsontype === 'Decimal128') {\n index = serializeDecimal128(buffer, key, value, index);\n } else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {\n index = serializeLong(buffer, key, value, index);\n } else if (value._bsontype === 'Double') {\n index = serializeDouble(buffer, key, value, index);\n } else if (value._bsontype === 'Code') {\n index = serializeCode(\n buffer,\n key,\n value,\n index,\n checkKeys,\n depth,\n serializeFunctions,\n ignoreUndefined,\n path\n );\n } else if (typeof value === 'function' && serializeFunctions) {\n index = serializeFunction(buffer, key, value, index);\n } else if (value._bsontype === 'Binary') {\n index = serializeBinary(buffer, key, value, index);\n } else if (value._bsontype === 'BSONSymbol') {\n index = serializeSymbol(buffer, key, value, index);\n } else if (value._bsontype === 'DBRef') {\n index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);\n } else if (value._bsontype === 'BSONRegExp') {\n index = serializeBSONRegExp(buffer, key, value, index);\n } else if (value._bsontype === 'Int32') {\n index = serializeInt32(buffer, key, value, index);\n } else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {\n index = serializeMinMax(buffer, key, value, index);\n } else if (typeof value._bsontype !== 'undefined') {\n throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);\n }\n }\n }\n\n // Remove the path\n path.delete(object);\n\n // Final padding byte for object\n buffer[index++] = 0x00;\n\n // Final size\n const size = index - startingIndex;\n // Write the size of the object\n buffer[startingIndex++] = size & 0xff;\n buffer[startingIndex++] = (size >> 8) & 0xff;\n buffer[startingIndex++] = (size >> 16) & 0xff;\n buffer[startingIndex++] = (size >> 24) & 0xff;\n return index;\n}\n","import { Binary } from './binary';\nimport type { Document } from './bson';\nimport { Code } from './code';\nimport {\n BSON_INT32_MAX,\n BSON_INT32_MIN,\n BSON_INT64_MAX,\n BSON_INT64_MIN,\n BSON_MAJOR_VERSION\n} from './constants';\nimport { DBRef, isDBRefLike } from './db_ref';\nimport { Decimal128 } from './decimal128';\nimport { Double } from './double';\nimport { BSONError, BSONRuntimeError, BSONVersionError } from './error';\nimport { Int32 } from './int_32';\nimport { Long } from './long';\nimport { MaxKey } from './max_key';\nimport { MinKey } from './min_key';\nimport { ObjectId } from './objectid';\nimport { isDate, isRegExp, isMap } from './parser/utils';\nimport { BSONRegExp } from './regexp';\nimport { BSONSymbol } from './symbol';\nimport { Timestamp } from './timestamp';\n\n/** @public */\nexport type EJSONOptions = {\n /**\n * Output using the Extended JSON v1 spec\n * @defaultValue `false`\n */\n legacy?: boolean;\n /**\n * Enable Extended JSON's `relaxed` mode, which attempts to return native JS types where possible, rather than BSON types\n * @defaultValue `false` */\n relaxed?: boolean;\n /**\n * Enable native bigint support\n * @defaultValue `false`\n */\n useBigInt64?: boolean;\n};\n\n/** @internal */\ntype BSONType =\n | Binary\n | Code\n | DBRef\n | Decimal128\n | Double\n | Int32\n | Long\n | MaxKey\n | MinKey\n | ObjectId\n | BSONRegExp\n | BSONSymbol\n | Timestamp;\n\nfunction isBSONType(value: unknown): value is BSONType {\n return (\n value != null &&\n typeof value === 'object' &&\n '_bsontype' in value &&\n typeof value._bsontype === 'string'\n );\n}\n\n// all the types where we don't need to do any special processing and can just pass the EJSON\n//straight to type.fromExtendedJSON\nconst keysToCodecs = {\n $oid: ObjectId,\n $binary: Binary,\n $uuid: Binary,\n $symbol: BSONSymbol,\n $numberInt: Int32,\n $numberDecimal: Decimal128,\n $numberDouble: Double,\n $numberLong: Long,\n $minKey: MinKey,\n $maxKey: MaxKey,\n $regex: BSONRegExp,\n $regularExpression: BSONRegExp,\n $timestamp: Timestamp\n} as const;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction deserializeValue(value: any, options: EJSONOptions = {}) {\n if (typeof value === 'number') {\n // TODO(NODE-4377): EJSON js number handling diverges from BSON\n const in32BitRange = value <= BSON_INT32_MAX && value >= BSON_INT32_MIN;\n const in64BitRange = value <= BSON_INT64_MAX && value >= BSON_INT64_MIN;\n\n if (options.relaxed || options.legacy) {\n return value;\n }\n\n if (Number.isInteger(value) && !Object.is(value, -0)) {\n // interpret as being of the smallest BSON integer type that can represent the number exactly\n if (in32BitRange) {\n return new Int32(value);\n }\n if (in64BitRange) {\n if (options.useBigInt64) {\n // eslint-disable-next-line no-restricted-globals -- This is allowed here as useBigInt64=true\n return BigInt(value);\n }\n return Long.fromNumber(value);\n }\n }\n\n // If the number is a non-integer or out of integer range, should interpret as BSON Double.\n return new Double(value);\n }\n\n // from here on out we're looking for bson types, so bail if its not an object\n if (value == null || typeof value !== 'object') return value;\n\n // upgrade deprecated undefined to null\n if (value.$undefined) return null;\n\n const keys = Object.keys(value).filter(\n k => k.startsWith('$') && value[k] != null\n ) as (keyof typeof keysToCodecs)[];\n for (let i = 0; i < keys.length; i++) {\n const c = keysToCodecs[keys[i]];\n if (c) return c.fromExtendedJSON(value, options);\n }\n\n if (value.$date != null) {\n const d = value.$date;\n const date = new Date();\n\n if (options.legacy) {\n if (typeof d === 'number') date.setTime(d);\n else if (typeof d === 'string') date.setTime(Date.parse(d));\n else if (typeof d === 'bigint') date.setTime(Number(d));\n else throw new BSONRuntimeError(`Unrecognized type for EJSON date: ${typeof d}`);\n } else {\n if (typeof d === 'string') date.setTime(Date.parse(d));\n else if (Long.isLong(d)) date.setTime(d.toNumber());\n else if (typeof d === 'number' && options.relaxed) date.setTime(d);\n else if (typeof d === 'bigint') date.setTime(Number(d));\n else throw new BSONRuntimeError(`Unrecognized type for EJSON date: ${typeof d}`);\n }\n return date;\n }\n\n if (value.$code != null) {\n const copy = Object.assign({}, value);\n if (value.$scope) {\n copy.$scope = deserializeValue(value.$scope);\n }\n\n return Code.fromExtendedJSON(value);\n }\n\n if (isDBRefLike(value) || value.$dbPointer) {\n const v = value.$ref ? value : value.$dbPointer;\n\n // we run into this in a \"degenerate EJSON\" case (with $id and $ref order flipped)\n // because of the order JSON.parse goes through the document\n if (v instanceof DBRef) return v;\n\n const dollarKeys = Object.keys(v).filter(k => k.startsWith('$'));\n let valid = true;\n dollarKeys.forEach(k => {\n if (['$ref', '$id', '$db'].indexOf(k) === -1) valid = false;\n });\n\n // only make DBRef if $ keys are all valid\n if (valid) return DBRef.fromExtendedJSON(v);\n }\n\n return value;\n}\n\ntype EJSONSerializeOptions = EJSONOptions & {\n seenObjects: { obj: unknown; propertyName: string }[];\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction serializeArray(array: any[], options: EJSONSerializeOptions): any[] {\n return array.map((v: unknown, index: number) => {\n options.seenObjects.push({ propertyName: `index ${index}`, obj: null });\n try {\n return serializeValue(v, options);\n } finally {\n options.seenObjects.pop();\n }\n });\n}\n\nfunction getISOString(date: Date) {\n const isoStr = date.toISOString();\n // we should only show milliseconds in timestamp if they're non-zero\n return date.getUTCMilliseconds() !== 0 ? isoStr : isoStr.slice(0, -5) + 'Z';\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction serializeValue(value: any, options: EJSONSerializeOptions): any {\n if (value instanceof Map || isMap(value)) {\n const obj: Record = Object.create(null);\n for (const [k, v] of value) {\n if (typeof k !== 'string') {\n throw new BSONError('Can only serialize maps with string keys');\n }\n obj[k] = v;\n }\n\n return serializeValue(obj, options);\n }\n\n if ((typeof value === 'object' || typeof value === 'function') && value !== null) {\n const index = options.seenObjects.findIndex(entry => entry.obj === value);\n if (index !== -1) {\n const props = options.seenObjects.map(entry => entry.propertyName);\n const leadingPart = props\n .slice(0, index)\n .map(prop => `${prop} -> `)\n .join('');\n const alreadySeen = props[index];\n const circularPart =\n ' -> ' +\n props\n .slice(index + 1, props.length - 1)\n .map(prop => `${prop} -> `)\n .join('');\n const current = props[props.length - 1];\n const leadingSpace = ' '.repeat(leadingPart.length + alreadySeen.length / 2);\n const dashes = '-'.repeat(\n circularPart.length + (alreadySeen.length + current.length) / 2 - 1\n );\n\n throw new BSONError(\n 'Converting circular structure to EJSON:\\n' +\n ` ${leadingPart}${alreadySeen}${circularPart}${current}\\n` +\n ` ${leadingSpace}\\\\${dashes}/`\n );\n }\n options.seenObjects[options.seenObjects.length - 1].obj = value;\n }\n\n if (Array.isArray(value)) return serializeArray(value, options);\n\n if (value === undefined) return null;\n\n if (value instanceof Date || isDate(value)) {\n const dateNum = value.getTime(),\n // is it in year range 1970-9999?\n inRange = dateNum > -1 && dateNum < 253402318800000;\n\n if (options.legacy) {\n return options.relaxed && inRange\n ? { $date: value.getTime() }\n : { $date: getISOString(value) };\n }\n return options.relaxed && inRange\n ? { $date: getISOString(value) }\n : { $date: { $numberLong: value.getTime().toString() } };\n }\n\n if (typeof value === 'number' && (!options.relaxed || !isFinite(value))) {\n if (Number.isInteger(value) && !Object.is(value, -0)) {\n // interpret as being of the smallest BSON integer type that can represent the number exactly\n if (value >= BSON_INT32_MIN && value <= BSON_INT32_MAX) {\n return { $numberInt: value.toString() };\n }\n if (value >= BSON_INT64_MIN && value <= BSON_INT64_MAX) {\n // TODO(NODE-4377): EJSON js number handling diverges from BSON\n return { $numberLong: value.toString() };\n }\n }\n return { $numberDouble: Object.is(value, -0) ? '-0.0' : value.toString() };\n }\n\n if (typeof value === 'bigint') {\n /* eslint-disable no-restricted-globals -- This is allowed as we are accepting a bigint as input */\n if (!options.relaxed) {\n return { $numberLong: BigInt.asIntN(64, value).toString() };\n }\n return Number(BigInt.asIntN(64, value));\n /* eslint-enable */\n }\n\n if (value instanceof RegExp || isRegExp(value)) {\n let flags = value.flags;\n if (flags === undefined) {\n const match = value.toString().match(/[gimuy]*$/);\n if (match) {\n flags = match[0];\n }\n }\n\n const rx = new BSONRegExp(value.source, flags);\n return rx.toExtendedJSON(options);\n }\n\n if (value != null && typeof value === 'object') return serializeDocument(value, options);\n return value;\n}\n\nconst BSON_TYPE_MAPPINGS = {\n Binary: (o: Binary) => new Binary(o.value(), o.sub_type),\n Code: (o: Code) => new Code(o.code, o.scope),\n DBRef: (o: DBRef) => new DBRef(o.collection || o.namespace, o.oid, o.db, o.fields), // \"namespace\" for 1.x library backwards compat\n Decimal128: (o: Decimal128) => new Decimal128(o.bytes),\n Double: (o: Double) => new Double(o.value),\n Int32: (o: Int32) => new Int32(o.value),\n Long: (\n o: Long & {\n low_: number;\n high_: number;\n unsigned_: boolean | undefined;\n }\n ) =>\n Long.fromBits(\n // underscore variants for 1.x backwards compatibility\n o.low != null ? o.low : o.low_,\n o.low != null ? o.high : o.high_,\n o.low != null ? o.unsigned : o.unsigned_\n ),\n MaxKey: () => new MaxKey(),\n MinKey: () => new MinKey(),\n ObjectId: (o: ObjectId) => new ObjectId(o),\n BSONRegExp: (o: BSONRegExp) => new BSONRegExp(o.pattern, o.options),\n BSONSymbol: (o: BSONSymbol) => new BSONSymbol(o.value),\n Timestamp: (o: Timestamp) => Timestamp.fromBits(o.low, o.high)\n} as const;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction serializeDocument(doc: any, options: EJSONSerializeOptions) {\n if (doc == null || typeof doc !== 'object') throw new BSONError('not an object instance');\n\n const bsontype: BSONType['_bsontype'] = doc._bsontype;\n if (typeof bsontype === 'undefined') {\n // It's a regular object. Recursively serialize its property values.\n const _doc: Document = {};\n for (const name of Object.keys(doc)) {\n options.seenObjects.push({ propertyName: name, obj: null });\n try {\n const value = serializeValue(doc[name], options);\n if (name === '__proto__') {\n Object.defineProperty(_doc, name, {\n value,\n writable: true,\n enumerable: true,\n configurable: true\n });\n } else {\n _doc[name] = value;\n }\n } finally {\n options.seenObjects.pop();\n }\n }\n return _doc;\n } else if (\n doc != null &&\n typeof doc === 'object' &&\n typeof doc._bsontype === 'string' &&\n doc[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION\n ) {\n throw new BSONVersionError();\n } else if (isBSONType(doc)) {\n // the \"document\" is really just a BSON type object\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n let outDoc: any = doc;\n if (typeof outDoc.toExtendedJSON !== 'function') {\n // There's no EJSON serialization function on the object. It's probably an\n // object created by a previous version of this library (or another library)\n // that's duck-typing objects to look like they were generated by this library).\n // Copy the object into this library's version of that type.\n const mapper = BSON_TYPE_MAPPINGS[doc._bsontype];\n if (!mapper) {\n throw new BSONError('Unrecognized or invalid _bsontype: ' + doc._bsontype);\n }\n outDoc = mapper(outDoc);\n }\n\n // Two BSON types may have nested objects that may need to be serialized too\n if (bsontype === 'Code' && outDoc.scope) {\n outDoc = new Code(outDoc.code, serializeValue(outDoc.scope, options));\n } else if (bsontype === 'DBRef' && outDoc.oid) {\n outDoc = new DBRef(\n serializeValue(outDoc.collection, options),\n serializeValue(outDoc.oid, options),\n serializeValue(outDoc.db, options),\n serializeValue(outDoc.fields, options)\n );\n }\n\n return outDoc.toExtendedJSON(options);\n } else {\n throw new BSONError('_bsontype must be a string, but was: ' + typeof bsontype);\n }\n}\n\n/**\n * Parse an Extended JSON string, constructing the JavaScript value or object described by that\n * string.\n *\n * @example\n * ```js\n * const { EJSON } = require('bson');\n * const text = '{ \"int32\": { \"$numberInt\": \"10\" } }';\n *\n * // prints { int32: { [String: '10'] _bsontype: 'Int32', value: '10' } }\n * console.log(EJSON.parse(text, { relaxed: false }));\n *\n * // prints { int32: 10 }\n * console.log(EJSON.parse(text));\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction parse(text: string, options?: EJSONOptions): any {\n const ejsonOptions = {\n useBigInt64: options?.useBigInt64 ?? false,\n relaxed: options?.relaxed ?? true,\n legacy: options?.legacy ?? false\n };\n return JSON.parse(text, (key, value) => {\n if (key.indexOf('\\x00') !== -1) {\n throw new BSONError(\n `BSON Document field names cannot contain null bytes, found: ${JSON.stringify(key)}`\n );\n }\n return deserializeValue(value, ejsonOptions);\n });\n}\n\n/**\n * Converts a BSON document to an Extended JSON string, optionally replacing values if a replacer\n * function is specified or optionally including only the specified properties if a replacer array\n * is specified.\n *\n * @param value - The value to convert to extended JSON\n * @param replacer - A function that alters the behavior of the stringification process, or an array of String and Number objects that serve as a whitelist for selecting/filtering the properties of the value object to be included in the JSON string. If this value is null or not provided, all properties of the object are included in the resulting JSON string\n * @param space - A String or Number object that's used to insert white space into the output JSON string for readability purposes.\n * @param options - Optional settings\n *\n * @example\n * ```js\n * const { EJSON } = require('bson');\n * const Int32 = require('mongodb').Int32;\n * const doc = { int32: new Int32(10) };\n *\n * // prints '{\"int32\":{\"$numberInt\":\"10\"}}'\n * console.log(EJSON.stringify(doc, { relaxed: false }));\n *\n * // prints '{\"int32\":10}'\n * console.log(EJSON.stringify(doc));\n * ```\n */\nfunction stringify(\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n value: any,\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n replacer?: (number | string)[] | ((this: any, key: string, value: any) => any) | EJSONOptions,\n space?: string | number,\n options?: EJSONOptions\n): string {\n if (space != null && typeof space === 'object') {\n options = space;\n space = 0;\n }\n if (replacer != null && typeof replacer === 'object' && !Array.isArray(replacer)) {\n options = replacer;\n replacer = undefined;\n space = 0;\n }\n const serializeOptions = Object.assign({ relaxed: true, legacy: false }, options, {\n seenObjects: [{ propertyName: '(root)', obj: null }]\n });\n\n const doc = serializeValue(value, serializeOptions);\n return JSON.stringify(doc, replacer as Parameters[1], space);\n}\n\n/**\n * Serializes an object to an Extended JSON string, and reparse it as a JavaScript object.\n *\n * @param value - The object to serialize\n * @param options - Optional settings passed to the `stringify` function\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction EJSONserialize(value: any, options?: EJSONOptions): Document {\n options = options || {};\n return JSON.parse(stringify(value, options));\n}\n\n/**\n * Deserializes an Extended JSON object into a plain JavaScript object with native/BSON types\n *\n * @param ejson - The Extended JSON object to deserialize\n * @param options - Optional settings passed to the parse method\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction EJSONdeserialize(ejson: Document, options?: EJSONOptions): any {\n options = options || {};\n return parse(JSON.stringify(ejson), options);\n}\n\n/** @public */\nconst EJSON: {\n parse: typeof parse;\n stringify: typeof stringify;\n serialize: typeof EJSONserialize;\n deserialize: typeof EJSONdeserialize;\n} = Object.create(null);\nEJSON.parse = parse;\nEJSON.stringify = stringify;\nEJSON.serialize = EJSONserialize;\nEJSON.deserialize = EJSONdeserialize;\nObject.freeze(EJSON);\nexport { EJSON };\n","import { Binary, UUID } from './binary';\nimport { Code } from './code';\nimport { DBRef } from './db_ref';\nimport { Decimal128 } from './decimal128';\nimport { Double } from './double';\nimport { Int32 } from './int_32';\nimport { Long } from './long';\nimport { MaxKey } from './max_key';\nimport { MinKey } from './min_key';\nimport { ObjectId } from './objectid';\nimport { internalCalculateObjectSize } from './parser/calculate_size';\n// Parts of the parser\nimport { internalDeserialize, type DeserializeOptions } from './parser/deserializer';\nimport { serializeInto, type SerializeOptions } from './parser/serializer';\nimport { BSONRegExp } from './regexp';\nimport { BSONSymbol } from './symbol';\nimport { Timestamp } from './timestamp';\nimport { ByteUtils } from './utils/byte_utils';\nexport type { UUIDExtended, BinaryExtended, BinaryExtendedLegacy, BinarySequence } from './binary';\nexport type { CodeExtended } from './code';\nexport type { DBRefLike } from './db_ref';\nexport type { Decimal128Extended } from './decimal128';\nexport type { DoubleExtended } from './double';\nexport type { EJSONOptions } from './extended_json';\nexport type { Int32Extended } from './int_32';\nexport type { LongExtended } from './long';\nexport type { MaxKeyExtended } from './max_key';\nexport type { MinKeyExtended } from './min_key';\nexport type { ObjectIdExtended, ObjectIdLike } from './objectid';\nexport type { BSONRegExpExtended, BSONRegExpExtendedLegacy } from './regexp';\nexport type { BSONSymbolExtended } from './symbol';\nexport type { LongWithoutOverrides, TimestampExtended, TimestampOverrides } from './timestamp';\nexport type { LongWithoutOverridesClass } from './timestamp';\nexport type { SerializeOptions, DeserializeOptions };\n\nexport {\n Code,\n BSONSymbol,\n DBRef,\n Binary,\n ObjectId,\n UUID,\n Long,\n Timestamp,\n Double,\n Int32,\n MinKey,\n MaxKey,\n BSONRegExp,\n Decimal128\n};\nexport { BSONValue } from './bson_value';\nexport { BSONError, BSONVersionError, BSONRuntimeError } from './error';\nexport { BSONType } from './constants';\nexport { EJSON } from './extended_json';\n\n/** @public */\nexport interface Document {\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n [key: string]: any;\n}\n\n/** @internal */\n// Default Max Size\nconst MAXSIZE = 1024 * 1024 * 17;\n\n// Current Internal Temporary Serialization Buffer\nlet buffer = ByteUtils.allocate(MAXSIZE);\n\n/**\n * Sets the size of the internal serialization buffer.\n *\n * @param size - The desired size for the internal serialization buffer in bytes\n * @public\n */\nexport function setInternalBufferSize(size: number): void {\n // Resize the internal serialization buffer if needed\n if (buffer.length < size) {\n buffer = ByteUtils.allocate(size);\n }\n}\n\n/**\n * Serialize a Javascript object.\n *\n * @param object - the Javascript object to serialize.\n * @returns Buffer object containing the serialized object.\n * @public\n */\nexport function serialize(object: Document, options: SerializeOptions = {}): Uint8Array {\n // Unpack the options\n const checkKeys = typeof options.checkKeys === 'boolean' ? options.checkKeys : false;\n const serializeFunctions =\n typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;\n const ignoreUndefined =\n typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : true;\n const minInternalBufferSize =\n typeof options.minInternalBufferSize === 'number' ? options.minInternalBufferSize : MAXSIZE;\n\n // Resize the internal serialization buffer if needed\n if (buffer.length < minInternalBufferSize) {\n buffer = ByteUtils.allocate(minInternalBufferSize);\n }\n\n // Attempt to serialize\n const serializationIndex = serializeInto(\n buffer,\n object,\n checkKeys,\n 0,\n 0,\n serializeFunctions,\n ignoreUndefined,\n null\n );\n\n // Create the final buffer\n const finishedBuffer = ByteUtils.allocate(serializationIndex);\n\n // Copy into the finished buffer\n finishedBuffer.set(buffer.subarray(0, serializationIndex), 0);\n\n // Return the buffer\n return finishedBuffer;\n}\n\n/**\n * Serialize a Javascript object using a predefined Buffer and index into the buffer,\n * useful when pre-allocating the space for serialization.\n *\n * @param object - the Javascript object to serialize.\n * @param finalBuffer - the Buffer you pre-allocated to store the serialized BSON object.\n * @returns the index pointing to the last written byte in the buffer.\n * @public\n */\nexport function serializeWithBufferAndIndex(\n object: Document,\n finalBuffer: Uint8Array,\n options: SerializeOptions = {}\n): number {\n // Unpack the options\n const checkKeys = typeof options.checkKeys === 'boolean' ? options.checkKeys : false;\n const serializeFunctions =\n typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;\n const ignoreUndefined =\n typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : true;\n const startIndex = typeof options.index === 'number' ? options.index : 0;\n\n // Attempt to serialize\n const serializationIndex = serializeInto(\n buffer,\n object,\n checkKeys,\n 0,\n 0,\n serializeFunctions,\n ignoreUndefined,\n null\n );\n\n finalBuffer.set(buffer.subarray(0, serializationIndex), startIndex);\n\n // Return the index\n return startIndex + serializationIndex - 1;\n}\n\n/**\n * Deserialize data as BSON.\n *\n * @param buffer - the buffer containing the serialized set of BSON documents.\n * @returns returns the deserialized Javascript Object.\n * @public\n */\nexport function deserialize(buffer: Uint8Array, options: DeserializeOptions = {}): Document {\n return internalDeserialize(ByteUtils.toLocalBufferType(buffer), options);\n}\n\n/** @public */\nexport type CalculateObjectSizeOptions = Pick<\n SerializeOptions,\n 'serializeFunctions' | 'ignoreUndefined'\n>;\n\n/**\n * Calculate the bson size for a passed in Javascript object.\n *\n * @param object - the Javascript object to calculate the BSON byte size for\n * @returns size of BSON object in bytes\n * @public\n */\nexport function calculateObjectSize(\n object: Document,\n options: CalculateObjectSizeOptions = {}\n): number {\n options = options || {};\n\n const serializeFunctions =\n typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;\n const ignoreUndefined =\n typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : true;\n\n return internalCalculateObjectSize(object, serializeFunctions, ignoreUndefined);\n}\n\n/**\n * Deserialize stream data as BSON documents.\n *\n * @param data - the buffer containing the serialized set of BSON documents.\n * @param startIndex - the start index in the data Buffer where the deserialization is to start.\n * @param numberOfDocuments - number of documents to deserialize.\n * @param documents - an array where to store the deserialized documents.\n * @param docStartIndex - the index in the documents array from where to start inserting documents.\n * @param options - additional options used for the deserialization.\n * @returns next index in the buffer after deserialization **x** numbers of documents.\n * @public\n */\nexport function deserializeStream(\n data: Uint8Array | ArrayBuffer,\n startIndex: number,\n numberOfDocuments: number,\n documents: Document[],\n docStartIndex: number,\n options: DeserializeOptions\n): number {\n const internalOptions = Object.assign(\n { allowObjectSmallerThanBufferSize: true, index: 0 },\n options\n );\n const bufferData = ByteUtils.toLocalBufferType(data);\n\n let index = startIndex;\n // Loop over all documents\n for (let i = 0; i < numberOfDocuments; i++) {\n // Find size of the document\n const size =\n bufferData[index] |\n (bufferData[index + 1] << 8) |\n (bufferData[index + 2] << 16) |\n (bufferData[index + 3] << 24);\n // Update options with index\n internalOptions.index = index;\n // Parse the document at this point\n documents[docStartIndex + i] = internalDeserialize(bufferData, internalOptions);\n // Adjust index by the document size\n index = index + size;\n }\n\n // Return object containing end index of parsing and list of documents\n return index;\n}\n","import { checkJson } from '../decorators/nojson'\nimport { ReturnModelType } from '@typegoose/typegoose'\n\nimport { Connection } from 'mongoose'\nimport { ObjectId } from 'bson'\nimport { AnyParamConstructor } from '@typegoose/typegoose/lib/types'\n\nconst jsonExcludeKeys = ['updatedAt', '__v']\nconst saveExcludeKeys = ['createdAt', 'updatedAt', '__v', '_id']\n\nconst isTrue = (obj: any): boolean =>{\n return (\n obj === 'true' ||\n obj === 'TRUE' ||\n obj === 'True' ||\n obj === 'on' ||\n obj === 'ON' ||\n obj === true ||\n obj === 1 ||\n obj === '1' ||\n obj === 'YES' ||\n obj === 'yes'\n )\n}\n\nexport abstract class BaseModule {\n static db: Connection\n\n public updateFromReq(data: any) {\n for (let key in data) {\n if (saveExcludeKeys.indexOf(key) == -1) {\n this[key] = data[key]\n }\n }\n }\n\n /**\n * 插入或更新\n * @param condition\n * @param data\n */\n public static insertOrUpdate(\n this: ReturnModelType>,\n condition: any,\n data: any,\n ) {\n return this.findOneAndUpdate(condition, data, { upsert: true, new: true, setDefaultsOnInsert: true })\n }\n\n /**\n * 虚拟删除\n * @param {string[]} ids\n */\n public static deleteVirtual(this: ReturnModelType>, ids: string[]) {\n return this.updateMany(\n // @ts-ignore\n {\n _id: { $in: ids },\n },\n {\n $set: {\n deleted: true,\n deleteTime: new Date(),\n },\n },\n )\n }\n\n /**\n * 自定义分页查询\n * @param data\n * @param {boolean} json\n */\n public static async pageQuery(\n this: ReturnModelType>,\n data: any,\n json: boolean = false,\n ) {\n let { start, limit, page } = data\n limit = +limit || 10\n start = +start || (+page - 1) * limit || 0\n // @ts-ignore\n let { opt, sort } = this.parseQueryParam(data)\n let records = await this.find(opt).sort(sort).skip(start).limit(limit)\n let total = await this.countDocuments(opt)\n if (json) {\n records.map(o => o.toJson())\n }\n return { records, total, start, limit }\n }\n\n public toJson() {\n let result: any = {}\n // @ts-ignore\n for (let key in this._doc) {\n if (checkJson(this, key + '') && jsonExcludeKeys.indexOf(key) == -1) {\n result[key] = this[key]\n }\n }\n return result\n }\n\n /**\n * 通用的查询条件拼接方法\n * @param {{}} params req.params\n * @param options\n * sort: 排序 比如: {createdAt: 1} 默认是 {_id: 1}\n * opt: 设置一些特殊的过滤条件, 比如{deleted: 0}\n * timeKey: 如果需要查询创建时间, 而且创建时间不为 createdAt, 可以用此字段设置\n * matchKey: 指定关键字查询的匹配字段, 可为string或[string]\n *\n * @return {{opt: any, sort: {_id: number}}}\n */\n public static parseQueryParam(params: {}, options?: any) {\n const opt: any = { deleted: { $ne: true } }\n // @ts-ignore\n let obj = this.schema.paths\n for (let key in params) {\n if (key !== 'sort' && obj.hasOwnProperty(key)) {\n switch (obj[key].instance) {\n case 'String':\n opt[key] = { $regex: params[key], $options: 'i' }\n break\n case 'Number':\n opt[key] = params[key]\n break\n case 'Array':\n if (Array.isArray(params[key])) {\n opt[key] = { $in: params[key] }\n } else {\n opt[key] = params[key]\n }\n break\n case 'Date':\n // TODO:\n break\n case 'Boolean':\n opt[key] = isTrue(params[key])\n break\n case 'ObjectID':\n if (/^[0-9a-fA-F]{24}$/.test(params[key])) {\n opt[key] = new ObjectId(params[key])\n }\n break\n }\n }\n }\n if (params.hasOwnProperty('key') && params['key']) {\n let orArr = []\n if (options?.matchKey) {\n if (Array.isArray(options?.matchKey)) {\n for (let key in options?.matchKey) {\n let _tmp = {}\n _tmp[key] = { $regex: params['key'], $options: 'i' }\n orArr.push(_tmp)\n }\n } else {\n let _tmp = {}\n _tmp[options.matchKey] = { $regex: params['key'], $options: 'i' }\n orArr.push(_tmp)\n }\n } else {\n for (let key in obj) {\n if (obj[key].instance === 'String') {\n let _tmp = {}\n _tmp[key] = { $regex: params['key'], $options: 'i' }\n orArr.push(_tmp)\n }\n }\n }\n\n Object.assign(opt, { $or: orArr })\n }\n let timeKey = options?.timeKey ? options.timeKey : 'createdAt'\n if (params.hasOwnProperty('timeBegin') && !params.hasOwnProperty('timeEnd')) {\n let timeBegin = params['timeBegin']\n if (!(timeBegin instanceof Date)) {\n timeBegin = new Date(parseInt(timeBegin))\n }\n opt[timeKey] = { $gte: timeBegin }\n } else if (params.hasOwnProperty('timeBegin') && params.hasOwnProperty('timeEnd')) {\n let timeBegin = params['timeBegin']\n if (!(timeBegin instanceof Date)) {\n timeBegin = new Date(parseInt(timeBegin))\n }\n let timeEnd = params['timeEnd']\n if (!(timeEnd instanceof Date)) {\n timeEnd = new Date(parseInt(timeEnd))\n }\n let tmpB = {}\n tmpB[timeKey] = { $gte: timeBegin }\n let tmpE = {}\n tmpE[timeKey] = { $lte: timeEnd }\n opt['$and'] = [tmpB, tmpE]\n } else if (!params.hasOwnProperty('timeBegin') && params.hasOwnProperty('timeEnd')) {\n let timeEnd = params['timeEnd']\n if (!(timeEnd instanceof Date)) {\n timeEnd = new Date(parseInt(timeEnd))\n }\n opt[timeKey] = { $lte: timeEnd }\n }\n if (options?.opt) {\n Object.assign(opt, options.opt)\n }\n let sort = { _id: 1 }\n if (params.hasOwnProperty('sort')) {\n sort = params['sort']\n }\n return { opt, sort }\n }\n public getTimestampOfID() {\n // Extract the timestamp from the ObjectId\n // @ts-ignore\n return this._id.getTimestamp()\n }\n}\n","import { AsyncQueue, createAsyncQueue } from 'common/AsyncQueue'\nimport { singleton } from 'decorators/singleton'\nimport { logger } from 'logger/logger'\nimport { UserLog } from 'models/UserLog'\n\n@singleton\nexport class LoggerQueue {\n private queue: AsyncQueue\n\n constructor() {\n this.queue = createAsyncQueue()\n }\n\n public addLog(name: string, req: any, logObj: any = {}) {\n this.queue.push(async () => {\n const user = req.user\n const ip = req.headers['x-forwarded-for'] || req.ip\n const path = req.url\n const params = req.method === 'GET' ? req.query : req.body\n const dataObj = JSON.stringify(logObj) === '{}' ? params : logObj\n try {\n const history = new UserLog({\n user: user ? user.id : '',\n path: path,\n method: req.method,\n params: dataObj,\n referer: req.headers['referer'],\n user_agent: req.headers['user-agent'],\n ip,\n name,\n })\n await history.save()\n } catch (err) {\n logger.error('error add user log: ')\n logger.error(err)\n }\n })\n }\n}\n","import { LoggerQueue } from 'queue/logger.queue'\nimport { colorConsole } from 'tracer'\n\n\ndeclare module Tracer {\n interface Logger {\n db: (name: string, req: any, logObj?: any) => void\n }\n}\n\nconst level = process.env.NODE_ENV === 'production' ? 'info' : 'log'\nconst _logger = colorConsole({ dateformat: 'yyyy-mm-dd HH:MM:ss.L', level })\nObject.assign(_logger, {\n db: (name: string, req: any, logObj?: any) => {\n logObj = logObj || {}\n new LoggerQueue().addLog(name, req, logObj)\n }\n})\nexport const logger = _logger\n"],"mappings":"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","names":["Reflect","hasOwn","metadataRegistry","metadata","OrdinaryDefineOwnMetadata","OrdinaryHasOwnMetadata","OrdinaryGetOwnMetadata","OrdinaryOwnMetadataKeys","defineMetadata","hasOwnMetadata","getOwnMetadata","getOwnMetadataKeys","deleteMetadata","MapIterator","index","Map","Set","WeakMap","buffer","mongoose","buffer","crypto","index","constants.JS_INT_MAX","constants.JS_INT_MIN","index","prop","mongoose"]} \ No newline at end of file diff --git a/package.json b/package.json index 3778d9d..2ec8d75 100644 --- a/package.json +++ b/package.json @@ -2,13 +2,28 @@ "name": "mongobase", "version": "1.0.0", "description": "", - "main": "index.js", + "main": "./dist/index.js", + "exports": { + ".": { + "import": "./dist/index.js", + "types": "./dist/index.d.ts" + } + }, + "type": "module", "scripts": { - "test": "echo \"Error: no test specified\" && exit 1" + "build": "tsup", + "lint": "eslint --ext .ts src/**", + "format": "eslint --ext .ts src/** --fix" }, "author": "zhl", "license": "ISC", + "dependencies": { + "@typegoose/typegoose": "^12.1.0", + "mongoose": "^8.1.0", + "tracer": "^1.3.0" + }, "devDependencies": { + "@types/node": "16", "@typescript-eslint/eslint-plugin": "^6.19.0", "@typescript-eslint/parser": "^6.19.0", "eslint-config-prettier": "^9.1.0", diff --git a/src/common/AsyncQueue.ts b/src/common/AsyncQueue.ts new file mode 100644 index 0000000..792c27e --- /dev/null +++ b/src/common/AsyncQueue.ts @@ -0,0 +1,107 @@ +type Callback = () => Promise + +export type AsyncQueue = { + push: (task: Callback) => Promise + flush: () => Promise + size: number +} + +/** + * Ensures that each callback pushed onto the queue is executed in series. + * Such a quetie 😻 + * @param opts.dedupeConcurrent If dedupeConcurrent is `true` it ensures that if multiple + * tasks are pushed onto the queue while there is an active task, only the + * last one will be executed, once the active task has completed. + * e.g. in the below example, only 0 and 3 will be executed. + * ``` + * const queue = createAsyncQueue({ dedupeConcurrent: true }) + * queue.push(async () => console.log(0)) // returns 0 + * queue.push(async () => console.log(1)) // returns 3 + * queue.push(async () => console.log(2)) // returns 3 + * queue.push(async () => console.log(3)) // returns 3 + * ``` + * */ +export function createAsyncQueue(opts = { dedupeConcurrent: false }): AsyncQueue { + const { dedupeConcurrent } = opts + let queue: Callback[] = [] + let running: Promise | undefined + let nextPromise = new DeferredPromise() + const push = (task: Callback) => { + let taskPromise = new DeferredPromise() + if (dedupeConcurrent) { + queue = [] + if (nextPromise.started) nextPromise = new DeferredPromise() + taskPromise = nextPromise + } + queue.push(() => { + taskPromise.started = true + task().then(taskPromise.resolve).catch(taskPromise.reject) + return taskPromise.promise + }) + if (!running) running = start() + return taskPromise.promise + } + const start = async () => { + while (queue.length) { + const task = queue.shift()! + await task().catch(() => {}) + } + running = undefined + } + return { + push, + flush: () => running || Promise.resolve(), + get size() { + return queue.length + }, + } +} + +export const createAsyncQueues = (opts = { dedupeConcurrent: false }) => { + const queues: { [queueId: string]: AsyncQueue } = {} + const push = (queueId: string, task: Callback) => { + if (!queues[queueId]) queues[queueId] = createAsyncQueue(opts) + return queues[queueId].push(task) + } + const flush = (queueId: string) => { + if (!queues[queueId]) queues[queueId] = createAsyncQueue(opts) + return queues[queueId].flush() + } + return { push, flush } +} + +class DeferredPromise { + started = false + resolve: (x: T | PromiseLike) => void = () => {} + reject: (x: E) => void = () => {} + promise: Promise + + constructor() { + this.promise = new Promise((res, rej) => { + this.resolve = res + this.reject = rej + }) + } +} + +// function main() { +// const queue = createAsyncQueue() +// queue.push(async () => { +// console.log(0) +// }) // returns 0 +// queue.push(async () => { +// console.log(1) + +// return new Promise((resolve, reject) => { +// setTimeout(() => { +// console.log('12') +// resolve() +// }, 1000) +// }) +// }) // returns 3 +// queue.push(async () => console.log(2)) // returns 3 +// queue.push(async () => console.log(3)) // returns 3 +// console.log('hi') +// } + +// main() diff --git a/src/decorators/dbconn.ts b/src/decorators/dbconn.ts new file mode 100644 index 0000000..3dc3689 --- /dev/null +++ b/src/decorators/dbconn.ts @@ -0,0 +1,14 @@ +import { mongoose } from '@typegoose/typegoose' + +/** + * 为model指定数据库连接 + * @param {string} name 数据库连接名字， 在config中必须要有对应的配置， 比如main， 则必须要有 db_main + * */ +export function dbconn(name?: string) { + return target => { + name = name || 'main' + const dbName = ('db_' + name).toUpperCase() + const url = process.env[dbName] + target['db'] = mongoose.createConnection(url, {}) + } +} diff --git a/src/decorators/nojson.ts b/src/decorators/nojson.ts new file mode 100644 index 0000000..553108c --- /dev/null +++ b/src/decorators/nojson.ts @@ -0,0 +1,30 @@ +import 'reflect-metadata' +import { singleton } from './singleton' + + +@singleton +export class NoJsonClass { + private noJsonPropSet: Set = new Set() + + public addKey(className: string, propertyKey: string) { + this.noJsonPropSet.add(className + '_' + propertyKey) + } + + public checkExist(className: string, propertyKey: string) { + return this.noJsonPropSet.has(className + '_' + propertyKey) + } +} +/** + * 在不需要toJson方法输出的字段上加上 @noJson + * @return {{(target: Function): void, (target: Object, propertyKey: (string | symbol)): void}} + */ +export function noJson() { + // return Reflect.metadata(noJsonMetadataKey, !0) + return function (target: Object, propertyKey: string) { + new NoJsonClass().addKey(target.constructor.name, propertyKey) + } +} + +export function checkJson(target: any, propertyKey: string) { + return !new NoJsonClass().checkExist(target.constructor.modelName, propertyKey) +} diff --git a/src/decorators/singleton.ts b/src/decorators/singleton.ts new file mode 100644 index 0000000..c43327d --- /dev/null +++ b/src/decorators/singleton.ts @@ -0,0 +1,29 @@ +/** + * 单例化一个class + * 使用方法: + * @singleton + * class Test {} + * new Test() === new Test() // returns `true` + * 也可以不使用 decorator + * const TestSingleton = singleton(Test) + * new TestSingleton() === new TestSingleton() //returns 'true' + */ + +export const SINGLETON_KEY = Symbol() + +export type Singleton any> = T & { + [SINGLETON_KEY]: T extends new (...args: any[]) => infer I ? I : never +} +export const singleton = any>(classTarget: T) => + new Proxy(classTarget, { + construct(target: Singleton, argumentsList, newTarget) { + // Skip proxy for children + if (target.prototype !== newTarget.prototype) { + return Reflect.construct(target, argumentsList, newTarget) + } + if (!target[SINGLETON_KEY]) { + target[SINGLETON_KEY] = Reflect.construct(target, argumentsList, newTarget) + } + return target[SINGLETON_KEY] + }, + }) diff --git a/src/index.ts b/src/index.ts new file mode 100644 index 0000000..cb2f8e0 --- /dev/null +++ b/src/index.ts @@ -0,0 +1,5 @@ +export * from './decorators/dbconn' +export * from './decorators/nojson' +export { logger } from './logger/logger' +export { UserLog } from './models/UserLog' +export { BaseModule } from './models/Base' \ No newline at end of file diff --git a/src/logger/logger.ts b/src/logger/logger.ts new file mode 100644 index 0000000..cfcc256 --- /dev/null +++ b/src/logger/logger.ts @@ -0,0 +1,19 @@ +import { LoggerQueue } from 'queue/logger.queue' +import { colorConsole } from 'tracer' + + +declare module Tracer { + interface Logger { + db: (name: string, req: any, logObj?: any) => void + } +} + +const level = process.env.NODE_ENV === 'production' ? 'info' : 'log' +const _logger = colorConsole({ dateformat: 'yyyy-mm-dd HH:MM:ss.L', level }) +Object.assign(_logger, { + db: (name: string, req: any, logObj?: any) => { + logObj = logObj || {} + new LoggerQueue().addLog(name, req, logObj) + } +}) +export const logger = _logger diff --git a/src/models/Base.ts b/src/models/Base.ts new file mode 100644 index 0000000..a54fe52 --- /dev/null +++ b/src/models/Base.ts @@ -0,0 +1,216 @@ +import { checkJson } from '../decorators/nojson' +import { ReturnModelType } from '@typegoose/typegoose' + +import { Connection } from 'mongoose' +import { ObjectId } from 'bson' +import { AnyParamConstructor } from '@typegoose/typegoose/lib/types' + +const jsonExcludeKeys = ['updatedAt', '__v'] +const saveExcludeKeys = ['createdAt', 'updatedAt', '__v', '_id'] + +const isTrue = (obj: any): boolean =>{ + return ( + obj === 'true' || + obj === 'TRUE' || + obj === 'True' || + obj === 'on' || + obj === 'ON' || + obj === true || + obj === 1 || + obj === '1' || + obj === 'YES' || + obj === 'yes' + ) +} + +export abstract class BaseModule { + static db: Connection + + public updateFromReq(data: any) { + for (let key in data) { + if (saveExcludeKeys.indexOf(key) == -1) { + this[key] = data[key] + } + } + } + + /** + * 插入或更新 + * @param condition + * @param data + */ + public static insertOrUpdate( + this: ReturnModelType>, + condition: any, + data: any, + ) { + return this.findOneAndUpdate(condition, data, { upsert: true, new: true, setDefaultsOnInsert: true }) + } + + /** + * 虚拟删除 + * @param {string[]} ids + */ + public static deleteVirtual(this: ReturnModelType>, ids: string[]) { + return this.updateMany( + // @ts-ignore + { + _id: { $in: ids }, + }, + { + $set: { + deleted: true, + deleteTime: new Date(), + }, + }, + ) + } + + /** + * 自定义分页查询 + * @param data + * @param {boolean} json + */ + public static async pageQuery( + this: ReturnModelType>, + data: any, + json: boolean = false, + ) { + let { start, limit, page } = data + limit = +limit || 10 + start = +start || (+page - 1) * limit || 0 + // @ts-ignore + let { opt, sort } = this.parseQueryParam(data) + let records = await this.find(opt).sort(sort).skip(start).limit(limit) + let total = await this.countDocuments(opt) + if (json) { + records.map(o => o.toJson()) + } + return { records, total, start, limit } + } + + public toJson() { + let result: any = {} + // @ts-ignore + for (let key in this._doc) { + if (checkJson(this, key + '') && jsonExcludeKeys.indexOf(key) == -1) { + result[key] = this[key] + } + } + return result + } + + /** + * 通用的查询条件拼接方法 + * @param {{}} params req.params + * @param options + * sort: 排序 比如: {createdAt: 1} 默认是 {_id: 1} + * opt: 设置一些特殊的过滤条件, 比如{deleted: 0} + * timeKey: 如果需要查询创建时间, 而且创建时间不为 createdAt, 可以用此字段设置 + * matchKey: 指定关键字查询的匹配字段, 可为string或[string] + * + * @return {{opt: any, sort: {_id: number}}} + */ + public static parseQueryParam(params: {}, options?: any) { + const opt: any = { deleted: { $ne: true } } + // @ts-ignore + let obj = this.schema.paths + for (let key in params) { + if (key !== 'sort' && obj.hasOwnProperty(key)) { + switch (obj[key].instance) { + case 'String': + opt[key] = { $regex: params[key], $options: 'i' } + break + case 'Number': + opt[key] = params[key] + break + case 'Array': + if (Array.isArray(params[key])) { + opt[key] = { $in: params[key] } + } else { + opt[key] = params[key] + } + break + case 'Date': + // TODO: + break + case 'Boolean': + opt[key] = isTrue(params[key]) + break + case 'ObjectID': + if (/^[0-9a-fA-F]{24}$/.test(params[key])) { + opt[key] = new ObjectId(params[key]) + } + break + } + } + } + if (params.hasOwnProperty('key') && params['key']) { + let orArr = [] + if (options?.matchKey) { + if (Array.isArray(options?.matchKey)) { + for (let key in options?.matchKey) { + let _tmp = {} + _tmp[key] = { $regex: params['key'], $options: 'i' } + orArr.push(_tmp) + } + } else { + let _tmp = {} + _tmp[options.matchKey] = { $regex: params['key'], $options: 'i' } + orArr.push(_tmp) + } + } else { + for (let key in obj) { + if (obj[key].instance === 'String') { + let _tmp = {} + _tmp[key] = { $regex: params['key'], $options: 'i' } + orArr.push(_tmp) + } + } + } + + Object.assign(opt, { $or: orArr }) + } + let timeKey = options?.timeKey ? options.timeKey : 'createdAt' + if (params.hasOwnProperty('timeBegin') && !params.hasOwnProperty('timeEnd')) { + let timeBegin = params['timeBegin'] + if (!(timeBegin instanceof Date)) { + timeBegin = new Date(parseInt(timeBegin)) + } + opt[timeKey] = { $gte: timeBegin } + } else if (params.hasOwnProperty('timeBegin') && params.hasOwnProperty('timeEnd')) { + let timeBegin = params['timeBegin'] + if (!(timeBegin instanceof Date)) { + timeBegin = new Date(parseInt(timeBegin)) + } + let timeEnd = params['timeEnd'] + if (!(timeEnd instanceof Date)) { + timeEnd = new Date(parseInt(timeEnd)) + } + let tmpB = {} + tmpB[timeKey] = { $gte: timeBegin } + let tmpE = {} + tmpE[timeKey] = { $lte: timeEnd } + opt['$and'] = [tmpB, tmpE] + } else if (!params.hasOwnProperty('timeBegin') && params.hasOwnProperty('timeEnd')) { + let timeEnd = params['timeEnd'] + if (!(timeEnd instanceof Date)) { + timeEnd = new Date(parseInt(timeEnd)) + } + opt[timeKey] = { $lte: timeEnd } + } + if (options?.opt) { + Object.assign(opt, options.opt) + } + let sort = { _id: 1 } + if (params.hasOwnProperty('sort')) { + sort = params['sort'] + } + return { opt, sort } + } + public getTimestampOfID() { + // Extract the timestamp from the ObjectId + // @ts-ignore + return this._id.getTimestamp() + } +} diff --git a/src/models/UserLog.ts b/src/models/UserLog.ts new file mode 100644 index 0000000..37a41e6 --- /dev/null +++ b/src/models/UserLog.ts @@ -0,0 +1,31 @@ +import { dbconn } from 'decorators/dbconn' +import { getModelForClass, index, modelOptions, mongoose, prop } from '@typegoose/typegoose' +import { Severity } from '@typegoose/typegoose/lib/internal/constants' +import { BaseModule } from './Base' + +/** + * 用户操作记录 + */ +@dbconn() +@index({ user: 1 }, { unique: false }) +@index({ name: 1 }, { unique: false }) +@modelOptions({ schemaOptions: { collection: 'user_log', timestamps: true }, options: { allowMixed: Severity.ALLOW } }) +class UserLogClass extends BaseModule { + @prop() + public user: string + @prop() + public name: string + @prop() + public method: string + @prop() + public path: string + @prop() + public referer: string + @prop() + public user_agent: string + @prop() + public ip: string + @prop({ type: mongoose.Schema.Types.Mixed }) + public params: any +} +export const UserLog = getModelForClass(UserLogClass, { existingConnection: UserLogClass['db'] }) diff --git a/src/queue/logger.queue.ts b/src/queue/logger.queue.ts new file mode 100644 index 0000000..af210e2 --- /dev/null +++ b/src/queue/logger.queue.ts @@ -0,0 +1,39 @@ +import { AsyncQueue, createAsyncQueue } from 'common/AsyncQueue' +import { singleton } from 'decorators/singleton' +import { logger } from 'logger/logger' +import { UserLog } from 'models/UserLog' + +@singleton +export class LoggerQueue { + private queue: AsyncQueue + + constructor() { + this.queue = createAsyncQueue() + } + + public addLog(name: string, req: any, logObj: any = {}) { + this.queue.push(async () => { + const user = req.user + const ip = req.headers['x-forwarded-for'] || req.ip + const path = req.url + const params = req.method === 'GET' ? req.query : req.body + const dataObj = JSON.stringify(logObj) === '{}' ? params : logObj + try { + const history = new UserLog({ + user: user ? user.id : '', + path: path, + method: req.method, + params: dataObj, + referer: req.headers['referer'], + user_agent: req.headers['user-agent'], + ip, + name, + }) + await history.save() + } catch (err) { + logger.error('error add user log: ') + logger.error(err) + } + }) + } +} diff --git a/tsconfig.json b/tsconfig.json index 6ace6f6..2a3cea4 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -5,17 +5,17 @@ "compilerOptions": { "experimentalDecorators": true, "emitDecoratorMetadata": true, - "module": "commonjs", + "module": "esnext", "esModuleInterop": true, "resolveJsonModule": true, - "target": "es2020", + "target": "es2022", "moduleResolution": "node", "sourceMap": true, "outDir": "./dist", "baseUrl": "./src", "rootDir": "./src" }, - "lib": ["es2020"], + "lib": ["es2021"], "include": [ "src/**/*.ts", "typings/extend.d.ts" diff --git a/tsup.config.ts b/tsup.config.ts new file mode 100644 index 0000000..309fdc5 --- /dev/null +++ b/tsup.config.ts @@ -0,0 +1,10 @@ +import { defineConfig } from "tsup"; + +export default defineConfig({ + entry: ["src/index.ts"], + format: ["esm"], // Build for and ESmodules + dts: true, // Generate declaration file (.d.ts) + splitting: false, + sourcemap: true, + clean: true, +}); \ No newline at end of file diff --git a/yarn.lock b/yarn.lock index d7f1b41..87a6f7a 100644 --- a/yarn.lock +++ b/yarn.lock @@ -9,12 +9,165 @@ dependencies: "@jridgewell/trace-mapping" "0.3.9" -"@jridgewell/resolve-uri@^3.0.3": +"@esbuild/aix-ppc64@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/aix-ppc64/-/aix-ppc64-0.19.11.tgz#2acd20be6d4f0458bc8c784103495ff24f13b1d3" + integrity sha512-FnzU0LyE3ySQk7UntJO4+qIiQgI7KoODnZg5xzXIrFJlKd2P2gwHsHY4927xj9y5PJmJSzULiUCWmv7iWnNa7g== + +"@esbuild/android-arm64@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.19.11.tgz#b45d000017385c9051a4f03e17078abb935be220" + integrity sha512-aiu7K/5JnLj//KOnOfEZ0D90obUkRzDMyqd/wNAUQ34m4YUPVhRZpnqKV9uqDGxT7cToSDnIHsGooyIczu9T+Q== + +"@esbuild/android-arm@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.19.11.tgz#f46f55414e1c3614ac682b29977792131238164c" + integrity sha512-5OVapq0ClabvKvQ58Bws8+wkLCV+Rxg7tUVbo9xu034Nm536QTII4YzhaFriQ7rMrorfnFKUsArD2lqKbFY4vw== + +"@esbuild/android-x64@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.19.11.tgz#bfc01e91740b82011ef503c48f548950824922b2" + integrity sha512-eccxjlfGw43WYoY9QgB82SgGgDbibcqyDTlk3l3C0jOVHKxrjdc9CTwDUQd0vkvYg5um0OH+GpxYvp39r+IPOg== + +"@esbuild/darwin-arm64@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.19.11.tgz#533fb7f5a08c37121d82c66198263dcc1bed29bf" + integrity sha512-ETp87DRWuSt9KdDVkqSoKoLFHYTrkyz2+65fj9nfXsaV3bMhTCjtQfw3y+um88vGRKRiF7erPrh/ZuIdLUIVxQ== + +"@esbuild/darwin-x64@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.19.11.tgz#62f3819eff7e4ddc656b7c6815a31cf9a1e7d98e" + integrity sha512-fkFUiS6IUK9WYUO/+22omwetaSNl5/A8giXvQlcinLIjVkxwTLSktbF5f/kJMftM2MJp9+fXqZ5ezS7+SALp4g== + +"@esbuild/freebsd-arm64@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.19.11.tgz#d478b4195aa3ca44160272dab85ef8baf4175b4a" + integrity sha512-lhoSp5K6bxKRNdXUtHoNc5HhbXVCS8V0iZmDvyWvYq9S5WSfTIHU2UGjcGt7UeS6iEYp9eeymIl5mJBn0yiuxA== + +"@esbuild/freebsd-x64@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.19.11.tgz#7bdcc1917409178257ca6a1a27fe06e797ec18a2" + integrity sha512-JkUqn44AffGXitVI6/AbQdoYAq0TEullFdqcMY/PCUZ36xJ9ZJRtQabzMA+Vi7r78+25ZIBosLTOKnUXBSi1Kw== + +"@esbuild/linux-arm64@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.19.11.tgz#58ad4ff11685fcc735d7ff4ca759ab18fcfe4545" + integrity sha512-LneLg3ypEeveBSMuoa0kwMpCGmpu8XQUh+mL8XXwoYZ6Be2qBnVtcDI5azSvh7vioMDhoJFZzp9GWp9IWpYoUg== + +"@esbuild/linux-arm@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.19.11.tgz#ce82246d873b5534d34de1e5c1b33026f35e60e3" + integrity sha512-3CRkr9+vCV2XJbjwgzjPtO8T0SZUmRZla+UL1jw+XqHZPkPgZiyWvbDvl9rqAN8Zl7qJF0O/9ycMtjU67HN9/Q== + +"@esbuild/linux-ia32@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.19.11.tgz#cbae1f313209affc74b80f4390c4c35c6ab83fa4" + integrity sha512-caHy++CsD8Bgq2V5CodbJjFPEiDPq8JJmBdeyZ8GWVQMjRD0sU548nNdwPNvKjVpamYYVL40AORekgfIubwHoA== + +"@esbuild/linux-loong64@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.19.11.tgz#5f32aead1c3ec8f4cccdb7ed08b166224d4e9121" + integrity sha512-ppZSSLVpPrwHccvC6nQVZaSHlFsvCQyjnvirnVjbKSHuE5N24Yl8F3UwYUUR1UEPaFObGD2tSvVKbvR+uT1Nrg== + +"@esbuild/linux-mips64el@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.19.11.tgz#38eecf1cbb8c36a616261de858b3c10d03419af9" + integrity sha512-B5x9j0OgjG+v1dF2DkH34lr+7Gmv0kzX6/V0afF41FkPMMqaQ77pH7CrhWeR22aEeHKaeZVtZ6yFwlxOKPVFyg== + +"@esbuild/linux-ppc64@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.19.11.tgz#9c5725a94e6ec15b93195e5a6afb821628afd912" + integrity sha512-MHrZYLeCG8vXblMetWyttkdVRjQlQUb/oMgBNurVEnhj4YWOr4G5lmBfZjHYQHHN0g6yDmCAQRR8MUHldvvRDA== + +"@esbuild/linux-riscv64@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.19.11.tgz#2dc4486d474a2a62bbe5870522a9a600e2acb916" + integrity sha512-f3DY++t94uVg141dozDu4CCUkYW+09rWtaWfnb3bqe4w5NqmZd6nPVBm+qbz7WaHZCoqXqHz5p6CM6qv3qnSSQ== + +"@esbuild/linux-s390x@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.19.11.tgz#4ad8567df48f7dd4c71ec5b1753b6f37561a65a8" + integrity sha512-A5xdUoyWJHMMlcSMcPGVLzYzpcY8QP1RtYzX5/bS4dvjBGVxdhuiYyFwp7z74ocV7WDc0n1harxmpq2ePOjI0Q== + +"@esbuild/linux-x64@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.19.11.tgz#b7390c4d5184f203ebe7ddaedf073df82a658766" + integrity sha512-grbyMlVCvJSfxFQUndw5mCtWs5LO1gUlwP4CDi4iJBbVpZcqLVT29FxgGuBJGSzyOxotFG4LoO5X+M1350zmPA== + +"@esbuild/netbsd-x64@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.19.11.tgz#d633c09492a1721377f3bccedb2d821b911e813d" + integrity sha512-13jvrQZJc3P230OhU8xgwUnDeuC/9egsjTkXN49b3GcS5BKvJqZn86aGM8W9pd14Kd+u7HuFBMVtrNGhh6fHEQ== + +"@esbuild/openbsd-x64@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.19.11.tgz#17388c76e2f01125bf831a68c03a7ffccb65d1a2" + integrity sha512-ysyOGZuTp6SNKPE11INDUeFVVQFrhcNDVUgSQVDzqsqX38DjhPEPATpid04LCoUr2WXhQTEZ8ct/EgJCUDpyNw== + +"@esbuild/sunos-x64@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.19.11.tgz#e320636f00bb9f4fdf3a80e548cb743370d41767" + integrity sha512-Hf+Sad9nVwvtxy4DXCZQqLpgmRTQqyFyhT3bZ4F2XlJCjxGmRFF0Shwn9rzhOYRB61w9VMXUkxlBy56dk9JJiQ== + +"@esbuild/win32-arm64@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.19.11.tgz#c778b45a496e90b6fc373e2a2bb072f1441fe0ee" + integrity sha512-0P58Sbi0LctOMOQbpEOvOL44Ne0sqbS0XWHMvvrg6NE5jQ1xguCSSw9jQeUk2lfrXYsKDdOe6K+oZiwKPilYPQ== + +"@esbuild/win32-ia32@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.19.11.tgz#481a65fee2e5cce74ec44823e6b09ecedcc5194c" + integrity sha512-6YOrWS+sDJDmshdBIQU+Uoyh7pQKrdykdefC1avn76ss5c+RN6gut3LZA4E2cH5xUEp5/cA0+YxRaVtRAb0xBg== + +"@esbuild/win32-x64@0.19.11": + version "0.19.11" + resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.19.11.tgz#a5d300008960bb39677c46bf16f53ec70d8dee04" + integrity sha512-vfkhltrjCAb603XaFhqhAF4LGDi2M4OrCRrFusyQ+iTLQ/o60QQXxc9cZC/FFpihBI9N1Grn6SMKVJ4KP7Fuiw== + +"@eslint-community/eslint-utils@^4.4.0": + version "4.4.0" + resolved "https://registry.yarnpkg.com/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz#a23514e8fb9af1269d5f7788aa556798d61c6b59" + integrity sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA== + dependencies: + eslint-visitor-keys "^3.3.0" + +"@eslint-community/regexpp@^4.5.1": + version "4.10.0" + resolved "https://registry.yarnpkg.com/@eslint-community/regexpp/-/regexpp-4.10.0.tgz#548f6de556857c8bb73bbee70c35dc82a2e74d63" + integrity sha512-Cu96Sd2By9mCNTx2iyKOmq10v22jUVQv0lQnlGNy16oE9589yE+QADPbrMGCkA51cKZSg3Pu/aTJVTGfL/qjUA== + +"@isaacs/cliui@^8.0.2": + version "8.0.2" + resolved "https://registry.yarnpkg.com/@isaacs/cliui/-/cliui-8.0.2.tgz#b37667b7bc181c168782259bab42474fbf52b550" + integrity sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA== + dependencies: + string-width "^5.1.2" + string-width-cjs "npm:string-width@^4.2.0" + strip-ansi "^7.0.1" + strip-ansi-cjs "npm:strip-ansi@^6.0.1" + wrap-ansi "^8.1.0" + wrap-ansi-cjs "npm:wrap-ansi@^7.0.0" + +"@jridgewell/gen-mapping@^0.3.2": + version "0.3.3" + resolved "https://registry.yarnpkg.com/@jridgewell/gen-mapping/-/gen-mapping-0.3.3.tgz#7e02e6eb5df901aaedb08514203b096614024098" + integrity sha512-HLhSWOLRi875zjjMG/r+Nv0oCW8umGb0BgEhyX3dDX3egwZtB8PqLnjz3yedt8R5StBrzcg4aBpnh8UA9D1BoQ== + dependencies: + "@jridgewell/set-array" "^1.0.1" + "@jridgewell/sourcemap-codec" "^1.4.10" + "@jridgewell/trace-mapping" "^0.3.9" + +"@jridgewell/resolve-uri@^3.0.3", "@jridgewell/resolve-uri@^3.1.0": version "3.1.1" resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz#c08679063f279615a3326583ba3a90d1d82cc721" integrity sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA== -"@jridgewell/sourcemap-codec@^1.4.10": +"@jridgewell/set-array@^1.0.1": + version "1.1.2" + resolved "https://registry.yarnpkg.com/@jridgewell/set-array/-/set-array-1.1.2.tgz#7c6cf998d6d20b914c0a55a91ae928ff25965e72" + integrity sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw== + +"@jridgewell/sourcemap-codec@^1.4.10", "@jridgewell/sourcemap-codec@^1.4.14": version "1.4.15" resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz#d7c6e6755c78567a951e04ab52ef0fd26de59f32" integrity sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg== @@ -27,6 +180,117 @@ "@jridgewell/resolve-uri" "^3.0.3" "@jridgewell/sourcemap-codec" "^1.4.10" +"@jridgewell/trace-mapping@^0.3.9": + version "0.3.21" + resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.21.tgz#5dc1df7b3dc4a6209e503a924e1ca56097a2bb15" + integrity sha512-SRfKmRe1KvYnxjEMtxEr+J4HIeMX5YBg/qhRHpxEIGjhX1rshcHlnFUE9K0GazhVKWM7B+nARSkV8LuvJdJ5/g== + dependencies: + "@jridgewell/resolve-uri" "^3.1.0" + "@jridgewell/sourcemap-codec" "^1.4.14" + +"@mongodb-js/saslprep@^1.1.0": + version "1.1.4" + resolved "https://registry.yarnpkg.com/@mongodb-js/saslprep/-/saslprep-1.1.4.tgz#24ec1c4915a65f5c506bb88c081731450d91bb1c" + integrity sha512-8zJ8N1x51xo9hwPh6AWnKdLGEC5N3lDa6kms1YHmFBoRhTpJR6HG8wWk0td1MVCu9cD4YBrvjZEtd5Obw0Fbnw== + dependencies: + sparse-bitfield "^3.0.3" + +"@nodelib/fs.scandir@2.1.5": + version "2.1.5" + resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz#7619c2eb21b25483f6d167548b4cfd5a7488c3d5" + integrity sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g== + dependencies: + "@nodelib/fs.stat" "2.0.5" + run-parallel "^1.1.9" + +"@nodelib/fs.stat@2.0.5", "@nodelib/fs.stat@^2.0.2": + version "2.0.5" + resolved "https://registry.yarnpkg.com/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz#5bd262af94e9d25bd1e71b05deed44876a222e8b" + integrity sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A== + +"@nodelib/fs.walk@^1.2.3": + version "1.2.8" + resolved "https://registry.yarnpkg.com/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz#e95737e8bb6746ddedf69c556953494f196fe69a" + integrity sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg== + dependencies: + "@nodelib/fs.scandir" "2.1.5" + fastq "^1.6.0" + +"@pkgjs/parseargs@^0.11.0": + version "0.11.0" + resolved "https://registry.yarnpkg.com/@pkgjs/parseargs/-/parseargs-0.11.0.tgz#a77ea742fab25775145434eb1d2328cf5013ac33" + integrity sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg== + +"@pkgr/core@^0.1.0": + version "0.1.1" + resolved "https://registry.yarnpkg.com/@pkgr/core/-/core-0.1.1.tgz#1ec17e2edbec25c8306d424ecfbf13c7de1aaa31" + integrity sha512-cq8o4cWH0ibXh9VGi5P20Tu9XF/0fFXl9EUinr9QfTM7a7p0oTA4iJRCQWppXR1Pg8dSM0UCItCkPwsk9qWWYA== + +"@rollup/rollup-android-arm-eabi@4.9.5": + version "4.9.5" + resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.9.5.tgz#b752b6c88a14ccfcbdf3f48c577ccc3a7f0e66b9" + integrity sha512-idWaG8xeSRCfRq9KpRysDHJ/rEHBEXcHuJ82XY0yYFIWnLMjZv9vF/7DOq8djQ2n3Lk6+3qfSH8AqlmHlmi1MA== + +"@rollup/rollup-android-arm64@4.9.5": + version "4.9.5" + resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.9.5.tgz#33757c3a448b9ef77b6f6292d8b0ec45c87e9c1a" + integrity sha512-f14d7uhAMtsCGjAYwZGv6TwuS3IFaM4ZnGMUn3aCBgkcHAYErhV1Ad97WzBvS2o0aaDv4mVz+syiN0ElMyfBPg== + +"@rollup/rollup-darwin-arm64@4.9.5": + version "4.9.5" + resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.9.5.tgz#5234ba62665a3f443143bc8bcea9df2cc58f55fb" + integrity sha512-ndoXeLx455FffL68OIUrVr89Xu1WLzAG4n65R8roDlCoYiQcGGg6MALvs2Ap9zs7AHg8mpHtMpwC8jBBjZrT/w== + +"@rollup/rollup-darwin-x64@4.9.5": + version "4.9.5" + resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.9.5.tgz#981256c054d3247b83313724938d606798a919d1" + integrity sha512-UmElV1OY2m/1KEEqTlIjieKfVwRg0Zwg4PLgNf0s3glAHXBN99KLpw5A5lrSYCa1Kp63czTpVll2MAqbZYIHoA== + +"@rollup/rollup-linux-arm-gnueabihf@4.9.5": + version "4.9.5" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.9.5.tgz#120678a5a2b3a283a548dbb4d337f9187a793560" + integrity sha512-Q0LcU61v92tQB6ae+udZvOyZ0wfpGojtAKrrpAaIqmJ7+psq4cMIhT/9lfV6UQIpeItnq/2QDROhNLo00lOD1g== + +"@rollup/rollup-linux-arm64-gnu@4.9.5": + version "4.9.5" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.9.5.tgz#c99d857e2372ece544b6f60b85058ad259f64114" + integrity sha512-dkRscpM+RrR2Ee3eOQmRWFjmV/payHEOrjyq1VZegRUa5OrZJ2MAxBNs05bZuY0YCtpqETDy1Ix4i/hRqX98cA== + +"@rollup/rollup-linux-arm64-musl@4.9.5": + version "4.9.5" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.9.5.tgz#3064060f568a5718c2a06858cd6e6d24f2ff8632" + integrity sha512-QaKFVOzzST2xzY4MAmiDmURagWLFh+zZtttuEnuNn19AiZ0T3fhPyjPPGwLNdiDT82ZE91hnfJsUiDwF9DClIQ== + +"@rollup/rollup-linux-riscv64-gnu@4.9.5": + version "4.9.5" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.9.5.tgz#987d30b5d2b992fff07d055015991a57ff55fbad" + integrity sha512-HeGqmRJuyVg6/X6MpE2ur7GbymBPS8Np0S/vQFHDmocfORT+Zt76qu+69NUoxXzGqVP1pzaY6QIi0FJWLC3OPA== + +"@rollup/rollup-linux-x64-gnu@4.9.5": + version "4.9.5" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.9.5.tgz#85946ee4d068bd12197aeeec2c6f679c94978a49" + integrity sha512-Dq1bqBdLaZ1Gb/l2e5/+o3B18+8TI9ANlA1SkejZqDgdU/jK/ThYaMPMJpVMMXy2uRHvGKbkz9vheVGdq3cJfA== + +"@rollup/rollup-linux-x64-musl@4.9.5": + version "4.9.5" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.9.5.tgz#fe0b20f9749a60eb1df43d20effa96c756ddcbd4" + integrity sha512-ezyFUOwldYpj7AbkwyW9AJ203peub81CaAIVvckdkyH8EvhEIoKzaMFJj0G4qYJ5sw3BpqhFrsCc30t54HV8vg== + +"@rollup/rollup-win32-arm64-msvc@4.9.5": + version "4.9.5" + resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.9.5.tgz#422661ef0e16699a234465d15b2c1089ef963b2a" + integrity sha512-aHSsMnUw+0UETB0Hlv7B/ZHOGY5bQdwMKJSzGfDfvyhnpmVxLMGnQPGNE9wgqkLUs3+gbG1Qx02S2LLfJ5GaRQ== + +"@rollup/rollup-win32-ia32-msvc@4.9.5": + version "4.9.5" + resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.9.5.tgz#7b73a145891c202fbcc08759248983667a035d85" + integrity sha512-AiqiLkb9KSf7Lj/o1U3SEP9Zn+5NuVKgFdRIZkvd4N0+bYrTOovVd0+LmYCPQGbocT4kvFyK+LXCDiXPBF3fyA== + +"@rollup/rollup-win32-x64-msvc@4.9.5": + version "4.9.5" + resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.9.5.tgz#10491ccf4f63c814d4149e0316541476ea603602" + integrity sha512-1q+mykKE3Vot1kaFJIDoUFv5TuW+QQVaf2FmTT9krg86pQrGStOSJJ0Zil7CFagyxDuouTepzt5Y5TVzyajOdQ== + "@tsconfig/node10@^1.0.7": version "1.0.9" resolved "https://registry.yarnpkg.com/@tsconfig/node10/-/node10-1.0.9.tgz#df4907fc07a886922637b15e02d4cebc4c0021b2" @@ -47,6 +311,135 @@ resolved "https://registry.yarnpkg.com/@tsconfig/node16/-/node16-1.0.4.tgz#0b92dcc0cc1c81f6f306a381f28e31b1a56536e9" integrity sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA== +"@typegoose/typegoose@^12.1.0": + version "12.1.0" + resolved "https://registry.yarnpkg.com/@typegoose/typegoose/-/typegoose-12.1.0.tgz#06da94152fef00e69978ecd5de6db83a7ae420b7" + integrity sha512-RhqsFvTCTshtYxuzsHCGwPLJXgX1sc5aguZJ4w3ax6shVHaVQSG4VZddo/BowfP+0CSjp4J8XeCtrunkzkhJOg== + dependencies: + lodash "^4.17.20" + loglevel "^1.8.1" + reflect-metadata "^0.2.1" + semver "^7.5.4" + tslib "^2.6.2" + +"@types/estree@1.0.5": + version "1.0.5" + resolved "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.5.tgz#a6ce3e556e00fd9895dd872dd172ad0d4bd687f4" + integrity sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw== + +"@types/json-schema@^7.0.12": + version "7.0.15" + resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.15.tgz#596a1747233694d50f6ad8a7869fcb6f56cf5841" + integrity sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA== + +"@types/node@16": + version "16.18.71" + resolved "https://registry.yarnpkg.com/@types/node/-/node-16.18.71.tgz#305a955ab99353d4b8a9e9b6b6682ed6cbc186cc" + integrity sha512-ARO+458bNJQeNEFuPyT6W+q9ULotmsQzhV3XABsFSxEvRMUYENcBsNAHWYPlahU+UHa5gCVwyKT1Z3f1Wwr26Q== + +"@types/semver@^7.5.0": + version "7.5.6" + resolved "https://registry.yarnpkg.com/@types/semver/-/semver-7.5.6.tgz#c65b2bfce1bec346582c07724e3f8c1017a20339" + integrity sha512-dn1l8LaMea/IjDoHNd9J52uBbInB796CDffS6VdIxvqYCPSG0V0DzHp76GpaWnlhg88uYyPbXCDIowa86ybd5A== + +"@types/webidl-conversions@*": + version "7.0.3" + resolved "https://registry.yarnpkg.com/@types/webidl-conversions/-/webidl-conversions-7.0.3.tgz#1306dbfa53768bcbcfc95a1c8cde367975581859" + integrity sha512-CiJJvcRtIgzadHCYXw7dqEnMNRjhGZlYK05Mj9OyktqV8uVT8fD2BFOB7S1uwBE3Kj2Z+4UyPmFw/Ixgw/LAlA== + +"@types/whatwg-url@^11.0.2": + version "11.0.4" + resolved "https://registry.yarnpkg.com/@types/whatwg-url/-/whatwg-url-11.0.4.tgz#ffed0dc8d89d91f62e3f368fcbda222a487c4f63" + integrity sha512-lXCmTWSHJvf0TRSO58nm978b8HJ/EdsSsEKLd3ODHFjo+3VGAyyTp4v50nWvwtzBxSMQrVOK7tcuN0zGPLICMw== + dependencies: + "@types/webidl-conversions" "*" + +"@typescript-eslint/eslint-plugin@^6.19.0": + version "6.19.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-6.19.0.tgz#db03f3313b57a30fbbdad2e6929e88fc7feaf9ba" + integrity sha512-DUCUkQNklCQYnrBSSikjVChdc84/vMPDQSgJTHBZ64G9bA9w0Crc0rd2diujKbTdp6w2J47qkeHQLoi0rpLCdg== + dependencies: + "@eslint-community/regexpp" "^4.5.1" + "@typescript-eslint/scope-manager" "6.19.0" + "@typescript-eslint/type-utils" "6.19.0" + "@typescript-eslint/utils" "6.19.0" + "@typescript-eslint/visitor-keys" "6.19.0" + debug "^4.3.4" + graphemer "^1.4.0" + ignore "^5.2.4" + natural-compare "^1.4.0" + semver "^7.5.4" + ts-api-utils "^1.0.1" + +"@typescript-eslint/parser@^6.19.0": + version "6.19.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-6.19.0.tgz#80344086f362181890ade7e94fc35fe0480bfdf5" + integrity sha512-1DyBLG5SH7PYCd00QlroiW60YJ4rWMuUGa/JBV0iZuqi4l4IK3twKPq5ZkEebmGqRjXWVgsUzfd3+nZveewgow== + dependencies: + "@typescript-eslint/scope-manager" "6.19.0" + "@typescript-eslint/types" "6.19.0" + "@typescript-eslint/typescript-estree" "6.19.0" + "@typescript-eslint/visitor-keys" "6.19.0" + debug "^4.3.4" + +"@typescript-eslint/scope-manager@6.19.0": + version "6.19.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-6.19.0.tgz#b6d2abb825b29ab70cb542d220e40c61c1678116" + integrity sha512-dO1XMhV2ehBI6QN8Ufi7I10wmUovmLU0Oru3n5LVlM2JuzB4M+dVphCPLkVpKvGij2j/pHBWuJ9piuXx+BhzxQ== + dependencies: + "@typescript-eslint/types" "6.19.0" + "@typescript-eslint/visitor-keys" "6.19.0" + +"@typescript-eslint/type-utils@6.19.0": + version "6.19.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/type-utils/-/type-utils-6.19.0.tgz#522a494ef0d3e9fdc5e23a7c22c9331bbade0101" + integrity sha512-mcvS6WSWbjiSxKCwBcXtOM5pRkPQ6kcDds/juxcy/727IQr3xMEcwr/YLHW2A2+Fp5ql6khjbKBzOyjuPqGi/w== + dependencies: + "@typescript-eslint/typescript-estree" "6.19.0" + "@typescript-eslint/utils" "6.19.0" + debug "^4.3.4" + ts-api-utils "^1.0.1" + +"@typescript-eslint/types@6.19.0": + version "6.19.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-6.19.0.tgz#689b0498c436272a6a2059b09f44bcbd90de294a" + integrity sha512-lFviGV/vYhOy3m8BJ/nAKoAyNhInTdXpftonhWle66XHAtT1ouBlkjL496b5H5hb8dWXHwtypTqgtb/DEa+j5A== + +"@typescript-eslint/typescript-estree@6.19.0": + version "6.19.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-6.19.0.tgz#0813ba364a409afb4d62348aec0202600cb468fa" + integrity sha512-o/zefXIbbLBZ8YJ51NlkSAt2BamrK6XOmuxSR3hynMIzzyMY33KuJ9vuMdFSXW+H0tVvdF9qBPTHA91HDb4BIQ== + dependencies: + "@typescript-eslint/types" "6.19.0" + "@typescript-eslint/visitor-keys" "6.19.0" + debug "^4.3.4" + globby "^11.1.0" + is-glob "^4.0.3" + minimatch "9.0.3" + semver "^7.5.4" + ts-api-utils "^1.0.1" + +"@typescript-eslint/utils@6.19.0": + version "6.19.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/utils/-/utils-6.19.0.tgz#557b72c3eeb4f73bef8037c85dae57b21beb1a4b" + integrity sha512-QR41YXySiuN++/dC9UArYOg4X86OAYP83OWTewpVx5ct1IZhjjgTLocj7QNxGhWoTqknsgpl7L+hGygCO+sdYw== + dependencies: + "@eslint-community/eslint-utils" "^4.4.0" + "@types/json-schema" "^7.0.12" + "@types/semver" "^7.5.0" + "@typescript-eslint/scope-manager" "6.19.0" + "@typescript-eslint/types" "6.19.0" + "@typescript-eslint/typescript-estree" "6.19.0" + semver "^7.5.4" + +"@typescript-eslint/visitor-keys@6.19.0": + version "6.19.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-6.19.0.tgz#4565e0ecd63ca1f81b96f1dd76e49f746c6b2b49" + integrity sha512-hZaUCORLgubBvtGpp1JEFEazcuEdfxta9j4iUwdSAr7mEsYYAp3EAUyCZk3VEEqGj6W+AV4uWyrDGtrlawAsgQ== + dependencies: + "@typescript-eslint/types" "6.19.0" + eslint-visitor-keys "^3.4.1" + acorn-walk@^8.1.1: version "8.3.2" resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.3.2.tgz#7703af9415f1b6db9315d6895503862e231d34aa" @@ -57,26 +450,864 @@ acorn@^8.4.1: resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.11.3.tgz#71e0b14e13a4ec160724b38fb7b0f233b1b81d7a" integrity sha512-Y9rRfJG5jcKOE0CLisYbojUjIrIEE7AGMzA/Sm4BslANhbS+cDMpgBdcPT91oJ7OuJ9hYJBx59RjbhxVnrF8Xg== +ansi-regex@^5.0.1: + version "5.0.1" + resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304" + integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ== + +ansi-regex@^6.0.1: + version "6.0.1" + resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-6.0.1.tgz#3183e38fae9a65d7cb5e53945cd5897d0260a06a" + integrity sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA== + +ansi-styles@^4.0.0: + version "4.3.0" + resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937" + integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg== + dependencies: + color-convert "^2.0.1" + +ansi-styles@^6.1.0: + version "6.2.1" + resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-6.2.1.tgz#0e62320cf99c21afff3b3012192546aacbfb05c5" + integrity sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug== + +any-promise@^1.0.0: + version "1.3.0" + resolved "https://registry.yarnpkg.com/any-promise/-/any-promise-1.3.0.tgz#abc6afeedcea52e809cdc0376aed3ce39635d17f" + integrity sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A== + +anymatch@~3.1.2: + version "3.1.3" + resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.3.tgz#790c58b19ba1720a84205b57c618d5ad8524973e" + integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw== + dependencies: + normalize-path "^3.0.0" + picomatch "^2.0.4" + arg@^4.1.0: version "4.1.3" resolved "https://registry.yarnpkg.com/arg/-/arg-4.1.3.tgz#269fc7ad5b8e42cb63c896d5666017261c144089" integrity sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA== +array-union@^2.1.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/array-union/-/array-union-2.1.0.tgz#b798420adbeb1de828d84acd8a2e23d3efe85e8d" + integrity sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw== + +balanced-match@^1.0.0: + version "1.0.2" + resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee" + integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw== + +binary-extensions@^2.0.0: + version "2.2.0" + resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-2.2.0.tgz#75f502eeaf9ffde42fc98829645be4ea76bd9e2d" + integrity sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA== + +brace-expansion@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-2.0.1.tgz#1edc459e0f0c548486ecf9fc99f2221364b9a0ae" + integrity sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA== + dependencies: + balanced-match "^1.0.0" + +braces@^3.0.2, braces@~3.0.2: + version "3.0.2" + resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.2.tgz#3454e1a462ee8d599e236df336cd9ea4f8afe107" + integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A== + dependencies: + fill-range "^7.0.1" + +bson@^6.2.0: + version "6.2.0" + resolved "https://registry.yarnpkg.com/bson/-/bson-6.2.0.tgz#4b6acafc266ba18eeee111373c2699304a9ba0a3" + integrity sha512-ID1cI+7bazPDyL9wYy9GaQ8gEEohWvcUl/Yf0dIdutJxnmInEEyCsb4awy/OiBfall7zBA179Pahi3vCdFze3Q== + +bundle-require@^4.0.0: + version "4.0.2" + resolved "https://registry.yarnpkg.com/bundle-require/-/bundle-require-4.0.2.tgz#65fc74ff14eabbba36d26c9a6161bd78fff6b29e" + integrity sha512-jwzPOChofl67PSTW2SGubV9HBQAhhR2i6nskiOThauo9dzwDUgOWQScFVaJkjEfYX+UXiD+LEx8EblQMc2wIag== + dependencies: + load-tsconfig "^0.2.3" + +cac@^6.7.12: + version "6.7.14" + resolved "https://registry.yarnpkg.com/cac/-/cac-6.7.14.tgz#804e1e6f506ee363cb0e3ccbb09cad5dd9870959" + integrity sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ== + +chokidar@^3.5.1: + version "3.5.3" + resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.5.3.tgz#1cf37c8707b932bd1af1ae22c0432e2acd1903bd" + integrity sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw== + dependencies: + anymatch "~3.1.2" + braces "~3.0.2" + glob-parent "~5.1.2" + is-binary-path "~2.1.0" + is-glob "~4.0.1" + normalize-path "~3.0.0" + readdirp "~3.6.0" + optionalDependencies: + fsevents "~2.3.2" + +color-convert@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3" + integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ== + dependencies: + color-name "~1.1.4" + +color-name@~1.1.4: + version "1.1.4" + resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2" + integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA== + +colors@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/colors/-/colors-1.4.0.tgz#c50491479d4c1bdaed2c9ced32cf7c7dc2360f78" + integrity sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA== + +commander@^4.0.0: + version "4.1.1" + resolved "https://registry.yarnpkg.com/commander/-/commander-4.1.1.tgz#9fd602bd936294e9e9ef46a3f4d6964044b18068" + integrity sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA== + create-require@^1.1.0: version "1.1.1" resolved "https://registry.yarnpkg.com/create-require/-/create-require-1.1.1.tgz#c1d7e8f1e5f6cfc9ff65f9cd352d37348756c333" integrity sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ== +cross-spawn@^7.0.0, cross-spawn@^7.0.3: + version "7.0.3" + resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.3.tgz#f73a85b9d5d41d045551c177e2882d4ac85728a6" + integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w== + dependencies: + path-key "^3.1.0" + shebang-command "^2.0.0" + which "^2.0.1" + +dateformat@4.5.1: + version "4.5.1" + resolved "https://registry.yarnpkg.com/dateformat/-/dateformat-4.5.1.tgz#c20e7a9ca77d147906b6dc2261a8be0a5bd2173c" + integrity sha512-OD0TZ+B7yP7ZgpJf5K2DIbj3FZvFvxgFUuaqA/V5zTjAtAAXZ1E8bktHxmAGs4x5b7PflqA9LeQ84Og7wYtF7Q== + +debug@4.x, debug@^4.3.1, debug@^4.3.4: + version "4.3.4" + resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.4.tgz#1319f6579357f2338d3337d2cdd4914bb5dcc865" + integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ== + dependencies: + ms "2.1.2" + diff@^4.0.1: version "4.0.2" resolved "https://registry.yarnpkg.com/diff/-/diff-4.0.2.tgz#60f3aecb89d5fae520c11aa19efc2bb982aade7d" integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A== +dir-glob@^3.0.1: + version "3.0.1" + resolved "https://registry.yarnpkg.com/dir-glob/-/dir-glob-3.0.1.tgz#56dbf73d992a4a93ba1584f4534063fd2e41717f" + integrity sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA== + dependencies: + path-type "^4.0.0" + +eastasianwidth@^0.2.0: + version "0.2.0" + resolved "https://registry.yarnpkg.com/eastasianwidth/-/eastasianwidth-0.2.0.tgz#696ce2ec0aa0e6ea93a397ffcf24aa7840c827cb" + integrity sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA== + +emoji-regex@^8.0.0: + version "8.0.0" + resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37" + integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A== + +emoji-regex@^9.2.2: + version "9.2.2" + resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-9.2.2.tgz#840c8803b0d8047f4ff0cf963176b32d4ef3ed72" + integrity sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg== + +esbuild@^0.19.2: + version "0.19.11" + resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.19.11.tgz#4a02dca031e768b5556606e1b468fe72e3325d96" + integrity sha512-HJ96Hev2hX/6i5cDVwcqiJBBtuo9+FeIJOtZ9W1kA5M6AMJRHUZlpYZ1/SbEwtO0ioNAW8rUooVpC/WehY2SfA== + optionalDependencies: + "@esbuild/aix-ppc64" "0.19.11" + "@esbuild/android-arm" "0.19.11" + "@esbuild/android-arm64" "0.19.11" + "@esbuild/android-x64" "0.19.11" + "@esbuild/darwin-arm64" "0.19.11" + "@esbuild/darwin-x64" "0.19.11" + "@esbuild/freebsd-arm64" "0.19.11" + "@esbuild/freebsd-x64" "0.19.11" + "@esbuild/linux-arm" "0.19.11" + "@esbuild/linux-arm64" "0.19.11" + "@esbuild/linux-ia32" "0.19.11" + "@esbuild/linux-loong64" "0.19.11" + "@esbuild/linux-mips64el" "0.19.11" + "@esbuild/linux-ppc64" "0.19.11" + "@esbuild/linux-riscv64" "0.19.11" + "@esbuild/linux-s390x" "0.19.11" + "@esbuild/linux-x64" "0.19.11" + "@esbuild/netbsd-x64" "0.19.11" + "@esbuild/openbsd-x64" "0.19.11" + "@esbuild/sunos-x64" "0.19.11" + "@esbuild/win32-arm64" "0.19.11" + "@esbuild/win32-ia32" "0.19.11" + "@esbuild/win32-x64" "0.19.11" + +eslint-config-prettier@^9.1.0: + version "9.1.0" + resolved "https://registry.yarnpkg.com/eslint-config-prettier/-/eslint-config-prettier-9.1.0.tgz#31af3d94578645966c082fcb71a5846d3c94867f" + integrity sha512-NSWl5BFQWEPi1j4TjVNItzYV7dZXZ+wP6I6ZhrBGpChQhZRUaElihE9uRRkcbRnNb76UMKDF3r+WTmNcGPKsqw== + +eslint-plugin-prettier@^5.1.3: + version "5.1.3" + resolved "https://registry.yarnpkg.com/eslint-plugin-prettier/-/eslint-plugin-prettier-5.1.3.tgz#17cfade9e732cef32b5f5be53bd4e07afd8e67e1" + integrity sha512-C9GCVAs4Eq7ZC/XFQHITLiHJxQngdtraXaM+LoUFoFp/lHNl2Zn8f3WQbe9HvTBBQ9YnKFB0/2Ajdqwo5D1EAw== + dependencies: + prettier-linter-helpers "^1.0.0" + synckit "^0.8.6" + +eslint-visitor-keys@^3.3.0, eslint-visitor-keys@^3.4.1: + version "3.4.3" + resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz#0cd72fe8550e3c2eae156a96a4dddcd1c8ac5800" + integrity sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag== + +execa@^5.0.0: + version "5.1.1" + resolved "https://registry.yarnpkg.com/execa/-/execa-5.1.1.tgz#f80ad9cbf4298f7bd1d4c9555c21e93741c411dd" + integrity sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg== + dependencies: + cross-spawn "^7.0.3" + get-stream "^6.0.0" + human-signals "^2.1.0" + is-stream "^2.0.0" + merge-stream "^2.0.0" + npm-run-path "^4.0.1" + onetime "^5.1.2" + signal-exit "^3.0.3" + strip-final-newline "^2.0.0" + +fast-diff@^1.1.2: + version "1.3.0" + resolved "https://registry.yarnpkg.com/fast-diff/-/fast-diff-1.3.0.tgz#ece407fa550a64d638536cd727e129c61616e0f0" + integrity sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw== + +fast-glob@^3.2.9: + version "3.3.2" + resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.3.2.tgz#a904501e57cfdd2ffcded45e99a54fef55e46129" + integrity sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow== + dependencies: + "@nodelib/fs.stat" "^2.0.2" + "@nodelib/fs.walk" "^1.2.3" + glob-parent "^5.1.2" + merge2 "^1.3.0" + micromatch "^4.0.4" + +fastq@^1.6.0: + version "1.16.0" + resolved "https://registry.yarnpkg.com/fastq/-/fastq-1.16.0.tgz#83b9a9375692db77a822df081edb6a9cf6839320" + integrity sha512-ifCoaXsDrsdkWTtiNJX5uzHDsrck5TzfKKDcuFFTIrrc/BS076qgEIfoIy1VeZqViznfKiysPYTh/QeHtnIsYA== + dependencies: + reusify "^1.0.4" + +fill-range@^7.0.1: + version "7.0.1" + resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-7.0.1.tgz#1919a6a7c75fe38b2c7c77e5198535da9acdda40" + integrity sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ== + dependencies: + to-regex-range "^5.0.1" + +foreground-child@^3.1.0: + version "3.1.1" + resolved "https://registry.yarnpkg.com/foreground-child/-/foreground-child-3.1.1.tgz#1d173e776d75d2772fed08efe4a0de1ea1b12d0d" + integrity sha512-TMKDUnIte6bfb5nWv7V/caI169OHgvwjb7V4WkeUvbQQdjr5rWKqHFiKWb/fcOwB+CzBT+qbWjvj+DVwRskpIg== + dependencies: + cross-spawn "^7.0.0" + signal-exit "^4.0.1" + +fsevents@~2.3.2: + version "2.3.3" + resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.3.tgz#cac6407785d03675a2a5e1a5305c697b347d90d6" + integrity sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw== + +get-stream@^6.0.0: + version "6.0.1" + resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-6.0.1.tgz#a262d8eef67aced57c2852ad6167526a43cbf7b7" + integrity sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg== + +glob-parent@^5.1.2, glob-parent@~5.1.2: + version "5.1.2" + resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4" + integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow== + dependencies: + is-glob "^4.0.1" + +glob@^10.3.10: + version "10.3.10" + resolved "https://registry.yarnpkg.com/glob/-/glob-10.3.10.tgz#0351ebb809fd187fe421ab96af83d3a70715df4b" + integrity sha512-fa46+tv1Ak0UPK1TOy/pZrIybNNt4HCv7SDzwyfiOZkvZLEbjsZkJBPtDHVshZjbecAoAGSC20MjLDG/qr679g== + dependencies: + foreground-child "^3.1.0" + jackspeak "^2.3.5" + minimatch "^9.0.1" + minipass "^5.0.0 || ^6.0.2 || ^7.0.0" + path-scurry "^1.10.1" + +globby@^11.0.3, globby@^11.1.0: + version "11.1.0" + resolved "https://registry.yarnpkg.com/globby/-/globby-11.1.0.tgz#bd4be98bb042f83d796f7e3811991fbe82a0d34b" + integrity sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g== + dependencies: + array-union "^2.1.0" + dir-glob "^3.0.1" + fast-glob "^3.2.9" + ignore "^5.2.0" + merge2 "^1.4.1" + slash "^3.0.0" + +graphemer@^1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/graphemer/-/graphemer-1.4.0.tgz#fb2f1d55e0e3a1849aeffc90c4fa0dd53a0e66c6" + integrity sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag== + +human-signals@^2.1.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/human-signals/-/human-signals-2.1.0.tgz#dc91fcba42e4d06e4abaed33b3e7a3c02f514ea0" + integrity sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw== + +ignore@^5.2.0, ignore@^5.2.4: + version "5.3.0" + resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.3.0.tgz#67418ae40d34d6999c95ff56016759c718c82f78" + integrity sha512-g7dmpshy+gD7mh88OC9NwSGTKoc3kyLAZQRU1mt53Aw/vnvfXnbC+F/7F7QoYVKbV+KNvJx8wArewKy1vXMtlg== + +is-binary-path@~2.1.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-2.1.0.tgz#ea1f7f3b80f064236e83470f86c09c254fb45b09" + integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw== + dependencies: + binary-extensions "^2.0.0" + +is-extglob@^2.1.1: + version "2.1.1" + resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2" + integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ== + +is-fullwidth-code-point@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d" + integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg== + +is-glob@^4.0.1, is-glob@^4.0.3, is-glob@~4.0.1: + version "4.0.3" + resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084" + integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg== + dependencies: + is-extglob "^2.1.1" + +is-number@^7.0.0: + version "7.0.0" + resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b" + integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng== + +is-stream@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.1.tgz#fac1e3d53b97ad5a9d0ae9cef2389f5810a5c077" + integrity sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg== + +isexe@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10" + integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw== + +jackspeak@^2.3.5: + version "2.3.6" + resolved "https://registry.yarnpkg.com/jackspeak/-/jackspeak-2.3.6.tgz#647ecc472238aee4b06ac0e461acc21a8c505ca8" + integrity sha512-N3yCS/NegsOBokc8GAdM8UcmfsKiSS8cipheD/nivzr700H+nsMOxJjQnvwOcRYVuFkdH0wGUvW2WbXGmrZGbQ== + dependencies: + "@isaacs/cliui" "^8.0.2" + optionalDependencies: + "@pkgjs/parseargs" "^0.11.0" + +joycon@^3.0.1: + version "3.1.1" + resolved "https://registry.yarnpkg.com/joycon/-/joycon-3.1.1.tgz#bce8596d6ae808f8b68168f5fc69280996894f03" + integrity sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw== + +kareem@2.5.1: + version "2.5.1" + resolved "https://registry.yarnpkg.com/kareem/-/kareem-2.5.1.tgz#7b8203e11819a8e77a34b3517d3ead206764d15d" + integrity sha512-7jFxRVm+jD+rkq3kY0iZDJfsO2/t4BBPeEb2qKn2lR/9KhuksYk5hxzfRYWMPV8P/x2d0kHD306YyWLzjjH+uA== + +lilconfig@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/lilconfig/-/lilconfig-3.0.0.tgz#f8067feb033b5b74dab4602a5f5029420be749bc" + integrity sha512-K2U4W2Ff5ibV7j7ydLr+zLAkIg5JJ4lPn1Ltsdt+Tz/IjQ8buJ55pZAxoP34lqIiwtF9iAvtLv3JGv7CAyAg+g== + +lines-and-columns@^1.1.6: + version "1.2.4" + resolved "https://registry.yarnpkg.com/lines-and-columns/-/lines-and-columns-1.2.4.tgz#eca284f75d2965079309dc0ad9255abb2ebc1632" + integrity sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg== + +load-tsconfig@^0.2.3: + version "0.2.5" + resolved "https://registry.yarnpkg.com/load-tsconfig/-/load-tsconfig-0.2.5.tgz#453b8cd8961bfb912dea77eb6c168fe8cca3d3a1" + integrity sha512-IXO6OCs9yg8tMKzfPZ1YmheJbZCiEsnBdcB03l0OcfK9prKnJb96siuHCr5Fl37/yo9DnKU+TLpxzTUspw9shg== + +lodash.sortby@^4.7.0: + version "4.7.0" + resolved "https://registry.yarnpkg.com/lodash.sortby/-/lodash.sortby-4.7.0.tgz#edd14c824e2cc9c1e0b0a1b42bb5210516a42438" + integrity sha512-HDWXG8isMntAyRF5vZ7xKuEvOhT4AhlRt/3czTSjvGUxjYCBVRQY48ViDHyfYz9VIoBkW4TMGQNapx+l3RUwdA== + +lodash@^4.17.20: + version "4.17.21" + resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c" + integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg== + +loglevel@^1.8.1: + version "1.8.1" + resolved "https://registry.yarnpkg.com/loglevel/-/loglevel-1.8.1.tgz#5c621f83d5b48c54ae93b6156353f555963377b4" + integrity sha512-tCRIJM51SHjAayKwC+QAg8hT8vg6z7GSgLJKGvzuPb1Wc+hLzqtuVLxp6/HzSPOozuK+8ErAhy7U/sVzw8Dgfg== + +lru-cache@^6.0.0: + version "6.0.0" + resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94" + integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA== + dependencies: + yallist "^4.0.0" + +"lru-cache@^9.1.1 || ^10.0.0": + version "10.1.0" + resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-10.1.0.tgz#2098d41c2dc56500e6c88584aa656c84de7d0484" + integrity sha512-/1clY/ui8CzjKFyjdvwPWJUYKiFVXG2I2cY0ssG7h4+hwk+XOIX7ZSG9Q7TW8TW3Kp3BUSqgFWBLgL4PJ+Blag== + make-error@^1.1.1: version "1.3.6" resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2" integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw== +memory-pager@^1.0.2: + version "1.5.0" + resolved "https://registry.yarnpkg.com/memory-pager/-/memory-pager-1.5.0.tgz#d8751655d22d384682741c972f2c3d6dfa3e66b5" + integrity sha512-ZS4Bp4r/Zoeq6+NLJpP+0Zzm0pR8whtGPf1XExKLJBAczGMnSi3It14OiNCStjQjM6NU1okjQGSxgEZN8eBYKg== + +merge-stream@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60" + integrity sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w== + +merge2@^1.3.0, merge2@^1.4.1: + version "1.4.1" + resolved "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae" + integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg== + +micromatch@^4.0.4: + version "4.0.5" + resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.5.tgz#bc8999a7cbbf77cdc89f132f6e467051b49090c6" + integrity sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA== + dependencies: + braces "^3.0.2" + picomatch "^2.3.1" + +mimic-fn@^2.1.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-2.1.0.tgz#7ed2c2ccccaf84d3ffcb7a69b57711fc2083401b" + integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg== + +minimatch@9.0.3, minimatch@^9.0.1: + version "9.0.3" + resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-9.0.3.tgz#a6e00c3de44c3a542bfaae70abfc22420a6da825" + integrity sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg== + dependencies: + brace-expansion "^2.0.1" + +"minipass@^5.0.0 || ^6.0.2 || ^7.0.0": + version "7.0.4" + resolved "https://registry.yarnpkg.com/minipass/-/minipass-7.0.4.tgz#dbce03740f50a4786ba994c1fb908844d27b038c" + integrity sha512-jYofLM5Dam9279rdkWzqHozUo4ybjdZmCsDHePy5V/PbBcVMiSZR97gmAy45aqi8CK1lG2ECd356FU86avfwUQ== + +mkdirp@^1.0.4: + version "1.0.4" + resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-1.0.4.tgz#3eb5ed62622756d79a5f0e2a221dfebad75c2f7e" + integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw== + +mongodb-connection-string-url@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/mongodb-connection-string-url/-/mongodb-connection-string-url-3.0.0.tgz#b4f87f92fd8593f3b9365f592515a06d304a1e9c" + integrity sha512-t1Vf+m1I5hC2M5RJx/7AtxgABy1cZmIPQRMXw+gEIPn/cZNF3Oiy+l0UIypUwVB5trcWHq3crg2g3uAR9aAwsQ== + dependencies: + "@types/whatwg-url" "^11.0.2" + whatwg-url "^13.0.0" + +mongodb@6.3.0: + version "6.3.0" + resolved "https://registry.yarnpkg.com/mongodb/-/mongodb-6.3.0.tgz#ec9993b19f7ed2ea715b903fcac6171c9d1d38ca" + integrity sha512-tt0KuGjGtLUhLoU263+xvQmPHEGTw5LbcNC73EoFRYgSHwZt5tsoJC110hDyO1kjQzpgNrpdcSza9PknWN4LrA== + dependencies: + "@mongodb-js/saslprep" "^1.1.0" + bson "^6.2.0" + mongodb-connection-string-url "^3.0.0" + +mongoose@^8.1.0: + version "8.1.0" + resolved "https://registry.yarnpkg.com/mongoose/-/mongoose-8.1.0.tgz#25be9a39295c0cbffc971fdd4fb6302dceeb2ded" + integrity sha512-kOA4Xnq2goqNpN9EmYElGNWfxA9H80fxcr7UdJKWi3UMflza0R7wpTihCpM67dE/0MNFljoa0sjQtlXVkkySAQ== + dependencies: + bson "^6.2.0" + kareem "2.5.1" + mongodb "6.3.0" + mpath "0.9.0" + mquery "5.0.0" + ms "2.1.3" + sift "16.0.1" + +mpath@0.9.0: + version "0.9.0" + resolved "https://registry.yarnpkg.com/mpath/-/mpath-0.9.0.tgz#0c122fe107846e31fc58c75b09c35514b3871904" + integrity sha512-ikJRQTk8hw5DEoFVxHG1Gn9T/xcjtdnOKIU1JTmGjZZlg9LST2mBLmcX3/ICIbgJydT2GOc15RnNy5mHmzfSew== + +mquery@5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/mquery/-/mquery-5.0.0.tgz#a95be5dfc610b23862df34a47d3e5d60e110695d" + integrity sha512-iQMncpmEK8R8ncT8HJGsGc9Dsp8xcgYMVSbs5jgnm1lFHTZqMJTUWTDx1LBO8+mK3tPNZWFLBghQEIOULSTHZg== + dependencies: + debug "4.x" + +ms@2.1.2: + version "2.1.2" + resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009" + integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w== + +ms@2.1.3: + version "2.1.3" + resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2" + integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA== + +mz@^2.7.0: + version "2.7.0" + resolved "https://registry.yarnpkg.com/mz/-/mz-2.7.0.tgz#95008057a56cafadc2bc63dde7f9ff6955948e32" + integrity sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q== + dependencies: + any-promise "^1.0.0" + object-assign "^4.0.1" + thenify-all "^1.0.0" + +natural-compare@^1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7" + integrity sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw== + +normalize-path@^3.0.0, normalize-path@~3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65" + integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA== + +npm-run-path@^4.0.1: + version "4.0.1" + resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-4.0.1.tgz#b7ecd1e5ed53da8e37a55e1c2269e0b97ed748ea" + integrity sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw== + dependencies: + path-key "^3.0.0" + +object-assign@^4.0.1: + version "4.1.1" + resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863" + integrity sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg== + +onetime@^5.1.2: + version "5.1.2" + resolved "https://registry.yarnpkg.com/onetime/-/onetime-5.1.2.tgz#d0e96ebb56b07476df1dd9c4806e5237985ca45e" + integrity sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg== + dependencies: + mimic-fn "^2.1.0" + +path-key@^3.0.0, path-key@^3.1.0: + version "3.1.1" + resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375" + integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q== + +path-scurry@^1.10.1: + version "1.10.1" + resolved "https://registry.yarnpkg.com/path-scurry/-/path-scurry-1.10.1.tgz#9ba6bf5aa8500fe9fd67df4f0d9483b2b0bfc698" + integrity sha512-MkhCqzzBEpPvxxQ71Md0b1Kk51W01lrYvlMzSUaIzNsODdd7mqhiimSZlr+VegAz5Z6Vzt9Xg2ttE//XBhH3EQ== + dependencies: + lru-cache "^9.1.1 || ^10.0.0" + minipass "^5.0.0 || ^6.0.2 || ^7.0.0" + +path-type@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/path-type/-/path-type-4.0.0.tgz#84ed01c0a7ba380afe09d90a8c180dcd9d03043b" + integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw== + +picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.3.1: + version "2.3.1" + resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42" + integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA== + +pirates@^4.0.1: + version "4.0.6" + resolved "https://registry.yarnpkg.com/pirates/-/pirates-4.0.6.tgz#3018ae32ecfcff6c29ba2267cbf21166ac1f36b9" + integrity sha512-saLsH7WeYYPiD25LDuLRRY/i+6HaPYr6G1OUlN39otzkSTxKnubR9RTxS3/Kk50s1g2JTgFwWQDQyplC5/SHZg== + +postcss-load-config@^4.0.1: + version "4.0.2" + resolved "https://registry.yarnpkg.com/postcss-load-config/-/postcss-load-config-4.0.2.tgz#7159dcf626118d33e299f485d6afe4aff7c4a3e3" + integrity sha512-bSVhyJGL00wMVoPUzAVAnbEoWyqRxkjv64tUl427SKnPrENtq6hJwUojroMz2VB+Q1edmi4IfrAPpami5VVgMQ== + dependencies: + lilconfig "^3.0.0" + yaml "^2.3.4" + +prettier-linter-helpers@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz#d23d41fe1375646de2d0104d3454a3008802cf7b" + integrity sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w== + dependencies: + fast-diff "^1.1.2" + +prettier@^3.2.3: + version "3.2.4" + resolved "https://registry.yarnpkg.com/prettier/-/prettier-3.2.4.tgz#4723cadeac2ce7c9227de758e5ff9b14e075f283" + integrity sha512-FWu1oLHKCrtpO1ypU6J0SbK2d9Ckwysq6bHj/uaCP26DxrPpppCLQRGVuqAxSTvhF00AcvDRyYrLNW7ocBhFFQ== + +punycode@^2.1.0, punycode@^2.3.0: + version "2.3.1" + resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.3.1.tgz#027422e2faec0b25e1549c3e1bd8309b9133b6e5" + integrity sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg== + +queue-microtask@^1.2.2: + version "1.2.3" + resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243" + integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A== + +readdirp@~3.6.0: + version "3.6.0" + resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-3.6.0.tgz#74a370bd857116e245b29cc97340cd431a02a6c7" + integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA== + dependencies: + picomatch "^2.2.1" + +reflect-metadata@^0.2.1: + version "0.2.1" + resolved "https://registry.yarnpkg.com/reflect-metadata/-/reflect-metadata-0.2.1.tgz#8d5513c0f5ef2b4b9c3865287f3c0940c1f67f74" + integrity sha512-i5lLI6iw9AU3Uu4szRNPPEkomnkjRTaVt9hy/bn5g/oSzekBSMeLZblcjP74AW0vBabqERLLIrz+gR8QYR54Tw== + +resolve-from@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-5.0.0.tgz#c35225843df8f776df21c57557bc087e9dfdfc69" + integrity sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw== + +reusify@^1.0.4: + version "1.0.4" + resolved "https://registry.yarnpkg.com/reusify/-/reusify-1.0.4.tgz#90da382b1e126efc02146e90845a88db12925d76" + integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw== + +rollup@^4.0.2: + version "4.9.5" + resolved "https://registry.yarnpkg.com/rollup/-/rollup-4.9.5.tgz#62999462c90f4c8b5d7c38fc7161e63b29101b05" + integrity sha512-E4vQW0H/mbNMw2yLSqJyjtkHY9dslf/p0zuT1xehNRqUTBOFMqEjguDvqhXr7N7r/4ttb2jr4T41d3dncmIgbQ== + dependencies: + "@types/estree" "1.0.5" + optionalDependencies: + "@rollup/rollup-android-arm-eabi" "4.9.5" + "@rollup/rollup-android-arm64" "4.9.5" + "@rollup/rollup-darwin-arm64" "4.9.5" + "@rollup/rollup-darwin-x64" "4.9.5" + "@rollup/rollup-linux-arm-gnueabihf" "4.9.5" + "@rollup/rollup-linux-arm64-gnu" "4.9.5" + "@rollup/rollup-linux-arm64-musl" "4.9.5" + "@rollup/rollup-linux-riscv64-gnu" "4.9.5" + "@rollup/rollup-linux-x64-gnu" "4.9.5" + "@rollup/rollup-linux-x64-musl" "4.9.5" + "@rollup/rollup-win32-arm64-msvc" "4.9.5" + "@rollup/rollup-win32-ia32-msvc" "4.9.5" + "@rollup/rollup-win32-x64-msvc" "4.9.5" + fsevents "~2.3.2" + +run-parallel@^1.1.9: + version "1.2.0" + resolved "https://registry.yarnpkg.com/run-parallel/-/run-parallel-1.2.0.tgz#66d1368da7bdf921eb9d95bd1a9229e7f21a43ee" + integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA== + dependencies: + queue-microtask "^1.2.2" + +semver@^7.5.4: + version "7.5.4" + resolved "https://registry.yarnpkg.com/semver/-/semver-7.5.4.tgz#483986ec4ed38e1c6c48c34894a9182dbff68a6e" + integrity sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA== + dependencies: + lru-cache "^6.0.0" + +shebang-command@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea" + integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA== + dependencies: + shebang-regex "^3.0.0" + +shebang-regex@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172" + integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A== + +sift@16.0.1: + version "16.0.1" + resolved "https://registry.yarnpkg.com/sift/-/sift-16.0.1.tgz#e9c2ccc72191585008cf3e36fc447b2d2633a053" + integrity sha512-Wv6BjQ5zbhW7VFefWusVP33T/EM0vYikCaQ2qR8yULbsilAT8/wQaXvuQ3ptGLpoKx+lihJE3y2UTgKDyyNHZQ== + +signal-exit@^3.0.3: + version "3.0.7" + resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.7.tgz#a9a1767f8af84155114eaabd73f99273c8f59ad9" + integrity sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ== + +signal-exit@^4.0.1: + version "4.1.0" + resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-4.1.0.tgz#952188c1cbd546070e2dd20d0f41c0ae0530cb04" + integrity sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw== + +slash@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/slash/-/slash-3.0.0.tgz#6539be870c165adbd5240220dbe361f1bc4d4634" + integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q== + +source-map@0.8.0-beta.0: + version "0.8.0-beta.0" + resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.8.0-beta.0.tgz#d4c1bb42c3f7ee925f005927ba10709e0d1d1f11" + integrity sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA== + dependencies: + whatwg-url "^7.0.0" + +sparse-bitfield@^3.0.3: + version "3.0.3" + resolved "https://registry.yarnpkg.com/sparse-bitfield/-/sparse-bitfield-3.0.3.tgz#ff4ae6e68656056ba4b3e792ab3334d38273ca11" + integrity sha512-kvzhi7vqKTfkh0PZU+2D2PIllw2ymqJKujUcyPMd9Y75Nv4nPbGJZXNhxsgdQab2BmlDct1YnfQCguEvHr7VsQ== + dependencies: + memory-pager "^1.0.2" + +"string-width-cjs@npm:string-width@^4.2.0", string-width@^4.1.0: + name string-width-cjs + version "4.2.3" + resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010" + integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g== + dependencies: + emoji-regex "^8.0.0" + is-fullwidth-code-point "^3.0.0" + strip-ansi "^6.0.1" + +string-width@^5.0.1, string-width@^5.1.2: + version "5.1.2" + resolved "https://registry.yarnpkg.com/string-width/-/string-width-5.1.2.tgz#14f8daec6d81e7221d2a357e668cab73bdbca794" + integrity sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA== + dependencies: + eastasianwidth "^0.2.0" + emoji-regex "^9.2.2" + strip-ansi "^7.0.1" + +"strip-ansi-cjs@npm:strip-ansi@^6.0.1", strip-ansi@^6.0.0, strip-ansi@^6.0.1: + name strip-ansi-cjs + version "6.0.1" + resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9" + integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A== + dependencies: + ansi-regex "^5.0.1" + +strip-ansi@^7.0.1: + version "7.1.0" + resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-7.1.0.tgz#d5b6568ca689d8561370b0707685d22434faff45" + integrity sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ== + dependencies: + ansi-regex "^6.0.1" + +strip-final-newline@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/strip-final-newline/-/strip-final-newline-2.0.0.tgz#89b852fb2fcbe936f6f4b3187afb0a12c1ab58ad" + integrity sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA== + +sucrase@^3.20.3: + version "3.35.0" + resolved "https://registry.yarnpkg.com/sucrase/-/sucrase-3.35.0.tgz#57f17a3d7e19b36d8995f06679d121be914ae263" + integrity sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA== + dependencies: + "@jridgewell/gen-mapping" "^0.3.2" + commander "^4.0.0" + glob "^10.3.10" + lines-and-columns "^1.1.6" + mz "^2.7.0" + pirates "^4.0.1" + ts-interface-checker "^0.1.9" + +synckit@^0.8.6: + version "0.8.8" + resolved "https://registry.yarnpkg.com/synckit/-/synckit-0.8.8.tgz#fe7fe446518e3d3d49f5e429f443cf08b6edfcd7" + integrity sha512-HwOKAP7Wc5aRGYdKH+dw0PRRpbO841v2DENBtjnR5HFWoiNByAl7vrx3p0G/rCyYXQsrxqtX48TImFtPcIHSpQ== + dependencies: + "@pkgr/core" "^0.1.0" + tslib "^2.6.2" + +thenify-all@^1.0.0: + version "1.6.0" + resolved "https://registry.yarnpkg.com/thenify-all/-/thenify-all-1.6.0.tgz#1a1918d402d8fc3f98fbf234db0bcc8cc10e9726" + integrity sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA== + dependencies: + thenify ">= 3.1.0 < 4" + +"thenify@>= 3.1.0 < 4": + version "3.3.1" + resolved "https://registry.yarnpkg.com/thenify/-/thenify-3.3.1.tgz#8932e686a4066038a016dd9e2ca46add9838a95f" + integrity sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw== + dependencies: + any-promise "^1.0.0" + +tinytim@0.1.1: + version "0.1.1" + resolved "https://registry.yarnpkg.com/tinytim/-/tinytim-0.1.1.tgz#c968a1e5559ad9553224ef7627bab34e3caef8a8" + integrity sha512-NIpsp9lBIxPNzB++HnMmUd4byzJSVbbO4F+As1Gb1IG/YQT5QvmBDjpx8SpDS8fhGC+t+Qw8ldQgbcAIaU+2cA== + +to-regex-range@^5.0.1: + version "5.0.1" + resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4" + integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ== + dependencies: + is-number "^7.0.0" + +tr46@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/tr46/-/tr46-1.0.1.tgz#a8b13fd6bfd2489519674ccde55ba3693b706d09" + integrity sha512-dTpowEjclQ7Kgx5SdBkqRzVhERQXov8/l9Ft9dVM9fmg0W0KQSVaXX9T4i6twCPNtYiZM53lpSSUAwJbFPOHxA== + dependencies: + punycode "^2.1.0" + +tr46@^4.1.1: + version "4.1.1" + resolved "https://registry.yarnpkg.com/tr46/-/tr46-4.1.1.tgz#281a758dcc82aeb4fe38c7dfe4d11a395aac8469" + integrity sha512-2lv/66T7e5yNyhAAC4NaKe5nVavzuGJQVVtRYLyQ2OI8tsJ61PMLlelehb0wi2Hx6+hT/OJUWZcw8MjlSRnxvw== + dependencies: + punycode "^2.3.0" + +tracer@^1.3.0: + version "1.3.0" + resolved "https://registry.yarnpkg.com/tracer/-/tracer-1.3.0.tgz#97e26d8102fc1a4dca771add772233c320eff1d6" + integrity sha512-8G2okIuUNThM1W8HU9YUCsQgxROw9VpewE2f8Tsw3B90b0acvBiATqnUIvv07qG/aBTs7ALDr7tLVUVD86kPPA== + dependencies: + colors "1.4.0" + dateformat "4.5.1" + mkdirp "^1.0.4" + tinytim "0.1.1" + +tree-kill@^1.2.2: + version "1.2.2" + resolved "https://registry.yarnpkg.com/tree-kill/-/tree-kill-1.2.2.tgz#4ca09a9092c88b73a7cdc5e8a01b507b0790a0cc" + integrity sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A== + +ts-api-utils@^1.0.1: + version "1.0.3" + resolved "https://registry.yarnpkg.com/ts-api-utils/-/ts-api-utils-1.0.3.tgz#f12c1c781d04427313dbac808f453f050e54a331" + integrity sha512-wNMeqtMz5NtwpT/UZGY5alT+VoKdSsOOP/kqHFcUW1P/VRhH2wJ48+DN2WwUliNbQ976ETwDL0Ifd2VVvgonvg== + +ts-interface-checker@^0.1.9: + version "0.1.13" + resolved "https://registry.yarnpkg.com/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz#784fd3d679722bc103b1b4b8030bcddb5db2a699" + integrity sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA== + ts-node@^10.9.2: version "10.9.2" resolved "https://registry.yarnpkg.com/ts-node/-/ts-node-10.9.2.tgz#70f021c9e185bccdca820e26dc413805c101c71f" @@ -96,6 +1327,31 @@ ts-node@^10.9.2: v8-compile-cache-lib "^3.0.1" yn "3.1.1" +tslib@^2.6.2: + version "2.6.2" + resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.6.2.tgz#703ac29425e7b37cd6fd456e92404d46d1f3e4ae" + integrity sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q== + +tsup@^8.0.1: + version "8.0.1" + resolved "https://registry.yarnpkg.com/tsup/-/tsup-8.0.1.tgz#04a0170f7bbe77e81da3b53006b0a40282291833" + integrity sha512-hvW7gUSG96j53ZTSlT4j/KL0q1Q2l6TqGBFc6/mu/L46IoNWqLLUzLRLP1R8Q7xrJTmkDxxDoojV5uCVs1sVOg== + dependencies: + bundle-require "^4.0.0" + cac "^6.7.12" + chokidar "^3.5.1" + debug "^4.3.1" + esbuild "^0.19.2" + execa "^5.0.0" + globby "^11.0.3" + joycon "^3.0.1" + postcss-load-config "^4.0.1" + resolve-from "^5.0.0" + rollup "^4.0.2" + source-map "0.8.0-beta.0" + sucrase "^3.20.3" + tree-kill "^1.2.2" + typescript@^5.3.3: version "5.3.3" resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.3.3.tgz#b3ce6ba258e72e6305ba66f5c9b452aaee3ffe37" @@ -106,6 +1362,68 @@ v8-compile-cache-lib@^3.0.1: resolved "https://registry.yarnpkg.com/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz#6336e8d71965cb3d35a1bbb7868445a7c05264bf" integrity sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg== +webidl-conversions@^4.0.2: + version "4.0.2" + resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-4.0.2.tgz#a855980b1f0b6b359ba1d5d9fb39ae941faa63ad" + integrity sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg== + +webidl-conversions@^7.0.0: + version "7.0.0" + resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-7.0.0.tgz#256b4e1882be7debbf01d05f0aa2039778ea080a" + integrity sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g== + +whatwg-url@^13.0.0: + version "13.0.0" + resolved "https://registry.yarnpkg.com/whatwg-url/-/whatwg-url-13.0.0.tgz#b7b536aca48306394a34e44bda8e99f332410f8f" + integrity sha512-9WWbymnqj57+XEuqADHrCJ2eSXzn8WXIW/YSGaZtb2WKAInQ6CHfaUUcTyyver0p8BDg5StLQq8h1vtZuwmOig== + dependencies: + tr46 "^4.1.1" + webidl-conversions "^7.0.0" + +whatwg-url@^7.0.0: + version "7.1.0" + resolved "https://registry.yarnpkg.com/whatwg-url/-/whatwg-url-7.1.0.tgz#c2c492f1eca612988efd3d2266be1b9fc6170d06" + integrity sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg== + dependencies: + lodash.sortby "^4.7.0" + tr46 "^1.0.1" + webidl-conversions "^4.0.2" + +which@^2.0.1: + version "2.0.2" + resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1" + integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA== + dependencies: + isexe "^2.0.0" + +"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0": + version "7.0.0" + resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43" + integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q== + dependencies: + ansi-styles "^4.0.0" + string-width "^4.1.0" + strip-ansi "^6.0.0" + +wrap-ansi@^8.1.0: + version "8.1.0" + resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-8.1.0.tgz#56dc22368ee570face1b49819975d9b9a5ead214" + integrity sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ== + dependencies: + ansi-styles "^6.1.0" + string-width "^5.0.1" + strip-ansi "^7.0.1" + +yallist@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72" + integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A== + +yaml@^2.3.4: + version "2.3.4" + resolved "https://registry.yarnpkg.com/yaml/-/yaml-2.3.4.tgz#53fc1d514be80aabf386dc6001eb29bf3b7523b2" + integrity sha512-8aAvwVUSHpfEqTQ4w/KMlf3HcRdt50E5ODIQJBw1fQ5RL34xabzxtUlzTXVqc4rkZsPbvrXKWnABCD7kWSmocA== + yn@3.1.1: version "3.1.1" resolved "https://registry.yarnpkg.com/yn/-/yn-3.1.1.tgz#1e87401a09d767c1d5eab26a6e4c185182d2eb50"