msgpackr 1.4.7 → 1.5.3

package/dist/node.cjs

@@ -20,6 +20,7 @@ var currentStructures;
 var srcString;
 var srcStringStart = 0;
 var srcStringEnd = 0;
+var bundledStrings;
 var referenceMap;
 var currentExtensions = [];
 var dataView;
@@ -60,12 +61,21 @@ class Unpackr {
 		srcStringEnd = 0;
 		srcString = null;
 		strings = EMPTY_ARRAY;
+		bundledStrings = null;
 		src = source;
 		// this provides cached access to the data view for a buffer if it is getting reused, which is a recommend
 		// technique for getting data from a database where it can be copied into an existing buffer instead of creating
 		// new ones
-		dataView = source.dataView || (source.dataView = new DataView(source.buffer, source.byteOffset, source.byteLength));
-		if (this) {
+		try {
+			dataView = source.dataView || (source.dataView = new DataView(source.buffer, source.byteOffset, source.byteLength));
+		} catch(error) {
+			// if it doesn't have a buffer, maybe it is the wrong type of object
+			src = null;
+			if (source instanceof Uint8Array)
+				throw error
+			throw new Error('Source must be a Uint8Array or Buffer but was a ' + ((source && typeof source == 'object') ? source.constructor.name : typeof source))
+		}
+		if (this instanceof Unpackr) {
 			currentUnpackr = this;
 			if (this.structures) {
 				currentStructures = this.structures;
@@ -148,6 +158,9 @@ function checkedRead() {
 				currentStructures.length = sharedLength;
 		}
 		let result = read();
+		if (bundledStrings) // bundled strings to skip past
+			position = bundledStrings.postBundlePosition;
+
 		if (position == srcEnd) {
 			// finished reading this source, cleanup references
 			if (currentStructures.restoreStructures)
@@ -242,7 +255,15 @@ function read() {
 		let value;
 		switch (token) {
 			case 0xc0: return null
-			case 0xc1: return C1; // "never-used", return special object to denote that
+			case 0xc1:
+				if (bundledStrings) {
+					value = read(); // followed by the length of the string in characters (not bytes!)
+					if (value > 0)
+						return bundledStrings[1].slice(bundledStrings.position1, bundledStrings.position1 += value)
+					else
+						return bundledStrings[0].slice(bundledStrings.position0, bundledStrings.position0 -= value)
+				}
+				return C1; // "never-used", return special object to denote that
 			case 0xc2: return false
 			case 0xc3: return true
 			case 0xc4:
@@ -297,10 +318,11 @@ function read() {
 				position += 4;
 				return value
 			case 0xcf:
-				if (currentUnpackr.uint64AsNumber)
-					return src[position++] * 0x100000000000000 + src[position++] * 0x1000000000000 + src[position++] * 0x10000000000 + src[position++] * 0x100000000 +
-						src[position++] * 0x1000000 + (src[position++] << 16) + (src[position++] << 8) + src[position++]
-				value = dataView.getBigUint64(position);
+				if (currentUnpackr.int64AsNumber) {
+					value = dataView.getUint32(position) * 0x100000000;
+					value += dataView.getUint32(position + 4);
+				} else
+					value = dataView.getBigUint64(position);
 				position += 8;
 				return value
 
@@ -316,7 +338,11 @@ function read() {
 				position += 4;
 				return value
 			case 0xd3:
-				value = dataView.getBigInt64(position);
+				if (currentUnpackr.int64AsNumber) {
+					value = dataView.getInt32(position) * 0x100000000;
+					value += dataView.getUint32(position + 4);
+				} else
+					value = dataView.getBigInt64(position);
 				position += 8;
 				return value
 
@@ -465,8 +491,10 @@ var readFixedString = readStringJS;
 var readString8 = readStringJS;
 var readString16 = readStringJS;
 var readString32 = readStringJS;
+exports.isNativeAccelerationEnabled = false;
 
 function setExtractor(extractStrings) {
+	exports.isNativeAccelerationEnabled = true;
 	readFixedString = readString(1);
 	readString8 = readString(2);
 	readString16 = readString(3);
@@ -475,6 +503,8 @@ function setExtractor(extractStrings) {
 		return function readString(length) {
 			let string = strings[stringPosition++];
 			if (string == null) {
+				if (bundledStrings)
+					return readStringJS(length)
 				let extraction = extractStrings(position - headerLength, srcEnd, src);
 				if (typeof extraction == 'string') {
 					string = extraction;
@@ -733,6 +763,36 @@ function shortStringInJS(length) {
 	}
 }
 
+function readOnlyJSString() {
+	let token = src[position++];
+	let length;
+	if (token < 0xc0) {
+		// fixstr
+		length = token - 0xa0;
+	} else {
+		switch(token) {
+			case 0xd9:
+			// str 8
+				length = src[position++];
+				break
+			case 0xda:
+			// str 16
+				length = dataView.getUint16(position);
+				position += 2;
+				break
+			case 0xdb:
+			// str 32
+				length = dataView.getUint32(position);
+				position += 4;
+				break
+			default:
+				throw new Error('Expected string')
+		}
+	}
+	return readStringJS(length)
+}
+
+
 function readBin(length) {
 	return currentUnpackr.copyBuffers ?
 		// specifically use the copying slice (not the node one)
@@ -884,6 +944,19 @@ currentExtensions[0x78] = () => {
 	let data = read();
 	return new RegExp(data[0], data[1])
 };
+const TEMP_BUNDLE = [];
+currentExtensions[0x62] = (data) => {
+	let dataSize = (data[0] << 24) + (data[1] << 16) + (data[2] << 8) + data[3];
+	let dataPosition = position;
+	position += dataSize - data.length;
+	bundledStrings = TEMP_BUNDLE;
+	bundledStrings = [readOnlyJSString(), readOnlyJSString()];
+	bundledStrings.position0 = 0;
+	bundledStrings.position1 = 0;
+	bundledStrings.postBundlePosition = position;
+	position = dataPosition;
+	return read()
+};
 
 currentExtensions[0xff] = (data) => {
 	// 32-bit date extension
@@ -898,7 +971,7 @@ currentExtensions[0xff] = (data) => {
 			((data[0] << 24) + (data[1] << 16) + (data[2] << 8) + data[3]) / 1000000 +
 			(((data[4] & 0x80) ? -0x1000000000000 : 0) + data[6] * 0x10000000000 + data[7] * 0x100000000 + data[8] * 0x1000000 + (data[9] << 16) + (data[10] << 8) + data[11]) * 1000)
 	else
-		throw new Error('Invalid timestamp length')
+		return new Date('invalid')
 }; // notepack defines extension 0 to mean undefined, so use that as the default here
 // registration of bulk record definition?
 // currentExtensions[0x52] = () =>
@@ -912,6 +985,7 @@ function saveState(callback) {
 	let savedSrcString = srcString;
 	let savedStrings = strings;
 	let savedReferenceMap = referenceMap;
+	let savedBundledStrings = bundledStrings;
 
 	// TODO: We may need to revisit this if we do more external calls to user code (since it could be slow)
 	let savedSrc = new Uint8Array(src.slice(0, srcEnd)); // we copy the data in case it changes while external data is processed
@@ -928,6 +1002,7 @@ function saveState(callback) {
 	srcString = savedSrcString;
 	strings = savedStrings;
 	referenceMap = savedReferenceMap;
+	bundledStrings = savedBundledStrings;
 	src = savedSrc;
 	sequentialMode = savedSequentialMode;
 	currentStructures = savedStructures;
@@ -981,10 +1056,13 @@ const hasNodeBuffer = typeof Buffer !== 'undefined';
 const ByteArrayAllocate = hasNodeBuffer ? Buffer.allocUnsafeSlow : Uint8Array;
 const ByteArray = hasNodeBuffer ? Buffer : Uint8Array;
 const MAX_BUFFER_SIZE = hasNodeBuffer ? 0x100000000 : 0x7fd00000;
-let target;
+let target, keysTarget;
 let targetView;
 let position$1 = 0;
 let safeEnd;
+let bundledStrings$1 = null;
+const MAX_BUNDLE_SIZE = 0xf000;
+const hasNonLatin = /[\u0080-\uFFFF]/;
 const RECORD_SYMBOL = Symbol('record-id');
 class Packr extends Unpackr {
 	constructor(options) {
@@ -1046,6 +1124,11 @@ class Packr extends Unpackr {
 				position$1 = (position$1 + 7) & 0x7ffffff8; // Word align to make any future copying of this buffer faster
 			start = position$1;
 			referenceMap = packr.structuredClone ? new Map() : null;
+			if (packr.bundleStrings && typeof value !== 'string') {
+				bundledStrings$1 = [];
+				bundledStrings$1.size = Infinity; // force a new bundle start on first string
+			} else
+				bundledStrings$1 = null;
 			sharedStructures = packr.structures;
 			if (sharedStructures) {
 				if (sharedStructures.uninitialized)
@@ -1081,9 +1164,12 @@ class Packr extends Unpackr {
 			}
 			if (hasSharedUpdate)
 				hasSharedUpdate = false;
-			structures = sharedStructures || [];
+			structures = sharedStructures || (packr.structures = []);
 			try {
 				pack(value);
+				if (bundledStrings$1) {
+					writeBundles(start, pack);
+				}
 				packr.offset = position$1; // update the offset so next serialization doesn't write over our buffer, but can continue writing to same buffer sequentially
 				if (referenceMap && referenceMap.idsToInsert) {
 					position$1 += referenceMap.idsToInsert.length * 6;
@@ -1094,7 +1180,7 @@ class Packr extends Unpackr {
 					referenceMap = null;
 					return serialized
 				}
-				if (encodeOptions === REUSE_BUFFER_MODE) {
+				if (encodeOptions & REUSE_BUFFER_MODE) {
 					target.start = start;
 					target.end = position$1;
 					return target
@@ -1104,6 +1190,8 @@ class Packr extends Unpackr {
 				if (sharedStructures) {
 					if (serializationsSinceTransitionRebuild < 10)
 						serializationsSinceTransitionRebuild++;
+					if (sharedStructures.length > maxSharedStructures)
+						sharedStructures.length = maxSharedStructures;
 					if (transitionsCount > 10000) {
 						// force a rebuild occasionally after a lot of transitions so it can get cleaned up
 						sharedStructures.transitions = null;
@@ -1133,6 +1221,8 @@ class Packr extends Unpackr {
 						return returnBuffer
 					}
 				}
+				if (encodeOptions & RESET_BUFFER_MODE)
+					position$1 = start;
 			}
 		};
 		const pack = (value) => {
@@ -1143,6 +1233,36 @@ class Packr extends Unpackr {
 			var length;
 			if (type === 'string') {
 				let strLength = value.length;
+				if (bundledStrings$1 && strLength >= 4 && strLength < 0x1000) {
+					if ((bundledStrings$1.size += strLength) > MAX_BUNDLE_SIZE) {
+						let extStart;
+						let maxBytes = (bundledStrings$1[0] ? bundledStrings$1[0].length * 3 + bundledStrings$1[1].length : 0) + 10;
+						if (position$1 + maxBytes > safeEnd)
+							target = makeRoom(position$1 + maxBytes);
+						if (bundledStrings$1.position) { // here we use the 0x62 extension to write the last bundle and reserve sapce for the reference pointer to the next/current bundle
+							target[position$1] = 0xc8; // ext 16
+							position$1 += 3; // reserve for the writing bundle size
+							target[position$1++] = 0x62; // 'b'
+							extStart = position$1 - start;
+							position$1 += 4; // reserve for writing bundle reference
+							writeBundles(start, pack); // write the last bundles
+							targetView.setUint16(extStart + start - 3, position$1 - start - extStart);
+						} else { // here we use the 0x62 extension just to reserve the space for the reference pointer to the bundle (will be updated once the bundle is written)
+							target[position$1++] = 0xd6; // fixext 4
+							target[position$1++] = 0x62; // 'b'
+							extStart = position$1 - start;
+							position$1 += 4; // reserve for writing bundle reference
+						}
+						bundledStrings$1 = ['', '']; // create new ones
+						bundledStrings$1.size = 0;
+						bundledStrings$1.position = extStart;
+					}
+					let twoByte = hasNonLatin.test(value);
+					bundledStrings$1[twoByte ? 0 : 1] += value;
+					target[position$1++] = 0xc1;
+					pack(twoByte ? -strLength : strLength);
+					return
+				}
 				let headerSize;
 				// first we estimate the header size, so we can write to the correct location
 				if (strLength < 0x20) {
@@ -1441,53 +1561,55 @@ class Packr extends Unpackr {
 			target[objectOffset++ + start] = size >> 8;
 			target[objectOffset + start] = size & 0xff;
 		} :
-
-	/*	sharedStructures ?  // For highly stable structures, using for-in can a little bit faster
+		(options.progressiveRecords && !useTwoByteRecords) ?  // this is about 2% faster for highly stable structures, since it only requires one for-in loop (but much more expensive when new structure needs to be written)
 		(object, safePrototype) => {
-			let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null))
-			let objectOffset = position++ - start
-			let wroteKeys
+			let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null));
+			let objectOffset = position$1++ - start;
+			let wroteKeys;
 			for (let key in object) {
 				if (safePrototype || object.hasOwnProperty(key)) {
-					nextTransition = transition[key]
-					if (!nextTransition) {
-						nextTransition = transition[key] = Object.create(null)
-						nextTransition.__keys__ = (transition.__keys__ || []).concat([key])
-						/*let keys = Object.keys(object)
-						if 
-						let size = 0
-						let startBranch = transition.__keys__ ? transition.__keys__.length : 0
-						for (let i = 0, l = keys.length; i++) {
-							let key = keys[i]
-							size += key.length << 2
-							if (i >= startBranch) {
-								nextTransition = nextTransition[key] = Object.create(null)
-								nextTransition.__keys__ = keys.slice(0, i + 1)
+					nextTransition = transition[key];
+					if (nextTransition)
+						transition = nextTransition;
+					else {
+						// record doesn't exist, create full new record and insert it
+						let keys = Object.keys(object);
+						let lastTransition = transition;
+						transition = structures.transitions;
+						let newTransitions = 0;
+						for (let i = 0, l = keys.length; i < l; i++) {
+							let key = keys[i];
+							nextTransition = transition[key];
+							if (!nextTransition) {
+								nextTransition = transition[key] = Object.create(null);
+								newTransitions++;
 							}
+							transition = nextTransition;
 						}
-						makeRoom(position + size)
-						nextTransition = transition[key]
-						target.copy(target, )
-						objectOffset
+						if (objectOffset + start + 1 == position$1) {
+							// first key, so we don't need to insert, we can just write record directly
+							position$1--;
+							newRecord(transition, keys, newTransitions);
+						} else // otherwise we need to insert the record, moving existing data after the record
+							insertNewRecord(transition, keys, objectOffset, newTransitions);
+						wroteKeys = true;
+						transition = lastTransition[key];
 					}
-					transition = nextTransition
-					pack(object[key])
+					pack(object[key]);
 				}
 			}
-			let id = transition.id
-			if (!id) {
-				id = transition.id = structures.push(transition.__keys__) + 63
-				if (sharedStructures.onUpdate)
-					sharedStructures.onUpdate(id, transition.__keys__)
+			if (!wroteKeys) {
+				let recordId = transition[RECORD_SYMBOL];
+				if (recordId)
+					target[objectOffset + start] = recordId;
+				else
+					insertNewRecord(transition, Object.keys(object), objectOffset, 0);
 			}
-			target[objectOffset + start] = id
-		}*/
-		(object) => {
-			let keys = Object.keys(object);
+		} :
+		(object, safePrototype) => {
 			let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null));
 			let newTransitions = 0;
-			for (let i = 0, l = keys.length; i < l; i++) {
-				let key = keys[i];
+			for (let key in object) if (safePrototype || object.hasOwnProperty(key)) {
 				nextTransition = transition[key];
 				if (!nextTransition) {
 					nextTransition = transition[key] = Object.create(null);
@@ -1503,57 +1625,12 @@ class Packr extends Unpackr {
 				} else
 					target[position$1++] = recordId;
 			} else {
-				recordId = structures.nextId;
-				if (!recordId)
-					recordId = 0x40;
-				if (recordId < sharedLimitId && this.shouldShareStructure && !this.shouldShareStructure(keys)) {
-					recordId = structures.nextOwnId;
-					if (!(recordId < maxStructureId))
-						recordId = sharedLimitId;
-					structures.nextOwnId = recordId + 1;
-				} else {
-					if (recordId >= maxStructureId)// cycle back around
-						recordId = sharedLimitId;
-					structures.nextId = recordId + 1;
-				}
-				let highByte = keys.highByte = recordId >= 0x60 && useTwoByteRecords ? (recordId - 0x60) >> 5 : -1;
-				transition[RECORD_SYMBOL] = recordId;
-				structures[recordId - 0x40] = keys;
-
-				if (recordId < sharedLimitId) {
-					keys.isShared = true;
-					structures.sharedLength = recordId - 0x3f;
-					hasSharedUpdate = true;
-					if (highByte >= 0) {
-						target[position$1++] = (recordId & 0x1f) + 0x60;
-						target[position$1++] = highByte;
-					} else {
-						target[position$1++] = recordId;
-					}
-				} else {
-					if (highByte >= 0) {
-						target[position$1++] = 0xd5; // fixext 2
-						target[position$1++] = 0x72; // "r" record defintion extension type
-						target[position$1++] = (recordId & 0x1f) + 0x60;
-						target[position$1++] = highByte;
-					} else {
-						target[position$1++] = 0xd4; // fixext 1
-						target[position$1++] = 0x72; // "r" record defintion extension type
-						target[position$1++] = recordId;
-					}
-
-					if (newTransitions)
-						transitionsCount += serializationsSinceTransitionRebuild * newTransitions;
-					// record the removal of the id, we can maintain our shared structure
-					if (recordIdsToRemove.length >= maxOwnStructures)
-						recordIdsToRemove.shift()[RECORD_SYMBOL] = 0; // we are cycling back through, and have to remove old ones
-					recordIdsToRemove.push(transition);
-					pack(keys);
-				}
+				newRecord(transition, transition.__keys__ || Object.keys(object), newTransitions);
 			}
 			// now write the values
-			for (let i = 0, l = keys.length; i < l; i++)
-				pack(object[keys[i]]);
+			for (let key in object)
+				if (safePrototype || object.hasOwnProperty(key))
+					pack(object[key]);
 		};
 		const makeRoom = (end) => {
 			let newSize;
@@ -1562,7 +1639,7 @@ class Packr extends Unpackr {
 				if ((end - start) > MAX_BUFFER_SIZE)
 					throw new Error('Packed buffer would be larger than maximum buffer size')
 				newSize = Math.min(MAX_BUFFER_SIZE,
-					Math.round(Math.max((end - start) * (end > 0x4000000 ? 1.25 : 2), 0x1000000) / 0x1000) * 0x1000);
+					Math.round(Math.max((end - start) * (end > 0x4000000 ? 1.25 : 2), 0x400000) / 0x1000) * 0x1000);
 			} else // faster handling for smaller buffers
 				newSize = ((Math.max((end - start) << 2, target.length - 1) >> 12) + 1) << 12;
 			let newBuffer = new ByteArrayAllocate(newSize);
@@ -1576,6 +1653,86 @@ class Packr extends Unpackr {
 			safeEnd = newBuffer.length - 10;
 			return target = newBuffer
 		};
+		const newRecord = (transition, keys, newTransitions) => {
+			let recordId = structures.nextId;
+			if (!recordId)
+				recordId = 0x40;
+			if (recordId < sharedLimitId && this.shouldShareStructure && !this.shouldShareStructure(keys)) {
+				recordId = structures.nextOwnId;
+				if (!(recordId < maxStructureId))
+					recordId = sharedLimitId;
+				structures.nextOwnId = recordId + 1;
+			} else {
+				if (recordId >= maxStructureId)// cycle back around
+					recordId = sharedLimitId;
+				structures.nextId = recordId + 1;
+			}
+			let highByte = keys.highByte = recordId >= 0x60 && useTwoByteRecords ? (recordId - 0x60) >> 5 : -1;
+			transition[RECORD_SYMBOL] = recordId;
+			transition.__keys__ = keys;
+			structures[recordId - 0x40] = keys;
+
+			if (recordId < sharedLimitId) {
+				keys.isShared = true;
+				structures.sharedLength = recordId - 0x3f;
+				hasSharedUpdate = true;
+				if (highByte >= 0) {
+					target[position$1++] = (recordId & 0x1f) + 0x60;
+					target[position$1++] = highByte;
+				} else {
+					target[position$1++] = recordId;
+				}
+			} else {
+				if (highByte >= 0) {
+					target[position$1++] = 0xd5; // fixext 2
+					target[position$1++] = 0x72; // "r" record defintion extension type
+					target[position$1++] = (recordId & 0x1f) + 0x60;
+					target[position$1++] = highByte;
+				} else {
+					target[position$1++] = 0xd4; // fixext 1
+					target[position$1++] = 0x72; // "r" record defintion extension type
+					target[position$1++] = recordId;
+				}
+
+				if (newTransitions)
+					transitionsCount += serializationsSinceTransitionRebuild * newTransitions;
+				// record the removal of the id, we can maintain our shared structure
+				if (recordIdsToRemove.length >= maxOwnStructures)
+					recordIdsToRemove.shift()[RECORD_SYMBOL] = 0; // we are cycling back through, and have to remove old ones
+				recordIdsToRemove.push(transition);
+				pack(keys);
+			}
+		};
+		const insertNewRecord = (transition, keys, insertionOffset, newTransitions) => {
+			let mainTarget = target;
+			let mainPosition = position$1;
+			let mainSafeEnd = safeEnd;
+			let mainStart = start;
+			target = keysTarget;
+			position$1 = 0;
+			start = 0;
+			if (!target)
+				keysTarget = target = new ByteArrayAllocate(8192);
+			safeEnd = target.length - 10;
+			newRecord(transition, keys, newTransitions);
+			keysTarget = target;
+			let keysPosition = position$1;
+			target = mainTarget;
+			position$1 = mainPosition;
+			safeEnd = mainSafeEnd;
+			start = mainStart;
+			if (keysPosition > 1) {
+				let newEnd = position$1 + keysPosition - 1;
+				if (newEnd > safeEnd)
+					makeRoom(newEnd);
+				let insertionPosition = insertionOffset + start;
+				target.copyWithin(insertionPosition + keysPosition, insertionPosition + 1, position$1);
+				target.set(keysTarget.slice(0, keysPosition), insertionPosition);
+				position$1 = newEnd;
+			} else {
+				target[insertionOffset + start] = keysTarget[0];
+			}
+		};
 	}
 	useBuffer(buffer) {
 		// this means we are finished using our own buffer and we can write over it safely
@@ -1583,11 +1740,15 @@ class Packr extends Unpackr {
 		targetView = new DataView(target.buffer, target.byteOffset, target.byteLength);
 		position$1 = 0;
 	}
+	clearSharedData() {
+		if (this.structures)
+			this.structures = [];
+	}
 }
 
 extensionClasses = [ Date, Set, Error, RegExp, ArrayBuffer, Object.getPrototypeOf(Uint8Array.prototype).constructor /*TypedArray*/, C1Type ];
 extensions = [{
-	pack(date, allocateForWrite) {
+	pack(date, allocateForWrite, pack) {
 		let seconds = date.getTime() / 1000;
 		if ((this.useTimestamp32 || date.getMilliseconds() === 0) && seconds >= 0 && seconds < 0x100000000) {
 			// Timestamp 32
@@ -1602,6 +1763,16 @@ extensions = [{
 			target[position++] = 0xff;
 			targetView.setUint32(position, date.getMilliseconds() * 4000000 + ((seconds / 1000 / 0x100000000) >> 0));
 			targetView.setUint32(position + 4, seconds);
+		} else if (isNaN(seconds)) {
+			if (this.onInvalidDate) {
+				allocateForWrite(0);
+				return pack(this.onInvalidDate())
+			}
+			// Intentionally invalid timestamp
+			let { target, targetView, position} = allocateForWrite(3);
+			target[position++] = 0xd4;
+			target[position++] = 0xff;
+			target[position++] = 0xff;
 		} else {
 			// Timestamp 96
 			let { target, targetView, position} = allocateForWrite(15);
@@ -1770,6 +1941,14 @@ function insertIds(serialized, idsToInsert) {
 	return serialized
 }
 
+function writeBundles(start, pack) {
+	targetView.setUint32(bundledStrings$1.position + start, position$1 - bundledStrings$1.position - start);
+	let writeStrings = bundledStrings$1;
+	bundledStrings$1 = null;
+	pack(writeStrings[0]);
+	pack(writeStrings[1]);
+}
+
 function addExtension$1(extension) {
 	if (extension.Class) {
 		if (!extension.pack && !extension.write)
@@ -1787,7 +1966,8 @@ const pack = defaultPackr.pack;
 const encode = defaultPackr.pack;
 const Encoder = Packr;
 const { NEVER, ALWAYS, DECIMAL_ROUND, DECIMAL_FIT } = FLOAT32_OPTIONS;
-const REUSE_BUFFER_MODE = 1000;
+const REUSE_BUFFER_MODE = 512;
+const RESET_BUFFER_MODE = 1024;
 
 class PackrStream extends stream.Transform {
 	constructor(options) {
@@ -1939,9 +2119,7 @@ function tryRequire(moduleId) {
 		let require$1 = module$1.createRequire((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('node.cjs', document.baseURI).href)));
 		return require$1(moduleId)
 	} catch (error) {
-		if (typeof window == 'undefined')
-			console.warn('Native extraction module not loaded, msgpackr will still run, but with decreased performance. ' + error.message.split('\n')[0]);
-		else
+		if (typeof window != 'undefined')
 			console.warn('For browser usage, directly use msgpackr/unpack or msgpackr/pack modules. ' + error.message.split('\n')[0]);
 	}
 }