@kokimoki/app 1.4.7 → 1.6.0

package/dist/kokimoki.min.js

@@ -1,3 +1,6 @@
+import require$$1 from 'path';
+import require$$2 from 'fs';
+
 const defaultFieldOptions = {};
 class Field {
     options;
@@ -151,6 +154,8 @@ class FormArray extends Field {
 class Form extends FormGroup {
 }
 
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
@@ -634,7 +639,7 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
 var eventsExports = events.exports;
 var EventEmitter$1 = /*@__PURE__*/getDefaultExportFromCjs(eventsExports);
 
-const KOKIMOKI_APP_VERSION = "1.4.7";
+const KOKIMOKI_APP_VERSION = "1.6.0";
 
 /**
  * Utility module to work with key-value stores.
@@ -862,8 +867,8 @@ class Observable {
  * @module math
  */
 
-const floor = Math.floor;
-const abs = Math.abs;
+const floor$2 = Math.floor;
+const abs$2 = Math.abs;
 
 /**
  * @function
@@ -871,7 +876,7 @@ const abs = Math.abs;
  * @param {number} b
  * @return {number} The smaller element of a and b
  */
-const min = (a, b) => a < b ? a : b;
+const min$2 = (a, b) => a < b ? a : b;
 
 /**
  * @function
@@ -879,7 +884,7 @@ const min = (a, b) => a < b ? a : b;
  * @param {number} b
  * @return {number} The bigger element of a and b
  */
-const max = (a, b) => a > b ? a : b;
+const max$3 = (a, b) => a > b ? a : b;
 
 /**
  * @param {number} n
@@ -1045,7 +1050,7 @@ const keys$1 = Object.keys;
  * @param {{[k:string]:V}} obj
  * @param {function(V,string):any} f
  */
-const forEach = (obj, f) => {
+const forEach$2 = (obj, f) => {
   for (const key in obj) {
     f(obj[key], key);
   }
@@ -1278,7 +1283,7 @@ const BITS31 = 0x7FFFFFFF;
 const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
 
 /* c8 ignore next */
-const isInteger = Number.isInteger || (num => typeof num === 'number' && isFinite(num) && floor(num) === num);
+const isInteger = Number.isInteger || (num => typeof num === 'number' && isFinite(num) && floor$2(num) === num);
 
 /**
  * Error helpers.
@@ -1702,7 +1707,7 @@ class IntDiffOptRleDecoder extends Decoder {
       const diff = readVarInt(this);
       // if the first bit is set, we read more data
       const hasCount = diff & 1;
-      this.diff = floor(diff / 2); // shift >> 1
+      this.diff = floor$2(diff / 2); // shift >> 1
       this.count = 1;
       if (hasCount) {
         this.count = readVarUint(this) + 2;
@@ -1865,7 +1870,7 @@ const verifyLen = (encoder, len) => {
   const bufferLen = encoder.cbuf.length;
   if (bufferLen - encoder.cpos < len) {
     encoder.bufs.push(createUint8ArrayViewFromArrayBuffer(encoder.cbuf.buffer, 0, encoder.cpos));
-    encoder.cbuf = new Uint8Array(max(bufferLen, len) * 2);
+    encoder.cbuf = new Uint8Array(max$3(bufferLen, len) * 2);
     encoder.cpos = 0;
   }
 };
@@ -1906,7 +1911,7 @@ const writeUint8 = write;
 const writeVarUint = (encoder, num) => {
   while (num > BITS7) {
     write(encoder, BIT8 | (BITS7 & num));
-    num = floor(num / 128); // shift >>> 7
+    num = floor$2(num / 128); // shift >>> 7
   }
   write(encoder, BITS7 & num);
 };
@@ -1927,12 +1932,12 @@ const writeVarInt = (encoder, num) => {
   }
   //             |- whether to continue reading         |- whether is negative     |- number
   write(encoder, (num > BITS6 ? BIT8 : 0) | (isNegative ? BIT7 : 0) | (BITS6 & num));
-  num = floor(num / 64); // shift >>> 6
+  num = floor$2(num / 64); // shift >>> 6
   // We don't need to consider the case of num === 0 so we can use a different
   // pattern here than above.
   while (num > 0) {
     write(encoder, (num > BITS7 ? BIT8 : 0) | (BITS7 & num));
-    num = floor(num / 128); // shift >>> 7
+    num = floor$2(num / 128); // shift >>> 7
   }
 };
 
@@ -1999,7 +2004,7 @@ const writeVarString = (utf8TextEncoder && /** @type {any} */ (utf8TextEncoder).
 const writeUint8Array = (encoder, uint8Array) => {
   const bufferLen = encoder.cbuf.length;
   const cpos = encoder.cpos;
-  const leftCopyLen = min(bufferLen - cpos, uint8Array.length);
+  const leftCopyLen = min$2(bufferLen - cpos, uint8Array.length);
   const rightCopyLen = uint8Array.length - leftCopyLen;
   encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos);
   encoder.cpos += leftCopyLen;
@@ -2008,7 +2013,7 @@ const writeUint8Array = (encoder, uint8Array) => {
     // Append new buffer
     encoder.bufs.push(encoder.cbuf);
     // must have at least size of remaining buffer
-    encoder.cbuf = new Uint8Array(max(bufferLen * 2, rightCopyLen));
+    encoder.cbuf = new Uint8Array(max$3(bufferLen * 2, rightCopyLen));
     // copy array
     encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
     encoder.cpos = rightCopyLen;
@@ -2126,7 +2131,7 @@ const writeAny = (encoder, data) => {
       writeVarString(encoder, data);
       break
     case 'number':
-      if (isInteger(data) && abs(data) <= BITS31) {
+      if (isInteger(data) && abs$2(data) <= BITS31) {
         // TYPE 125: INTEGER
         write(encoder, 125);
         writeVarInt(encoder, data);
@@ -2717,7 +2722,7 @@ const findIndexDS = (dis, clock) => {
   let left = 0;
   let right = dis.length - 1;
   while (left <= right) {
-    const midindex = floor((left + right) / 2);
+    const midindex = floor$2((left + right) / 2);
     const mid = dis[midindex];
     const midclock = mid.clock;
     if (midclock <= clock) {
@@ -2763,7 +2768,7 @@ const sortAndMergeDeleteSet = ds => {
       const left = dels[j - 1];
       const right = dels[i];
       if (left.clock + left.len >= right.clock) {
-        left.len = max(left.len, right.clock + right.len - left.clock);
+        left.len = max$3(left.len, right.clock + right.len - left.clock);
       } else {
         if (j < i) {
           dels[j] = right;
@@ -3889,7 +3894,7 @@ class UpdateEncoderV2 extends DSEncoderV2 {
  */
 const writeStructs = (encoder, structs, client, clock) => {
   // write first id
-  clock = max(clock, structs[0].id.clock); // make sure the first id exists
+  clock = max$3(clock, structs[0].id.clock); // make sure the first id exists
   const startNewStructs = findIndexSS(structs, clock);
   // write # encoded structs
   writeVarUint(encoder.restEncoder, structs.length - startNewStructs);
@@ -4669,7 +4674,7 @@ const findIndexSS = (structs, clock) => {
   // @todo does it even make sense to pivot the search?
   // If a good split misses, it might actually increase the time to find the correct item.
   // Currently, the only advantage is that search with pivoting might find the item on the first try.
-  let midindex = floor((clock / (midclock + mid.length - 1)) * right); // pivoting the search
+  let midindex = floor$2((clock / (midclock + mid.length - 1)) * right); // pivoting the search
   while (left <= right) {
     mid = structs[midindex];
     midclock = mid.id.clock;
@@ -4681,7 +4686,7 @@ const findIndexSS = (structs, clock) => {
     } else {
       right = midindex - 1;
     }
-    midindex = floor((left + right) / 2);
+    midindex = floor$2((left + right) / 2);
   }
   // Always check state before looking for a struct in StructStore
   // Therefore the case of not finding a struct is unexpected
@@ -5009,7 +5014,7 @@ const tryMergeDeleteSet = (ds, store) => {
     for (let di = deleteItems.length - 1; di >= 0; di--) {
       const deleteItem = deleteItems[di];
       // start with merging the item next to the last deleted item
-      const mostRightIndexToCheck = min(structs.length - 1, 1 + findIndexSS(structs, deleteItem.clock + deleteItem.len - 1));
+      const mostRightIndexToCheck = min$2(structs.length - 1, 1 + findIndexSS(structs, deleteItem.clock + deleteItem.len - 1));
       for (
         let si = mostRightIndexToCheck, struct = structs[si];
         si > 0 && struct.id.clock >= deleteItem.clock;
@@ -5096,7 +5101,7 @@ const cleanupTransactions = (transactionCleanups, i) => {
         if (beforeClock !== clock) {
           const structs = /** @type {Array<GC|Item>} */ (store.clients.get(client));
           // we iterate from right to left so we can safely remove entries
-          const firstChangePos = max(findIndexSS(structs, beforeClock), 1);
+          const firstChangePos = max$3(findIndexSS(structs, beforeClock), 1);
           for (let i = structs.length - 1; i >= firstChangePos;) {
             i -= 1 + tryToMergeWithLefts(structs, i);
           }
@@ -5502,7 +5507,7 @@ const diffUpdateV2 = (update, sv, YDecoder = UpdateDecoderV2, YEncoder = UpdateE
       continue
     }
     if (curr.id.clock + curr.length > svClock) {
-      writeStructToLazyStructWriter(lazyStructWriter, curr, max(svClock - curr.id.clock, 0));
+      writeStructToLazyStructWriter(lazyStructWriter, curr, max$3(svClock - curr.id.clock, 0));
       reader.next();
       while (reader.curr && reader.curr.id.client === currClient) {
         writeStructToLazyStructWriter(lazyStructWriter, reader.curr, 0);
@@ -5959,7 +5964,7 @@ const findMarker = (yarray, index) => {
   if (yarray._start === null || index === 0 || yarray._searchMarker === null) {
     return null
   }
-  const marker = yarray._searchMarker.length === 0 ? null : yarray._searchMarker.reduce((a, b) => abs(index - a.index) < abs(index - b.index) ? a : b);
+  const marker = yarray._searchMarker.length === 0 ? null : yarray._searchMarker.reduce((a, b) => abs$2(index - a.index) < abs$2(index - b.index) ? a : b);
   let p = yarray._start;
   let pindex = 0;
   if (marker !== null) {
@@ -6018,7 +6023,7 @@ const findMarker = (yarray, index) => {
   //   window.lengthes.push(marker.index - pindex)
   //   console.log('distance', marker.index - pindex, 'len', p && p.parent.length)
   // }
-  if (marker !== null && abs(marker.index - pindex) < /** @type {YText|YArray<any>} */ (p.parent).length / maxSearchMarker) {
+  if (marker !== null && abs$2(marker.index - pindex) < /** @type {YText|YArray<any>} */ (p.parent).length / maxSearchMarker) {
     // adjust existing marker
     overwriteMarker(marker, p, pindex);
     return marker
@@ -6065,7 +6070,7 @@ const updateMarkerChanges = (searchMarker, index, len) => {
       p.marker = true;
     }
     if (index < m.index || (len > 0 && index === m.index)) { // a simple index <= m.index check would actually suffice
-      m.index = max(index, m.index + len);
+      m.index = max$3(index, m.index + len);
     }
   }
 };
@@ -8973,7 +8978,7 @@ class YXmlElement extends YXmlFragment {
      */
     const el = new YXmlElement(this.nodeName);
     const attrs = this.getAttributes();
-    forEach(attrs, (value, key) => {
+    forEach$2(attrs, (value, key) => {
       if (typeof value === 'string') {
         el.setAttribute(key, value);
       }
@@ -12223,6 +12228,2572 @@ class KokimokiReqRes {
     }
 }
 
+var farmhash_modern = {exports: {}};
+
+var util = {};
+
+var types = {};
+
+/** @type {import('./shams')} */
+/* eslint complexity: [2, 18], max-statements: [2, 33] */
+var shams$1 = function hasSymbols() {
+	if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
+	if (typeof Symbol.iterator === 'symbol') { return true; }
+
+	/** @type {{ [k in symbol]?: unknown }} */
+	var obj = {};
+	var sym = Symbol('test');
+	var symObj = Object(sym);
+	if (typeof sym === 'string') { return false; }
+
+	if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }
+	if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }
+
+	// temp disabled per https://github.com/ljharb/object.assign/issues/17
+	// if (sym instanceof Symbol) { return false; }
+	// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
+	// if (!(symObj instanceof Symbol)) { return false; }
+
+	// if (typeof Symbol.prototype.toString !== 'function') { return false; }
+	// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }
+
+	var symVal = 42;
+	obj[sym] = symVal;
+	for (var _ in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
+	if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }
+
+	if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }
+
+	var syms = Object.getOwnPropertySymbols(obj);
+	if (syms.length !== 1 || syms[0] !== sym) { return false; }
+
+	if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }
+
+	if (typeof Object.getOwnPropertyDescriptor === 'function') {
+		// eslint-disable-next-line no-extra-parens
+		var descriptor = /** @type {PropertyDescriptor} */ (Object.getOwnPropertyDescriptor(obj, sym));
+		if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }
+	}
+
+	return true;
+};
+
+var hasSymbols$2 = shams$1;
+
+var shams = function hasToStringTagShams() {
+	return hasSymbols$2() && !!Symbol.toStringTag;
+};
+
+/** @type {import('.')} */
+var esObjectAtoms = Object;
+
+/** @type {import('.')} */
+var esErrors = Error;
+
+/** @type {import('./eval')} */
+var _eval = EvalError;
+
+/** @type {import('./range')} */
+var range = RangeError;
+
+/** @type {import('./ref')} */
+var ref = ReferenceError;
+
+/** @type {import('./syntax')} */
+var syntax = SyntaxError;
+
+/** @type {import('./type')} */
+var type = TypeError;
+
+/** @type {import('./uri')} */
+var uri = URIError;
+
+/** @type {import('./abs')} */
+var abs$1 = Math.abs;
+
+/** @type {import('./floor')} */
+var floor$1 = Math.floor;
+
+/** @type {import('./max')} */
+var max$2 = Math.max;
+
+/** @type {import('./min')} */
+var min$1 = Math.min;
+
+/** @type {import('./pow')} */
+var pow$1 = Math.pow;
+
+/** @type {import('./gOPD')} */
+var gOPD$1 = Object.getOwnPropertyDescriptor;
+
+/** @type {import('.')} */
+var $gOPD$1 = gOPD$1;
+
+if ($gOPD$1) {
+	try {
+		$gOPD$1([], 'length');
+	} catch (e) {
+		// IE 8 has a broken gOPD
+		$gOPD$1 = null;
+	}
+}
+
+var gopd = $gOPD$1;
+
+/** @type {import('.')} */
+var $defineProperty$1 = Object.defineProperty || false;
+if ($defineProperty$1) {
+	try {
+		$defineProperty$1({}, 'a', { value: 1 });
+	} catch (e) {
+		// IE 8 has a broken defineProperty
+		$defineProperty$1 = false;
+	}
+}
+
+var esDefineProperty = $defineProperty$1;
+
+var hasSymbols$1;
+var hasRequiredHasSymbols;
+
+function requireHasSymbols () {
+	if (hasRequiredHasSymbols) return hasSymbols$1;
+	hasRequiredHasSymbols = 1;
+
+	var origSymbol = typeof Symbol !== 'undefined' && Symbol;
+	var hasSymbolSham = shams$1;
+
+	/** @type {import('.')} */
+	hasSymbols$1 = function hasNativeSymbols() {
+		if (typeof origSymbol !== 'function') { return false; }
+		if (typeof Symbol !== 'function') { return false; }
+		if (typeof origSymbol('foo') !== 'symbol') { return false; }
+		if (typeof Symbol('bar') !== 'symbol') { return false; }
+
+		return hasSymbolSham();
+	};
+	return hasSymbols$1;
+}
+
+/* eslint no-invalid-this: 1 */
+
+var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
+var toStr$3 = Object.prototype.toString;
+var max$1 = Math.max;
+var funcType = '[object Function]';
+
+var concatty = function concatty(a, b) {
+    var arr = [];
+
+    for (var i = 0; i < a.length; i += 1) {
+        arr[i] = a[i];
+    }
+    for (var j = 0; j < b.length; j += 1) {
+        arr[j + a.length] = b[j];
+    }
+
+    return arr;
+};
+
+var slicy = function slicy(arrLike, offset) {
+    var arr = [];
+    for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) {
+        arr[j] = arrLike[i];
+    }
+    return arr;
+};
+
+var joiny = function (arr, joiner) {
+    var str = '';
+    for (var i = 0; i < arr.length; i += 1) {
+        str += arr[i];
+        if (i + 1 < arr.length) {
+            str += joiner;
+        }
+    }
+    return str;
+};
+
+var implementation$1 = function bind(that) {
+    var target = this;
+    if (typeof target !== 'function' || toStr$3.apply(target) !== funcType) {
+        throw new TypeError(ERROR_MESSAGE + target);
+    }
+    var args = slicy(arguments, 1);
+
+    var bound;
+    var binder = function () {
+        if (this instanceof bound) {
+            var result = target.apply(
+                this,
+                concatty(args, arguments)
+            );
+            if (Object(result) === result) {
+                return result;
+            }
+            return this;
+        }
+        return target.apply(
+            that,
+            concatty(args, arguments)
+        );
+
+    };
+
+    var boundLength = max$1(0, target.length - args.length);
+    var boundArgs = [];
+    for (var i = 0; i < boundLength; i++) {
+        boundArgs[i] = '$' + i;
+    }
+
+    bound = Function('binder', 'return function (' + joiny(boundArgs, ',') + '){ return binder.apply(this,arguments); }')(binder);
+
+    if (target.prototype) {
+        var Empty = function Empty() {};
+        Empty.prototype = target.prototype;
+        bound.prototype = new Empty();
+        Empty.prototype = null;
+    }
+
+    return bound;
+};
+
+var implementation = implementation$1;
+
+var functionBind = Function.prototype.bind || implementation;
+
+var functionCall;
+var hasRequiredFunctionCall;
+
+function requireFunctionCall () {
+	if (hasRequiredFunctionCall) return functionCall;
+	hasRequiredFunctionCall = 1;
+
+	/** @type {import('./functionCall')} */
+	functionCall = Function.prototype.call;
+	return functionCall;
+}
+
+var functionApply;
+var hasRequiredFunctionApply;
+
+function requireFunctionApply () {
+	if (hasRequiredFunctionApply) return functionApply;
+	hasRequiredFunctionApply = 1;
+
+	/** @type {import('./functionApply')} */
+	functionApply = Function.prototype.apply;
+	return functionApply;
+}
+
+var reflectApply$1;
+var hasRequiredReflectApply;
+
+function requireReflectApply () {
+	if (hasRequiredReflectApply) return reflectApply$1;
+	hasRequiredReflectApply = 1;
+
+	/** @type {import('./reflectApply')} */
+	reflectApply$1 = typeof Reflect !== 'undefined' && Reflect && Reflect.apply;
+	return reflectApply$1;
+}
+
+var actualApply;
+var hasRequiredActualApply;
+
+function requireActualApply () {
+	if (hasRequiredActualApply) return actualApply;
+	hasRequiredActualApply = 1;
+
+	var bind = functionBind;
+
+	var $apply = requireFunctionApply();
+	var $call = requireFunctionCall();
+	var $reflectApply = requireReflectApply();
+
+	/** @type {import('./actualApply')} */
+	actualApply = $reflectApply || bind.call($call, $apply);
+	return actualApply;
+}
+
+var callBindApplyHelpers;
+var hasRequiredCallBindApplyHelpers;
+
+function requireCallBindApplyHelpers () {
+	if (hasRequiredCallBindApplyHelpers) return callBindApplyHelpers;
+	hasRequiredCallBindApplyHelpers = 1;
+
+	var bind = functionBind;
+	var $TypeError = type;
+
+	var $call = requireFunctionCall();
+	var $actualApply = requireActualApply();
+
+	/** @type {import('.')} */
+	callBindApplyHelpers = function callBindBasic(args) {
+		if (args.length < 1 || typeof args[0] !== 'function') {
+			throw new $TypeError('a function is required');
+		}
+		return $actualApply(bind, $call, args);
+	};
+	return callBindApplyHelpers;
+}
+
+var get;
+var hasRequiredGet;
+
+function requireGet () {
+	if (hasRequiredGet) return get;
+	hasRequiredGet = 1;
+
+	var callBind = requireCallBindApplyHelpers();
+	var gOPD = gopd;
+
+	var hasProtoAccessor;
+	try {
+		// eslint-disable-next-line no-extra-parens, no-proto
+		hasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */ ([]).__proto__ === Array.prototype;
+	} catch (e) {
+		if (!e || typeof e !== 'object' || !('code' in e) || e.code !== 'ERR_PROTO_ACCESS') {
+			throw e;
+		}
+	}
+
+	// eslint-disable-next-line no-extra-parens
+	var desc = !!hasProtoAccessor && gOPD && gOPD(Object.prototype, /** @type {keyof typeof Object.prototype} */ ('__proto__'));
+
+	var $Object = Object;
+	var $getPrototypeOf = $Object.getPrototypeOf;
+
+	/** @type {import('./get')} */
+	get = desc && typeof desc.get === 'function'
+		? callBind([desc.get])
+		: typeof $getPrototypeOf === 'function'
+			? /** @type {import('./get')} */ function getDunder(value) {
+				// eslint-disable-next-line eqeqeq
+				return $getPrototypeOf(value == null ? value : $Object(value));
+			}
+			: false;
+	return get;
+}
+
+var hasown;
+var hasRequiredHasown;
+
+function requireHasown () {
+	if (hasRequiredHasown) return hasown;
+	hasRequiredHasown = 1;
+
+	var call = Function.prototype.call;
+	var $hasOwn = Object.prototype.hasOwnProperty;
+	var bind = functionBind;
+
+	/** @type {import('.')} */
+	hasown = bind.call(call, $hasOwn);
+	return hasown;
+}
+
+var undefined$1;
+
+var $Object = esObjectAtoms;
+
+var $Error = esErrors;
+var $EvalError = _eval;
+var $RangeError = range;
+var $ReferenceError = ref;
+var $SyntaxError = syntax;
+var $TypeError = type;
+var $URIError = uri;
+
+var abs = abs$1;
+var floor = floor$1;
+var max = max$2;
+var min = min$1;
+var pow = pow$1;
+
+var $Function = Function;
+
+// eslint-disable-next-line consistent-return
+var getEvalledConstructor = function (expressionSyntax) {
+	try {
+		return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')();
+	} catch (e) {}
+};
+
+var $gOPD = gopd;
+var $defineProperty = esDefineProperty;
+
+var throwTypeError = function () {
+	throw new $TypeError();
+};
+var ThrowTypeError = $gOPD
+	? (function () {
+		try {
+			// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties
+			arguments.callee; // IE 8 does not throw here
+			return throwTypeError;
+		} catch (calleeThrows) {
+			try {
+				// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')
+				return $gOPD(arguments, 'callee').get;
+			} catch (gOPDthrows) {
+				return throwTypeError;
+			}
+		}
+	}())
+	: throwTypeError;
+
+var hasSymbols = requireHasSymbols()();
+var getDunderProto = requireGet();
+
+var getProto$1 = (typeof Reflect === 'function' && Reflect.getPrototypeOf)
+	|| $Object.getPrototypeOf
+	|| getDunderProto;
+
+var $apply = requireFunctionApply();
+var $call = requireFunctionCall();
+
+var needsEval = {};
+
+var TypedArray = typeof Uint8Array === 'undefined' || !getProto$1 ? undefined$1 : getProto$1(Uint8Array);
+
+var INTRINSICS = {
+	__proto__: null,
+	'%AggregateError%': typeof AggregateError === 'undefined' ? undefined$1 : AggregateError,
+	'%Array%': Array,
+	'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined$1 : ArrayBuffer,
+	'%ArrayIteratorPrototype%': hasSymbols && getProto$1 ? getProto$1([][Symbol.iterator]()) : undefined$1,
+	'%AsyncFromSyncIteratorPrototype%': undefined$1,
+	'%AsyncFunction%': needsEval,
+	'%AsyncGenerator%': needsEval,
+	'%AsyncGeneratorFunction%': needsEval,
+	'%AsyncIteratorPrototype%': needsEval,
+	'%Atomics%': typeof Atomics === 'undefined' ? undefined$1 : Atomics,
+	'%BigInt%': typeof BigInt === 'undefined' ? undefined$1 : BigInt,
+	'%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined$1 : BigInt64Array,
+	'%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined$1 : BigUint64Array,
+	'%Boolean%': Boolean,
+	'%DataView%': typeof DataView === 'undefined' ? undefined$1 : DataView,
+	'%Date%': Date,
+	'%decodeURI%': decodeURI,
+	'%decodeURIComponent%': decodeURIComponent,
+	'%encodeURI%': encodeURI,
+	'%encodeURIComponent%': encodeURIComponent,
+	'%Error%': $Error,
+	'%eval%': eval, // eslint-disable-line no-eval
+	'%EvalError%': $EvalError,
+	'%Float32Array%': typeof Float32Array === 'undefined' ? undefined$1 : Float32Array,
+	'%Float64Array%': typeof Float64Array === 'undefined' ? undefined$1 : Float64Array,
+	'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined$1 : FinalizationRegistry,
+	'%Function%': $Function,
+	'%GeneratorFunction%': needsEval,
+	'%Int8Array%': typeof Int8Array === 'undefined' ? undefined$1 : Int8Array,
+	'%Int16Array%': typeof Int16Array === 'undefined' ? undefined$1 : Int16Array,
+	'%Int32Array%': typeof Int32Array === 'undefined' ? undefined$1 : Int32Array,
+	'%isFinite%': isFinite,
+	'%isNaN%': isNaN,
+	'%IteratorPrototype%': hasSymbols && getProto$1 ? getProto$1(getProto$1([][Symbol.iterator]())) : undefined$1,
+	'%JSON%': typeof JSON === 'object' ? JSON : undefined$1,
+	'%Map%': typeof Map === 'undefined' ? undefined$1 : Map,
+	'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols || !getProto$1 ? undefined$1 : getProto$1(new Map()[Symbol.iterator]()),
+	'%Math%': Math,
+	'%Number%': Number,
+	'%Object%': $Object,
+	'%Object.getOwnPropertyDescriptor%': $gOPD,
+	'%parseFloat%': parseFloat,
+	'%parseInt%': parseInt,
+	'%Promise%': typeof Promise === 'undefined' ? undefined$1 : Promise,
+	'%Proxy%': typeof Proxy === 'undefined' ? undefined$1 : Proxy,
+	'%RangeError%': $RangeError,
+	'%ReferenceError%': $ReferenceError,
+	'%Reflect%': typeof Reflect === 'undefined' ? undefined$1 : Reflect,
+	'%RegExp%': RegExp,
+	'%Set%': typeof Set === 'undefined' ? undefined$1 : Set,
+	'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols || !getProto$1 ? undefined$1 : getProto$1(new Set()[Symbol.iterator]()),
+	'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined$1 : SharedArrayBuffer,
+	'%String%': String,
+	'%StringIteratorPrototype%': hasSymbols && getProto$1 ? getProto$1(''[Symbol.iterator]()) : undefined$1,
+	'%Symbol%': hasSymbols ? Symbol : undefined$1,
+	'%SyntaxError%': $SyntaxError,
+	'%ThrowTypeError%': ThrowTypeError,
+	'%TypedArray%': TypedArray,
+	'%TypeError%': $TypeError,
+	'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined$1 : Uint8Array,
+	'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined$1 : Uint8ClampedArray,
+	'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined$1 : Uint16Array,
+	'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined$1 : Uint32Array,
+	'%URIError%': $URIError,
+	'%WeakMap%': typeof WeakMap === 'undefined' ? undefined$1 : WeakMap,
+	'%WeakRef%': typeof WeakRef === 'undefined' ? undefined$1 : WeakRef,
+	'%WeakSet%': typeof WeakSet === 'undefined' ? undefined$1 : WeakSet,
+
+	'%Function.prototype.call%': $call,
+	'%Function.prototype.apply%': $apply,
+	'%Object.defineProperty%': $defineProperty,
+	'%Math.abs%': abs,
+	'%Math.floor%': floor,
+	'%Math.max%': max,
+	'%Math.min%': min,
+	'%Math.pow%': pow
+};
+
+if (getProto$1) {
+	try {
+		null.error; // eslint-disable-line no-unused-expressions
+	} catch (e) {
+		// https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229
+		var errorProto = getProto$1(getProto$1(e));
+		INTRINSICS['%Error.prototype%'] = errorProto;
+	}
+}
+
+var doEval = function doEval(name) {
+	var value;
+	if (name === '%AsyncFunction%') {
+		value = getEvalledConstructor('async function () {}');
+	} else if (name === '%GeneratorFunction%') {
+		value = getEvalledConstructor('function* () {}');
+	} else if (name === '%AsyncGeneratorFunction%') {
+		value = getEvalledConstructor('async function* () {}');
+	} else if (name === '%AsyncGenerator%') {
+		var fn = doEval('%AsyncGeneratorFunction%');
+		if (fn) {
+			value = fn.prototype;
+		}
+	} else if (name === '%AsyncIteratorPrototype%') {
+		var gen = doEval('%AsyncGenerator%');
+		if (gen && getProto$1) {
+			value = getProto$1(gen.prototype);
+		}
+	}
+
+	INTRINSICS[name] = value;
+
+	return value;
+};
+
+var LEGACY_ALIASES = {
+	__proto__: null,
+	'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],
+	'%ArrayPrototype%': ['Array', 'prototype'],
+	'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],
+	'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],
+	'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],
+	'%ArrayProto_values%': ['Array', 'prototype', 'values'],
+	'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],
+	'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],
+	'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],
+	'%BooleanPrototype%': ['Boolean', 'prototype'],
+	'%DataViewPrototype%': ['DataView', 'prototype'],
+	'%DatePrototype%': ['Date', 'prototype'],
+	'%ErrorPrototype%': ['Error', 'prototype'],
+	'%EvalErrorPrototype%': ['EvalError', 'prototype'],
+	'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],
+	'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],
+	'%FunctionPrototype%': ['Function', 'prototype'],
+	'%Generator%': ['GeneratorFunction', 'prototype'],
+	'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],
+	'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],
+	'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],
+	'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],
+	'%JSONParse%': ['JSON', 'parse'],
+	'%JSONStringify%': ['JSON', 'stringify'],
+	'%MapPrototype%': ['Map', 'prototype'],
+	'%NumberPrototype%': ['Number', 'prototype'],
+	'%ObjectPrototype%': ['Object', 'prototype'],
+	'%ObjProto_toString%': ['Object', 'prototype', 'toString'],
+	'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],
+	'%PromisePrototype%': ['Promise', 'prototype'],
+	'%PromiseProto_then%': ['Promise', 'prototype', 'then'],
+	'%Promise_all%': ['Promise', 'all'],
+	'%Promise_reject%': ['Promise', 'reject'],
+	'%Promise_resolve%': ['Promise', 'resolve'],
+	'%RangeErrorPrototype%': ['RangeError', 'prototype'],
+	'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],
+	'%RegExpPrototype%': ['RegExp', 'prototype'],
+	'%SetPrototype%': ['Set', 'prototype'],
+	'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],
+	'%StringPrototype%': ['String', 'prototype'],
+	'%SymbolPrototype%': ['Symbol', 'prototype'],
+	'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],
+	'%TypedArrayPrototype%': ['TypedArray', 'prototype'],
+	'%TypeErrorPrototype%': ['TypeError', 'prototype'],
+	'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],
+	'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],
+	'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],
+	'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],
+	'%URIErrorPrototype%': ['URIError', 'prototype'],
+	'%WeakMapPrototype%': ['WeakMap', 'prototype'],
+	'%WeakSetPrototype%': ['WeakSet', 'prototype']
+};
+
+var bind = functionBind;
+var hasOwn = requireHasown();
+var $concat = bind.call($call, Array.prototype.concat);
+var $spliceApply = bind.call($apply, Array.prototype.splice);
+var $replace = bind.call($call, String.prototype.replace);
+var $strSlice = bind.call($call, String.prototype.slice);
+var $exec = bind.call($call, RegExp.prototype.exec);
+
+/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
+var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
+var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */
+var stringToPath = function stringToPath(string) {
+	var first = $strSlice(string, 0, 1);
+	var last = $strSlice(string, -1);
+	if (first === '%' && last !== '%') {
+		throw new $SyntaxError('invalid intrinsic syntax, expected closing `%`');
+	} else if (last === '%' && first !== '%') {
+		throw new $SyntaxError('invalid intrinsic syntax, expected opening `%`');
+	}
+	var result = [];
+	$replace(string, rePropName, function (match, number, quote, subString) {
+		result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;
+	});
+	return result;
+};
+/* end adaptation */
+
+var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
+	var intrinsicName = name;
+	var alias;
+	if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
+		alias = LEGACY_ALIASES[intrinsicName];
+		intrinsicName = '%' + alias[0] + '%';
+	}
+
+	if (hasOwn(INTRINSICS, intrinsicName)) {
+		var value = INTRINSICS[intrinsicName];
+		if (value === needsEval) {
+			value = doEval(intrinsicName);
+		}
+		if (typeof value === 'undefined' && !allowMissing) {
+			throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
+		}
+
+		return {
+			alias: alias,
+			name: intrinsicName,
+			value: value
+		};
+	}
+
+	throw new $SyntaxError('intrinsic ' + name + ' does not exist!');
+};
+
+var getIntrinsic = function GetIntrinsic(name, allowMissing) {
+	if (typeof name !== 'string' || name.length === 0) {
+		throw new $TypeError('intrinsic name must be a non-empty string');
+	}
+	if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
+		throw new $TypeError('"allowMissing" argument must be a boolean');
+	}
+
+	if ($exec(/^%?[^%]*%?$/, name) === null) {
+		throw new $SyntaxError('`%` may not be present anywhere but at the beginning and end of the intrinsic name');
+	}
+	var parts = stringToPath(name);
+	var intrinsicBaseName = parts.length > 0 ? parts[0] : '';
+
+	var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);
+	var intrinsicRealName = intrinsic.name;
+	var value = intrinsic.value;
+	var skipFurtherCaching = false;
+
+	var alias = intrinsic.alias;
+	if (alias) {
+		intrinsicBaseName = alias[0];
+		$spliceApply(parts, $concat([0, 1], alias));
+	}
+
+	for (var i = 1, isOwn = true; i < parts.length; i += 1) {
+		var part = parts[i];
+		var first = $strSlice(part, 0, 1);
+		var last = $strSlice(part, -1);
+		if (
+			(
+				(first === '"' || first === "'" || first === '`')
+				|| (last === '"' || last === "'" || last === '`')
+			)
+			&& first !== last
+		) {
+			throw new $SyntaxError('property names with quotes must have matching quotes');
+		}
+		if (part === 'constructor' || !isOwn) {
+			skipFurtherCaching = true;
+		}
+
+		intrinsicBaseName += '.' + part;
+		intrinsicRealName = '%' + intrinsicBaseName + '%';
+
+		if (hasOwn(INTRINSICS, intrinsicRealName)) {
+			value = INTRINSICS[intrinsicRealName];
+		} else if (value != null) {
+			if (!(part in value)) {
+				if (!allowMissing) {
+					throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');
+				}
+				return void undefined$1;
+			}
+			if ($gOPD && (i + 1) >= parts.length) {
+				var desc = $gOPD(value, part);
+				isOwn = !!desc;
+
+				// By convention, when a data property is converted to an accessor
+				// property to emulate a data property that does not suffer from
+				// the override mistake, that accessor's getter is marked with
+				// an `originalValue` property. Here, when we detect this, we
+				// uphold the illusion by pretending to see that original data
+				// property, i.e., returning the value rather than the getter
+				// itself.
+				if (isOwn && 'get' in desc && !('originalValue' in desc.get)) {
+					value = desc.get;
+				} else {
+					value = value[part];
+				}
+			} else {
+				isOwn = hasOwn(value, part);
+				value = value[part];
+			}
+
+			if (isOwn && !skipFurtherCaching) {
+				INTRINSICS[intrinsicRealName] = value;
+			}
+		}
+	}
+	return value;
+};
+
+var callBind$2 = {exports: {}};
+
+(function (module) {
+
+	var bind = functionBind;
+	var GetIntrinsic = getIntrinsic;
+
+	var $apply = GetIntrinsic('%Function.prototype.apply%');
+	var $call = GetIntrinsic('%Function.prototype.call%');
+	var $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call, $apply);
+
+	var $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);
+	var $defineProperty = GetIntrinsic('%Object.defineProperty%', true);
+	var $max = GetIntrinsic('%Math.max%');
+
+	if ($defineProperty) {
+		try {
+			$defineProperty({}, 'a', { value: 1 });
+		} catch (e) {
+			// IE 8 has a broken defineProperty
+			$defineProperty = null;
+		}
+	}
+
+	module.exports = function callBind(originalFunction) {
+		var func = $reflectApply(bind, $call, arguments);
+		if ($gOPD && $defineProperty) {
+			var desc = $gOPD(func, 'length');
+			if (desc.configurable) {
+				// original length, plus the receiver, minus any additional arguments (after the receiver)
+				$defineProperty(
+					func,
+					'length',
+					{ value: 1 + $max(0, originalFunction.length - (arguments.length - 1)) }
+				);
+			}
+		}
+		return func;
+	};
+
+	var applyBind = function applyBind() {
+		return $reflectApply(bind, $apply, arguments);
+	};
+
+	if ($defineProperty) {
+		$defineProperty(module.exports, 'apply', { value: applyBind });
+	} else {
+		module.exports.apply = applyBind;
+	} 
+} (callBind$2));
+
+var callBindExports = callBind$2.exports;
+
+var GetIntrinsic = getIntrinsic;
+
+var callBind$1 = callBindExports;
+
+var $indexOf$1 = callBind$1(GetIntrinsic('String.prototype.indexOf'));
+
+var callBound$2 = function callBoundIntrinsic(name, allowMissing) {
+	var intrinsic = GetIntrinsic(name, !!allowMissing);
+	if (typeof intrinsic === 'function' && $indexOf$1(name, '.prototype.') > -1) {
+		return callBind$1(intrinsic);
+	}
+	return intrinsic;
+};
+
+var hasToStringTag$3 = shams();
+var callBound$1 = callBound$2;
+
+var $toString$1 = callBound$1('Object.prototype.toString');
+
+var isStandardArguments = function isArguments(value) {
+	if (hasToStringTag$3 && value && typeof value === 'object' && Symbol.toStringTag in value) {
+		return false;
+	}
+	return $toString$1(value) === '[object Arguments]';
+};
+
+var isLegacyArguments = function isArguments(value) {
+	if (isStandardArguments(value)) {
+		return true;
+	}
+	return value !== null &&
+		typeof value === 'object' &&
+		typeof value.length === 'number' &&
+		value.length >= 0 &&
+		$toString$1(value) !== '[object Array]' &&
+		$toString$1(value.callee) === '[object Function]';
+};
+
+var supportsStandardArguments = (function () {
+	return isStandardArguments(arguments);
+}());
+
+isStandardArguments.isLegacyArguments = isLegacyArguments; // for tests
+
+var isArguments = supportsStandardArguments ? isStandardArguments : isLegacyArguments;
+
+var toStr$2 = Object.prototype.toString;
+var fnToStr$1 = Function.prototype.toString;
+var isFnRegex = /^\s*(?:function)?\*/;
+var hasToStringTag$2 = shams();
+var getProto = Object.getPrototypeOf;
+var getGeneratorFunc = function () { // eslint-disable-line consistent-return
+	if (!hasToStringTag$2) {
+		return false;
+	}
+	try {
+		return Function('return function*() {}')();
+	} catch (e) {
+	}
+};
+var GeneratorFunction;
+
+var isGeneratorFunction = function isGeneratorFunction(fn) {
+	if (typeof fn !== 'function') {
+		return false;
+	}
+	if (isFnRegex.test(fnToStr$1.call(fn))) {
+		return true;
+	}
+	if (!hasToStringTag$2) {
+		var str = toStr$2.call(fn);
+		return str === '[object GeneratorFunction]';
+	}
+	if (!getProto) {
+		return false;
+	}
+	if (typeof GeneratorFunction === 'undefined') {
+		var generatorFunc = getGeneratorFunc();
+		GeneratorFunction = generatorFunc ? getProto(generatorFunc) : false;
+	}
+	return getProto(fn) === GeneratorFunction;
+};
+
+var fnToStr = Function.prototype.toString;
+var reflectApply = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;
+var badArrayLike;
+var isCallableMarker;
+if (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {
+	try {
+		badArrayLike = Object.defineProperty({}, 'length', {
+			get: function () {
+				throw isCallableMarker;
+			}
+		});
+		isCallableMarker = {};
+		// eslint-disable-next-line no-throw-literal
+		reflectApply(function () { throw 42; }, null, badArrayLike);
+	} catch (_) {
+		if (_ !== isCallableMarker) {
+			reflectApply = null;
+		}
+	}
+} else {
+	reflectApply = null;
+}
+
+var constructorRegex = /^\s*class\b/;
+var isES6ClassFn = function isES6ClassFunction(value) {
+	try {
+		var fnStr = fnToStr.call(value);
+		return constructorRegex.test(fnStr);
+	} catch (e) {
+		return false; // not a function
+	}
+};
+
+var tryFunctionObject = function tryFunctionToStr(value) {
+	try {
+		if (isES6ClassFn(value)) { return false; }
+		fnToStr.call(value);
+		return true;
+	} catch (e) {
+		return false;
+	}
+};
+var toStr$1 = Object.prototype.toString;
+var objectClass = '[object Object]';
+var fnClass = '[object Function]';
+var genClass = '[object GeneratorFunction]';
+var ddaClass = '[object HTMLAllCollection]'; // IE 11
+var ddaClass2 = '[object HTML document.all class]';
+var ddaClass3 = '[object HTMLCollection]'; // IE 9-10
+var hasToStringTag$1 = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`
+
+var isIE68 = !(0 in [,]); // eslint-disable-line no-sparse-arrays, comma-spacing
+
+var isDDA = function isDocumentDotAll() { return false; };
+if (typeof document === 'object') {
+	// Firefox 3 canonicalizes DDA to undefined when it's not accessed directly
+	var all = document.all;
+	if (toStr$1.call(all) === toStr$1.call(document.all)) {
+		isDDA = function isDocumentDotAll(value) {
+			/* globals document: false */
+			// in IE 6-8, typeof document.all is "object" and it's truthy
+			if ((isIE68 || !value) && (typeof value === 'undefined' || typeof value === 'object')) {
+				try {
+					var str = toStr$1.call(value);
+					return (
+						str === ddaClass
+						|| str === ddaClass2
+						|| str === ddaClass3 // opera 12.16
+						|| str === objectClass // IE 6-8
+					) && value('') == null; // eslint-disable-line eqeqeq
+				} catch (e) { /**/ }
+			}
+			return false;
+		};
+	}
+}
+
+var isCallable$1 = reflectApply
+	? function isCallable(value) {
+		if (isDDA(value)) { return true; }
+		if (!value) { return false; }
+		if (typeof value !== 'function' && typeof value !== 'object') { return false; }
+		try {
+			reflectApply(value, null, badArrayLike);
+		} catch (e) {
+			if (e !== isCallableMarker) { return false; }
+		}
+		return !isES6ClassFn(value) && tryFunctionObject(value);
+	}
+	: function isCallable(value) {
+		if (isDDA(value)) { return true; }
+		if (!value) { return false; }
+		if (typeof value !== 'function' && typeof value !== 'object') { return false; }
+		if (hasToStringTag$1) { return tryFunctionObject(value); }
+		if (isES6ClassFn(value)) { return false; }
+		var strClass = toStr$1.call(value);
+		if (strClass !== fnClass && strClass !== genClass && !(/^\[object HTML/).test(strClass)) { return false; }
+		return tryFunctionObject(value);
+	};
+
+var isCallable = isCallable$1;
+
+var toStr = Object.prototype.toString;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+var forEachArray = function forEachArray(array, iterator, receiver) {
+    for (var i = 0, len = array.length; i < len; i++) {
+        if (hasOwnProperty.call(array, i)) {
+            if (receiver == null) {
+                iterator(array[i], i, array);
+            } else {
+                iterator.call(receiver, array[i], i, array);
+            }
+        }
+    }
+};
+
+var forEachString = function forEachString(string, iterator, receiver) {
+    for (var i = 0, len = string.length; i < len; i++) {
+        // no such thing as a sparse string.
+        if (receiver == null) {
+            iterator(string.charAt(i), i, string);
+        } else {
+            iterator.call(receiver, string.charAt(i), i, string);
+        }
+    }
+};
+
+var forEachObject = function forEachObject(object, iterator, receiver) {
+    for (var k in object) {
+        if (hasOwnProperty.call(object, k)) {
+            if (receiver == null) {
+                iterator(object[k], k, object);
+            } else {
+                iterator.call(receiver, object[k], k, object);
+            }
+        }
+    }
+};
+
+var forEach$1 = function forEach(list, iterator, thisArg) {
+    if (!isCallable(iterator)) {
+        throw new TypeError('iterator must be a function');
+    }
+
+    var receiver;
+    if (arguments.length >= 3) {
+        receiver = thisArg;
+    }
+
+    if (toStr.call(list) === '[object Array]') {
+        forEachArray(list, iterator, receiver);
+    } else if (typeof list === 'string') {
+        forEachString(list, iterator, receiver);
+    } else {
+        forEachObject(list, iterator, receiver);
+    }
+};
+
+var forEach_1 = forEach$1;
+
+var possibleNames = [
+	'BigInt64Array',
+	'BigUint64Array',
+	'Float32Array',
+	'Float64Array',
+	'Int16Array',
+	'Int32Array',
+	'Int8Array',
+	'Uint16Array',
+	'Uint32Array',
+	'Uint8Array',
+	'Uint8ClampedArray'
+];
+
+var g$1 = typeof globalThis === 'undefined' ? commonjsGlobal : globalThis;
+
+var availableTypedArrays$1 = function availableTypedArrays() {
+	var out = [];
+	for (var i = 0; i < possibleNames.length; i++) {
+		if (typeof g$1[possibleNames[i]] === 'function') {
+			out[out.length] = possibleNames[i];
+		}
+	}
+	return out;
+};
+
+var forEach = forEach_1;
+var availableTypedArrays = availableTypedArrays$1;
+var callBind = callBindExports;
+var callBound = callBound$2;
+var gOPD = gopd;
+
+var $toString = callBound('Object.prototype.toString');
+var hasToStringTag = shams();
+
+var g = typeof globalThis === 'undefined' ? commonjsGlobal : globalThis;
+var typedArrays = availableTypedArrays();
+
+var $slice = callBound('String.prototype.slice');
+var getPrototypeOf = Object.getPrototypeOf; // require('getprototypeof');
+
+var $indexOf = callBound('Array.prototype.indexOf', true) || function indexOf(array, value) {
+	for (var i = 0; i < array.length; i += 1) {
+		if (array[i] === value) {
+			return i;
+		}
+	}
+	return -1;
+};
+var cache = { __proto__: null };
+if (hasToStringTag && gOPD && getPrototypeOf) {
+	forEach(typedArrays, function (typedArray) {
+		var arr = new g[typedArray]();
+		if (Symbol.toStringTag in arr) {
+			var proto = getPrototypeOf(arr);
+			var descriptor = gOPD(proto, Symbol.toStringTag);
+			if (!descriptor) {
+				var superProto = getPrototypeOf(proto);
+				descriptor = gOPD(superProto, Symbol.toStringTag);
+			}
+			cache['$' + typedArray] = callBind(descriptor.get);
+		}
+	});
+} else {
+	forEach(typedArrays, function (typedArray) {
+		var arr = new g[typedArray]();
+		cache['$' + typedArray] = callBind(arr.slice);
+	});
+}
+
+var tryTypedArrays = function tryAllTypedArrays(value) {
+	var found = false;
+	forEach(cache, function (getter, typedArray) {
+		if (!found) {
+			try {
+				if ('$' + getter(value) === typedArray) {
+					found = $slice(typedArray, 1);
+				}
+			} catch (e) { /**/ }
+		}
+	});
+	return found;
+};
+
+var trySlices = function tryAllSlices(value) {
+	var found = false;
+	forEach(cache, function (getter, name) {
+		if (!found) {
+			try {
+				getter(value);
+				found = $slice(name, 1);
+			} catch (e) { /**/ }
+		}
+	});
+	return found;
+};
+
+var whichTypedArray$1 = function whichTypedArray(value) {
+	if (!value || typeof value !== 'object') { return false; }
+	if (!hasToStringTag) {
+		var tag = $slice($toString(value), 8, -1);
+		if ($indexOf(typedArrays, tag) > -1) {
+			return tag;
+		}
+		if (tag !== 'Object') {
+			return false;
+		}
+		// node < 0.6 hits here on real Typed Arrays
+		return trySlices(value);
+	}
+	if (!gOPD) { return null; } // unknown engine
+	return tryTypedArrays(value);
+};
+
+var whichTypedArray = whichTypedArray$1;
+
+var isTypedArray = function isTypedArray(value) {
+	return !!whichTypedArray(value);
+};
+
+(function (exports) {
+
+	var isArgumentsObject = isArguments;
+	var isGeneratorFunction$1 = isGeneratorFunction;
+	var whichTypedArray = whichTypedArray$1;
+	var isTypedArray$1 = isTypedArray;
+
+	function uncurryThis(f) {
+	  return f.call.bind(f);
+	}
+
+	var BigIntSupported = typeof BigInt !== 'undefined';
+	var SymbolSupported = typeof Symbol !== 'undefined';
+
+	var ObjectToString = uncurryThis(Object.prototype.toString);
+
+	var numberValue = uncurryThis(Number.prototype.valueOf);
+	var stringValue = uncurryThis(String.prototype.valueOf);
+	var booleanValue = uncurryThis(Boolean.prototype.valueOf);
+
+	if (BigIntSupported) {
+	  var bigIntValue = uncurryThis(BigInt.prototype.valueOf);
+	}
+
+	if (SymbolSupported) {
+	  var symbolValue = uncurryThis(Symbol.prototype.valueOf);
+	}
+
+	function checkBoxedPrimitive(value, prototypeValueOf) {
+	  if (typeof value !== 'object') {
+	    return false;
+	  }
+	  try {
+	    prototypeValueOf(value);
+	    return true;
+	  } catch(e) {
+	    return false;
+	  }
+	}
+
+	exports.isArgumentsObject = isArgumentsObject;
+	exports.isGeneratorFunction = isGeneratorFunction$1;
+	exports.isTypedArray = isTypedArray$1;
+
+	// Taken from here and modified for better browser support
+	// https://github.com/sindresorhus/p-is-promise/blob/cda35a513bda03f977ad5cde3a079d237e82d7ef/index.js
+	function isPromise(input) {
+		return (
+			(
+				typeof Promise !== 'undefined' &&
+				input instanceof Promise
+			) ||
+			(
+				input !== null &&
+				typeof input === 'object' &&
+				typeof input.then === 'function' &&
+				typeof input.catch === 'function'
+			)
+		);
+	}
+	exports.isPromise = isPromise;
+
+	function isArrayBufferView(value) {
+	  if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView) {
+	    return ArrayBuffer.isView(value);
+	  }
+
+	  return (
+	    isTypedArray$1(value) ||
+	    isDataView(value)
+	  );
+	}
+	exports.isArrayBufferView = isArrayBufferView;
+
+
+	function isUint8Array(value) {
+	  return whichTypedArray(value) === 'Uint8Array';
+	}
+	exports.isUint8Array = isUint8Array;
+
+	function isUint8ClampedArray(value) {
+	  return whichTypedArray(value) === 'Uint8ClampedArray';
+	}
+	exports.isUint8ClampedArray = isUint8ClampedArray;
+
+	function isUint16Array(value) {
+	  return whichTypedArray(value) === 'Uint16Array';
+	}
+	exports.isUint16Array = isUint16Array;
+
+	function isUint32Array(value) {
+	  return whichTypedArray(value) === 'Uint32Array';
+	}
+	exports.isUint32Array = isUint32Array;
+
+	function isInt8Array(value) {
+	  return whichTypedArray(value) === 'Int8Array';
+	}
+	exports.isInt8Array = isInt8Array;
+
+	function isInt16Array(value) {
+	  return whichTypedArray(value) === 'Int16Array';
+	}
+	exports.isInt16Array = isInt16Array;
+
+	function isInt32Array(value) {
+	  return whichTypedArray(value) === 'Int32Array';
+	}
+	exports.isInt32Array = isInt32Array;
+
+	function isFloat32Array(value) {
+	  return whichTypedArray(value) === 'Float32Array';
+	}
+	exports.isFloat32Array = isFloat32Array;
+
+	function isFloat64Array(value) {
+	  return whichTypedArray(value) === 'Float64Array';
+	}
+	exports.isFloat64Array = isFloat64Array;
+
+	function isBigInt64Array(value) {
+	  return whichTypedArray(value) === 'BigInt64Array';
+	}
+	exports.isBigInt64Array = isBigInt64Array;
+
+	function isBigUint64Array(value) {
+	  return whichTypedArray(value) === 'BigUint64Array';
+	}
+	exports.isBigUint64Array = isBigUint64Array;
+
+	function isMapToString(value) {
+	  return ObjectToString(value) === '[object Map]';
+	}
+	isMapToString.working = (
+	  typeof Map !== 'undefined' &&
+	  isMapToString(new Map())
+	);
+
+	function isMap(value) {
+	  if (typeof Map === 'undefined') {
+	    return false;
+	  }
+
+	  return isMapToString.working
+	    ? isMapToString(value)
+	    : value instanceof Map;
+	}
+	exports.isMap = isMap;
+
+	function isSetToString(value) {
+	  return ObjectToString(value) === '[object Set]';
+	}
+	isSetToString.working = (
+	  typeof Set !== 'undefined' &&
+	  isSetToString(new Set())
+	);
+	function isSet(value) {
+	  if (typeof Set === 'undefined') {
+	    return false;
+	  }
+
+	  return isSetToString.working
+	    ? isSetToString(value)
+	    : value instanceof Set;
+	}
+	exports.isSet = isSet;
+
+	function isWeakMapToString(value) {
+	  return ObjectToString(value) === '[object WeakMap]';
+	}
+	isWeakMapToString.working = (
+	  typeof WeakMap !== 'undefined' &&
+	  isWeakMapToString(new WeakMap())
+	);
+	function isWeakMap(value) {
+	  if (typeof WeakMap === 'undefined') {
+	    return false;
+	  }
+
+	  return isWeakMapToString.working
+	    ? isWeakMapToString(value)
+	    : value instanceof WeakMap;
+	}
+	exports.isWeakMap = isWeakMap;
+
+	function isWeakSetToString(value) {
+	  return ObjectToString(value) === '[object WeakSet]';
+	}
+	isWeakSetToString.working = (
+	  typeof WeakSet !== 'undefined' &&
+	  isWeakSetToString(new WeakSet())
+	);
+	function isWeakSet(value) {
+	  return isWeakSetToString(value);
+	}
+	exports.isWeakSet = isWeakSet;
+
+	function isArrayBufferToString(value) {
+	  return ObjectToString(value) === '[object ArrayBuffer]';
+	}
+	isArrayBufferToString.working = (
+	  typeof ArrayBuffer !== 'undefined' &&
+	  isArrayBufferToString(new ArrayBuffer())
+	);
+	function isArrayBuffer(value) {
+	  if (typeof ArrayBuffer === 'undefined') {
+	    return false;
+	  }
+
+	  return isArrayBufferToString.working
+	    ? isArrayBufferToString(value)
+	    : value instanceof ArrayBuffer;
+	}
+	exports.isArrayBuffer = isArrayBuffer;
+
+	function isDataViewToString(value) {
+	  return ObjectToString(value) === '[object DataView]';
+	}
+	isDataViewToString.working = (
+	  typeof ArrayBuffer !== 'undefined' &&
+	  typeof DataView !== 'undefined' &&
+	  isDataViewToString(new DataView(new ArrayBuffer(1), 0, 1))
+	);
+	function isDataView(value) {
+	  if (typeof DataView === 'undefined') {
+	    return false;
+	  }
+
+	  return isDataViewToString.working
+	    ? isDataViewToString(value)
+	    : value instanceof DataView;
+	}
+	exports.isDataView = isDataView;
+
+	// Store a copy of SharedArrayBuffer in case it's deleted elsewhere
+	var SharedArrayBufferCopy = typeof SharedArrayBuffer !== 'undefined' ? SharedArrayBuffer : undefined;
+	function isSharedArrayBufferToString(value) {
+	  return ObjectToString(value) === '[object SharedArrayBuffer]';
+	}
+	function isSharedArrayBuffer(value) {
+	  if (typeof SharedArrayBufferCopy === 'undefined') {
+	    return false;
+	  }
+
+	  if (typeof isSharedArrayBufferToString.working === 'undefined') {
+	    isSharedArrayBufferToString.working = isSharedArrayBufferToString(new SharedArrayBufferCopy());
+	  }
+
+	  return isSharedArrayBufferToString.working
+	    ? isSharedArrayBufferToString(value)
+	    : value instanceof SharedArrayBufferCopy;
+	}
+	exports.isSharedArrayBuffer = isSharedArrayBuffer;
+
+	function isAsyncFunction(value) {
+	  return ObjectToString(value) === '[object AsyncFunction]';
+	}
+	exports.isAsyncFunction = isAsyncFunction;
+
+	function isMapIterator(value) {
+	  return ObjectToString(value) === '[object Map Iterator]';
+	}
+	exports.isMapIterator = isMapIterator;
+
+	function isSetIterator(value) {
+	  return ObjectToString(value) === '[object Set Iterator]';
+	}
+	exports.isSetIterator = isSetIterator;
+
+	function isGeneratorObject(value) {
+	  return ObjectToString(value) === '[object Generator]';
+	}
+	exports.isGeneratorObject = isGeneratorObject;
+
+	function isWebAssemblyCompiledModule(value) {
+	  return ObjectToString(value) === '[object WebAssembly.Module]';
+	}
+	exports.isWebAssemblyCompiledModule = isWebAssemblyCompiledModule;
+
+	function isNumberObject(value) {
+	  return checkBoxedPrimitive(value, numberValue);
+	}
+	exports.isNumberObject = isNumberObject;
+
+	function isStringObject(value) {
+	  return checkBoxedPrimitive(value, stringValue);
+	}
+	exports.isStringObject = isStringObject;
+
+	function isBooleanObject(value) {
+	  return checkBoxedPrimitive(value, booleanValue);
+	}
+	exports.isBooleanObject = isBooleanObject;
+
+	function isBigIntObject(value) {
+	  return BigIntSupported && checkBoxedPrimitive(value, bigIntValue);
+	}
+	exports.isBigIntObject = isBigIntObject;
+
+	function isSymbolObject(value) {
+	  return SymbolSupported && checkBoxedPrimitive(value, symbolValue);
+	}
+	exports.isSymbolObject = isSymbolObject;
+
+	function isBoxedPrimitive(value) {
+	  return (
+	    isNumberObject(value) ||
+	    isStringObject(value) ||
+	    isBooleanObject(value) ||
+	    isBigIntObject(value) ||
+	    isSymbolObject(value)
+	  );
+	}
+	exports.isBoxedPrimitive = isBoxedPrimitive;
+
+	function isAnyArrayBuffer(value) {
+	  return typeof Uint8Array !== 'undefined' && (
+	    isArrayBuffer(value) ||
+	    isSharedArrayBuffer(value)
+	  );
+	}
+	exports.isAnyArrayBuffer = isAnyArrayBuffer;
+
+	['isProxy', 'isExternal', 'isModuleNamespaceObject'].forEach(function(method) {
+	  Object.defineProperty(exports, method, {
+	    enumerable: false,
+	    value: function() {
+	      throw new Error(method + ' is not supported in userland');
+	    }
+	  });
+	}); 
+} (types));
+
+var isBuffer = function isBuffer(arg) {
+  return arg instanceof Buffer;
+};
+
+var inherits = {exports: {}};
+
+var inherits_browser = {exports: {}};
+
+var hasRequiredInherits_browser;
+
+function requireInherits_browser () {
+	if (hasRequiredInherits_browser) return inherits_browser.exports;
+	hasRequiredInherits_browser = 1;
+	if (typeof Object.create === 'function') {
+	  // implementation from standard node.js 'util' module
+	  inherits_browser.exports = function inherits(ctor, superCtor) {
+	    if (superCtor) {
+	      ctor.super_ = superCtor;
+	      ctor.prototype = Object.create(superCtor.prototype, {
+	        constructor: {
+	          value: ctor,
+	          enumerable: false,
+	          writable: true,
+	          configurable: true
+	        }
+	      });
+	    }
+	  };
+	} else {
+	  // old school shim for old browsers
+	  inherits_browser.exports = function inherits(ctor, superCtor) {
+	    if (superCtor) {
+	      ctor.super_ = superCtor;
+	      var TempCtor = function () {};
+	      TempCtor.prototype = superCtor.prototype;
+	      ctor.prototype = new TempCtor();
+	      ctor.prototype.constructor = ctor;
+	    }
+	  };
+	}
+	return inherits_browser.exports;
+}
+
+var hasRequiredInherits;
+
+function requireInherits () {
+	if (hasRequiredInherits) return inherits.exports;
+	hasRequiredInherits = 1;
+	try {
+	  var util = requireUtil();
+	  /* istanbul ignore next */
+	  if (typeof util.inherits !== 'function') throw '';
+	  inherits.exports = util.inherits;
+	} catch (e) {
+	  /* istanbul ignore next */
+	  inherits.exports = requireInherits_browser();
+	}
+	return inherits.exports;
+}
+
+var hasRequiredUtil;
+
+function requireUtil () {
+	if (hasRequiredUtil) return util;
+	hasRequiredUtil = 1;
+	(function (exports) {
+		// Copyright Joyent, Inc. and other Node contributors.
+		//
+		// Permission is hereby granted, free of charge, to any person obtaining a
+		// copy of this software and associated documentation files (the
+		// "Software"), to deal in the Software without restriction, including
+		// without limitation the rights to use, copy, modify, merge, publish,
+		// distribute, sublicense, and/or sell copies of the Software, and to permit
+		// persons to whom the Software is furnished to do so, subject to the
+		// following conditions:
+		//
+		// The above copyright notice and this permission notice shall be included
+		// in all copies or substantial portions of the Software.
+		//
+		// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+		// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+		// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+		// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+		// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+		// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+		// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+		var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||
+		  function getOwnPropertyDescriptors(obj) {
+		    var keys = Object.keys(obj);
+		    var descriptors = {};
+		    for (var i = 0; i < keys.length; i++) {
+		      descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);
+		    }
+		    return descriptors;
+		  };
+
+		var formatRegExp = /%[sdj%]/g;
+		exports.format = function(f) {
+		  if (!isString(f)) {
+		    var objects = [];
+		    for (var i = 0; i < arguments.length; i++) {
+		      objects.push(inspect(arguments[i]));
+		    }
+		    return objects.join(' ');
+		  }
+
+		  var i = 1;
+		  var args = arguments;
+		  var len = args.length;
+		  var str = String(f).replace(formatRegExp, function(x) {
+		    if (x === '%%') return '%';
+		    if (i >= len) return x;
+		    switch (x) {
+		      case '%s': return String(args[i++]);
+		      case '%d': return Number(args[i++]);
+		      case '%j':
+		        try {
+		          return JSON.stringify(args[i++]);
+		        } catch (_) {
+		          return '[Circular]';
+		        }
+		      default:
+		        return x;
+		    }
+		  });
+		  for (var x = args[i]; i < len; x = args[++i]) {
+		    if (isNull(x) || !isObject(x)) {
+		      str += ' ' + x;
+		    } else {
+		      str += ' ' + inspect(x);
+		    }
+		  }
+		  return str;
+		};
+
+
+		// Mark that a method should not be used.
+		// Returns a modified function which warns once by default.
+		// If --no-deprecation is set, then it is a no-op.
+		exports.deprecate = function(fn, msg) {
+		  if (typeof process !== 'undefined' && process.noDeprecation === true) {
+		    return fn;
+		  }
+
+		  // Allow for deprecating things in the process of starting up.
+		  if (typeof process === 'undefined') {
+		    return function() {
+		      return exports.deprecate(fn, msg).apply(this, arguments);
+		    };
+		  }
+
+		  var warned = false;
+		  function deprecated() {
+		    if (!warned) {
+		      if (process.throwDeprecation) {
+		        throw new Error(msg);
+		      } else if (process.traceDeprecation) {
+		        console.trace(msg);
+		      } else {
+		        console.error(msg);
+		      }
+		      warned = true;
+		    }
+		    return fn.apply(this, arguments);
+		  }
+
+		  return deprecated;
+		};
+
+
+		var debugs = {};
+		var debugEnvRegex = /^$/;
+
+		if (process.env.NODE_DEBUG) {
+		  var debugEnv = process.env.NODE_DEBUG;
+		  debugEnv = debugEnv.replace(/[|\\{}()[\]^$+?.]/g, '\\$&')
+		    .replace(/\*/g, '.*')
+		    .replace(/,/g, '$|^')
+		    .toUpperCase();
+		  debugEnvRegex = new RegExp('^' + debugEnv + '$', 'i');
+		}
+		exports.debuglog = function(set) {
+		  set = set.toUpperCase();
+		  if (!debugs[set]) {
+		    if (debugEnvRegex.test(set)) {
+		      var pid = process.pid;
+		      debugs[set] = function() {
+		        var msg = exports.format.apply(exports, arguments);
+		        console.error('%s %d: %s', set, pid, msg);
+		      };
+		    } else {
+		      debugs[set] = function() {};
+		    }
+		  }
+		  return debugs[set];
+		};
+
+
+		/**
+		 * Echos the value of a value. Trys to print the value out
+		 * in the best way possible given the different types.
+		 *
+		 * @param {Object} obj The object to print out.
+		 * @param {Object} opts Optional options object that alters the output.
+		 */
+		/* legacy: obj, showHidden, depth, colors*/
+		function inspect(obj, opts) {
+		  // default options
+		  var ctx = {
+		    seen: [],
+		    stylize: stylizeNoColor
+		  };
+		  // legacy...
+		  if (arguments.length >= 3) ctx.depth = arguments[2];
+		  if (arguments.length >= 4) ctx.colors = arguments[3];
+		  if (isBoolean(opts)) {
+		    // legacy...
+		    ctx.showHidden = opts;
+		  } else if (opts) {
+		    // got an "options" object
+		    exports._extend(ctx, opts);
+		  }
+		  // set default options
+		  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+		  if (isUndefined(ctx.depth)) ctx.depth = 2;
+		  if (isUndefined(ctx.colors)) ctx.colors = false;
+		  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+		  if (ctx.colors) ctx.stylize = stylizeWithColor;
+		  return formatValue(ctx, obj, ctx.depth);
+		}
+		exports.inspect = inspect;
+
+
+		// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+		inspect.colors = {
+		  'bold' : [1, 22],
+		  'italic' : [3, 23],
+		  'underline' : [4, 24],
+		  'inverse' : [7, 27],
+		  'white' : [37, 39],
+		  'grey' : [90, 39],
+		  'black' : [30, 39],
+		  'blue' : [34, 39],
+		  'cyan' : [36, 39],
+		  'green' : [32, 39],
+		  'magenta' : [35, 39],
+		  'red' : [31, 39],
+		  'yellow' : [33, 39]
+		};
+
+		// Don't use 'blue' not visible on cmd.exe
+		inspect.styles = {
+		  'special': 'cyan',
+		  'number': 'yellow',
+		  'boolean': 'yellow',
+		  'undefined': 'grey',
+		  'null': 'bold',
+		  'string': 'green',
+		  'date': 'magenta',
+		  // "name": intentionally not styling
+		  'regexp': 'red'
+		};
+
+
+		function stylizeWithColor(str, styleType) {
+		  var style = inspect.styles[styleType];
+
+		  if (style) {
+		    return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+		           '\u001b[' + inspect.colors[style][1] + 'm';
+		  } else {
+		    return str;
+		  }
+		}
+
+
+		function stylizeNoColor(str, styleType) {
+		  return str;
+		}
+
+
+		function arrayToHash(array) {
+		  var hash = {};
+
+		  array.forEach(function(val, idx) {
+		    hash[val] = true;
+		  });
+
+		  return hash;
+		}
+
+
+		function formatValue(ctx, value, recurseTimes) {
+		  // Provide a hook for user-specified inspect functions.
+		  // Check that value is an object with an inspect function on it
+		  if (ctx.customInspect &&
+		      value &&
+		      isFunction(value.inspect) &&
+		      // Filter out the util module, it's inspect function is special
+		      value.inspect !== exports.inspect &&
+		      // Also filter out any prototype objects using the circular check.
+		      !(value.constructor && value.constructor.prototype === value)) {
+		    var ret = value.inspect(recurseTimes, ctx);
+		    if (!isString(ret)) {
+		      ret = formatValue(ctx, ret, recurseTimes);
+		    }
+		    return ret;
+		  }
+
+		  // Primitive types cannot have properties
+		  var primitive = formatPrimitive(ctx, value);
+		  if (primitive) {
+		    return primitive;
+		  }
+
+		  // Look up the keys of the object.
+		  var keys = Object.keys(value);
+		  var visibleKeys = arrayToHash(keys);
+
+		  if (ctx.showHidden) {
+		    keys = Object.getOwnPropertyNames(value);
+		  }
+
+		  // IE doesn't make error fields non-enumerable
+		  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
+		  if (isError(value)
+		      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+		    return formatError(value);
+		  }
+
+		  // Some type of object without properties can be shortcutted.
+		  if (keys.length === 0) {
+		    if (isFunction(value)) {
+		      var name = value.name ? ': ' + value.name : '';
+		      return ctx.stylize('[Function' + name + ']', 'special');
+		    }
+		    if (isRegExp(value)) {
+		      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+		    }
+		    if (isDate(value)) {
+		      return ctx.stylize(Date.prototype.toString.call(value), 'date');
+		    }
+		    if (isError(value)) {
+		      return formatError(value);
+		    }
+		  }
+
+		  var base = '', array = false, braces = ['{', '}'];
+
+		  // Make Array say that they are Array
+		  if (isArray(value)) {
+		    array = true;
+		    braces = ['[', ']'];
+		  }
+
+		  // Make functions say that they are functions
+		  if (isFunction(value)) {
+		    var n = value.name ? ': ' + value.name : '';
+		    base = ' [Function' + n + ']';
+		  }
+
+		  // Make RegExps say that they are RegExps
+		  if (isRegExp(value)) {
+		    base = ' ' + RegExp.prototype.toString.call(value);
+		  }
+
+		  // Make dates with properties first say the date
+		  if (isDate(value)) {
+		    base = ' ' + Date.prototype.toUTCString.call(value);
+		  }
+
+		  // Make error with message first say the error
+		  if (isError(value)) {
+		    base = ' ' + formatError(value);
+		  }
+
+		  if (keys.length === 0 && (!array || value.length == 0)) {
+		    return braces[0] + base + braces[1];
+		  }
+
+		  if (recurseTimes < 0) {
+		    if (isRegExp(value)) {
+		      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+		    } else {
+		      return ctx.stylize('[Object]', 'special');
+		    }
+		  }
+
+		  ctx.seen.push(value);
+
+		  var output;
+		  if (array) {
+		    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+		  } else {
+		    output = keys.map(function(key) {
+		      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+		    });
+		  }
+
+		  ctx.seen.pop();
+
+		  return reduceToSingleString(output, base, braces);
+		}
+
+
+		function formatPrimitive(ctx, value) {
+		  if (isUndefined(value))
+		    return ctx.stylize('undefined', 'undefined');
+		  if (isString(value)) {
+		    var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+		                                             .replace(/'/g, "\\'")
+		                                             .replace(/\\"/g, '"') + '\'';
+		    return ctx.stylize(simple, 'string');
+		  }
+		  if (isNumber(value))
+		    return ctx.stylize('' + value, 'number');
+		  if (isBoolean(value))
+		    return ctx.stylize('' + value, 'boolean');
+		  // For some reason typeof null is "object", so special case here.
+		  if (isNull(value))
+		    return ctx.stylize('null', 'null');
+		}
+
+
+		function formatError(value) {
+		  return '[' + Error.prototype.toString.call(value) + ']';
+		}
+
+
+		function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+		  var output = [];
+		  for (var i = 0, l = value.length; i < l; ++i) {
+		    if (hasOwnProperty(value, String(i))) {
+		      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+		          String(i), true));
+		    } else {
+		      output.push('');
+		    }
+		  }
+		  keys.forEach(function(key) {
+		    if (!key.match(/^\d+$/)) {
+		      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+		          key, true));
+		    }
+		  });
+		  return output;
+		}
+
+
+		function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+		  var name, str, desc;
+		  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
+		  if (desc.get) {
+		    if (desc.set) {
+		      str = ctx.stylize('[Getter/Setter]', 'special');
+		    } else {
+		      str = ctx.stylize('[Getter]', 'special');
+		    }
+		  } else {
+		    if (desc.set) {
+		      str = ctx.stylize('[Setter]', 'special');
+		    }
+		  }
+		  if (!hasOwnProperty(visibleKeys, key)) {
+		    name = '[' + key + ']';
+		  }
+		  if (!str) {
+		    if (ctx.seen.indexOf(desc.value) < 0) {
+		      if (isNull(recurseTimes)) {
+		        str = formatValue(ctx, desc.value, null);
+		      } else {
+		        str = formatValue(ctx, desc.value, recurseTimes - 1);
+		      }
+		      if (str.indexOf('\n') > -1) {
+		        if (array) {
+		          str = str.split('\n').map(function(line) {
+		            return '  ' + line;
+		          }).join('\n').slice(2);
+		        } else {
+		          str = '\n' + str.split('\n').map(function(line) {
+		            return '   ' + line;
+		          }).join('\n');
+		        }
+		      }
+		    } else {
+		      str = ctx.stylize('[Circular]', 'special');
+		    }
+		  }
+		  if (isUndefined(name)) {
+		    if (array && key.match(/^\d+$/)) {
+		      return str;
+		    }
+		    name = JSON.stringify('' + key);
+		    if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+		      name = name.slice(1, -1);
+		      name = ctx.stylize(name, 'name');
+		    } else {
+		      name = name.replace(/'/g, "\\'")
+		                 .replace(/\\"/g, '"')
+		                 .replace(/(^"|"$)/g, "'");
+		      name = ctx.stylize(name, 'string');
+		    }
+		  }
+
+		  return name + ': ' + str;
+		}
+
+
+		function reduceToSingleString(output, base, braces) {
+		  var length = output.reduce(function(prev, cur) {
+		    if (cur.indexOf('\n') >= 0) ;
+		    return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+		  }, 0);
+
+		  if (length > 60) {
+		    return braces[0] +
+		           (base === '' ? '' : base + '\n ') +
+		           ' ' +
+		           output.join(',\n  ') +
+		           ' ' +
+		           braces[1];
+		  }
+
+		  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+		}
+
+
+		// NOTE: These type checking functions intentionally don't use `instanceof`
+		// because it is fragile and can be easily faked with `Object.create()`.
+		exports.types = types;
+
+		function isArray(ar) {
+		  return Array.isArray(ar);
+		}
+		exports.isArray = isArray;
+
+		function isBoolean(arg) {
+		  return typeof arg === 'boolean';
+		}
+		exports.isBoolean = isBoolean;
+
+		function isNull(arg) {
+		  return arg === null;
+		}
+		exports.isNull = isNull;
+
+		function isNullOrUndefined(arg) {
+		  return arg == null;
+		}
+		exports.isNullOrUndefined = isNullOrUndefined;
+
+		function isNumber(arg) {
+		  return typeof arg === 'number';
+		}
+		exports.isNumber = isNumber;
+
+		function isString(arg) {
+		  return typeof arg === 'string';
+		}
+		exports.isString = isString;
+
+		function isSymbol(arg) {
+		  return typeof arg === 'symbol';
+		}
+		exports.isSymbol = isSymbol;
+
+		function isUndefined(arg) {
+		  return arg === void 0;
+		}
+		exports.isUndefined = isUndefined;
+
+		function isRegExp(re) {
+		  return isObject(re) && objectToString(re) === '[object RegExp]';
+		}
+		exports.isRegExp = isRegExp;
+		exports.types.isRegExp = isRegExp;
+
+		function isObject(arg) {
+		  return typeof arg === 'object' && arg !== null;
+		}
+		exports.isObject = isObject;
+
+		function isDate(d) {
+		  return isObject(d) && objectToString(d) === '[object Date]';
+		}
+		exports.isDate = isDate;
+		exports.types.isDate = isDate;
+
+		function isError(e) {
+		  return isObject(e) &&
+		      (objectToString(e) === '[object Error]' || e instanceof Error);
+		}
+		exports.isError = isError;
+		exports.types.isNativeError = isError;
+
+		function isFunction(arg) {
+		  return typeof arg === 'function';
+		}
+		exports.isFunction = isFunction;
+
+		function isPrimitive(arg) {
+		  return arg === null ||
+		         typeof arg === 'boolean' ||
+		         typeof arg === 'number' ||
+		         typeof arg === 'string' ||
+		         typeof arg === 'symbol' ||  // ES6 symbol
+		         typeof arg === 'undefined';
+		}
+		exports.isPrimitive = isPrimitive;
+
+		exports.isBuffer = isBuffer;
+
+		function objectToString(o) {
+		  return Object.prototype.toString.call(o);
+		}
+
+
+		function pad(n) {
+		  return n < 10 ? '0' + n.toString(10) : n.toString(10);
+		}
+
+
+		var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+		              'Oct', 'Nov', 'Dec'];
+
+		// 26 Feb 16:19:34
+		function timestamp() {
+		  var d = new Date();
+		  var time = [pad(d.getHours()),
+		              pad(d.getMinutes()),
+		              pad(d.getSeconds())].join(':');
+		  return [d.getDate(), months[d.getMonth()], time].join(' ');
+		}
+
+
+		// log is just a thin wrapper to console.log that prepends a timestamp
+		exports.log = function() {
+		  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
+		};
+
+
+		/**
+		 * Inherit the prototype methods from one constructor into another.
+		 *
+		 * The Function.prototype.inherits from lang.js rewritten as a standalone
+		 * function (not on Function.prototype). NOTE: If this file is to be loaded
+		 * during bootstrapping this function needs to be rewritten using some native
+		 * functions as prototype setup using normal JavaScript does not work as
+		 * expected during bootstrapping (see mirror.js in r114903).
+		 *
+		 * @param {function} ctor Constructor function which needs to inherit the
+		 *     prototype.
+		 * @param {function} superCtor Constructor function to inherit prototype from.
+		 */
+		exports.inherits = requireInherits();
+
+		exports._extend = function(origin, add) {
+		  // Don't do anything if add isn't an object
+		  if (!add || !isObject(add)) return origin;
+
+		  var keys = Object.keys(add);
+		  var i = keys.length;
+		  while (i--) {
+		    origin[keys[i]] = add[keys[i]];
+		  }
+		  return origin;
+		};
+
+		function hasOwnProperty(obj, prop) {
+		  return Object.prototype.hasOwnProperty.call(obj, prop);
+		}
+
+		var kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;
+
+		exports.promisify = function promisify(original) {
+		  if (typeof original !== 'function')
+		    throw new TypeError('The "original" argument must be of type Function');
+
+		  if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
+		    var fn = original[kCustomPromisifiedSymbol];
+		    if (typeof fn !== 'function') {
+		      throw new TypeError('The "util.promisify.custom" argument must be of type Function');
+		    }
+		    Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+		      value: fn, enumerable: false, writable: false, configurable: true
+		    });
+		    return fn;
+		  }
+
+		  function fn() {
+		    var promiseResolve, promiseReject;
+		    var promise = new Promise(function (resolve, reject) {
+		      promiseResolve = resolve;
+		      promiseReject = reject;
+		    });
+
+		    var args = [];
+		    for (var i = 0; i < arguments.length; i++) {
+		      args.push(arguments[i]);
+		    }
+		    args.push(function (err, value) {
+		      if (err) {
+		        promiseReject(err);
+		      } else {
+		        promiseResolve(value);
+		      }
+		    });
+
+		    try {
+		      original.apply(this, args);
+		    } catch (err) {
+		      promiseReject(err);
+		    }
+
+		    return promise;
+		  }
+
+		  Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
+
+		  if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+		    value: fn, enumerable: false, writable: false, configurable: true
+		  });
+		  return Object.defineProperties(
+		    fn,
+		    getOwnPropertyDescriptors(original)
+		  );
+		};
+
+		exports.promisify.custom = kCustomPromisifiedSymbol;
+
+		function callbackifyOnRejected(reason, cb) {
+		  // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).
+		  // Because `null` is a special error value in callbacks which means "no error
+		  // occurred", we error-wrap so the callback consumer can distinguish between
+		  // "the promise rejected with null" or "the promise fulfilled with undefined".
+		  if (!reason) {
+		    var newReason = new Error('Promise was rejected with a falsy value');
+		    newReason.reason = reason;
+		    reason = newReason;
+		  }
+		  return cb(reason);
+		}
+
+		function callbackify(original) {
+		  if (typeof original !== 'function') {
+		    throw new TypeError('The "original" argument must be of type Function');
+		  }
+
+		  // We DO NOT return the promise as it gives the user a false sense that
+		  // the promise is actually somehow related to the callback's execution
+		  // and that the callback throwing will reject the promise.
+		  function callbackified() {
+		    var args = [];
+		    for (var i = 0; i < arguments.length; i++) {
+		      args.push(arguments[i]);
+		    }
+
+		    var maybeCb = args.pop();
+		    if (typeof maybeCb !== 'function') {
+		      throw new TypeError('The last argument must be of type Function');
+		    }
+		    var self = this;
+		    var cb = function() {
+		      return maybeCb.apply(self, arguments);
+		    };
+		    // In true node style we process the callback on `nextTick` with all the
+		    // implications (stack, `uncaughtException`, `async_hooks`)
+		    original.apply(this, args)
+		      .then(function(ret) { process.nextTick(cb.bind(null, null, ret)); },
+		            function(rej) { process.nextTick(callbackifyOnRejected.bind(null, rej, cb)); });
+		  }
+
+		  Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));
+		  Object.defineProperties(callbackified,
+		                          getOwnPropertyDescriptors(original));
+		  return callbackified;
+		}
+		exports.callbackify = callbackify; 
+	} (util));
+	return util;
+}
+
+(function (module) {
+	let imports = {};
+	imports['__wbindgen_placeholder__'] = module.exports;
+	let wasm;
+	const { TextDecoder, TextEncoder } = requireUtil();
+
+	const heap = new Array(128).fill(undefined);
+
+	heap.push(undefined, null, true, false);
+
+	function getObject(idx) { return heap[idx]; }
+
+	let heap_next = heap.length;
+
+	function dropObject(idx) {
+	    if (idx < 132) return;
+	    heap[idx] = heap_next;
+	    heap_next = idx;
+	}
+
+	function takeObject(idx) {
+	    const ret = getObject(idx);
+	    dropObject(idx);
+	    return ret;
+	}
+
+	let cachedUint8Memory0 = null;
+
+	function getUint8Memory0() {
+	    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
+	        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+	    }
+	    return cachedUint8Memory0;
+	}
+
+	let WASM_VECTOR_LEN = 0;
+
+	function passArray8ToWasm0(arg, malloc) {
+	    const ptr = malloc(arg.length * 1, 1) >>> 0;
+	    getUint8Memory0().set(arg, ptr / 1);
+	    WASM_VECTOR_LEN = arg.length;
+	    return ptr;
+	}
+	/**
+	* @param {Uint8Array} input
+	* @returns {number}
+	*/
+	module.exports.fingerprint32 = function(input) {
+	    const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+	    const len0 = WASM_VECTOR_LEN;
+	    const ret = wasm.fingerprint32(ptr0, len0);
+	    return ret >>> 0;
+	};
+
+	/**
+	* @param {Uint8Array} input
+	* @returns {bigint}
+	*/
+	module.exports.fingerprint64 = function(input) {
+	    const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+	    const len0 = WASM_VECTOR_LEN;
+	    const ret = wasm.bigquery_fingerprint(ptr0, len0);
+	    return BigInt.asUintN(64, ret);
+	};
+
+	/**
+	* @param {Uint8Array} input
+	* @returns {bigint}
+	*/
+	module.exports.bigquery_fingerprint = function(input) {
+	    const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+	    const len0 = WASM_VECTOR_LEN;
+	    const ret = wasm.bigquery_fingerprint(ptr0, len0);
+	    return ret;
+	};
+
+	/**
+	* @param {Uint8Array} input
+	* @returns {number}
+	*/
+	module.exports.hash32 = function(input) {
+	    const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+	    const len0 = WASM_VECTOR_LEN;
+	    const ret = wasm.hash32(ptr0, len0);
+	    return ret >>> 0;
+	};
+
+	/**
+	* @param {Uint8Array} input
+	* @param {number} seed
+	* @returns {number}
+	*/
+	module.exports.hash32_with_seed = function(input, seed) {
+	    const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+	    const len0 = WASM_VECTOR_LEN;
+	    const ret = wasm.hash32_with_seed(ptr0, len0, seed);
+	    return ret >>> 0;
+	};
+
+	/**
+	* @param {Uint8Array} input
+	* @returns {bigint}
+	*/
+	module.exports.hash64 = function(input) {
+	    const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+	    const len0 = WASM_VECTOR_LEN;
+	    const ret = wasm.hash64(ptr0, len0);
+	    return BigInt.asUintN(64, ret);
+	};
+
+	/**
+	* @param {Uint8Array} input
+	* @param {bigint} seed
+	* @returns {bigint}
+	*/
+	module.exports.hash64_with_seed = function(input, seed) {
+	    const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+	    const len0 = WASM_VECTOR_LEN;
+	    const ret = wasm.hash64_with_seed(ptr0, len0, seed);
+	    return BigInt.asUintN(64, ret);
+	};
+
+	let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+	cachedTextDecoder.decode();
+
+	function getStringFromWasm0(ptr, len) {
+	    ptr = ptr >>> 0;
+	    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+	}
+
+	function addHeapObject(obj) {
+	    if (heap_next === heap.length) heap.push(heap.length + 1);
+	    const idx = heap_next;
+	    heap_next = heap[idx];
+
+	    heap[idx] = obj;
+	    return idx;
+	}
+
+	let cachedTextEncoder = new TextEncoder('utf-8');
+
+	const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+	    ? function (arg, view) {
+	    return cachedTextEncoder.encodeInto(arg, view);
+	}
+	    : function (arg, view) {
+	    const buf = cachedTextEncoder.encode(arg);
+	    view.set(buf);
+	    return {
+	        read: arg.length,
+	        written: buf.length
+	    };
+	});
+
+	function passStringToWasm0(arg, malloc, realloc) {
+
+	    if (realloc === undefined) {
+	        const buf = cachedTextEncoder.encode(arg);
+	        const ptr = malloc(buf.length, 1) >>> 0;
+	        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+	        WASM_VECTOR_LEN = buf.length;
+	        return ptr;
+	    }
+
+	    let len = arg.length;
+	    let ptr = malloc(len, 1) >>> 0;
+
+	    const mem = getUint8Memory0();
+
+	    let offset = 0;
+
+	    for (; offset < len; offset++) {
+	        const code = arg.charCodeAt(offset);
+	        if (code > 0x7F) break;
+	        mem[ptr + offset] = code;
+	    }
+
+	    if (offset !== len) {
+	        if (offset !== 0) {
+	            arg = arg.slice(offset);
+	        }
+	        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+	        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+	        const ret = encodeString(arg, view);
+
+	        offset += ret.written;
+	    }
+
+	    WASM_VECTOR_LEN = offset;
+	    return ptr;
+	}
+
+	let cachedInt32Memory0 = null;
+
+	function getInt32Memory0() {
+	    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
+	        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+	    }
+	    return cachedInt32Memory0;
+	}
+
+	module.exports.__wbg_new_abda76e883ba8a5f = function() {
+	    const ret = new Error();
+	    return addHeapObject(ret);
+	};
+
+	module.exports.__wbg_stack_658279fe44541cf6 = function(arg0, arg1) {
+	    const ret = getObject(arg1).stack;
+	    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+	    const len1 = WASM_VECTOR_LEN;
+	    getInt32Memory0()[arg0 / 4 + 1] = len1;
+	    getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+	};
+
+	module.exports.__wbg_error_f851667af71bcfc6 = function(arg0, arg1) {
+	    let deferred0_0;
+	    let deferred0_1;
+	    try {
+	        deferred0_0 = arg0;
+	        deferred0_1 = arg1;
+	        console.error(getStringFromWasm0(arg0, arg1));
+	    } finally {
+	        wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+	    }
+	};
+
+	module.exports.__wbindgen_object_drop_ref = function(arg0) {
+	    takeObject(arg0);
+	};
+
+	const path = require$$1.join(__dirname, 'farmhash_modern_bg.wasm');
+	const bytes = require$$2.readFileSync(path);
+
+	const wasmModule = new WebAssembly.Module(bytes);
+	const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
+	wasm = wasmInstance.exports;
+	module.exports.__wasm = wasm; 
+} (farmhash_modern));
+
+var farmhash_modernExports = farmhash_modern.exports;
+
+function asBuffer(input) {
+    if (typeof input === 'string') {
+        return new TextEncoder().encode(input);
+    }
+    if (input instanceof Uint8Array) {
+        return input;
+    }
+    throw new Error('Expected input to be a string or Uint8Array');
+}
+/**
+ * Create a new farmhash based u32 for a string or an array of bytes.
+ * Fingerprint value should be portable and stable across library versions
+ * and platforms.
+ */
+function fingerprint32(input) {
+    return farmhash_modernExports.fingerprint32(asBuffer(input));
+}
+
+class KokimokiLocalStore extends KokimokiStore {
+    localRoomName;
+    _stateKey;
+    get stateKey() {
+        if (!this._stateKey) {
+            throw new Error("Not initialized");
+        }
+        return this._stateKey;
+    }
+    constructor(localRoomName, schema) {
+        super(`/l/${localRoomName}`, schema, RoomSubscriptionMode.ReadWrite);
+        this.localRoomName = localRoomName;
+        // Synchronize doc changes to local storage
+        // TODO: maybe do not serialize full state every time
+        this.doc.on("update", () => {
+            const value = encodeStateAsUpdate(this.doc);
+            const valueString = String.fromCharCode(...value);
+            const valueBase64 = btoa(valueString);
+            localStorage.setItem(this.stateKey, valueBase64);
+        });
+    }
+    getInitialUpdate(appId, clientId) {
+        this._stateKey = `${appId}/${clientId}/${this.localRoomName}`;
+        // get initial update from local storage
+        let initialUpdate = undefined;
+        const state = localStorage.getItem(this.stateKey);
+        if (state) {
+            const valueString = atob(state);
+            initialUpdate = Uint8Array.from(valueString, (c) => c.charCodeAt(0));
+        }
+        return {
+            roomHash: fingerprint32(this.roomName),
+            initialUpdate,
+        };
+    }
+}
+
 class KokimokiClient extends EventEmitter$1 {
     host;
     appId;
@@ -12663,7 +15234,13 @@ class KokimokiClient extends EventEmitter$1 {
         }
         // Send subscription request if connected to server
         if (!subscription.joined) {
-            const res = await this.sendSubscribeReq(store.roomName, store.mode);
+            let res;
+            if (store instanceof KokimokiLocalStore) {
+                res = store.getInitialUpdate(this.appId, this.id);
+            }
+            else {
+                res = await this.sendSubscribeReq(store.roomName, store.mode);
+            }
             this._subscriptionsByHash.set(res.roomHash, subscription);
             await subscription.applyInitialResponse(res.roomHash, res.initialUpdate);
             // Trigger onJoin event
@@ -12683,55 +15260,76 @@ class KokimokiClient extends EventEmitter$1 {
         }
     }
     async transact(handler) {
-        if (!this._connected) {
-            throw new Error("Client not connected");
-        }
+        // if (!this._connected) {
+        //   throw new Error("Client not connected");
+        // }
         const transaction = new KokimokiTransaction(this);
         await handler(transaction);
         const { updates, consumedMessages } = await transaction.getUpdates();
         if (!updates.length) {
             return;
         }
-        // Construct buffer
-        const writer = new WsMessageWriter();
+        // Construct buffers
+        const remoteUpdateWriter = new WsMessageWriter();
+        const localUpdateWriter = new WsMessageWriter();
         // Write message type
-        writer.writeInt32(WsMessageType.Transaction);
+        remoteUpdateWriter.writeInt32(WsMessageType.Transaction);
         // Update and write transaction ID
         const transactionId = ++this._messageId;
-        writer.writeInt32(transactionId);
-        // Write room hashes where messages were consumed
-        writer.writeInt32(consumedMessages.size);
+        remoteUpdateWriter.writeInt32(transactionId);
+        localUpdateWriter.writeInt32(transactionId);
+        // Write room hashes where messages were consumed (remote only)
+        remoteUpdateWriter.writeInt32(consumedMessages.size);
         for (const roomName of consumedMessages) {
             const subscription = this._subscriptionsByName.get(roomName);
             if (!subscription) {
                 throw new Error(`Cannot consume message in "${roomName}" because it hasn't been joined`);
             }
-            writer.writeUint32(subscription.roomHash);
+            remoteUpdateWriter.writeUint32(subscription.roomHash);
         }
         // Write updates
+        let localUpdates = 0, remoteUpdates = 0;
         for (const { roomName, update } of updates) {
             const subscription = this._subscriptionsByName.get(roomName);
             if (!subscription) {
                 throw new Error(`Cannot send update to "${roomName}" because it hasn't been joined`);
             }
-            writer.writeUint32(subscription.roomHash);
-            writer.writeUint8Array(update);
-        }
-        const buffer = writer.getBuffer();
-        // Wait for server to apply transaction
-        await new Promise((resolve, reject) => {
-            this._transactionPromises.set(transactionId, { resolve, reject });
-            // Send update to server
-            try {
-                this.ws.send(buffer);
+            if (subscription.store instanceof KokimokiLocalStore) {
+                localUpdates++;
+                localUpdateWriter.writeUint32(subscription.roomHash);
+                localUpdateWriter.writeUint8Array(update);
             }
-            catch (e) {
-                // Not connected
-                console.log("Failed to send update to server:", e);
-                // TODO: merge updates or something
-                throw e;
+            else {
+                remoteUpdates++;
+                remoteUpdateWriter.writeUint32(subscription.roomHash);
+                remoteUpdateWriter.writeUint8Array(update);
             }
-        });
+        }
+        // Wait for server to apply transaction
+        if (remoteUpdates) {
+            const remoteBuffer = remoteUpdateWriter.getBuffer();
+            await new Promise((resolve, reject) => {
+                this._transactionPromises.set(transactionId, { resolve, reject });
+                // Send update to server
+                try {
+                    this.ws.send(remoteBuffer);
+                }
+                catch (e) {
+                    // Not connected
+                    console.log("Failed to send update to server:", e);
+                    // Delete transaction promise
+                    this._transactionPromises.delete(transactionId);
+                    // TODO: merge updates or something
+                    reject(e);
+                }
+            });
+        }
+        // Apply local updates
+        if (localUpdates) {
+            const localBuffer = localUpdateWriter.getBuffer();
+            const reader = new WsMessageReader(localBuffer);
+            this.handleRoomUpdateMessage(reader);
+        }
     }
     async close() {
         this._autoReconnect = false;
@@ -12761,6 +15359,14 @@ class KokimokiClient extends EventEmitter$1 {
         }
         return store;
     }
+    // local store
+    localStore(name, schema) {
+        const store = new KokimokiLocalStore(name, schema);
+        this.join(store)
+            .then(() => { })
+            .catch(() => { });
+        return store;
+    }
     // queue
     queue(name, schema, mode, autoJoin = true) {
         const queue = new KokimokiQueue(name, schema, mode);