@automerge/automerge-repo-react-hooks 2.5.6 → 2.6.0-alpha.0

package/dist/index.js

@@ -1460,8 +1460,9 @@ function useDocHandle(id, { suspense } = { suspense: false }) {
   );
   if (id && !currentHandle) {
     const progress = repo.findWithProgress(id);
-    if (progress.state === "ready") {
-      currentHandle = progress.handle;
+    const state = progress.peek();
+    if (state.state === "ready") {
+      currentHandle = state.handle;
     }
   }
   let wrapper = id ? wrapperCache.get(id) : void 0;
@@ -1555,8 +1556,9 @@ function useDocHandles(ids, { suspense = false } = {}) {
       } catch (e) {
         continue;
       }
-      if (progress.state === "ready") {
-        map.set(id, progress.handle);
+      const state = progress.peek();
+      if (state.state === "ready") {
+        map.set(id, state.handle);
       }
     }
     return map;
@@ -3122,1589 +3124,831 @@ if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); }
     return t;
 };
 
-var browser = {exports: {}};
-
-/**
- * Helpers.
- */
-
-var ms;
-var hasRequiredMs;
-
-function requireMs () {
-	if (hasRequiredMs) return ms;
-	hasRequiredMs = 1;
-	var s = 1000;
-	var m = s * 60;
-	var h = m * 60;
-	var d = h * 24;
-	var w = d * 7;
-	var y = d * 365.25;
-
-	/**
-	 * Parse or format the given `val`.
-	 *
-	 * Options:
-	 *
-	 *  - `long` verbose formatting [false]
-	 *
-	 * @param {String|Number} val
-	 * @param {Object} [options]
-	 * @throws {Error} throw an error if val is not a non-empty string or a number
-	 * @return {String|Number}
-	 * @api public
-	 */
+let decoder;
+try {
+	decoder = new TextDecoder();
+} catch(error) {}
+let src;
+let srcEnd;
+let position$1 = 0;
+const LEGACY_RECORD_INLINE_ID = 105;
+const RECORD_DEFINITIONS_ID = 0xdffe;
+const RECORD_INLINE_ID = 0xdfff; // temporary first-come first-serve tag // proposed tag: 0x7265 // 're'
+const BUNDLED_STRINGS_ID = 0xdff9;
+const PACKED_REFERENCE_TAG_ID = 6;
+const STOP_CODE = {};
+let maxArraySize = 112810000; // This is the maximum array size in V8. We would potentially detect and set it higher
+// for JSC, but this is pretty large and should be sufficient for most use cases
+let maxMapSize = 16810000; // JavaScript has a fixed maximum map size of about 16710000, but JS itself enforces this,
+let currentDecoder = {};
+let currentStructures;
+let srcString;
+let srcStringStart = 0;
+let srcStringEnd = 0;
+let bundledStrings$1;
+let referenceMap;
+let currentExtensions = [];
+let currentExtensionRanges = [];
+let packedValues;
+let dataView;
+let restoreMapsAsObject;
+let defaultOptions = {
+	useRecords: false,
+	mapsAsObjects: true
+};
+let sequentialMode = false;
+let inlineObjectReadThreshold = 2;
+// no-eval build
+try {
+	new Function('');
+} catch(error) {
+	// if eval variants are not supported, do not create inline object readers ever
+	inlineObjectReadThreshold = Infinity;
+}
 
-	ms = function (val, options) {
-	  options = options || {};
-	  var type = typeof val;
-	  if (type === 'string' && val.length > 0) {
-	    return parse(val);
-	  } else if (type === 'number' && isFinite(val)) {
-	    return options.long ? fmtLong(val) : fmtShort(val);
-	  }
-	  throw new Error(
-	    'val is not a non-empty string or a valid number. val=' +
-	      JSON.stringify(val)
-	  );
-	};
 
-	/**
-	 * Parse the given `str` and return milliseconds.
-	 *
-	 * @param {String} str
-	 * @return {Number}
-	 * @api private
-	 */
 
-	function parse(str) {
-	  str = String(str);
-	  if (str.length > 100) {
-	    return;
-	  }
-	  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
-	    str
-	  );
-	  if (!match) {
-	    return;
-	  }
-	  var n = parseFloat(match[1]);
-	  var type = (match[2] || 'ms').toLowerCase();
-	  switch (type) {
-	    case 'years':
-	    case 'year':
-	    case 'yrs':
-	    case 'yr':
-	    case 'y':
-	      return n * y;
-	    case 'weeks':
-	    case 'week':
-	    case 'w':
-	      return n * w;
-	    case 'days':
-	    case 'day':
-	    case 'd':
-	      return n * d;
-	    case 'hours':
-	    case 'hour':
-	    case 'hrs':
-	    case 'hr':
-	    case 'h':
-	      return n * h;
-	    case 'minutes':
-	    case 'minute':
-	    case 'mins':
-	    case 'min':
-	    case 'm':
-	      return n * m;
-	    case 'seconds':
-	    case 'second':
-	    case 'secs':
-	    case 'sec':
-	    case 's':
-	      return n * s;
-	    case 'milliseconds':
-	    case 'millisecond':
-	    case 'msecs':
-	    case 'msec':
-	    case 'ms':
-	      return n;
-	    default:
-	      return undefined;
-	  }
+class Decoder {
+	constructor(options) {
+		if (options) {
+			if ((options.keyMap || options._keyMap) && !options.useRecords) {
+				options.useRecords = false;
+				options.mapsAsObjects = true;
+			}
+			if (options.useRecords === false && options.mapsAsObjects === undefined)
+				options.mapsAsObjects = true;
+			if (options.getStructures)
+				options.getShared = options.getStructures;
+			if (options.getShared && !options.structures)
+				(options.structures = []).uninitialized = true; // this is what we use to denote an uninitialized structures
+			if (options.keyMap) {
+				this.mapKey = new Map();
+				for (let [k,v] of Object.entries(options.keyMap)) this.mapKey.set(v,k);
+			}
+		}
+		Object.assign(this, options);
 	}
-
-	/**
-	 * Short format for `ms`.
-	 *
-	 * @param {Number} ms
-	 * @return {String}
-	 * @api private
-	 */
-
-	function fmtShort(ms) {
-	  var msAbs = Math.abs(ms);
-	  if (msAbs >= d) {
-	    return Math.round(ms / d) + 'd';
-	  }
-	  if (msAbs >= h) {
-	    return Math.round(ms / h) + 'h';
-	  }
-	  if (msAbs >= m) {
-	    return Math.round(ms / m) + 'm';
-	  }
-	  if (msAbs >= s) {
-	    return Math.round(ms / s) + 's';
-	  }
-	  return ms + 'ms';
+	/*
+	decodeKey(key) {
+		return this.keyMap
+			? Object.keys(this.keyMap)[Object.values(this.keyMap).indexOf(key)] || key
+			: key
 	}
-
-	/**
-	 * Long format for `ms`.
-	 *
-	 * @param {Number} ms
-	 * @return {String}
-	 * @api private
-	 */
-
-	function fmtLong(ms) {
-	  var msAbs = Math.abs(ms);
-	  if (msAbs >= d) {
-	    return plural(ms, msAbs, d, 'day');
-	  }
-	  if (msAbs >= h) {
-	    return plural(ms, msAbs, h, 'hour');
-	  }
-	  if (msAbs >= m) {
-	    return plural(ms, msAbs, m, 'minute');
-	  }
-	  if (msAbs >= s) {
-	    return plural(ms, msAbs, s, 'second');
-	  }
-	  return ms + ' ms';
+	*/
+	decodeKey(key) {
+		return this.keyMap ? this.mapKey.get(key) || key : key
 	}
-
-	/**
-	 * Pluralization helper.
-	 */
-
-	function plural(ms, msAbs, n, name) {
-	  var isPlural = msAbs >= n * 1.5;
-	  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+	
+	encodeKey(key) {
+		return this.keyMap && this.keyMap.hasOwnProperty(key) ? this.keyMap[key] : key
 	}
-	return ms;
-}
 
-var common;
-var hasRequiredCommon;
-
-function requireCommon () {
-	if (hasRequiredCommon) return common;
-	hasRequiredCommon = 1;
-	/**
-	 * This is the common logic for both the Node.js and web browser
-	 * implementations of `debug()`.
-	 */
+	encodeKeys(rec) {
+		if (!this._keyMap) return rec
+		let map = new Map();
+		for (let [k,v] of Object.entries(rec)) map.set((this._keyMap.hasOwnProperty(k) ? this._keyMap[k] : k), v);
+		return map
+	}
 
-	function setup(env) {
-		createDebug.debug = createDebug;
-		createDebug.default = createDebug;
-		createDebug.coerce = coerce;
-		createDebug.disable = disable;
-		createDebug.enable = enable;
-		createDebug.enabled = enabled;
-		createDebug.humanize = requireMs();
-		createDebug.destroy = destroy;
-
-		Object.keys(env).forEach(key => {
-			createDebug[key] = env[key];
-		});
-
-		/**
-		* The currently active debug mode names, and names to skip.
-		*/
-
-		createDebug.names = [];
-		createDebug.skips = [];
-
-		/**
-		* Map of special "%n" handling functions, for the debug "format" argument.
-		*
-		* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
-		*/
-		createDebug.formatters = {};
-
-		/**
-		* Selects a color for a debug namespace
-		* @param {String} namespace The namespace string for the debug instance to be colored
-		* @return {Number|String} An ANSI color code for the given namespace
-		* @api private
-		*/
-		function selectColor(namespace) {
-			let hash = 0;
-
-			for (let i = 0; i < namespace.length; i++) {
-				hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
-				hash |= 0; // Convert to 32bit integer
+	decodeKeys(map) {
+		if (!this._keyMap || map.constructor.name != 'Map') return map
+		if (!this._mapKey) {
+			this._mapKey = new Map();
+			for (let [k,v] of Object.entries(this._keyMap)) this._mapKey.set(v,k);
+		}
+		let res = {};
+		//map.forEach((v,k) => res[Object.keys(this._keyMap)[Object.values(this._keyMap).indexOf(k)] || k] = v)
+		map.forEach((v,k) => res[safeKey(this._mapKey.has(k) ? this._mapKey.get(k) : k)] =  v);
+		return res
+	}
+	
+	mapDecode(source, end) {
+	
+		let res = this.decode(source);
+		if (this._keyMap) { 
+			//Experiemntal support for Optimised KeyMap  decoding 
+			switch (res.constructor.name) {
+				case 'Array': return res.map(r => this.decodeKeys(r))
+				//case 'Map': return this.decodeKeys(res)
 			}
-
-			return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
 		}
-		createDebug.selectColor = selectColor;
-
-		/**
-		* Create a debugger with the given `namespace`.
-		*
-		* @param {String} namespace
-		* @return {Function}
-		* @api public
-		*/
-		function createDebug(namespace) {
-			let prevTime;
-			let enableOverride = null;
-			let namespacesCache;
-			let enabledCache;
-
-			function debug(...args) {
-				// Disabled?
-				if (!debug.enabled) {
-					return;
-				}
-
-				const self = debug;
-
-				// Set `diff` timestamp
-				const curr = Number(new Date());
-				const ms = curr - (prevTime || curr);
-				self.diff = ms;
-				self.prev = prevTime;
-				self.curr = curr;
-				prevTime = curr;
-
-				args[0] = createDebug.coerce(args[0]);
+		return res
+	}
 
-				if (typeof args[0] !== 'string') {
-					// Anything else let's inspect with %O
-					args.unshift('%O');
+	decode(source, end) {
+		if (src) {
+			// re-entrant execution, save the state and restore it after we do this decode
+			return saveState(() => {
+				clearSource();
+				return this ? this.decode(source, end) : Decoder.prototype.decode.call(defaultOptions, source, end)
+			})
+		}
+		srcEnd = end > -1 ? end : source.length;
+		position$1 = 0;
+		srcStringEnd = 0;
+		srcString = null;
+		bundledStrings$1 = 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
+		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 Decoder) {
+			currentDecoder = this;
+			packedValues = this.sharedValues &&
+				(this.pack ? new Array(this.maxPrivatePackedValues || 16).concat(this.sharedValues) :
+				this.sharedValues);
+			if (this.structures) {
+				currentStructures = this.structures;
+				return checkedRead()
+			} else if (!currentStructures || currentStructures.length > 0) {
+				currentStructures = [];
+			}
+		} else {
+			currentDecoder = defaultOptions;
+			if (!currentStructures || currentStructures.length > 0)
+				currentStructures = [];
+			packedValues = null;
+		}
+		return checkedRead()
+	}
+	decodeMultiple(source, forEach) {
+		let values, lastPosition = 0;
+		try {
+			let size = source.length;
+			sequentialMode = true;
+			let value = this ? this.decode(source, size) : defaultDecoder.decode(source, size);
+			if (forEach) {
+				if (forEach(value) === false) {
+					return
 				}
-
-				// Apply any `formatters` transformations
-				let index = 0;
-				args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
-					// If we encounter an escaped % then don't increase the array index
-					if (match === '%%') {
-						return '%';
-					}
-					index++;
-					const formatter = createDebug.formatters[format];
-					if (typeof formatter === 'function') {
-						const val = args[index];
-						match = formatter.call(self, val);
-
-						// Now we need to remove `args[index]` since it's inlined in the `format`
-						args.splice(index, 1);
-						index--;
+				while(position$1 < size) {
+					lastPosition = position$1;
+					if (forEach(checkedRead()) === false) {
+						return
 					}
-					return match;
-				});
-
-				// Apply env-specific formatting (colors, etc.)
-				createDebug.formatArgs.call(self, args);
-
-				const logFn = self.log || createDebug.log;
-				logFn.apply(self, args);
+				}
 			}
-
-			debug.namespace = namespace;
-			debug.useColors = createDebug.useColors();
-			debug.color = createDebug.selectColor(namespace);
-			debug.extend = extend;
-			debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
-
-			Object.defineProperty(debug, 'enabled', {
-				enumerable: true,
-				configurable: false,
-				get: () => {
-					if (enableOverride !== null) {
-						return enableOverride;
-					}
-					if (namespacesCache !== createDebug.namespaces) {
-						namespacesCache = createDebug.namespaces;
-						enabledCache = createDebug.enabled(namespace);
-					}
-
-					return enabledCache;
-				},
-				set: v => {
-					enableOverride = v;
+			else {
+				values = [ value ];
+				while(position$1 < size) {
+					lastPosition = position$1;
+					values.push(checkedRead());
 				}
-			});
-
-			// Env-specific initialization logic for debug instances
-			if (typeof createDebug.init === 'function') {
-				createDebug.init(debug);
+				return values
 			}
-
-			return debug;
+		} catch(error) {
+			error.lastPosition = lastPosition;
+			error.values = values;
+			throw error
+		} finally {
+			sequentialMode = false;
+			clearSource();
 		}
-
-		function extend(namespace, delimiter) {
-			const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
-			newDebug.log = this.log;
-			return newDebug;
+	}
+}
+function checkedRead() {
+	try {
+		let result = read();
+		if (bundledStrings$1) {
+			if (position$1 >= bundledStrings$1.postBundlePosition) {
+				let error = new Error('Unexpected bundle position');
+				error.incomplete = true;
+				throw error
+			}
+			// bundled strings to skip past
+			position$1 = bundledStrings$1.postBundlePosition;
+			bundledStrings$1 = null;
 		}
 
-		/**
-		* Enables a debug mode by namespaces. This can include modes
-		* separated by a colon and wildcards.
-		*
-		* @param {String} namespaces
-		* @api public
-		*/
-		function enable(namespaces) {
-			createDebug.save(namespaces);
-			createDebug.namespaces = namespaces;
-
-			createDebug.names = [];
-			createDebug.skips = [];
-
-			const split = (typeof namespaces === 'string' ? namespaces : '')
-				.trim()
-				.replace(/\s+/g, ',')
-				.split(',')
-				.filter(Boolean);
-
-			for (const ns of split) {
-				if (ns[0] === '-') {
-					createDebug.skips.push(ns.slice(1));
-				} else {
-					createDebug.names.push(ns);
-				}
-			}
+		if (position$1 == srcEnd) {
+			// finished reading this source, cleanup references
+			currentStructures = null;
+			src = null;
+			if (referenceMap)
+				referenceMap = null;
+		} else if (position$1 > srcEnd) {
+			// over read
+			let error = new Error('Unexpected end of CBOR data');
+			error.incomplete = true;
+			throw error
+		} else if (!sequentialMode) {
+			throw new Error('Data read, but end of buffer not reached')
 		}
+		// else more to read, but we are reading sequentially, so don't clear source yet
+		return result
+	} catch(error) {
+		clearSource();
+		if (error instanceof RangeError || error.message.startsWith('Unexpected end of buffer')) {
+			error.incomplete = true;
+		}
+		throw error
+	}
+}
 
-		/**
-		 * Checks if the given string matches a namespace template, honoring
-		 * asterisks as wildcards.
-		 *
-		 * @param {String} search
-		 * @param {String} template
-		 * @return {Boolean}
-		 */
-		function matchesTemplate(search, template) {
-			let searchIndex = 0;
-			let templateIndex = 0;
-			let starIndex = -1;
-			let matchIndex = 0;
-
-			while (searchIndex < search.length) {
-				if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === '*')) {
-					// Match character or proceed with wildcard
-					if (template[templateIndex] === '*') {
-						starIndex = templateIndex;
-						matchIndex = searchIndex;
-						templateIndex++; // Skip the '*'
-					} else {
-						searchIndex++;
-						templateIndex++;
+function read() {
+	let token = src[position$1++];
+	let majorType = token >> 5;
+	token = token & 0x1f;
+	if (token > 0x17) {
+		switch (token) {
+			case 0x18:
+				token = src[position$1++];
+				break
+			case 0x19:
+				if (majorType == 7) {
+					return getFloat16()
+				}
+				token = dataView.getUint16(position$1);
+				position$1 += 2;
+				break
+			case 0x1a:
+				if (majorType == 7) {
+					let value = dataView.getFloat32(position$1);
+					if (currentDecoder.useFloat32 > 2) {
+						// this does rounding of numbers that were encoded in 32-bit float to nearest significant decimal digit that could be preserved
+						let multiplier = mult10[((src[position$1] & 0x7f) << 1) | (src[position$1 + 1] >> 7)];
+						position$1 += 4;
+						return ((multiplier * value + (value > 0 ? 0.5 : -0.5)) >> 0) / multiplier
 					}
-				} else if (starIndex !== -1) { // eslint-disable-line no-negated-condition
-					// Backtrack to the last '*' and try to match more characters
-					templateIndex = starIndex + 1;
-					matchIndex++;
-					searchIndex = matchIndex;
-				} else {
-					return false; // No match
+					position$1 += 4;
+					return value
 				}
-			}
-
-			// Handle trailing '*' in template
-			while (templateIndex < template.length && template[templateIndex] === '*') {
-				templateIndex++;
-			}
-
-			return templateIndex === template.length;
-		}
-
-		/**
-		* Disable debug output.
-		*
-		* @return {String} namespaces
-		* @api public
-		*/
-		function disable() {
-			const namespaces = [
-				...createDebug.names,
-				...createDebug.skips.map(namespace => '-' + namespace)
-			].join(',');
-			createDebug.enable('');
-			return namespaces;
-		}
-
-		/**
-		* Returns true if the given mode name is enabled, false otherwise.
-		*
-		* @param {String} name
-		* @return {Boolean}
-		* @api public
-		*/
-		function enabled(name) {
-			for (const skip of createDebug.skips) {
-				if (matchesTemplate(name, skip)) {
-					return false;
+				token = dataView.getUint32(position$1);
+				position$1 += 4;
+				break
+			case 0x1b:
+				if (majorType == 7) {
+					let value = dataView.getFloat64(position$1);
+					position$1 += 8;
+					return value
 				}
-			}
-
-			for (const ns of createDebug.names) {
-				if (matchesTemplate(name, ns)) {
-					return true;
+				if (majorType > 1) {
+					if (dataView.getUint32(position$1) > 0)
+						throw new Error('JavaScript does not support arrays, maps, or strings with length over 4294967295')
+					token = dataView.getUint32(position$1 + 4);
+				} else if (currentDecoder.int64AsNumber) {
+					token = dataView.getUint32(position$1) * 0x100000000;
+					token += dataView.getUint32(position$1 + 4);
+				} else
+					token = dataView.getBigUint64(position$1);
+				position$1 += 8;
+				break
+			case 0x1f: 
+				// indefinite length
+				switch(majorType) {
+					case 2: // byte string
+					case 3: // text string
+						throw new Error('Indefinite length not supported for byte or text strings')
+					case 4: // array
+						let array = [];
+						let value, i = 0;
+						while ((value = read()) != STOP_CODE) {
+							if (i >= maxArraySize) throw new Error(`Array length exceeds ${maxArraySize}`)
+							array[i++] = value;
+						}
+						return majorType == 4 ? array : majorType == 3 ? array.join('') : Buffer.concat(array)
+					case 5: // map
+						let key;
+						if (currentDecoder.mapsAsObjects) {
+							let object = {};
+							let i = 0;
+							if (currentDecoder.keyMap) {
+								while((key = read()) != STOP_CODE) {
+									if (i++ >= maxMapSize) throw new Error(`Property count exceeds ${maxMapSize}`)
+									object[safeKey(currentDecoder.decodeKey(key))] = read();
+								}
+							}
+							else {
+								while ((key = read()) != STOP_CODE) {
+									if (i++ >= maxMapSize) throw new Error(`Property count exceeds ${maxMapSize}`)
+									object[safeKey(key)] = read();
+								}
+							}
+							return object
+						} else {
+							if (restoreMapsAsObject) {
+								currentDecoder.mapsAsObjects = true;
+								restoreMapsAsObject = false;
+							}
+							let map = new Map();
+							if (currentDecoder.keyMap) {
+								let i = 0;
+								while((key = read()) != STOP_CODE) {
+									if (i++ >= maxMapSize) {
+										throw new Error(`Map size exceeds ${maxMapSize}`);
+									}
+									map.set(currentDecoder.decodeKey(key), read());
+								}
+							}
+							else {
+								let i = 0;
+								while ((key = read()) != STOP_CODE) {
+									if (i++ >= maxMapSize) {
+										throw new Error(`Map size exceeds ${maxMapSize}`);
+									}
+									map.set(key, read());
+								}
+							}
+							return map
+						}
+					case 7:
+						return STOP_CODE
+					default:
+						throw new Error('Invalid major type for indefinite length ' + majorType)
 				}
-			}
-
-			return false;
-		}
-
-		/**
-		* Coerce `val`.
-		*
-		* @param {Mixed} val
-		* @return {Mixed}
-		* @api private
-		*/
-		function coerce(val) {
-			if (val instanceof Error) {
-				return val.stack || val.message;
-			}
-			return val;
-		}
-
-		/**
-		* XXX DO NOT USE. This is a temporary stub function.
-		* XXX It WILL be removed in the next major release.
-		*/
-		function destroy() {
-			console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+			default:
+				throw new Error('Unknown token ' + token)
 		}
-
-		createDebug.enable(createDebug.load());
-
-		return createDebug;
 	}
-
-	common = setup;
-	return common;
-}
-
-/* eslint-env browser */
-
-var hasRequiredBrowser;
-
-function requireBrowser () {
-	if (hasRequiredBrowser) return browser.exports;
-	hasRequiredBrowser = 1;
-	(function (module, exports) {
-		/**
-		 * This is the web browser implementation of `debug()`.
-		 */
-
-		exports.formatArgs = formatArgs;
-		exports.save = save;
-		exports.load = load;
-		exports.useColors = useColors;
-		exports.storage = localstorage();
-		exports.destroy = (() => {
-			let warned = false;
-
-			return () => {
-				if (!warned) {
-					warned = true;
-					console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
-				}
-			};
-		})();
-
-		/**
-		 * Colors.
-		 */
-
-		exports.colors = [
-			'#0000CC',
-			'#0000FF',
-			'#0033CC',
-			'#0033FF',
-			'#0066CC',
-			'#0066FF',
-			'#0099CC',
-			'#0099FF',
-			'#00CC00',
-			'#00CC33',
-			'#00CC66',
-			'#00CC99',
-			'#00CCCC',
-			'#00CCFF',
-			'#3300CC',
-			'#3300FF',
-			'#3333CC',
-			'#3333FF',
-			'#3366CC',
-			'#3366FF',
-			'#3399CC',
-			'#3399FF',
-			'#33CC00',
-			'#33CC33',
-			'#33CC66',
-			'#33CC99',
-			'#33CCCC',
-			'#33CCFF',
-			'#6600CC',
-			'#6600FF',
-			'#6633CC',
-			'#6633FF',
-			'#66CC00',
-			'#66CC33',
-			'#9900CC',
-			'#9900FF',
-			'#9933CC',
-			'#9933FF',
-			'#99CC00',
-			'#99CC33',
-			'#CC0000',
-			'#CC0033',
-			'#CC0066',
-			'#CC0099',
-			'#CC00CC',
-			'#CC00FF',
-			'#CC3300',
-			'#CC3333',
-			'#CC3366',
-			'#CC3399',
-			'#CC33CC',
-			'#CC33FF',
-			'#CC6600',
-			'#CC6633',
-			'#CC9900',
-			'#CC9933',
-			'#CCCC00',
-			'#CCCC33',
-			'#FF0000',
-			'#FF0033',
-			'#FF0066',
-			'#FF0099',
-			'#FF00CC',
-			'#FF00FF',
-			'#FF3300',
-			'#FF3333',
-			'#FF3366',
-			'#FF3399',
-			'#FF33CC',
-			'#FF33FF',
-			'#FF6600',
-			'#FF6633',
-			'#FF9900',
-			'#FF9933',
-			'#FFCC00',
-			'#FFCC33'
-		];
-
-		/**
-		 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
-		 * and the Firebug extension (any Firefox version) are known
-		 * to support "%c" CSS customizations.
-		 *
-		 * TODO: add a `localStorage` variable to explicitly enable/disable colors
-		 */
-
-		// eslint-disable-next-line complexity
-		function useColors() {
-			// NB: In an Electron preload script, document will be defined but not fully
-			// initialized. Since we know we're in Chrome, we'll just detect this case
-			// explicitly
-			if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
-				return true;
+	switch (majorType) {
+		case 0: // positive int
+			return token
+		case 1: // negative int
+			return ~token
+		case 2: // buffer
+			return readBin(token)
+		case 3: // string
+			if (srcStringEnd >= position$1) {
+				return srcString.slice(position$1 - srcStringStart, (position$1 += token) - srcStringStart)
 			}
-
-			// Internet Explorer and Edge do not support colors.
-			if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
-				return false;
+			if (srcStringEnd == 0 && srcEnd < 140 && token < 32) {
+				// for small blocks, avoiding the overhead of the extract call is helpful
+				let string = token < 16 ? shortStringInJS(token) : longStringInJS(token);
+				if (string != null)
+					return string
 			}
-
-			let m;
-
-			// Is webkit? http://stackoverflow.com/a/16459606/376773
-			// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
-			// eslint-disable-next-line no-return-assign
-			return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
-				// Is firebug? http://stackoverflow.com/a/398120/376773
-				(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
-				// Is firefox >= v31?
-				// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
-				(typeof navigator !== 'undefined' && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31) ||
-				// Double check webkit in userAgent just in case we are in a worker
-				(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
-		}
-
-		/**
-		 * Colorize log arguments if enabled.
-		 *
-		 * @api public
-		 */
-
-		function formatArgs(args) {
-			args[0] = (this.useColors ? '%c' : '') +
-				this.namespace +
-				(this.useColors ? ' %c' : ' ') +
-				args[0] +
-				(this.useColors ? '%c ' : ' ') +
-				'+' + module.exports.humanize(this.diff);
-
-			if (!this.useColors) {
-				return;
+			return readFixedString(token)
+		case 4: // array
+			if (token >= maxArraySize) throw new Error(`Array length exceeds ${maxArraySize}`)
+			let array = new Array(token);
+		  //if (currentDecoder.keyMap) for (let i = 0; i < token; i++) array[i] = currentDecoder.decodeKey(read())	
+			//else 
+			for (let i = 0; i < token; i++) array[i] = read();
+			return array
+		case 5: // map
+			if (token >= maxMapSize) throw new Error(`Map size exceeds ${maxArraySize}`)
+			if (currentDecoder.mapsAsObjects) {
+				let object = {};
+				if (currentDecoder.keyMap) for (let i = 0; i < token; i++) object[safeKey(currentDecoder.decodeKey(read()))] = read();
+				else for (let i = 0; i < token; i++) object[safeKey(read())] = read();
+				return object
+			} else {
+				if (restoreMapsAsObject) {
+					currentDecoder.mapsAsObjects = true;
+					restoreMapsAsObject = false;
+				}
+				let map = new Map();
+				if (currentDecoder.keyMap) for (let i = 0; i < token; i++) map.set(currentDecoder.decodeKey(read()),read());
+				else for (let i = 0; i < token; i++) map.set(read(), read());
+				return map
 			}
-
-			const c = 'color: ' + this.color;
-			args.splice(1, 0, c, 'color: inherit');
-
-			// The final "%c" is somewhat tricky, because there could be other
-			// arguments passed either before or after the %c, so we need to
-			// figure out the correct index to insert the CSS into
-			let index = 0;
-			let lastC = 0;
-			args[0].replace(/%[a-zA-Z%]/g, match => {
-				if (match === '%%') {
-					return;
+		case 6: // extension
+			if (token >= BUNDLED_STRINGS_ID) {
+				let structure = currentStructures[token & 0x1fff]; // check record structures first
+				// At some point we may provide an option for dynamic tag assignment with a range like token >= 8 && (token < 16 || (token > 0x80 && token < 0xc0) || (token > 0x130 && token < 0x4000))
+				if (structure) {
+					if (!structure.read) structure.read = createStructureReader(structure);
+					return structure.read()
 				}
-				index++;
-				if (match === '%c') {
-					// We only are interested in the *last* %c
-					// (the user may have provided their own)
-					lastC = index;
+				if (token < 0x10000) {
+					if (token == RECORD_INLINE_ID) { // we do a special check for this so that we can keep the
+						// currentExtensions as densely stored array (v8 stores arrays densely under about 3000 elements)
+						let length = readJustLength();
+						let id = read();
+						let structure = read();
+						recordDefinition(id, structure);
+						let object = {};
+						if (currentDecoder.keyMap) for (let i = 2; i < length; i++) {
+							let key = currentDecoder.decodeKey(structure[i - 2]);
+							object[safeKey(key)] = read();
+						}
+						else for (let i = 2; i < length; i++) {
+							let key = structure[i - 2];
+							object[safeKey(key)] = read();
+						}
+						return object
+					}
+					else if (token == RECORD_DEFINITIONS_ID) {
+						let length = readJustLength();
+						let id = read();
+						for (let i = 2; i < length; i++) {
+							recordDefinition(id++, read());
+						}
+						return read()
+					} else if (token == BUNDLED_STRINGS_ID) {
+						return readBundleExt()
+					}
+					if (currentDecoder.getShared) {
+						loadShared();
+						structure = currentStructures[token & 0x1fff];
+						if (structure) {
+							if (!structure.read)
+								structure.read = createStructureReader(structure);
+							return structure.read()
+						}
+					}
 				}
-			});
-
-			args.splice(lastC, 0, c);
-		}
-
-		/**
-		 * Invokes `console.debug()` when available.
-		 * No-op when `console.debug` is not a "function".
-		 * If `console.debug` is not available, falls back
-		 * to `console.log`.
-		 *
-		 * @api public
-		 */
-		exports.log = console.debug || console.log || (() => {});
-
-		/**
-		 * Save `namespaces`.
-		 *
-		 * @param {String} namespaces
-		 * @api private
-		 */
-		function save(namespaces) {
-			try {
-				if (namespaces) {
-					exports.storage.setItem('debug', namespaces);
-				} else {
-					exports.storage.removeItem('debug');
+			}
+			let extension = currentExtensions[token];
+			if (extension) {
+				if (extension.handlesRead)
+					return extension(read)
+				else
+					return extension(read())
+			} else {
+				let input = read();
+				for (let i = 0; i < currentExtensionRanges.length; i++) {
+					let value = currentExtensionRanges[i](token, input);
+					if (value !== undefined)
+						return value
 				}
-			} catch (error) {
-				// Swallow
-				// XXX (@Qix-) should we be logging these?
+				return new Tag(input, token)
 			}
-		}
-
-		/**
-		 * Load `namespaces`.
-		 *
-		 * @return {String} returns the previously persisted debug modes
-		 * @api private
-		 */
-		function load() {
-			let r;
-			try {
-				r = exports.storage.getItem('debug') || exports.storage.getItem('DEBUG') ;
-			} catch (error) {
-				// Swallow
-				// XXX (@Qix-) should we be logging these?
+		case 7: // fixed value
+			switch (token) {
+				case 0x14: return false
+				case 0x15: return true
+				case 0x16: return null
+				case 0x17: return; // undefined
+				case 0x1f:
+				default:
+					let packedValue = (packedValues || getPackedValues())[token];
+					if (packedValue !== undefined)
+						return packedValue
+					throw new Error('Unknown token ' + token)
 			}
-
-			// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
-			if (!r && typeof process !== 'undefined' && 'env' in process) {
-				r = process.env.DEBUG;
+		default: // negative int
+			if (isNaN(token)) {
+				let error = new Error('Unexpected end of CBOR data');
+				error.incomplete = true;
+				throw error
 			}
-
-			return r;
+			throw new Error('Unknown CBOR token ' + token)
+	}
+}
+const validName = /^[a-zA-Z_$][a-zA-Z\d_$]*$/;
+function createStructureReader(structure) {
+	if (!structure) throw new Error('Structure is required in record definition');
+	function readObject() {
+		// get the array size from the header
+		let length = src[position$1++];
+		//let majorType = token >> 5
+		length = length & 0x1f;
+		if (length > 0x17) {
+			switch (length) {
+				case 0x18:
+					length = src[position$1++];
+					break
+				case 0x19:
+					length = dataView.getUint16(position$1);
+					position$1 += 2;
+					break
+				case 0x1a:
+					length = dataView.getUint32(position$1);
+					position$1 += 4;
+					break
+				default:
+					throw new Error('Expected array header, but got ' + src[position$1 - 1])
+			}
+		}
+		// This initial function is quick to instantiate, but runs slower. After several iterations pay the cost to build the faster function
+		let compiledReader = this.compiledReader; // first look to see if we have the fast compiled function
+		while(compiledReader) {
+			// we have a fast compiled object literal reader
+			if (compiledReader.propertyCount === length)
+				return compiledReader(read) // with the right length, so we use it
+			compiledReader = compiledReader.next; // see if there is another reader with the right length
+		}
+		if (this.slowReads++ >= inlineObjectReadThreshold) { // create a fast compiled reader
+			let array = this.length == length ? this : this.slice(0, length);
+			compiledReader = currentDecoder.keyMap 
+			? new Function('r', 'return {' + array.map(k => currentDecoder.decodeKey(k)).map(k => validName.test(k) ? safeKey(k) + ':r()' : ('[' + JSON.stringify(k) + ']:r()')).join(',') + '}')
+			: new Function('r', 'return {' + array.map(key => validName.test(key) ? safeKey(key) + ':r()' : ('[' + JSON.stringify(key) + ']:r()')).join(',') + '}');
+			if (this.compiledReader)
+				compiledReader.next = this.compiledReader; // if there is an existing one, we store multiple readers as a linked list because it is usually pretty rare to have multiple readers (of different length) for the same structure
+			compiledReader.propertyCount = length;
+			this.compiledReader = compiledReader;
+			return compiledReader(read)
 		}
+		let object = {};
+		if (currentDecoder.keyMap) for (let i = 0; i < length; i++) object[safeKey(currentDecoder.decodeKey(this[i]))] = read();
+		else for (let i = 0; i < length; i++) {
+			object[safeKey(this[i])] = read();
+		}
+		return object
+	}
+	structure.slowReads = 0;
+	return readObject
+}
 
-		/**
-		 * Localstorage attempts to return the localstorage.
-		 *
-		 * This is necessary because safari throws
-		 * when a user disables cookies/localstorage
-		 * and you attempt to access it.
-		 *
-		 * @return {LocalStorage}
-		 * @api private
-		 */
+function safeKey(key) {
+	// protect against prototype pollution
+	if (typeof key === 'string') return key === '__proto__' ? '__proto_' : key
+	if (typeof key === 'number' || typeof key === 'boolean' || typeof key === 'bigint') return key.toString();
+	if (key == null) return key + '';
+	// protect against expensive (DoS) string conversions
+	throw new Error('Invalid property name type ' + typeof key);
+}
 
-		function localstorage() {
-			try {
-				// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
-				// The Browser also has localStorage in the global context.
-				return localStorage;
-			} catch (error) {
-				// Swallow
-				// XXX (@Qix-) should we be logging these?
+let readFixedString = readStringJS;
+function readStringJS(length) {
+	let result;
+	if (length < 16) {
+		if (result = shortStringInJS(length))
+			return result
+	}
+	if (length > 64 && decoder)
+		return decoder.decode(src.subarray(position$1, position$1 += length))
+	const end = position$1 + length;
+	const units = [];
+	result = '';
+	while (position$1 < end) {
+		const byte1 = src[position$1++];
+		if ((byte1 & 0x80) === 0) {
+			// 1 byte
+			units.push(byte1);
+		} else if ((byte1 & 0xe0) === 0xc0) {
+			// 2 bytes
+			const byte2 = src[position$1++] & 0x3f;
+			units.push(((byte1 & 0x1f) << 6) | byte2);
+		} else if ((byte1 & 0xf0) === 0xe0) {
+			// 3 bytes
+			const byte2 = src[position$1++] & 0x3f;
+			const byte3 = src[position$1++] & 0x3f;
+			units.push(((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3);
+		} else if ((byte1 & 0xf8) === 0xf0) {
+			// 4 bytes
+			const byte2 = src[position$1++] & 0x3f;
+			const byte3 = src[position$1++] & 0x3f;
+			const byte4 = src[position$1++] & 0x3f;
+			let unit = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4;
+			if (unit > 0xffff) {
+				unit -= 0x10000;
+				units.push(((unit >>> 10) & 0x3ff) | 0xd800);
+				unit = 0xdc00 | (unit & 0x3ff);
 			}
+			units.push(unit);
+		} else {
+			units.push(byte1);
 		}
 
-		module.exports = requireCommon()(exports);
-
-		const {formatters} = module.exports;
+		if (units.length >= 0x1000) {
+			result += fromCharCode.apply(String, units);
+			units.length = 0;
+		}
+	}
 
-		/**
-		 * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
-		 */
+	if (units.length > 0) {
+		result += fromCharCode.apply(String, units);
+	}
 
-		formatters.j = function (v) {
-			try {
-				return JSON.stringify(v);
-			} catch (error) {
-				return '[UnexpectedJSONParseError]: ' + error.message;
-			}
-		}; 
-	} (browser, browser.exports));
-	return browser.exports;
+	return result
 }
-
-var browserExports = requireBrowser();
-const debug = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
-
-let decoder;
-try {
-	decoder = new TextDecoder();
-} catch(error) {}
-let src;
-let srcEnd;
-let position$1 = 0;
-const LEGACY_RECORD_INLINE_ID = 105;
-const RECORD_DEFINITIONS_ID = 0xdffe;
-const RECORD_INLINE_ID = 0xdfff; // temporary first-come first-serve tag // proposed tag: 0x7265 // 're'
-const BUNDLED_STRINGS_ID = 0xdff9;
-const PACKED_REFERENCE_TAG_ID = 6;
-const STOP_CODE = {};
-let maxArraySize = 112810000; // This is the maximum array size in V8. We would potentially detect and set it higher
-// for JSC, but this is pretty large and should be sufficient for most use cases
-let maxMapSize = 16810000; // JavaScript has a fixed maximum map size of about 16710000, but JS itself enforces this,
-let currentDecoder = {};
-let currentStructures;
-let srcString;
-let srcStringStart = 0;
-let srcStringEnd = 0;
-let bundledStrings$1;
-let referenceMap;
-let currentExtensions = [];
-let currentExtensionRanges = [];
-let packedValues;
-let dataView;
-let restoreMapsAsObject;
-let defaultOptions = {
-	useRecords: false,
-	mapsAsObjects: true
-};
-let sequentialMode = false;
-let inlineObjectReadThreshold = 2;
-// no-eval build
-try {
-	new Function('');
-} catch(error) {
-	// if eval variants are not supported, do not create inline object readers ever
-	inlineObjectReadThreshold = Infinity;
+let fromCharCode = String.fromCharCode;
+function longStringInJS(length) {
+	let start = position$1;
+	let bytes = new Array(length);
+	for (let i = 0; i < length; i++) {
+		const byte = src[position$1++];
+		if ((byte & 0x80) > 0) {
+			position$1 = start;
+    			return
+    		}
+    		bytes[i] = byte;
+    	}
+    	return fromCharCode.apply(String, bytes)
 }
-
-
-
-class Decoder {
-	constructor(options) {
-		if (options) {
-			if ((options.keyMap || options._keyMap) && !options.useRecords) {
-				options.useRecords = false;
-				options.mapsAsObjects = true;
+function shortStringInJS(length) {
+	if (length < 4) {
+		if (length < 2) {
+			if (length === 0)
+				return ''
+			else {
+				let a = src[position$1++];
+				if ((a & 0x80) > 1) {
+					position$1 -= 1;
+					return
+				}
+				return fromCharCode(a)
 			}
-			if (options.useRecords === false && options.mapsAsObjects === undefined)
-				options.mapsAsObjects = true;
-			if (options.getStructures)
-				options.getShared = options.getStructures;
-			if (options.getShared && !options.structures)
-				(options.structures = []).uninitialized = true; // this is what we use to denote an uninitialized structures
-			if (options.keyMap) {
-				this.mapKey = new Map();
-				for (let [k,v] of Object.entries(options.keyMap)) this.mapKey.set(v,k);
+		} else {
+			let a = src[position$1++];
+			let b = src[position$1++];
+			if ((a & 0x80) > 0 || (b & 0x80) > 0) {
+				position$1 -= 2;
+				return
 			}
-		}
-		Object.assign(this, options);
-	}
-	/*
-	decodeKey(key) {
-		return this.keyMap
-			? Object.keys(this.keyMap)[Object.values(this.keyMap).indexOf(key)] || key
-			: key
-	}
-	*/
-	decodeKey(key) {
-		return this.keyMap ? this.mapKey.get(key) || key : key
-	}
-	
-	encodeKey(key) {
-		return this.keyMap && this.keyMap.hasOwnProperty(key) ? this.keyMap[key] : key
-	}
-
-	encodeKeys(rec) {
-		if (!this._keyMap) return rec
-		let map = new Map();
-		for (let [k,v] of Object.entries(rec)) map.set((this._keyMap.hasOwnProperty(k) ? this._keyMap[k] : k), v);
-		return map
-	}
-
-	decodeKeys(map) {
-		if (!this._keyMap || map.constructor.name != 'Map') return map
-		if (!this._mapKey) {
-			this._mapKey = new Map();
-			for (let [k,v] of Object.entries(this._keyMap)) this._mapKey.set(v,k);
-		}
-		let res = {};
-		//map.forEach((v,k) => res[Object.keys(this._keyMap)[Object.values(this._keyMap).indexOf(k)] || k] = v)
-		map.forEach((v,k) => res[safeKey(this._mapKey.has(k) ? this._mapKey.get(k) : k)] =  v);
-		return res
-	}
-	
-	mapDecode(source, end) {
-	
-		let res = this.decode(source);
-		if (this._keyMap) { 
-			//Experiemntal support for Optimised KeyMap  decoding 
-			switch (res.constructor.name) {
-				case 'Array': return res.map(r => this.decodeKeys(r))
-				//case 'Map': return this.decodeKeys(res)
+			if (length < 3)
+				return fromCharCode(a, b)
+			let c = src[position$1++];
+			if ((c & 0x80) > 0) {
+				position$1 -= 3;
+				return
 			}
+			return fromCharCode(a, b, c)
 		}
-		return res
-	}
-
-	decode(source, end) {
-		if (src) {
-			// re-entrant execution, save the state and restore it after we do this decode
-			return saveState(() => {
-				clearSource();
-				return this ? this.decode(source, end) : Decoder.prototype.decode.call(defaultOptions, source, end)
-			})
-		}
-		srcEnd = end > -1 ? end : source.length;
-		position$1 = 0;
-		srcStringEnd = 0;
-		srcString = null;
-		bundledStrings$1 = 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
-		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 Decoder) {
-			currentDecoder = this;
-			packedValues = this.sharedValues &&
-				(this.pack ? new Array(this.maxPrivatePackedValues || 16).concat(this.sharedValues) :
-				this.sharedValues);
-			if (this.structures) {
-				currentStructures = this.structures;
-				return checkedRead()
-			} else if (!currentStructures || currentStructures.length > 0) {
-				currentStructures = [];
-			}
-		} else {
-			currentDecoder = defaultOptions;
-			if (!currentStructures || currentStructures.length > 0)
-				currentStructures = [];
-			packedValues = null;
+	} else {
+		let a = src[position$1++];
+		let b = src[position$1++];
+		let c = src[position$1++];
+		let d = src[position$1++];
+		if ((a & 0x80) > 0 || (b & 0x80) > 0 || (c & 0x80) > 0 || (d & 0x80) > 0) {
+			position$1 -= 4;
+			return
 		}
-		return checkedRead()
-	}
-	decodeMultiple(source, forEach) {
-		let values, lastPosition = 0;
-		try {
-			let size = source.length;
-			sequentialMode = true;
-			let value = this ? this.decode(source, size) : defaultDecoder.decode(source, size);
-			if (forEach) {
-				if (forEach(value) === false) {
+		if (length < 6) {
+			if (length === 4)
+				return fromCharCode(a, b, c, d)
+			else {
+				let e = src[position$1++];
+				if ((e & 0x80) > 0) {
+					position$1 -= 5;
 					return
 				}
-				while(position$1 < size) {
-					lastPosition = position$1;
-					if (forEach(checkedRead()) === false) {
+				return fromCharCode(a, b, c, d, e)
+			}
+		} else if (length < 8) {
+			let e = src[position$1++];
+			let f = src[position$1++];
+			if ((e & 0x80) > 0 || (f & 0x80) > 0) {
+				position$1 -= 6;
+				return
+			}
+			if (length < 7)
+				return fromCharCode(a, b, c, d, e, f)
+			let g = src[position$1++];
+			if ((g & 0x80) > 0) {
+				position$1 -= 7;
+				return
+			}
+			return fromCharCode(a, b, c, d, e, f, g)
+		} else {
+			let e = src[position$1++];
+			let f = src[position$1++];
+			let g = src[position$1++];
+			let h = src[position$1++];
+			if ((e & 0x80) > 0 || (f & 0x80) > 0 || (g & 0x80) > 0 || (h & 0x80) > 0) {
+				position$1 -= 8;
+				return
+			}
+			if (length < 10) {
+				if (length === 8)
+					return fromCharCode(a, b, c, d, e, f, g, h)
+				else {
+					let i = src[position$1++];
+					if ((i & 0x80) > 0) {
+						position$1 -= 9;
 						return
 					}
+					return fromCharCode(a, b, c, d, e, f, g, h, i)
 				}
-			}
-			else {
-				values = [ value ];
-				while(position$1 < size) {
-					lastPosition = position$1;
-					values.push(checkedRead());
+			} else if (length < 12) {
+				let i = src[position$1++];
+				let j = src[position$1++];
+				if ((i & 0x80) > 0 || (j & 0x80) > 0) {
+					position$1 -= 10;
+					return
 				}
-				return values
-			}
-		} catch(error) {
-			error.lastPosition = lastPosition;
-			error.values = values;
-			throw error
-		} finally {
-			sequentialMode = false;
-			clearSource();
-		}
-	}
-}
-function checkedRead() {
-	try {
-		let result = read();
-		if (bundledStrings$1) {
-			if (position$1 >= bundledStrings$1.postBundlePosition) {
-				let error = new Error('Unexpected bundle position');
-				error.incomplete = true;
-				throw error
-			}
-			// bundled strings to skip past
-			position$1 = bundledStrings$1.postBundlePosition;
-			bundledStrings$1 = null;
-		}
-
-		if (position$1 == srcEnd) {
-			// finished reading this source, cleanup references
-			currentStructures = null;
-			src = null;
-			if (referenceMap)
-				referenceMap = null;
-		} else if (position$1 > srcEnd) {
-			// over read
-			let error = new Error('Unexpected end of CBOR data');
-			error.incomplete = true;
-			throw error
-		} else if (!sequentialMode) {
-			throw new Error('Data read, but end of buffer not reached')
-		}
-		// else more to read, but we are reading sequentially, so don't clear source yet
-		return result
-	} catch(error) {
-		clearSource();
-		if (error instanceof RangeError || error.message.startsWith('Unexpected end of buffer')) {
-			error.incomplete = true;
-		}
-		throw error
-	}
-}
-
-function read() {
-	let token = src[position$1++];
-	let majorType = token >> 5;
-	token = token & 0x1f;
-	if (token > 0x17) {
-		switch (token) {
-			case 0x18:
-				token = src[position$1++];
-				break
-			case 0x19:
-				if (majorType == 7) {
-					return getFloat16()
-				}
-				token = dataView.getUint16(position$1);
-				position$1 += 2;
-				break
-			case 0x1a:
-				if (majorType == 7) {
-					let value = dataView.getFloat32(position$1);
-					if (currentDecoder.useFloat32 > 2) {
-						// this does rounding of numbers that were encoded in 32-bit float to nearest significant decimal digit that could be preserved
-						let multiplier = mult10[((src[position$1] & 0x7f) << 1) | (src[position$1 + 1] >> 7)];
-						position$1 += 4;
-						return ((multiplier * value + (value > 0 ? 0.5 : -0.5)) >> 0) / multiplier
-					}
-					position$1 += 4;
-					return value
-				}
-				token = dataView.getUint32(position$1);
-				position$1 += 4;
-				break
-			case 0x1b:
-				if (majorType == 7) {
-					let value = dataView.getFloat64(position$1);
-					position$1 += 8;
-					return value
-				}
-				if (majorType > 1) {
-					if (dataView.getUint32(position$1) > 0)
-						throw new Error('JavaScript does not support arrays, maps, or strings with length over 4294967295')
-					token = dataView.getUint32(position$1 + 4);
-				} else if (currentDecoder.int64AsNumber) {
-					token = dataView.getUint32(position$1) * 0x100000000;
-					token += dataView.getUint32(position$1 + 4);
-				} else
-					token = dataView.getBigUint64(position$1);
-				position$1 += 8;
-				break
-			case 0x1f: 
-				// indefinite length
-				switch(majorType) {
-					case 2: // byte string
-					case 3: // text string
-						throw new Error('Indefinite length not supported for byte or text strings')
-					case 4: // array
-						let array = [];
-						let value, i = 0;
-						while ((value = read()) != STOP_CODE) {
-							if (i >= maxArraySize) throw new Error(`Array length exceeds ${maxArraySize}`)
-							array[i++] = value;
-						}
-						return majorType == 4 ? array : majorType == 3 ? array.join('') : Buffer.concat(array)
-					case 5: // map
-						let key;
-						if (currentDecoder.mapsAsObjects) {
-							let object = {};
-							let i = 0;
-							if (currentDecoder.keyMap) {
-								while((key = read()) != STOP_CODE) {
-									if (i++ >= maxMapSize) throw new Error(`Property count exceeds ${maxMapSize}`)
-									object[safeKey(currentDecoder.decodeKey(key))] = read();
-								}
-							}
-							else {
-								while ((key = read()) != STOP_CODE) {
-									if (i++ >= maxMapSize) throw new Error(`Property count exceeds ${maxMapSize}`)
-									object[safeKey(key)] = read();
-								}
-							}
-							return object
-						} else {
-							if (restoreMapsAsObject) {
-								currentDecoder.mapsAsObjects = true;
-								restoreMapsAsObject = false;
-							}
-							let map = new Map();
-							if (currentDecoder.keyMap) {
-								let i = 0;
-								while((key = read()) != STOP_CODE) {
-									if (i++ >= maxMapSize) {
-										throw new Error(`Map size exceeds ${maxMapSize}`);
-									}
-									map.set(currentDecoder.decodeKey(key), read());
-								}
-							}
-							else {
-								let i = 0;
-								while ((key = read()) != STOP_CODE) {
-									if (i++ >= maxMapSize) {
-										throw new Error(`Map size exceeds ${maxMapSize}`);
-									}
-									map.set(key, read());
-								}
-							}
-							return map
-						}
-					case 7:
-						return STOP_CODE
-					default:
-						throw new Error('Invalid major type for indefinite length ' + majorType)
+				if (length < 11)
+					return fromCharCode(a, b, c, d, e, f, g, h, i, j)
+				let k = src[position$1++];
+				if ((k & 0x80) > 0) {
+					position$1 -= 11;
+					return
 				}
-			default:
-				throw new Error('Unknown token ' + token)
-		}
-	}
-	switch (majorType) {
-		case 0: // positive int
-			return token
-		case 1: // negative int
-			return ~token
-		case 2: // buffer
-			return readBin(token)
-		case 3: // string
-			if (srcStringEnd >= position$1) {
-				return srcString.slice(position$1 - srcStringStart, (position$1 += token) - srcStringStart)
-			}
-			if (srcStringEnd == 0 && srcEnd < 140 && token < 32) {
-				// for small blocks, avoiding the overhead of the extract call is helpful
-				let string = token < 16 ? shortStringInJS(token) : longStringInJS(token);
-				if (string != null)
-					return string
-			}
-			return readFixedString(token)
-		case 4: // array
-			if (token >= maxArraySize) throw new Error(`Array length exceeds ${maxArraySize}`)
-			let array = new Array(token);
-		  //if (currentDecoder.keyMap) for (let i = 0; i < token; i++) array[i] = currentDecoder.decodeKey(read())	
-			//else 
-			for (let i = 0; i < token; i++) array[i] = read();
-			return array
-		case 5: // map
-			if (token >= maxMapSize) throw new Error(`Map size exceeds ${maxArraySize}`)
-			if (currentDecoder.mapsAsObjects) {
-				let object = {};
-				if (currentDecoder.keyMap) for (let i = 0; i < token; i++) object[safeKey(currentDecoder.decodeKey(read()))] = read();
-				else for (let i = 0; i < token; i++) object[safeKey(read())] = read();
-				return object
+				return fromCharCode(a, b, c, d, e, f, g, h, i, j, k)
 			} else {
-				if (restoreMapsAsObject) {
-					currentDecoder.mapsAsObjects = true;
-					restoreMapsAsObject = false;
-				}
-				let map = new Map();
-				if (currentDecoder.keyMap) for (let i = 0; i < token; i++) map.set(currentDecoder.decodeKey(read()),read());
-				else for (let i = 0; i < token; i++) map.set(read(), read());
-				return map
-			}
-		case 6: // extension
-			if (token >= BUNDLED_STRINGS_ID) {
-				let structure = currentStructures[token & 0x1fff]; // check record structures first
-				// At some point we may provide an option for dynamic tag assignment with a range like token >= 8 && (token < 16 || (token > 0x80 && token < 0xc0) || (token > 0x130 && token < 0x4000))
-				if (structure) {
-					if (!structure.read) structure.read = createStructureReader(structure);
-					return structure.read()
+				let i = src[position$1++];
+				let j = src[position$1++];
+				let k = src[position$1++];
+				let l = src[position$1++];
+				if ((i & 0x80) > 0 || (j & 0x80) > 0 || (k & 0x80) > 0 || (l & 0x80) > 0) {
+					position$1 -= 12;
+					return
 				}
-				if (token < 0x10000) {
-					if (token == RECORD_INLINE_ID) { // we do a special check for this so that we can keep the
-						// currentExtensions as densely stored array (v8 stores arrays densely under about 3000 elements)
-						let length = readJustLength();
-						let id = read();
-						let structure = read();
-						recordDefinition(id, structure);
-						let object = {};
-						if (currentDecoder.keyMap) for (let i = 2; i < length; i++) {
-							let key = currentDecoder.decodeKey(structure[i - 2]);
-							object[safeKey(key)] = read();
-						}
-						else for (let i = 2; i < length; i++) {
-							let key = structure[i - 2];
-							object[safeKey(key)] = read();
-						}
-						return object
-					}
-					else if (token == RECORD_DEFINITIONS_ID) {
-						let length = readJustLength();
-						let id = read();
-						for (let i = 2; i < length; i++) {
-							recordDefinition(id++, read());
+				if (length < 14) {
+					if (length === 12)
+						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l)
+					else {
+						let m = src[position$1++];
+						if ((m & 0x80) > 0) {
+							position$1 -= 13;
+							return
 						}
-						return read()
-					} else if (token == BUNDLED_STRINGS_ID) {
-						return readBundleExt()
+						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m)
 					}
-					if (currentDecoder.getShared) {
-						loadShared();
-						structure = currentStructures[token & 0x1fff];
-						if (structure) {
-							if (!structure.read)
-								structure.read = createStructureReader(structure);
-							return structure.read()
-						}
+				} else {
+					let m = src[position$1++];
+					let n = src[position$1++];
+					if ((m & 0x80) > 0 || (n & 0x80) > 0) {
+						position$1 -= 14;
+						return
 					}
+					if (length < 15)
+						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n)
+					let o = src[position$1++];
+					if ((o & 0x80) > 0) {
+						position$1 -= 15;
+						return
+					}
+					return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
 				}
 			}
-			let extension = currentExtensions[token];
-			if (extension) {
-				if (extension.handlesRead)
-					return extension(read)
-				else
-					return extension(read())
-			} else {
-				let input = read();
-				for (let i = 0; i < currentExtensionRanges.length; i++) {
-					let value = currentExtensionRanges[i](token, input);
-					if (value !== undefined)
-						return value
-				}
-				return new Tag(input, token)
-			}
-		case 7: // fixed value
-			switch (token) {
-				case 0x14: return false
-				case 0x15: return true
-				case 0x16: return null
-				case 0x17: return; // undefined
-				case 0x1f:
-				default:
-					let packedValue = (packedValues || getPackedValues())[token];
-					if (packedValue !== undefined)
-						return packedValue
-					throw new Error('Unknown token ' + token)
-			}
-		default: // negative int
-			if (isNaN(token)) {
-				let error = new Error('Unexpected end of CBOR data');
-				error.incomplete = true;
-				throw error
-			}
-			throw new Error('Unknown CBOR token ' + token)
-	}
-}
-const validName = /^[a-zA-Z_$][a-zA-Z\d_$]*$/;
-function createStructureReader(structure) {
-	if (!structure) throw new Error('Structure is required in record definition');
-	function readObject() {
-		// get the array size from the header
-		let length = src[position$1++];
-		//let majorType = token >> 5
-		length = length & 0x1f;
-		if (length > 0x17) {
-			switch (length) {
-				case 0x18:
-					length = src[position$1++];
-					break
-				case 0x19:
-					length = dataView.getUint16(position$1);
-					position$1 += 2;
-					break
-				case 0x1a:
-					length = dataView.getUint32(position$1);
-					position$1 += 4;
-					break
-				default:
-					throw new Error('Expected array header, but got ' + src[position$1 - 1])
-			}
-		}
-		// This initial function is quick to instantiate, but runs slower. After several iterations pay the cost to build the faster function
-		let compiledReader = this.compiledReader; // first look to see if we have the fast compiled function
-		while(compiledReader) {
-			// we have a fast compiled object literal reader
-			if (compiledReader.propertyCount === length)
-				return compiledReader(read) // with the right length, so we use it
-			compiledReader = compiledReader.next; // see if there is another reader with the right length
-		}
-		if (this.slowReads++ >= inlineObjectReadThreshold) { // create a fast compiled reader
-			let array = this.length == length ? this : this.slice(0, length);
-			compiledReader = currentDecoder.keyMap 
-			? new Function('r', 'return {' + array.map(k => currentDecoder.decodeKey(k)).map(k => validName.test(k) ? safeKey(k) + ':r()' : ('[' + JSON.stringify(k) + ']:r()')).join(',') + '}')
-			: new Function('r', 'return {' + array.map(key => validName.test(key) ? safeKey(key) + ':r()' : ('[' + JSON.stringify(key) + ']:r()')).join(',') + '}');
-			if (this.compiledReader)
-				compiledReader.next = this.compiledReader; // if there is an existing one, we store multiple readers as a linked list because it is usually pretty rare to have multiple readers (of different length) for the same structure
-			compiledReader.propertyCount = length;
-			this.compiledReader = compiledReader;
-			return compiledReader(read)
-		}
-		let object = {};
-		if (currentDecoder.keyMap) for (let i = 0; i < length; i++) object[safeKey(currentDecoder.decodeKey(this[i]))] = read();
-		else for (let i = 0; i < length; i++) {
-			object[safeKey(this[i])] = read();
 		}
-		return object
 	}
-	structure.slowReads = 0;
-	return readObject
 }
 
-function safeKey(key) {
-	// protect against prototype pollution
-	if (typeof key === 'string') return key === '__proto__' ? '__proto_' : key
-	if (typeof key === 'number' || typeof key === 'boolean' || typeof key === 'bigint') return key.toString();
-	if (key == null) return key + '';
-	// protect against expensive (DoS) string conversions
-	throw new Error('Invalid property name type ' + typeof key);
+function readBin(length) {
+	return currentDecoder.copyBuffers ?
+		// specifically use the copying slice (not the node one)
+		Uint8Array.prototype.slice.call(src, position$1, position$1 += length) :
+		src.subarray(position$1, position$1 += length)
 }
+let f32Array = new Float32Array(1);
+let u8Array = new Uint8Array(f32Array.buffer, 0, 4);
+function getFloat16() {
+	let byte0 = src[position$1++];
+	let byte1 = src[position$1++];
+	let exponent = (byte0 & 0x7f) >> 2;
+	if (exponent === 0x1f) { // specials
+		if (byte1 || (byte0 & 3))
+			return NaN;
+		return (byte0 & 0x80) ? -Infinity : Infinity;
+	}
+	if (exponent === 0) { // sub-normals
+		// significand with 10 fractional bits and divided by 2^14
+		let abs = (((byte0 & 3) << 8) | byte1) / (1 << 24);
+		return (byte0 & 0x80) ? -abs : abs
+	}
 
-let readFixedString = readStringJS;
-function readStringJS(length) {
-	let result;
-	if (length < 16) {
-		if (result = shortStringInJS(length))
-			return result
+	u8Array[3] = (byte0 & 0x80) | // sign bit
+		((exponent >> 1) + 56); // 4 of 5 of the exponent bits, re-offset-ed
+	u8Array[2] = ((byte0 & 7) << 5) | // last exponent bit and first two mantissa bits
+		(byte1 >> 3); // next 5 bits of mantissa
+	u8Array[1] = byte1 << 5; // last three bits of mantissa
+	u8Array[0] = 0;
+	return f32Array[0];
+}
+
+new Array(4096);
+
+class Tag {
+	constructor(value, tag) {
+		this.value = value;
+		this.tag = tag;
 	}
-	if (length > 64 && decoder)
-		return decoder.decode(src.subarray(position$1, position$1 += length))
-	const end = position$1 + length;
-	const units = [];
-	result = '';
-	while (position$1 < end) {
-		const byte1 = src[position$1++];
-		if ((byte1 & 0x80) === 0) {
-			// 1 byte
-			units.push(byte1);
-		} else if ((byte1 & 0xe0) === 0xc0) {
-			// 2 bytes
-			const byte2 = src[position$1++] & 0x3f;
-			units.push(((byte1 & 0x1f) << 6) | byte2);
-		} else if ((byte1 & 0xf0) === 0xe0) {
-			// 3 bytes
-			const byte2 = src[position$1++] & 0x3f;
-			const byte3 = src[position$1++] & 0x3f;
-			units.push(((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3);
-		} else if ((byte1 & 0xf8) === 0xf0) {
-			// 4 bytes
-			const byte2 = src[position$1++] & 0x3f;
-			const byte3 = src[position$1++] & 0x3f;
-			const byte4 = src[position$1++] & 0x3f;
-			let unit = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4;
-			if (unit > 0xffff) {
-				unit -= 0x10000;
-				units.push(((unit >>> 10) & 0x3ff) | 0xd800);
-				unit = 0xdc00 | (unit & 0x3ff);
-			}
-			units.push(unit);
-		} else {
-			units.push(byte1);
-		}
+}
 
-		if (units.length >= 0x1000) {
-			result += fromCharCode.apply(String, units);
-			units.length = 0;
-		}
+currentExtensions[0] = (dateString) => {
+	// string date extension
+	return new Date(dateString)
+};
+
+currentExtensions[1] = (epochSec) => {
+	// numeric date extension
+	return new Date(Math.round(epochSec * 1000))
+};
+
+currentExtensions[2] = (buffer) => {
+	// bigint extension
+	let value = BigInt(0);
+	for (let i = 0, l = buffer.byteLength; i < l; i++) {
+		value = BigInt(buffer[i]) + (value << BigInt(8));
 	}
+	return value
+};
 
-	if (units.length > 0) {
-		result += fromCharCode.apply(String, units);
+currentExtensions[3] = (buffer) => {
+	// negative bigint extension
+	return BigInt(-1) - currentExtensions[2](buffer)
+};
+currentExtensions[4] = (fraction) => {
+	// best to reparse to maintain accuracy
+	return +(fraction[1] + 'e' + fraction[0])
+};
+
+currentExtensions[5] = (fraction) => {
+	// probably not sufficiently accurate
+	return fraction[1] * Math.exp(fraction[0] * Math.log(2))
+};
+
+// the registration of the record definition extension
+const recordDefinition = (id, structure) => {
+	id = id - 0xe000;
+	let existingStructure = currentStructures[id];
+	if (existingStructure && existingStructure.isShared) {
+		(currentStructures.restoreStructures || (currentStructures.restoreStructures = []))[id] = existingStructure;
 	}
-
-	return result
-}
-let fromCharCode = String.fromCharCode;
-function longStringInJS(length) {
-	let start = position$1;
-	let bytes = new Array(length);
-	for (let i = 0; i < length; i++) {
-		const byte = src[position$1++];
-		if ((byte & 0x80) > 0) {
-			position$1 = start;
-    			return
-    		}
-    		bytes[i] = byte;
-    	}
-    	return fromCharCode.apply(String, bytes)
-}
-function shortStringInJS(length) {
-	if (length < 4) {
-		if (length < 2) {
-			if (length === 0)
-				return ''
-			else {
-				let a = src[position$1++];
-				if ((a & 0x80) > 1) {
-					position$1 -= 1;
-					return
-				}
-				return fromCharCode(a)
-			}
-		} else {
-			let a = src[position$1++];
-			let b = src[position$1++];
-			if ((a & 0x80) > 0 || (b & 0x80) > 0) {
-				position$1 -= 2;
-				return
-			}
-			if (length < 3)
-				return fromCharCode(a, b)
-			let c = src[position$1++];
-			if ((c & 0x80) > 0) {
-				position$1 -= 3;
-				return
-			}
-			return fromCharCode(a, b, c)
-		}
-	} else {
-		let a = src[position$1++];
-		let b = src[position$1++];
-		let c = src[position$1++];
-		let d = src[position$1++];
-		if ((a & 0x80) > 0 || (b & 0x80) > 0 || (c & 0x80) > 0 || (d & 0x80) > 0) {
-			position$1 -= 4;
-			return
-		}
-		if (length < 6) {
-			if (length === 4)
-				return fromCharCode(a, b, c, d)
-			else {
-				let e = src[position$1++];
-				if ((e & 0x80) > 0) {
-					position$1 -= 5;
-					return
-				}
-				return fromCharCode(a, b, c, d, e)
-			}
-		} else if (length < 8) {
-			let e = src[position$1++];
-			let f = src[position$1++];
-			if ((e & 0x80) > 0 || (f & 0x80) > 0) {
-				position$1 -= 6;
-				return
-			}
-			if (length < 7)
-				return fromCharCode(a, b, c, d, e, f)
-			let g = src[position$1++];
-			if ((g & 0x80) > 0) {
-				position$1 -= 7;
-				return
-			}
-			return fromCharCode(a, b, c, d, e, f, g)
-		} else {
-			let e = src[position$1++];
-			let f = src[position$1++];
-			let g = src[position$1++];
-			let h = src[position$1++];
-			if ((e & 0x80) > 0 || (f & 0x80) > 0 || (g & 0x80) > 0 || (h & 0x80) > 0) {
-				position$1 -= 8;
-				return
-			}
-			if (length < 10) {
-				if (length === 8)
-					return fromCharCode(a, b, c, d, e, f, g, h)
-				else {
-					let i = src[position$1++];
-					if ((i & 0x80) > 0) {
-						position$1 -= 9;
-						return
-					}
-					return fromCharCode(a, b, c, d, e, f, g, h, i)
-				}
-			} else if (length < 12) {
-				let i = src[position$1++];
-				let j = src[position$1++];
-				if ((i & 0x80) > 0 || (j & 0x80) > 0) {
-					position$1 -= 10;
-					return
-				}
-				if (length < 11)
-					return fromCharCode(a, b, c, d, e, f, g, h, i, j)
-				let k = src[position$1++];
-				if ((k & 0x80) > 0) {
-					position$1 -= 11;
-					return
-				}
-				return fromCharCode(a, b, c, d, e, f, g, h, i, j, k)
-			} else {
-				let i = src[position$1++];
-				let j = src[position$1++];
-				let k = src[position$1++];
-				let l = src[position$1++];
-				if ((i & 0x80) > 0 || (j & 0x80) > 0 || (k & 0x80) > 0 || (l & 0x80) > 0) {
-					position$1 -= 12;
-					return
-				}
-				if (length < 14) {
-					if (length === 12)
-						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l)
-					else {
-						let m = src[position$1++];
-						if ((m & 0x80) > 0) {
-							position$1 -= 13;
-							return
-						}
-						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m)
-					}
-				} else {
-					let m = src[position$1++];
-					let n = src[position$1++];
-					if ((m & 0x80) > 0 || (n & 0x80) > 0) {
-						position$1 -= 14;
-						return
-					}
-					if (length < 15)
-						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n)
-					let o = src[position$1++];
-					if ((o & 0x80) > 0) {
-						position$1 -= 15;
-						return
-					}
-					return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
-				}
-			}
-		}
-	}
-}
-
-function readBin(length) {
-	return currentDecoder.copyBuffers ?
-		// specifically use the copying slice (not the node one)
-		Uint8Array.prototype.slice.call(src, position$1, position$1 += length) :
-		src.subarray(position$1, position$1 += length)
-}
-let f32Array = new Float32Array(1);
-let u8Array = new Uint8Array(f32Array.buffer, 0, 4);
-function getFloat16() {
-	let byte0 = src[position$1++];
-	let byte1 = src[position$1++];
-	let exponent = (byte0 & 0x7f) >> 2;
-	if (exponent === 0x1f) { // specials
-		if (byte1 || (byte0 & 3))
-			return NaN;
-		return (byte0 & 0x80) ? -Infinity : Infinity;
-	}
-	if (exponent === 0) { // sub-normals
-		// significand with 10 fractional bits and divided by 2^14
-		let abs = (((byte0 & 3) << 8) | byte1) / (1 << 24);
-		return (byte0 & 0x80) ? -abs : abs
-	}
-
-	u8Array[3] = (byte0 & 0x80) | // sign bit
-		((exponent >> 1) + 56); // 4 of 5 of the exponent bits, re-offset-ed
-	u8Array[2] = ((byte0 & 7) << 5) | // last exponent bit and first two mantissa bits
-		(byte1 >> 3); // next 5 bits of mantissa
-	u8Array[1] = byte1 << 5; // last three bits of mantissa
-	u8Array[0] = 0;
-	return f32Array[0];
-}
-
-new Array(4096);
-
-class Tag {
-	constructor(value, tag) {
-		this.value = value;
-		this.tag = tag;
-	}
-}
-
-currentExtensions[0] = (dateString) => {
-	// string date extension
-	return new Date(dateString)
-};
-
-currentExtensions[1] = (epochSec) => {
-	// numeric date extension
-	return new Date(Math.round(epochSec * 1000))
-};
-
-currentExtensions[2] = (buffer) => {
-	// bigint extension
-	let value = BigInt(0);
-	for (let i = 0, l = buffer.byteLength; i < l; i++) {
-		value = BigInt(buffer[i]) + (value << BigInt(8));
-	}
-	return value
-};
-
-currentExtensions[3] = (buffer) => {
-	// negative bigint extension
-	return BigInt(-1) - currentExtensions[2](buffer)
-};
-currentExtensions[4] = (fraction) => {
-	// best to reparse to maintain accuracy
-	return +(fraction[1] + 'e' + fraction[0])
-};
-
-currentExtensions[5] = (fraction) => {
-	// probably not sufficiently accurate
-	return fraction[1] * Math.exp(fraction[0] * Math.log(2))
-};
-
-// the registration of the record definition extension
-const recordDefinition = (id, structure) => {
-	id = id - 0xe000;
-	let existingStructure = currentStructures[id];
-	if (existingStructure && existingStructure.isShared) {
-		(currentStructures.restoreStructures || (currentStructures.restoreStructures = []))[id] = existingStructure;
-	}
-	currentStructures[id] = structure;
+	currentStructures[id] = structure;
 
 	structure.read = createStructureReader(structure);
 };
@@ -5677,569 +4921,1327 @@ class Encoder extends Decoder {
 					encode(object[key]);
 					size++;
 				}
-			} else { 
-				for (let key in object) if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key)) {
-						encode(key);
-						encode(object[key]);
-					size++;
+			} else { 
+				for (let key in object) if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key)) {
+						encode(key);
+						encode(object[key]);
+					size++;
+				}
+			}
+			target[objectOffset++ + start] = size >> 8;
+			target[objectOffset + start] = size & 0xff;
+		} :
+		(object, skipValues) => {
+			let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null));
+			let newTransitions = 0;
+			let length = 0;
+			let parentRecordId;
+			let keys;
+			if (this.keyMap) {
+				keys = Object.keys(object).map(k => this.encodeKey(k));
+				length = keys.length;
+				for (let i = 0; i < length; i++) {
+					let key = keys[i];
+					nextTransition = transition[key];
+					if (!nextTransition) {
+						nextTransition = transition[key] = Object.create(null);
+						newTransitions++;
+					}
+					transition = nextTransition;
+				}				
+			} else {
+				for (let key in object) if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key)) {
+					nextTransition = transition[key];
+					if (!nextTransition) {
+						if (transition[RECORD_SYMBOL] & 0x100000) {// this indicates it is a brancheable/extendable terminal node, so we will use this record id and extend it
+							parentRecordId = transition[RECORD_SYMBOL] & 0xffff;
+						}
+						nextTransition = transition[key] = Object.create(null);
+						newTransitions++;
+					}
+					transition = nextTransition;
+					length++;
+				}
+			}
+			let recordId = transition[RECORD_SYMBOL];
+			if (recordId !== undefined) {
+				recordId &= 0xffff;
+				target[position++] = 0xd9;
+				target[position++] = (recordId >> 8) | 0xe0;
+				target[position++] = recordId & 0xff;
+			} else {
+				if (!keys)
+					keys = transition.__keys__ || (transition.__keys__ = Object.keys(object));
+				if (parentRecordId === undefined) {
+					recordId = structures.nextId++;
+					if (!recordId) {
+						recordId = 0;
+						structures.nextId = 1;
+					}
+					if (recordId >= MAX_STRUCTURES) {// cycle back around
+						structures.nextId = (recordId = maxSharedStructures) + 1;
+					}
+				} else {
+					recordId = parentRecordId;
+				}
+				structures[recordId] = keys;
+				if (recordId < maxSharedStructures) {
+					target[position++] = 0xd9;
+					target[position++] = (recordId >> 8) | 0xe0;
+					target[position++] = recordId & 0xff;
+					transition = structures.transitions;
+					for (let i = 0; i < length; i++) {
+						if (transition[RECORD_SYMBOL] === undefined || (transition[RECORD_SYMBOL] & 0x100000))
+							transition[RECORD_SYMBOL] = recordId;
+						transition = transition[keys[i]];
+					}
+					transition[RECORD_SYMBOL] = recordId | 0x100000; // indicates it is a extendable terminal
+					hasSharedUpdate = true;
+				} else {
+					transition[RECORD_SYMBOL] = recordId;
+					targetView.setUint32(position, 0xd9dfff00); // tag two byte, then record definition id
+					position += 3;
+					if (newTransitions)
+						transitionsCount += serializationsSinceTransitionRebuild * newTransitions;
+					// record the removal of the id, we can maintain our shared structure
+					if (recordIdsToRemove.length >= MAX_STRUCTURES - maxSharedStructures)
+						recordIdsToRemove.shift()[RECORD_SYMBOL] = undefined; // we are cycling back through, and have to remove old ones
+					recordIdsToRemove.push(transition);
+					writeArrayHeader(length + 2);
+					encode(0xe000 + recordId);
+					encode(keys);
+					if (skipValues) return; // special exit for iterator
+					for (let key in object)
+						if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key))
+							encode(object[key]);
+					return
+				}
+			}
+			if (length < 0x18) { // write the array header
+				target[position++] = 0x80 | length;
+			} else {
+				writeArrayHeader(length);
+			}
+			if (skipValues) return; // special exit for iterator
+			for (let key in object)
+				if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key))
+					encode(object[key]);
+		};
+		const makeRoom = (end) => {
+			let newSize;
+			if (end > 0x1000000) {
+				// special handling for really large buffers
+				if ((end - start) > MAX_BUFFER_SIZE)
+					throw new Error('Encoded 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), 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);
+			targetView = new DataView(newBuffer.buffer, 0, newSize);
+			if (target.copy)
+				target.copy(newBuffer, 0, start, end);
+			else
+				newBuffer.set(target.slice(start, end));
+			position -= start;
+			start = 0;
+			safeEnd = newBuffer.length - 10;
+			return target = newBuffer
+		};
+		let chunkThreshold = 100;
+		let continuedChunkThreshold = 1000;
+		this.encodeAsIterable = function(value, options) {
+			return startEncoding(value, options, encodeObjectAsIterable);
+		};
+		this.encodeAsAsyncIterable = function(value, options) {
+			return startEncoding(value, options, encodeObjectAsAsyncIterable);
+		};
+
+		function* encodeObjectAsIterable(object, iterateProperties, finalIterable) {
+			let constructor = object.constructor;
+			if (constructor === Object) {
+				let useRecords = encoder.useRecords !== false;
+				if (useRecords)
+					writeObject(object, true); // write the record identifier
+				else
+					writeEntityLength(Object.keys(object).length, 0xa0);
+				for (let key in object) {
+					let value = object[key];
+					if (!useRecords) encode(key);
+					if (value && typeof value === 'object') {
+						if (iterateProperties[key])
+							yield* encodeObjectAsIterable(value, iterateProperties[key]);
+						else
+							yield* tryEncode(value, iterateProperties, key);
+					} else encode(value);
+				}
+			} else if (constructor === Array) {
+				let length = object.length;
+				writeArrayHeader(length);
+				for (let i = 0; i < length; i++) {
+					let value = object[i];
+					if (value && (typeof value === 'object' || position - start > chunkThreshold)) {
+						if (iterateProperties.element)
+							yield* encodeObjectAsIterable(value, iterateProperties.element);
+						else
+							yield* tryEncode(value, iterateProperties, 'element');
+					} else encode(value);
+				}
+			} else if (object[Symbol.iterator] && !object.buffer) { // iterator, but exclude typed arrays
+				target[position++] = 0x9f; // start indefinite array
+				for (let value of object) {
+					if (value && (typeof value === 'object' || position - start > chunkThreshold)) {
+						if (iterateProperties.element)
+							yield* encodeObjectAsIterable(value, iterateProperties.element);
+						else
+							yield* tryEncode(value, iterateProperties, 'element');
+					} else encode(value);
+				}
+				target[position++] = 0xff; // stop byte
+			} else if (isBlob(object)){
+				writeEntityLength(object.size, 0x40); // encode as binary data
+				yield target.subarray(start, position);
+				yield object; // directly return blobs, they have to be encoded asynchronously
+				restartEncoding();
+			} else if (object[Symbol.asyncIterator]) {
+				target[position++] = 0x9f; // start indefinite array
+				yield target.subarray(start, position);
+				yield object; // directly return async iterators, they have to be encoded asynchronously
+				restartEncoding();
+				target[position++] = 0xff; // stop byte
+			} else {
+				encode(object);
+			}
+			if (finalIterable && position > start) yield target.subarray(start, position);
+			else if (position - start > chunkThreshold) {
+				yield target.subarray(start, position);
+				restartEncoding();
+			}
+		}
+		function* tryEncode(value, iterateProperties, key) {
+			let restart = position - start;
+			try {
+				encode(value);
+				if (position - start > chunkThreshold) {
+					yield target.subarray(start, position);
+					restartEncoding();
+				}
+			} catch (error) {
+				if (error.iteratorNotHandled) {
+					iterateProperties[key] = {};
+					position = start + restart; // restart our position so we don't have partial data from last encode
+					yield* encodeObjectAsIterable.call(this, value, iterateProperties[key]);
+				} else throw error;
+			}
+		}
+		function restartEncoding() {
+			chunkThreshold = continuedChunkThreshold;
+			encoder.encode(null, THROW_ON_ITERABLE); // restart encoding
+		}
+		function startEncoding(value, options, encodeIterable) {
+			if (options && options.chunkThreshold) // explicitly specified chunk sizes
+				chunkThreshold = continuedChunkThreshold = options.chunkThreshold;
+			else // we start with a smaller threshold to get initial bytes sent quickly
+				chunkThreshold = 100;
+			if (value && typeof value === 'object') {
+				encoder.encode(null, THROW_ON_ITERABLE); // start encoding
+				return encodeIterable(value, encoder.iterateProperties || (encoder.iterateProperties = {}), true);
+			}
+			return [encoder.encode(value)];
+		}
+
+		async function* encodeObjectAsAsyncIterable(value, iterateProperties) {
+			for (let encodedValue of encodeObjectAsIterable(value, iterateProperties, true)) {
+				let constructor = encodedValue.constructor;
+				if (constructor === ByteArray || constructor === Uint8Array)
+					yield encodedValue;
+				else if (isBlob(encodedValue)) {
+					let reader = encodedValue.stream().getReader();
+					let next;
+					while (!(next = await reader.read()).done) {
+						yield next.value;
+					}
+				} else if (encodedValue[Symbol.asyncIterator]) {
+					for await (let asyncValue of encodedValue) {
+						restartEncoding();
+						if (asyncValue)
+							yield* encodeObjectAsAsyncIterable(asyncValue, iterateProperties.async || (iterateProperties.async = {}));
+						else yield encoder.encode(asyncValue);
+					}
+				} else {
+					yield encodedValue;
+				}
+			}
+		}
+	}
+	useBuffer(buffer) {
+		// this means we are finished using our own buffer and we can write over it safely
+		target = buffer;
+		targetView = new DataView(target.buffer, target.byteOffset, target.byteLength);
+		position = 0;
+	}
+	clearSharedData() {
+		if (this.structures)
+			this.structures = [];
+		if (this.sharedValues)
+			this.sharedValues = undefined;
+	}
+	updateSharedData() {
+		let lastVersion = this.sharedVersion || 0;
+		this.sharedVersion = lastVersion + 1;
+		let structuresCopy = this.structures.slice(0);
+		let sharedData = new SharedData(structuresCopy, this.sharedValues, this.sharedVersion);
+		let saveResults = this.saveShared(sharedData,
+				existingShared => (existingShared && existingShared.version || 0) == lastVersion);
+		if (saveResults === false) {
+			// get updated structures and try again if the update failed
+			sharedData = this.getShared() || {};
+			this.structures = sharedData.structures || [];
+			this.sharedValues = sharedData.packedValues;
+			this.sharedVersion = sharedData.version;
+			this.structures.nextId = this.structures.length;
+		} else {
+			// restore structures
+			structuresCopy.forEach((structure, i) => this.structures[i] = structure);
+		}
+		// saveShared may fail to write and reload, or may have reloaded to check compatibility and overwrite saved data, either way load the correct shared data
+		return saveResults
+	}
+}
+function writeEntityLength(length, majorValue) {
+	if (length < 0x18)
+		target[position++] = majorValue | length;
+	else if (length < 0x100) {
+		target[position++] = majorValue | 0x18;
+		target[position++] = length;
+	} else if (length < 0x10000) {
+		target[position++] = majorValue | 0x19;
+		target[position++] = length >> 8;
+		target[position++] = length & 0xff;
+	} else {
+		target[position++] = majorValue | 0x1a;
+		targetView.setUint32(position, length);
+		position += 4;
+	}
+
+}
+class SharedData {
+	constructor(structures, values, version) {
+		this.structures = structures;
+		this.packedValues = values;
+		this.version = version;
+	}
+}
+
+function writeArrayHeader(length) {
+	if (length < 0x18)
+		target[position++] = 0x80 | length;
+	else if (length < 0x100) {
+		target[position++] = 0x98;
+		target[position++] = length;
+	} else if (length < 0x10000) {
+		target[position++] = 0x99;
+		target[position++] = length >> 8;
+		target[position++] = length & 0xff;
+	} else {
+		target[position++] = 0x9a;
+		targetView.setUint32(position, length);
+		position += 4;
+	}
+}
+
+const BlobConstructor = typeof Blob === 'undefined' ? function(){} : Blob;
+function isBlob(object) {
+	if (object instanceof BlobConstructor)
+		return true;
+	let tag = object[Symbol.toStringTag];
+	return tag === 'Blob' || tag === 'File';
+}
+function findRepetitiveStrings(value, packedValues) {
+	switch(typeof value) {
+		case 'string':
+			if (value.length > 3) {
+				if (packedValues.objectMap[value] > -1 || packedValues.values.length >= packedValues.maxValues)
+					return
+				let packedStatus = packedValues.get(value);
+				if (packedStatus) {
+					if (++packedStatus.count == 2) {
+						packedValues.values.push(value);
+					}
+				} else {
+					packedValues.set(value, {
+						count: 1,
+					});
+					if (packedValues.samplingPackedValues) {
+						let status = packedValues.samplingPackedValues.get(value);
+						if (status)
+							status.count++;
+						else
+							packedValues.samplingPackedValues.set(value, {
+								count: 1,
+							});
+					}
+				}
+			}
+			break
+		case 'object':
+			if (value) {
+				if (value instanceof Array) {
+					for (let i = 0, l = value.length; i < l; i++) {
+						findRepetitiveStrings(value[i], packedValues);
+					}
+
+				} else {
+					let includeKeys = !packedValues.encoder.useRecords;
+					for (var key in value) {
+						if (value.hasOwnProperty(key)) {
+							if (includeKeys)
+								findRepetitiveStrings(key, packedValues);
+							findRepetitiveStrings(value[key], packedValues);
+						}
+					}
+				}
+			}
+			break
+		case 'function': console.log(value);
+	}
+}
+const isLittleEndianMachine = new Uint8Array(new Uint16Array([1]).buffer)[0] == 1;
+extensionClasses = [ Date, Set, Error, RegExp, Tag, ArrayBuffer,
+	Uint8Array, Uint8ClampedArray, Uint16Array, Uint32Array,
+	typeof BigUint64Array == 'undefined' ? function() {} : BigUint64Array, Int8Array, Int16Array, Int32Array,
+	typeof BigInt64Array == 'undefined' ? function() {} : BigInt64Array,
+	Float32Array, Float64Array, SharedData ];
+
+//Object.getPrototypeOf(Uint8Array.prototype).constructor /*TypedArray*/
+extensions = [{ // Date
+	tag: 1,
+	encode(date, encode) {
+		let seconds = date.getTime() / 1000;
+		if ((this.useTimestamp32 || date.getMilliseconds() === 0) && seconds >= 0 && seconds < 0x100000000) {
+			// Timestamp 32
+			target[position++] = 0x1a;
+			targetView.setUint32(position, seconds);
+			position += 4;
+		} else {
+			// Timestamp float64
+			target[position++] = 0xfb;
+			targetView.setFloat64(position, seconds);
+			position += 8;
+		}
+	}
+}, { // Set
+	tag: 258, // https://github.com/input-output-hk/cbor-sets-spec/blob/master/CBOR_SETS.md
+	encode(set, encode) {
+		let array = Array.from(set);
+		encode(array);
+	}
+}, { // Error
+	tag: 27, // http://cbor.schmorp.de/generic-object
+	encode(error, encode) {
+		encode([ error.name, error.message ]);
+	}
+}, { // RegExp
+	tag: 27, // http://cbor.schmorp.de/generic-object
+	encode(regex, encode) {
+		encode([ 'RegExp', regex.source, regex.flags ]);
+	}
+}, { // Tag
+	getTag(tag) {
+		return tag.tag
+	},
+	encode(tag, encode) {
+		encode(tag.value);
+	}
+}, { // ArrayBuffer
+	encode(arrayBuffer, encode, makeRoom) {
+		writeBuffer(arrayBuffer, makeRoom);
+	}
+}, { // Uint8Array
+	getTag(typedArray) {
+		if (typedArray.constructor === Uint8Array) {
+			if (this.tagUint8Array || hasNodeBuffer && this.tagUint8Array !== false)
+				return 64;
+		} // else no tag
+	},
+	encode(typedArray, encode, makeRoom) {
+		writeBuffer(typedArray, makeRoom);
+	}
+},
+	typedArrayEncoder(68, 1),
+	typedArrayEncoder(69, 2),
+	typedArrayEncoder(70, 4),
+	typedArrayEncoder(71, 8),
+	typedArrayEncoder(72, 1),
+	typedArrayEncoder(77, 2),
+	typedArrayEncoder(78, 4),
+	typedArrayEncoder(79, 8),
+	typedArrayEncoder(85, 4),
+	typedArrayEncoder(86, 8),
+{
+	encode(sharedData, encode) { // write SharedData
+		let packedValues = sharedData.packedValues || [];
+		let sharedStructures = sharedData.structures || [];
+		if (packedValues.values.length > 0) {
+			target[position++] = 0xd8; // one-byte tag
+			target[position++] = 51; // tag 51 for packed shared structures https://www.potaroo.net/ietf/ids/draft-ietf-cbor-packed-03.txt
+			writeArrayHeader(4);
+			let valuesArray = packedValues.values;
+			encode(valuesArray);
+			writeArrayHeader(0); // prefixes
+			writeArrayHeader(0); // suffixes
+			packedObjectMap = Object.create(sharedPackedObjectMap || null);
+			for (let i = 0, l = valuesArray.length; i < l; i++) {
+				packedObjectMap[valuesArray[i]] = i;
+			}
+		}
+		if (sharedStructures) {
+			targetView.setUint32(position, 0xd9dffe00);
+			position += 3;
+			let definitions = sharedStructures.slice(0);
+			definitions.unshift(0xe000);
+			definitions.push(new Tag(sharedData.version, 0x53687264));
+			encode(definitions);
+		} else
+			encode(new Tag(sharedData.version, 0x53687264));
+		}
+	}];
+function typedArrayEncoder(tag, size) {
+	if (!isLittleEndianMachine && size > 1)
+		tag -= 4; // the big endian equivalents are 4 less
+	return {
+		tag: tag,
+		encode: function writeExtBuffer(typedArray, encode) {
+			let length = typedArray.byteLength;
+			let offset = typedArray.byteOffset || 0;
+			let buffer = typedArray.buffer || typedArray;
+			encode(hasNodeBuffer ? Buffer$1.from(buffer, offset, length) :
+				new Uint8Array(buffer, offset, length));
+		}
+	}
+}
+function writeBuffer(buffer, makeRoom) {
+	let length = buffer.byteLength;
+	if (length < 0x18) {
+		target[position++] = 0x40 + length;
+	} else if (length < 0x100) {
+		target[position++] = 0x58;
+		target[position++] = length;
+	} else if (length < 0x10000) {
+		target[position++] = 0x59;
+		target[position++] = length >> 8;
+		target[position++] = length & 0xff;
+	} else {
+		target[position++] = 0x5a;
+		targetView.setUint32(position, length);
+		position += 4;
+	}
+	if (position + length >= target.length) {
+		makeRoom(position + length);
+	}
+	// if it is already a typed array (has an ArrayBuffer), use that, but if it is an ArrayBuffer itself,
+	// must wrap it to set it.
+	target.set(buffer.buffer ? buffer : new Uint8Array(buffer), position);
+	position += length;
+}
+
+function insertIds(serialized, idsToInsert) {
+	// insert the ids that need to be referenced for structured clones
+	let nextId;
+	let distanceToMove = idsToInsert.length * 2;
+	let lastEnd = serialized.length - distanceToMove;
+	idsToInsert.sort((a, b) => a.offset > b.offset ? 1 : -1);
+	for (let id = 0; id < idsToInsert.length; id++) {
+		let referee = idsToInsert[id];
+		referee.id = id;
+		for (let position of referee.references) {
+			serialized[position++] = id >> 8;
+			serialized[position] = id & 0xff;
+		}
+	}
+	while (nextId = idsToInsert.pop()) {
+		let offset = nextId.offset;
+		serialized.copyWithin(offset + distanceToMove, offset, lastEnd);
+		distanceToMove -= 2;
+		let position = offset + distanceToMove;
+		serialized[position++] = 0xd8;
+		serialized[position++] = 28; // http://cbor.schmorp.de/value-sharing
+		lastEnd = offset;
+	}
+	return serialized
+}
+function writeBundles(start, encode) {
+	targetView.setUint32(bundledStrings.position + start, position - bundledStrings.position - start + 1); // the offset to bundle
+	let writeStrings = bundledStrings;
+	bundledStrings = null;
+	encode(writeStrings[0]);
+	encode(writeStrings[1]);
+}
+let defaultEncoder = new Encoder({ useRecords: false });
+defaultEncoder.encode;
+defaultEncoder.encodeAsIterable;
+defaultEncoder.encodeAsAsyncIterable;
+const REUSE_BUFFER_MODE = 512;
+const RESET_BUFFER_MODE = 1024;
+const THROW_ON_ITERABLE = 2048;
+
+var browser = {exports: {}};
+
+/**
+ * Helpers.
+ */
+
+var ms;
+var hasRequiredMs;
+
+function requireMs () {
+	if (hasRequiredMs) return ms;
+	hasRequiredMs = 1;
+	var s = 1000;
+	var m = s * 60;
+	var h = m * 60;
+	var d = h * 24;
+	var w = d * 7;
+	var y = d * 365.25;
+
+	/**
+	 * Parse or format the given `val`.
+	 *
+	 * Options:
+	 *
+	 *  - `long` verbose formatting [false]
+	 *
+	 * @param {String|Number} val
+	 * @param {Object} [options]
+	 * @throws {Error} throw an error if val is not a non-empty string or a number
+	 * @return {String|Number}
+	 * @api public
+	 */
+
+	ms = function (val, options) {
+	  options = options || {};
+	  var type = typeof val;
+	  if (type === 'string' && val.length > 0) {
+	    return parse(val);
+	  } else if (type === 'number' && isFinite(val)) {
+	    return options.long ? fmtLong(val) : fmtShort(val);
+	  }
+	  throw new Error(
+	    'val is not a non-empty string or a valid number. val=' +
+	      JSON.stringify(val)
+	  );
+	};
+
+	/**
+	 * Parse the given `str` and return milliseconds.
+	 *
+	 * @param {String} str
+	 * @return {Number}
+	 * @api private
+	 */
+
+	function parse(str) {
+	  str = String(str);
+	  if (str.length > 100) {
+	    return;
+	  }
+	  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+	    str
+	  );
+	  if (!match) {
+	    return;
+	  }
+	  var n = parseFloat(match[1]);
+	  var type = (match[2] || 'ms').toLowerCase();
+	  switch (type) {
+	    case 'years':
+	    case 'year':
+	    case 'yrs':
+	    case 'yr':
+	    case 'y':
+	      return n * y;
+	    case 'weeks':
+	    case 'week':
+	    case 'w':
+	      return n * w;
+	    case 'days':
+	    case 'day':
+	    case 'd':
+	      return n * d;
+	    case 'hours':
+	    case 'hour':
+	    case 'hrs':
+	    case 'hr':
+	    case 'h':
+	      return n * h;
+	    case 'minutes':
+	    case 'minute':
+	    case 'mins':
+	    case 'min':
+	    case 'm':
+	      return n * m;
+	    case 'seconds':
+	    case 'second':
+	    case 'secs':
+	    case 'sec':
+	    case 's':
+	      return n * s;
+	    case 'milliseconds':
+	    case 'millisecond':
+	    case 'msecs':
+	    case 'msec':
+	    case 'ms':
+	      return n;
+	    default:
+	      return undefined;
+	  }
+	}
+
+	/**
+	 * Short format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtShort(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return Math.round(ms / d) + 'd';
+	  }
+	  if (msAbs >= h) {
+	    return Math.round(ms / h) + 'h';
+	  }
+	  if (msAbs >= m) {
+	    return Math.round(ms / m) + 'm';
+	  }
+	  if (msAbs >= s) {
+	    return Math.round(ms / s) + 's';
+	  }
+	  return ms + 'ms';
+	}
+
+	/**
+	 * Long format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtLong(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return plural(ms, msAbs, d, 'day');
+	  }
+	  if (msAbs >= h) {
+	    return plural(ms, msAbs, h, 'hour');
+	  }
+	  if (msAbs >= m) {
+	    return plural(ms, msAbs, m, 'minute');
+	  }
+	  if (msAbs >= s) {
+	    return plural(ms, msAbs, s, 'second');
+	  }
+	  return ms + ' ms';
+	}
+
+	/**
+	 * Pluralization helper.
+	 */
+
+	function plural(ms, msAbs, n, name) {
+	  var isPlural = msAbs >= n * 1.5;
+	  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+	}
+	return ms;
+}
+
+var common;
+var hasRequiredCommon;
+
+function requireCommon () {
+	if (hasRequiredCommon) return common;
+	hasRequiredCommon = 1;
+	/**
+	 * This is the common logic for both the Node.js and web browser
+	 * implementations of `debug()`.
+	 */
+
+	function setup(env) {
+		createDebug.debug = createDebug;
+		createDebug.default = createDebug;
+		createDebug.coerce = coerce;
+		createDebug.disable = disable;
+		createDebug.enable = enable;
+		createDebug.enabled = enabled;
+		createDebug.humanize = requireMs();
+		createDebug.destroy = destroy;
+
+		Object.keys(env).forEach(key => {
+			createDebug[key] = env[key];
+		});
+
+		/**
+		* The currently active debug mode names, and names to skip.
+		*/
+
+		createDebug.names = [];
+		createDebug.skips = [];
+
+		/**
+		* Map of special "%n" handling functions, for the debug "format" argument.
+		*
+		* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+		*/
+		createDebug.formatters = {};
+
+		/**
+		* Selects a color for a debug namespace
+		* @param {String} namespace The namespace string for the debug instance to be colored
+		* @return {Number|String} An ANSI color code for the given namespace
+		* @api private
+		*/
+		function selectColor(namespace) {
+			let hash = 0;
+
+			for (let i = 0; i < namespace.length; i++) {
+				hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
+				hash |= 0; // Convert to 32bit integer
+			}
+
+			return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+		}
+		createDebug.selectColor = selectColor;
+
+		/**
+		* Create a debugger with the given `namespace`.
+		*
+		* @param {String} namespace
+		* @return {Function}
+		* @api public
+		*/
+		function createDebug(namespace) {
+			let prevTime;
+			let enableOverride = null;
+			let namespacesCache;
+			let enabledCache;
+
+			function debug(...args) {
+				// Disabled?
+				if (!debug.enabled) {
+					return;
+				}
+
+				const self = debug;
+
+				// Set `diff` timestamp
+				const curr = Number(new Date());
+				const ms = curr - (prevTime || curr);
+				self.diff = ms;
+				self.prev = prevTime;
+				self.curr = curr;
+				prevTime = curr;
+
+				args[0] = createDebug.coerce(args[0]);
+
+				if (typeof args[0] !== 'string') {
+					// Anything else let's inspect with %O
+					args.unshift('%O');
 				}
-			}
-			target[objectOffset++ + start] = size >> 8;
-			target[objectOffset + start] = size & 0xff;
-		} :
-		(object, skipValues) => {
-			let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null));
-			let newTransitions = 0;
-			let length = 0;
-			let parentRecordId;
-			let keys;
-			if (this.keyMap) {
-				keys = Object.keys(object).map(k => this.encodeKey(k));
-				length = keys.length;
-				for (let i = 0; i < length; i++) {
-					let key = keys[i];
-					nextTransition = transition[key];
-					if (!nextTransition) {
-						nextTransition = transition[key] = Object.create(null);
-						newTransitions++;
+
+				// Apply any `formatters` transformations
+				let index = 0;
+				args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+					// If we encounter an escaped % then don't increase the array index
+					if (match === '%%') {
+						return '%';
 					}
-					transition = nextTransition;
-				}				
-			} else {
-				for (let key in object) if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key)) {
-					nextTransition = transition[key];
-					if (!nextTransition) {
-						if (transition[RECORD_SYMBOL] & 0x100000) {// this indicates it is a brancheable/extendable terminal node, so we will use this record id and extend it
-							parentRecordId = transition[RECORD_SYMBOL] & 0xffff;
-						}
-						nextTransition = transition[key] = Object.create(null);
-						newTransitions++;
+					index++;
+					const formatter = createDebug.formatters[format];
+					if (typeof formatter === 'function') {
+						const val = args[index];
+						match = formatter.call(self, val);
+
+						// Now we need to remove `args[index]` since it's inlined in the `format`
+						args.splice(index, 1);
+						index--;
 					}
-					transition = nextTransition;
-					length++;
-				}
+					return match;
+				});
+
+				// Apply env-specific formatting (colors, etc.)
+				createDebug.formatArgs.call(self, args);
+
+				const logFn = self.log || createDebug.log;
+				logFn.apply(self, args);
 			}
-			let recordId = transition[RECORD_SYMBOL];
-			if (recordId !== undefined) {
-				recordId &= 0xffff;
-				target[position++] = 0xd9;
-				target[position++] = (recordId >> 8) | 0xe0;
-				target[position++] = recordId & 0xff;
-			} else {
-				if (!keys)
-					keys = transition.__keys__ || (transition.__keys__ = Object.keys(object));
-				if (parentRecordId === undefined) {
-					recordId = structures.nextId++;
-					if (!recordId) {
-						recordId = 0;
-						structures.nextId = 1;
-					}
-					if (recordId >= MAX_STRUCTURES) {// cycle back around
-						structures.nextId = (recordId = maxSharedStructures) + 1;
+
+			debug.namespace = namespace;
+			debug.useColors = createDebug.useColors();
+			debug.color = createDebug.selectColor(namespace);
+			debug.extend = extend;
+			debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
+
+			Object.defineProperty(debug, 'enabled', {
+				enumerable: true,
+				configurable: false,
+				get: () => {
+					if (enableOverride !== null) {
+						return enableOverride;
 					}
-				} else {
-					recordId = parentRecordId;
-				}
-				structures[recordId] = keys;
-				if (recordId < maxSharedStructures) {
-					target[position++] = 0xd9;
-					target[position++] = (recordId >> 8) | 0xe0;
-					target[position++] = recordId & 0xff;
-					transition = structures.transitions;
-					for (let i = 0; i < length; i++) {
-						if (transition[RECORD_SYMBOL] === undefined || (transition[RECORD_SYMBOL] & 0x100000))
-							transition[RECORD_SYMBOL] = recordId;
-						transition = transition[keys[i]];
+					if (namespacesCache !== createDebug.namespaces) {
+						namespacesCache = createDebug.namespaces;
+						enabledCache = createDebug.enabled(namespace);
 					}
-					transition[RECORD_SYMBOL] = recordId | 0x100000; // indicates it is a extendable terminal
-					hasSharedUpdate = true;
-				} else {
-					transition[RECORD_SYMBOL] = recordId;
-					targetView.setUint32(position, 0xd9dfff00); // tag two byte, then record definition id
-					position += 3;
-					if (newTransitions)
-						transitionsCount += serializationsSinceTransitionRebuild * newTransitions;
-					// record the removal of the id, we can maintain our shared structure
-					if (recordIdsToRemove.length >= MAX_STRUCTURES - maxSharedStructures)
-						recordIdsToRemove.shift()[RECORD_SYMBOL] = undefined; // we are cycling back through, and have to remove old ones
-					recordIdsToRemove.push(transition);
-					writeArrayHeader(length + 2);
-					encode(0xe000 + recordId);
-					encode(keys);
-					if (skipValues) return; // special exit for iterator
-					for (let key in object)
-						if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key))
-							encode(object[key]);
-					return
+
+					return enabledCache;
+				},
+				set: v => {
+					enableOverride = v;
 				}
+			});
+
+			// Env-specific initialization logic for debug instances
+			if (typeof createDebug.init === 'function') {
+				createDebug.init(debug);
 			}
-			if (length < 0x18) { // write the array header
-				target[position++] = 0x80 | length;
-			} else {
-				writeArrayHeader(length);
-			}
-			if (skipValues) return; // special exit for iterator
-			for (let key in object)
-				if (typeof object.hasOwnProperty !== 'function' || object.hasOwnProperty(key))
-					encode(object[key]);
-		};
-		const makeRoom = (end) => {
-			let newSize;
-			if (end > 0x1000000) {
-				// special handling for really large buffers
-				if ((end - start) > MAX_BUFFER_SIZE)
-					throw new Error('Encoded 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), 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);
-			targetView = new DataView(newBuffer.buffer, 0, newSize);
-			if (target.copy)
-				target.copy(newBuffer, 0, start, end);
-			else
-				newBuffer.set(target.slice(start, end));
-			position -= start;
-			start = 0;
-			safeEnd = newBuffer.length - 10;
-			return target = newBuffer
-		};
-		let chunkThreshold = 100;
-		let continuedChunkThreshold = 1000;
-		this.encodeAsIterable = function(value, options) {
-			return startEncoding(value, options, encodeObjectAsIterable);
-		};
-		this.encodeAsAsyncIterable = function(value, options) {
-			return startEncoding(value, options, encodeObjectAsAsyncIterable);
-		};
 
-		function* encodeObjectAsIterable(object, iterateProperties, finalIterable) {
-			let constructor = object.constructor;
-			if (constructor === Object) {
-				let useRecords = encoder.useRecords !== false;
-				if (useRecords)
-					writeObject(object, true); // write the record identifier
-				else
-					writeEntityLength(Object.keys(object).length, 0xa0);
-				for (let key in object) {
-					let value = object[key];
-					if (!useRecords) encode(key);
-					if (value && typeof value === 'object') {
-						if (iterateProperties[key])
-							yield* encodeObjectAsIterable(value, iterateProperties[key]);
-						else
-							yield* tryEncode(value, iterateProperties, key);
-					} else encode(value);
-				}
-			} else if (constructor === Array) {
-				let length = object.length;
-				writeArrayHeader(length);
-				for (let i = 0; i < length; i++) {
-					let value = object[i];
-					if (value && (typeof value === 'object' || position - start > chunkThreshold)) {
-						if (iterateProperties.element)
-							yield* encodeObjectAsIterable(value, iterateProperties.element);
-						else
-							yield* tryEncode(value, iterateProperties, 'element');
-					} else encode(value);
+			return debug;
+		}
+
+		function extend(namespace, delimiter) {
+			const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
+			newDebug.log = this.log;
+			return newDebug;
+		}
+
+		/**
+		* Enables a debug mode by namespaces. This can include modes
+		* separated by a colon and wildcards.
+		*
+		* @param {String} namespaces
+		* @api public
+		*/
+		function enable(namespaces) {
+			createDebug.save(namespaces);
+			createDebug.namespaces = namespaces;
+
+			createDebug.names = [];
+			createDebug.skips = [];
+
+			const split = (typeof namespaces === 'string' ? namespaces : '')
+				.trim()
+				.replace(/\s+/g, ',')
+				.split(',')
+				.filter(Boolean);
+
+			for (const ns of split) {
+				if (ns[0] === '-') {
+					createDebug.skips.push(ns.slice(1));
+				} else {
+					createDebug.names.push(ns);
 				}
-			} else if (object[Symbol.iterator] && !object.buffer) { // iterator, but exclude typed arrays
-				target[position++] = 0x9f; // start indefinite array
-				for (let value of object) {
-					if (value && (typeof value === 'object' || position - start > chunkThreshold)) {
-						if (iterateProperties.element)
-							yield* encodeObjectAsIterable(value, iterateProperties.element);
-						else
-							yield* tryEncode(value, iterateProperties, 'element');
-					} else encode(value);
+			}
+		}
+
+		/**
+		 * Checks if the given string matches a namespace template, honoring
+		 * asterisks as wildcards.
+		 *
+		 * @param {String} search
+		 * @param {String} template
+		 * @return {Boolean}
+		 */
+		function matchesTemplate(search, template) {
+			let searchIndex = 0;
+			let templateIndex = 0;
+			let starIndex = -1;
+			let matchIndex = 0;
+
+			while (searchIndex < search.length) {
+				if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === '*')) {
+					// Match character or proceed with wildcard
+					if (template[templateIndex] === '*') {
+						starIndex = templateIndex;
+						matchIndex = searchIndex;
+						templateIndex++; // Skip the '*'
+					} else {
+						searchIndex++;
+						templateIndex++;
+					}
+				} else if (starIndex !== -1) { // eslint-disable-line no-negated-condition
+					// Backtrack to the last '*' and try to match more characters
+					templateIndex = starIndex + 1;
+					matchIndex++;
+					searchIndex = matchIndex;
+				} else {
+					return false; // No match
 				}
-				target[position++] = 0xff; // stop byte
-			} else if (isBlob(object)){
-				writeEntityLength(object.size, 0x40); // encode as binary data
-				yield target.subarray(start, position);
-				yield object; // directly return blobs, they have to be encoded asynchronously
-				restartEncoding();
-			} else if (object[Symbol.asyncIterator]) {
-				target[position++] = 0x9f; // start indefinite array
-				yield target.subarray(start, position);
-				yield object; // directly return async iterators, they have to be encoded asynchronously
-				restartEncoding();
-				target[position++] = 0xff; // stop byte
-			} else {
-				encode(object);
 			}
-			if (finalIterable && position > start) yield target.subarray(start, position);
-			else if (position - start > chunkThreshold) {
-				yield target.subarray(start, position);
-				restartEncoding();
+
+			// Handle trailing '*' in template
+			while (templateIndex < template.length && template[templateIndex] === '*') {
+				templateIndex++;
 			}
+
+			return templateIndex === template.length;
 		}
-		function* tryEncode(value, iterateProperties, key) {
-			let restart = position - start;
-			try {
-				encode(value);
-				if (position - start > chunkThreshold) {
-					yield target.subarray(start, position);
-					restartEncoding();
+
+		/**
+		* Disable debug output.
+		*
+		* @return {String} namespaces
+		* @api public
+		*/
+		function disable() {
+			const namespaces = [
+				...createDebug.names,
+				...createDebug.skips.map(namespace => '-' + namespace)
+			].join(',');
+			createDebug.enable('');
+			return namespaces;
+		}
+
+		/**
+		* Returns true if the given mode name is enabled, false otherwise.
+		*
+		* @param {String} name
+		* @return {Boolean}
+		* @api public
+		*/
+		function enabled(name) {
+			for (const skip of createDebug.skips) {
+				if (matchesTemplate(name, skip)) {
+					return false;
+				}
+			}
+
+			for (const ns of createDebug.names) {
+				if (matchesTemplate(name, ns)) {
+					return true;
 				}
-			} catch (error) {
-				if (error.iteratorNotHandled) {
-					iterateProperties[key] = {};
-					position = start + restart; // restart our position so we don't have partial data from last encode
-					yield* encodeObjectAsIterable.call(this, value, iterateProperties[key]);
-				} else throw error;
 			}
+
+			return false;
 		}
-		function restartEncoding() {
-			chunkThreshold = continuedChunkThreshold;
-			encoder.encode(null, THROW_ON_ITERABLE); // restart encoding
+
+		/**
+		* Coerce `val`.
+		*
+		* @param {Mixed} val
+		* @return {Mixed}
+		* @api private
+		*/
+		function coerce(val) {
+			if (val instanceof Error) {
+				return val.stack || val.message;
+			}
+			return val;
 		}
-		function startEncoding(value, options, encodeIterable) {
-			if (options && options.chunkThreshold) // explicitly specified chunk sizes
-				chunkThreshold = continuedChunkThreshold = options.chunkThreshold;
-			else // we start with a smaller threshold to get initial bytes sent quickly
-				chunkThreshold = 100;
-			if (value && typeof value === 'object') {
-				encoder.encode(null, THROW_ON_ITERABLE); // start encoding
-				return encodeIterable(value, encoder.iterateProperties || (encoder.iterateProperties = {}), true);
+
+		/**
+		* XXX DO NOT USE. This is a temporary stub function.
+		* XXX It WILL be removed in the next major release.
+		*/
+		function destroy() {
+			console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+		}
+
+		createDebug.enable(createDebug.load());
+
+		return createDebug;
+	}
+
+	common = setup;
+	return common;
+}
+
+/* eslint-env browser */
+
+var hasRequiredBrowser;
+
+function requireBrowser () {
+	if (hasRequiredBrowser) return browser.exports;
+	hasRequiredBrowser = 1;
+	(function (module, exports) {
+		/**
+		 * This is the web browser implementation of `debug()`.
+		 */
+
+		exports.formatArgs = formatArgs;
+		exports.save = save;
+		exports.load = load;
+		exports.useColors = useColors;
+		exports.storage = localstorage();
+		exports.destroy = (() => {
+			let warned = false;
+
+			return () => {
+				if (!warned) {
+					warned = true;
+					console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+				}
+			};
+		})();
+
+		/**
+		 * Colors.
+		 */
+
+		exports.colors = [
+			'#0000CC',
+			'#0000FF',
+			'#0033CC',
+			'#0033FF',
+			'#0066CC',
+			'#0066FF',
+			'#0099CC',
+			'#0099FF',
+			'#00CC00',
+			'#00CC33',
+			'#00CC66',
+			'#00CC99',
+			'#00CCCC',
+			'#00CCFF',
+			'#3300CC',
+			'#3300FF',
+			'#3333CC',
+			'#3333FF',
+			'#3366CC',
+			'#3366FF',
+			'#3399CC',
+			'#3399FF',
+			'#33CC00',
+			'#33CC33',
+			'#33CC66',
+			'#33CC99',
+			'#33CCCC',
+			'#33CCFF',
+			'#6600CC',
+			'#6600FF',
+			'#6633CC',
+			'#6633FF',
+			'#66CC00',
+			'#66CC33',
+			'#9900CC',
+			'#9900FF',
+			'#9933CC',
+			'#9933FF',
+			'#99CC00',
+			'#99CC33',
+			'#CC0000',
+			'#CC0033',
+			'#CC0066',
+			'#CC0099',
+			'#CC00CC',
+			'#CC00FF',
+			'#CC3300',
+			'#CC3333',
+			'#CC3366',
+			'#CC3399',
+			'#CC33CC',
+			'#CC33FF',
+			'#CC6600',
+			'#CC6633',
+			'#CC9900',
+			'#CC9933',
+			'#CCCC00',
+			'#CCCC33',
+			'#FF0000',
+			'#FF0033',
+			'#FF0066',
+			'#FF0099',
+			'#FF00CC',
+			'#FF00FF',
+			'#FF3300',
+			'#FF3333',
+			'#FF3366',
+			'#FF3399',
+			'#FF33CC',
+			'#FF33FF',
+			'#FF6600',
+			'#FF6633',
+			'#FF9900',
+			'#FF9933',
+			'#FFCC00',
+			'#FFCC33'
+		];
+
+		/**
+		 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+		 * and the Firebug extension (any Firefox version) are known
+		 * to support "%c" CSS customizations.
+		 *
+		 * TODO: add a `localStorage` variable to explicitly enable/disable colors
+		 */
+
+		// eslint-disable-next-line complexity
+		function useColors() {
+			// NB: In an Electron preload script, document will be defined but not fully
+			// initialized. Since we know we're in Chrome, we'll just detect this case
+			// explicitly
+			if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
+				return true;
 			}
-			return [encoder.encode(value)];
-		}
 
-		async function* encodeObjectAsAsyncIterable(value, iterateProperties) {
-			for (let encodedValue of encodeObjectAsIterable(value, iterateProperties, true)) {
-				let constructor = encodedValue.constructor;
-				if (constructor === ByteArray || constructor === Uint8Array)
-					yield encodedValue;
-				else if (isBlob(encodedValue)) {
-					let reader = encodedValue.stream().getReader();
-					let next;
-					while (!(next = await reader.read()).done) {
-						yield next.value;
-					}
-				} else if (encodedValue[Symbol.asyncIterator]) {
-					for await (let asyncValue of encodedValue) {
-						restartEncoding();
-						if (asyncValue)
-							yield* encodeObjectAsAsyncIterable(asyncValue, iterateProperties.async || (iterateProperties.async = {}));
-						else yield encoder.encode(asyncValue);
-					}
-				} else {
-					yield encodedValue;
-				}
+			// Internet Explorer and Edge do not support colors.
+			if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+				return false;
 			}
+
+			let m;
+
+			// Is webkit? http://stackoverflow.com/a/16459606/376773
+			// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+			// eslint-disable-next-line no-return-assign
+			return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
+				// Is firebug? http://stackoverflow.com/a/398120/376773
+				(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
+				// Is firefox >= v31?
+				// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+				(typeof navigator !== 'undefined' && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31) ||
+				// Double check webkit in userAgent just in case we are in a worker
+				(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
 		}
-	}
-	useBuffer(buffer) {
-		// this means we are finished using our own buffer and we can write over it safely
-		target = buffer;
-		targetView = new DataView(target.buffer, target.byteOffset, target.byteLength);
-		position = 0;
-	}
-	clearSharedData() {
-		if (this.structures)
-			this.structures = [];
-		if (this.sharedValues)
-			this.sharedValues = undefined;
-	}
-	updateSharedData() {
-		let lastVersion = this.sharedVersion || 0;
-		this.sharedVersion = lastVersion + 1;
-		let structuresCopy = this.structures.slice(0);
-		let sharedData = new SharedData(structuresCopy, this.sharedValues, this.sharedVersion);
-		let saveResults = this.saveShared(sharedData,
-				existingShared => (existingShared && existingShared.version || 0) == lastVersion);
-		if (saveResults === false) {
-			// get updated structures and try again if the update failed
-			sharedData = this.getShared() || {};
-			this.structures = sharedData.structures || [];
-			this.sharedValues = sharedData.packedValues;
-			this.sharedVersion = sharedData.version;
-			this.structures.nextId = this.structures.length;
-		} else {
-			// restore structures
-			structuresCopy.forEach((structure, i) => this.structures[i] = structure);
-		}
-		// saveShared may fail to write and reload, or may have reloaded to check compatibility and overwrite saved data, either way load the correct shared data
-		return saveResults
-	}
-}
-function writeEntityLength(length, majorValue) {
-	if (length < 0x18)
-		target[position++] = majorValue | length;
-	else if (length < 0x100) {
-		target[position++] = majorValue | 0x18;
-		target[position++] = length;
-	} else if (length < 0x10000) {
-		target[position++] = majorValue | 0x19;
-		target[position++] = length >> 8;
-		target[position++] = length & 0xff;
-	} else {
-		target[position++] = majorValue | 0x1a;
-		targetView.setUint32(position, length);
-		position += 4;
-	}
 
-}
-class SharedData {
-	constructor(structures, values, version) {
-		this.structures = structures;
-		this.packedValues = values;
-		this.version = version;
-	}
-}
+		/**
+		 * Colorize log arguments if enabled.
+		 *
+		 * @api public
+		 */
 
-function writeArrayHeader(length) {
-	if (length < 0x18)
-		target[position++] = 0x80 | length;
-	else if (length < 0x100) {
-		target[position++] = 0x98;
-		target[position++] = length;
-	} else if (length < 0x10000) {
-		target[position++] = 0x99;
-		target[position++] = length >> 8;
-		target[position++] = length & 0xff;
-	} else {
-		target[position++] = 0x9a;
-		targetView.setUint32(position, length);
-		position += 4;
-	}
-}
+		function formatArgs(args) {
+			args[0] = (this.useColors ? '%c' : '') +
+				this.namespace +
+				(this.useColors ? ' %c' : ' ') +
+				args[0] +
+				(this.useColors ? '%c ' : ' ') +
+				'+' + module.exports.humanize(this.diff);
 
-const BlobConstructor = typeof Blob === 'undefined' ? function(){} : Blob;
-function isBlob(object) {
-	if (object instanceof BlobConstructor)
-		return true;
-	let tag = object[Symbol.toStringTag];
-	return tag === 'Blob' || tag === 'File';
-}
-function findRepetitiveStrings(value, packedValues) {
-	switch(typeof value) {
-		case 'string':
-			if (value.length > 3) {
-				if (packedValues.objectMap[value] > -1 || packedValues.values.length >= packedValues.maxValues)
-					return
-				let packedStatus = packedValues.get(value);
-				if (packedStatus) {
-					if (++packedStatus.count == 2) {
-						packedValues.values.push(value);
-					}
-				} else {
-					packedValues.set(value, {
-						count: 1,
-					});
-					if (packedValues.samplingPackedValues) {
-						let status = packedValues.samplingPackedValues.get(value);
-						if (status)
-							status.count++;
-						else
-							packedValues.samplingPackedValues.set(value, {
-								count: 1,
-							});
-					}
-				}
+			if (!this.useColors) {
+				return;
 			}
-			break
-		case 'object':
-			if (value) {
-				if (value instanceof Array) {
-					for (let i = 0, l = value.length; i < l; i++) {
-						findRepetitiveStrings(value[i], packedValues);
-					}
 
+			const c = 'color: ' + this.color;
+			args.splice(1, 0, c, 'color: inherit');
+
+			// The final "%c" is somewhat tricky, because there could be other
+			// arguments passed either before or after the %c, so we need to
+			// figure out the correct index to insert the CSS into
+			let index = 0;
+			let lastC = 0;
+			args[0].replace(/%[a-zA-Z%]/g, match => {
+				if (match === '%%') {
+					return;
+				}
+				index++;
+				if (match === '%c') {
+					// We only are interested in the *last* %c
+					// (the user may have provided their own)
+					lastC = index;
+				}
+			});
+
+			args.splice(lastC, 0, c);
+		}
+
+		/**
+		 * Invokes `console.debug()` when available.
+		 * No-op when `console.debug` is not a "function".
+		 * If `console.debug` is not available, falls back
+		 * to `console.log`.
+		 *
+		 * @api public
+		 */
+		exports.log = console.debug || console.log || (() => {});
+
+		/**
+		 * Save `namespaces`.
+		 *
+		 * @param {String} namespaces
+		 * @api private
+		 */
+		function save(namespaces) {
+			try {
+				if (namespaces) {
+					exports.storage.setItem('debug', namespaces);
 				} else {
-					let includeKeys = !packedValues.encoder.useRecords;
-					for (var key in value) {
-						if (value.hasOwnProperty(key)) {
-							if (includeKeys)
-								findRepetitiveStrings(key, packedValues);
-							findRepetitiveStrings(value[key], packedValues);
-						}
-					}
+					exports.storage.removeItem('debug');
 				}
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
 			}
-			break
-		case 'function': console.log(value);
-	}
-}
-const isLittleEndianMachine = new Uint8Array(new Uint16Array([1]).buffer)[0] == 1;
-extensionClasses = [ Date, Set, Error, RegExp, Tag, ArrayBuffer,
-	Uint8Array, Uint8ClampedArray, Uint16Array, Uint32Array,
-	typeof BigUint64Array == 'undefined' ? function() {} : BigUint64Array, Int8Array, Int16Array, Int32Array,
-	typeof BigInt64Array == 'undefined' ? function() {} : BigInt64Array,
-	Float32Array, Float64Array, SharedData ];
-
-//Object.getPrototypeOf(Uint8Array.prototype).constructor /*TypedArray*/
-extensions = [{ // Date
-	tag: 1,
-	encode(date, encode) {
-		let seconds = date.getTime() / 1000;
-		if ((this.useTimestamp32 || date.getMilliseconds() === 0) && seconds >= 0 && seconds < 0x100000000) {
-			// Timestamp 32
-			target[position++] = 0x1a;
-			targetView.setUint32(position, seconds);
-			position += 4;
-		} else {
-			// Timestamp float64
-			target[position++] = 0xfb;
-			targetView.setFloat64(position, seconds);
-			position += 8;
 		}
-	}
-}, { // Set
-	tag: 258, // https://github.com/input-output-hk/cbor-sets-spec/blob/master/CBOR_SETS.md
-	encode(set, encode) {
-		let array = Array.from(set);
-		encode(array);
-	}
-}, { // Error
-	tag: 27, // http://cbor.schmorp.de/generic-object
-	encode(error, encode) {
-		encode([ error.name, error.message ]);
-	}
-}, { // RegExp
-	tag: 27, // http://cbor.schmorp.de/generic-object
-	encode(regex, encode) {
-		encode([ 'RegExp', regex.source, regex.flags ]);
-	}
-}, { // Tag
-	getTag(tag) {
-		return tag.tag
-	},
-	encode(tag, encode) {
-		encode(tag.value);
-	}
-}, { // ArrayBuffer
-	encode(arrayBuffer, encode, makeRoom) {
-		writeBuffer(arrayBuffer, makeRoom);
-	}
-}, { // Uint8Array
-	getTag(typedArray) {
-		if (typedArray.constructor === Uint8Array) {
-			if (this.tagUint8Array || hasNodeBuffer && this.tagUint8Array !== false)
-				return 64;
-		} // else no tag
-	},
-	encode(typedArray, encode, makeRoom) {
-		writeBuffer(typedArray, makeRoom);
-	}
-},
-	typedArrayEncoder(68, 1),
-	typedArrayEncoder(69, 2),
-	typedArrayEncoder(70, 4),
-	typedArrayEncoder(71, 8),
-	typedArrayEncoder(72, 1),
-	typedArrayEncoder(77, 2),
-	typedArrayEncoder(78, 4),
-	typedArrayEncoder(79, 8),
-	typedArrayEncoder(85, 4),
-	typedArrayEncoder(86, 8),
-{
-	encode(sharedData, encode) { // write SharedData
-		let packedValues = sharedData.packedValues || [];
-		let sharedStructures = sharedData.structures || [];
-		if (packedValues.values.length > 0) {
-			target[position++] = 0xd8; // one-byte tag
-			target[position++] = 51; // tag 51 for packed shared structures https://www.potaroo.net/ietf/ids/draft-ietf-cbor-packed-03.txt
-			writeArrayHeader(4);
-			let valuesArray = packedValues.values;
-			encode(valuesArray);
-			writeArrayHeader(0); // prefixes
-			writeArrayHeader(0); // suffixes
-			packedObjectMap = Object.create(sharedPackedObjectMap || null);
-			for (let i = 0, l = valuesArray.length; i < l; i++) {
-				packedObjectMap[valuesArray[i]] = i;
+
+		/**
+		 * Load `namespaces`.
+		 *
+		 * @return {String} returns the previously persisted debug modes
+		 * @api private
+		 */
+		function load() {
+			let r;
+			try {
+				r = exports.storage.getItem('debug') || exports.storage.getItem('DEBUG') ;
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
 			}
+
+			// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+			if (!r && typeof process !== 'undefined' && 'env' in process) {
+				r = process.env.DEBUG;
+			}
+
+			return r;
 		}
-		if (sharedStructures) {
-			targetView.setUint32(position, 0xd9dffe00);
-			position += 3;
-			let definitions = sharedStructures.slice(0);
-			definitions.unshift(0xe000);
-			definitions.push(new Tag(sharedData.version, 0x53687264));
-			encode(definitions);
-		} else
-			encode(new Tag(sharedData.version, 0x53687264));
-		}
-	}];
-function typedArrayEncoder(tag, size) {
-	if (!isLittleEndianMachine && size > 1)
-		tag -= 4; // the big endian equivalents are 4 less
-	return {
-		tag: tag,
-		encode: function writeExtBuffer(typedArray, encode) {
-			let length = typedArray.byteLength;
-			let offset = typedArray.byteOffset || 0;
-			let buffer = typedArray.buffer || typedArray;
-			encode(hasNodeBuffer ? Buffer$1.from(buffer, offset, length) :
-				new Uint8Array(buffer, offset, length));
-		}
-	}
-}
-function writeBuffer(buffer, makeRoom) {
-	let length = buffer.byteLength;
-	if (length < 0x18) {
-		target[position++] = 0x40 + length;
-	} else if (length < 0x100) {
-		target[position++] = 0x58;
-		target[position++] = length;
-	} else if (length < 0x10000) {
-		target[position++] = 0x59;
-		target[position++] = length >> 8;
-		target[position++] = length & 0xff;
-	} else {
-		target[position++] = 0x5a;
-		targetView.setUint32(position, length);
-		position += 4;
-	}
-	if (position + length >= target.length) {
-		makeRoom(position + length);
-	}
-	// if it is already a typed array (has an ArrayBuffer), use that, but if it is an ArrayBuffer itself,
-	// must wrap it to set it.
-	target.set(buffer.buffer ? buffer : new Uint8Array(buffer), position);
-	position += length;
-}
 
-function insertIds(serialized, idsToInsert) {
-	// insert the ids that need to be referenced for structured clones
-	let nextId;
-	let distanceToMove = idsToInsert.length * 2;
-	let lastEnd = serialized.length - distanceToMove;
-	idsToInsert.sort((a, b) => a.offset > b.offset ? 1 : -1);
-	for (let id = 0; id < idsToInsert.length; id++) {
-		let referee = idsToInsert[id];
-		referee.id = id;
-		for (let position of referee.references) {
-			serialized[position++] = id >> 8;
-			serialized[position] = id & 0xff;
+		/**
+		 * Localstorage attempts to return the localstorage.
+		 *
+		 * This is necessary because safari throws
+		 * when a user disables cookies/localstorage
+		 * and you attempt to access it.
+		 *
+		 * @return {LocalStorage}
+		 * @api private
+		 */
+
+		function localstorage() {
+			try {
+				// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+				// The Browser also has localStorage in the global context.
+				return localStorage;
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
+			}
 		}
-	}
-	while (nextId = idsToInsert.pop()) {
-		let offset = nextId.offset;
-		serialized.copyWithin(offset + distanceToMove, offset, lastEnd);
-		distanceToMove -= 2;
-		let position = offset + distanceToMove;
-		serialized[position++] = 0xd8;
-		serialized[position++] = 28; // http://cbor.schmorp.de/value-sharing
-		lastEnd = offset;
-	}
-	return serialized
-}
-function writeBundles(start, encode) {
-	targetView.setUint32(bundledStrings.position + start, position - bundledStrings.position - start + 1); // the offset to bundle
-	let writeStrings = bundledStrings;
-	bundledStrings = null;
-	encode(writeStrings[0]);
-	encode(writeStrings[1]);
+
+		module.exports = requireCommon()(exports);
+
+		const {formatters} = module.exports;
+
+		/**
+		 * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+		 */
+
+		formatters.j = function (v) {
+			try {
+				return JSON.stringify(v);
+			} catch (error) {
+				return '[UnexpectedJSONParseError]: ' + error.message;
+			}
+		}; 
+	} (browser, browser.exports));
+	return browser.exports;
 }
-let defaultEncoder = new Encoder({ useRecords: false });
-defaultEncoder.encode;
-defaultEncoder.encodeAsIterable;
-defaultEncoder.encodeAsAsyncIterable;
-const REUSE_BUFFER_MODE = 512;
-const RESET_BUFFER_MODE = 1024;
-const THROW_ON_ITERABLE = 2048;
+
+var browserExports = requireBrowser();
+const debug = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
 
 var sha256$1 = {exports: {}};
 
@@ -6688,13 +6690,6 @@ debug("automerge-repo:collectionsync");
  */
 new FinalizationRegistry(cleanup => cleanup());
 
-/* c8 ignore start */
-/**
- * A promise that never settles
- */
-new Promise(() => { });
-/* c8 ignore end */
-
 const DEFAULT_HEARTBEAT_INTERVAL_MS = 15_000;
 const DEFAULT_PEER_TTL_MS = 3 * DEFAULT_HEARTBEAT_INTERVAL_MS;
 const PRESENCE_MESSAGE_MARKER = "__presence";