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