lib0 0.2.39 → 0.2.43

package/dist/test.cjs

@@ -16,7 +16,7 @@ var isomorphic_js = require('isomorphic.js');
  *
  * @function
  */
-const create = () => new Map();
+const create$7 = () => new Map();
 
 /**
  * Copy a Map object into a fresh Map object.
@@ -27,7 +27,7 @@ const create = () => new Map();
  * @return {Map<X,Y>}
  */
 const copy = m => {
-  const r = create();
+  const r = create$7();
   m.forEach((v, k) => { r.set(k, v); });
   return r
 };
@@ -66,7 +66,7 @@ const setIfUndefined = (map, key, createT) => {
  * @param {function(V,K):R} f
  * @return {Array<R>}
  */
-const map = (m, f) => {
+const map$3 = (m, f) => {
   const res = [];
   for (const [key, value] of m) {
     res.push(f(value, key));
@@ -203,7 +203,7 @@ const decodeUtf8 = utf8TextDecoder ? _decodeUtf8Native : _decodeUtf8Polyfill;
 /* istanbul ignore next */
 const undefinedToNull = v => v === undefined ? null : v;
 
-/* global localStorage */
+/* global localStorage, addEventListener */
 
 /**
  * Isomorphic variable storage.
@@ -221,10 +221,10 @@ class VarStoragePolyfill {
 
   /**
    * @param {string} key
-   * @param {any} value
+   * @param {any} newValue
    */
-  setItem (key, value) {
-    this.map.set(key, value);
+  setItem (key, newValue) {
+    this.map.set(key, newValue);
   }
 
   /**
@@ -240,12 +240,14 @@ class VarStoragePolyfill {
  * @type {any}
  */
 let _localStorage = new VarStoragePolyfill();
+let usePolyfill = true;
 
 try {
   // if the same-origin rule is violated, accessing localStorage might thrown an error
   /* istanbul ignore next */
   if (typeof localStorage !== 'undefined') {
     _localStorage = localStorage;
+    usePolyfill = false;
   }
 } catch (e) { }
 
@@ -255,6 +257,15 @@ try {
  */
 const varStorage = _localStorage;
 
+/* istanbul ignore next */
+/**
+ * A polyfill for `addEventListener('storage', event => {..})` that does nothing if the polyfill is being used.
+ *
+ * @param {function({ key: string, newValue: string, oldValue: string }): void} eventHandler
+ * @function
+ */
+const onChange = eventHandler => usePolyfill || addEventListener('storage', /** @type {any} */ (eventHandler));
+
 /**
  * Isomorphic module to work access the environment (query params, env variables).
  *
@@ -278,7 +289,7 @@ let params;
 const computeParams = () => {
   if (params === undefined) {
     if (isNode) {
-      params = create();
+      params = create$7();
       const pargs = process.argv;
       let currParamName = null;
       /* istanbul ignore next */
@@ -301,7 +312,7 @@ const computeParams = () => {
       }
     // in ReactNative for example this would not be true (unless connected to the Remote Debugger)
     } else if (typeof location === 'object') {
-      params = create()
+      params = create$7()
       // eslint-disable-next-line no-undef
       ;(location.search || '?').slice(1).split('&').forEach(kv => {
         if (kv.length !== 0) {
@@ -311,7 +322,7 @@ const computeParams = () => {
         }
       });
     } else {
-      params = create();
+      params = create$7();
     }
   }
   return params
@@ -361,7 +372,7 @@ const production = hasConf('production');
  *
  * @return {Symbol}
  */
-const create$1 = Symbol;
+const create$6 = Symbol;
 
 /**
  * Working with value pairs.
@@ -389,7 +400,7 @@ class Pair {
  * @param {R} right
  * @return {Pair<L,R>}
  */
-const create$2 = (left, right) => new Pair(left, right);
+const create$5 = (left, right) => new Pair(left, right);
 
 /**
  * @template L,R
@@ -404,7 +415,7 @@ const createReversed = (right, left) => new Pair(left, right);
  * @param {Array<Pair<L,R>>} arr
  * @param {function(L, R):any} f
  */
-const forEach = (arr, f) => arr.forEach(p => f(p.left, p.right));
+const forEach$1 = (arr, f) => arr.forEach(p => f(p.left, p.right));
 
 /**
  * @template L,R,X
@@ -412,7 +423,7 @@ const forEach = (arr, f) => arr.forEach(p => f(p.left, p.right));
  * @param {function(L, R):X} f
  * @return {Array<X>}
  */
-const map$1 = (arr, f) => arr.map(p => f(p.left, p.right));
+const map$2 = (arr, f) => arr.map(p => f(p.left, p.right));
 
 /* eslint-env browser */
 
@@ -452,7 +463,7 @@ const createTextNode = text => doc.createTextNode(text);
  */
 /* istanbul ignore next */
 const setAttributes = (el, attrs) => {
-  forEach(attrs, (key, value) => {
+  forEach$1(attrs, (key, value) => {
     if (value === false) {
       el.removeAttribute(key);
     } else if (value === true) {
@@ -531,7 +542,7 @@ const text = createTextNode;
  * @return {string}
  */
 /* istanbul ignore next */
-const mapToStyleString = m => map(m, (value, key) => `${key}:${value};`).join('');
+const mapToStyleString = m => map$3(m, (value, key) => `${key}:${value};`).join('');
 
 /**
  * @param {Node} parent
@@ -541,6 +552,14 @@ const mapToStyleString = m => map(m, (value, key) => `${key}:${value};`).join(''
 /* istanbul ignore next */
 const appendChild = (parent, child) => parent.appendChild(child);
 
+doc.ELEMENT_NODE;
+doc.TEXT_NODE;
+doc.CDATA_SECTION_NODE;
+doc.COMMENT_NODE;
+doc.DOCUMENT_NODE;
+doc.DOCUMENT_TYPE_NODE;
+doc.DOCUMENT_FRAGMENT_NODE;
+
 /**
  * JSON utility functions.
  *
@@ -566,21 +585,21 @@ const stringify = JSON.stringify;
 /**
  * @type {Array<function>}
  */
-let queue = [];
+let queue$1 = [];
 
 const _runQueue = () => {
-  for (let i = 0; i < queue.length; i++) {
-    queue[i]();
+  for (let i = 0; i < queue$1.length; i++) {
+    queue$1[i]();
   }
-  queue = [];
+  queue$1 = [];
 };
 
 /**
  * @param {function():void} f
  */
-const enqueue = f => {
-  queue.push(f);
-  if (queue.length === 1) {
+const enqueue$1 = f => {
+  queue$1.push(f);
+  if (queue$1.length === 1) {
     setTimeout(_runQueue, 0);
   }
 };
@@ -667,7 +686,7 @@ const log10 = Math.log10;
  * @param {number} b
  * @return {number} The sum of a and b
  */
-const add = (a, b) => a + b;
+const add$1 = (a, b) => a + b;
 
 /**
  * @function
@@ -685,7 +704,7 @@ const min = (a, b) => a < b ? a : b;
  */
 const max = (a, b) => a > b ? a : b;
 
-const isNaN = Number.isNaN;
+const isNaN$1 = Number.isNaN;
 /**
  * Base 10 exponential function. Returns the value of 10 raised to the power of pow.
  *
@@ -818,7 +837,7 @@ const appendTo = (dest, src) => {
  * @param {function(ITEM, number, Array<ITEM>):boolean} f
  * @return {boolean}
  */
-const every = (arr, f) => arr.every(f);
+const every$1 = (arr, f) => arr.every(f);
 
 /**
  * @template ELEM
@@ -827,7 +846,7 @@ const every = (arr, f) => arr.every(f);
  * @param {Array<ELEM>} b
  * @return {boolean}
  */
-const equalFlat = (a, b) => a.length === b.length && every(a, (item, index) => item === b[index]);
+const equalFlat$1 = (a, b) => a.length === b.length && every$1(a, (item, index) => item === b[index]);
 
 /**
  * @template ELEM
@@ -845,7 +864,7 @@ const flatten = arr => arr.reduce((acc, val) => acc.concat(val), []);
 /**
  * @return {Object<string,any>} obj
  */
-const create$3 = () => Object.create(null);
+const create$4 = () => Object.create(null);
 
 /**
  * Object.assign
@@ -861,7 +880,7 @@ const keys = Object.keys;
  * @param {Object<string,any>} obj
  * @param {function(any,string):any} f
  */
-const forEach$1 = (obj, f) => {
+const forEach = (obj, f) => {
   for (const key in obj) {
     f(obj[key], key);
   }
@@ -873,7 +892,7 @@ const forEach$1 = (obj, f) => {
  * @param {function(any,string):R} f
  * @return {Array<R>}
  */
-const map$2 = (obj, f) => {
+const map$1 = (obj, f) => {
   const results = [];
   for (const key in obj) {
     results.push(f(obj[key], key));
@@ -885,7 +904,7 @@ const map$2 = (obj, f) => {
  * @param {Object<string,any>} obj
  * @return {number}
  */
-const length = obj => keys(obj).length;
+const length$1 = obj => keys(obj).length;
 
 /**
  * @param {Object<string,any>} obj
@@ -906,7 +925,7 @@ const some = (obj, f) => {
  * @param {function(any,string):boolean} f
  * @return {boolean}
  */
-const every$1 = (obj, f) => {
+const every = (obj, f) => {
   for (const key in obj) {
     if (!f(obj[key], key)) {
       return false
@@ -929,7 +948,7 @@ const hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key)
  * @param {Object<string,any>} b
  * @return {boolean}
  */
-const equalFlat$1 = (a, b) => a === b || (length(a) === length(b) && every$1(a, (val, key) => (val !== undefined || hasProperty(b, key)) && b[key] === val));
+const equalFlat = (a, b) => a === b || (length$1(a) === length$1(b) && every(a, (val, key) => (val !== undefined || hasProperty(b, key)) && b[key] === val));
 
 /**
  * Common functions and function call helpers.
@@ -953,7 +972,7 @@ const equalityStrict = (a, b) => a === b;
  * @param {Array<T>|object} b
  * @return {boolean}
  */
-const equalityFlat = (a, b) => a === b || (a != null && b != null && a.constructor === b.constructor && ((a instanceof Array && equalFlat(a, /** @type {Array<T>} */ (b))) || (typeof a === 'object' && equalFlat$1(a, b))));
+const equalityFlat = (a, b) => a === b || (a != null && b != null && a.constructor === b.constructor && ((a instanceof Array && equalFlat$1(a, /** @type {Array<T>} */ (b))) || (typeof a === 'object' && equalFlat(a, b))));
 
 /**
  * @param {any} a
@@ -1009,7 +1028,7 @@ const equalityDeep = (a, b) => {
       break
     }
     case Object:
-      if (length(a) !== length(b)) {
+      if (length$1(a) !== length$1(b)) {
         return false
       }
       for (const key in a) {
@@ -1040,29 +1059,29 @@ const equalityDeep = (a, b) => {
  * @module logging
  */
 
-const BOLD = create$1();
-const UNBOLD = create$1();
-const BLUE = create$1();
-const GREY = create$1();
-const GREEN = create$1();
-const RED = create$1();
-const PURPLE = create$1();
-const ORANGE = create$1();
-const UNCOLOR = create$1();
+const BOLD = create$6();
+const UNBOLD = create$6();
+const BLUE = create$6();
+const GREY = create$6();
+const GREEN = create$6();
+const RED = create$6();
+const PURPLE = create$6();
+const ORANGE = create$6();
+const UNCOLOR = create$6();
 
 /**
  * @type {Object<Symbol,pair.Pair<string,string>>}
  */
 const _browserStyleMap = {
-  [BOLD]: create$2('font-weight', 'bold'),
-  [UNBOLD]: create$2('font-weight', 'normal'),
-  [BLUE]: create$2('color', 'blue'),
-  [GREEN]: create$2('color', 'green'),
-  [GREY]: create$2('color', 'grey'),
-  [RED]: create$2('color', 'red'),
-  [PURPLE]: create$2('color', 'purple'),
-  [ORANGE]: create$2('color', 'orange'), // not well supported in chrome when debugging node with inspector - TODO: deprecate
-  [UNCOLOR]: create$2('color', 'black')
+  [BOLD]: create$5('font-weight', 'bold'),
+  [UNBOLD]: create$5('font-weight', 'normal'),
+  [BLUE]: create$5('color', 'blue'),
+  [GREEN]: create$5('color', 'green'),
+  [GREY]: create$5('color', 'grey'),
+  [RED]: create$5('color', 'red'),
+  [PURPLE]: create$5('color', 'purple'),
+  [ORANGE]: create$5('color', 'orange'), // not well supported in chrome when debugging node with inspector - TODO: deprecate
+  [UNCOLOR]: create$5('color', 'black')
 };
 
 const _nodeStyleMap = {
@@ -1085,7 +1104,7 @@ const _nodeStyleMap = {
 const computeBrowserLoggingArgs = args => {
   const strBuilder = [];
   const styles = [];
-  const currentStyle = create();
+  const currentStyle = create$7();
   /**
    * @type {Array<string|Object|number>}
    */
@@ -1214,7 +1233,7 @@ const printImgBase64 = (base64, height) => printImg(`data:image/gif;base64,${bas
 /**
  * @param {Array<string|Symbol|Object|number>} args
  */
-const group = (...args) => {
+const group$1 = (...args) => {
   console.group(...computeLoggingArgs(args));
   /* istanbul ignore next */
   vconsoles.forEach(vc => vc.group(args));
@@ -1240,7 +1259,7 @@ const groupEnd = () => {
  * @param {HTMLCanvasElement} canvas
  * @param {number} height
  */
-const printCanvas = (canvas, height) => printImg(canvas.toDataURL(), height);
+const printCanvas$1 = (canvas, height) => printImg(canvas.toDataURL(), height);
 
 const vconsoles = new Set();
 
@@ -1263,7 +1282,7 @@ const _computeLineSpans = args => {
     } else {
       if (arg.constructor === String || arg.constructor === Number) {
         // @ts-ignore
-        const span = element('span', [create$2('style', mapToStyleString(currentStyle))], [text(arg)]);
+        const span = element('span', [create$5('style', mapToStyleString(currentStyle))], [text(arg)]);
         if (span.innerHTML === '') {
           span.innerHTML = '&nbsp;';
         }
@@ -1308,11 +1327,11 @@ class VConsole {
    * @param {boolean} collapsed
    */
   group (args, collapsed = false) {
-    enqueue(() => {
-      const triangleDown = element('span', [create$2('hidden', collapsed), create$2('style', 'color:grey;font-size:120%;')], [text('▼')]);
-      const triangleRight = element('span', [create$2('hidden', !collapsed), create$2('style', 'color:grey;font-size:125%;')], [text('▶')]);
-      const content = element('div', [create$2('style', `${lineStyle};padding-left:${this.depth * 10}px`)], [triangleDown, triangleRight, text(' ')].concat(_computeLineSpans(args)));
-      const nextContainer = element('div', [create$2('hidden', collapsed)]);
+    enqueue$1(() => {
+      const triangleDown = element('span', [create$5('hidden', collapsed), create$5('style', 'color:grey;font-size:120%;')], [text('▼')]);
+      const triangleRight = element('span', [create$5('hidden', !collapsed), create$5('style', 'color:grey;font-size:125%;')], [text('▶')]);
+      const content = element('div', [create$5('style', `${lineStyle};padding-left:${this.depth * 10}px`)], [triangleDown, triangleRight, text(' ')].concat(_computeLineSpans(args)));
+      const nextContainer = element('div', [create$5('hidden', collapsed)]);
       const nextLine = element('div', [], [content, nextContainer]);
       append(this.ccontainer, [nextLine]);
       this.ccontainer = nextContainer;
@@ -1334,7 +1353,7 @@ class VConsole {
   }
 
   groupEnd () {
-    enqueue(() => {
+    enqueue$1(() => {
       if (this.depth > 0) {
         this.depth--;
         // @ts-ignore
@@ -1347,8 +1366,8 @@ class VConsole {
    * @param {Array<string|Symbol|Object|number>} args
    */
   print (args) {
-    enqueue(() => {
-      append(this.ccontainer, [element('div', [create$2('style', `${lineStyle};padding-left:${this.depth * 10}px`)], _computeLineSpans(args))]);
+    enqueue$1(() => {
+      append(this.ccontainer, [element('div', [create$5('style', `${lineStyle};padding-left:${this.depth * 10}px`)], _computeLineSpans(args))]);
     });
   }
 
@@ -1364,8 +1383,8 @@ class VConsole {
    * @param {number} height
    */
   printImg (url, height) {
-    enqueue(() => {
-      append(this.ccontainer, [element('img', [create$2('src', url), create$2('height', `${round(height * 1.5)}px`)])]);
+    enqueue$1(() => {
+      append(this.ccontainer, [element('img', [create$5('src', url), create$5('height', `${round(height * 1.5)}px`)])]);
     });
   }
 
@@ -1373,13 +1392,13 @@ class VConsole {
    * @param {Node} node
    */
   printDom (node) {
-    enqueue(() => {
+    enqueue$1(() => {
       append(this.ccontainer, [node]);
     });
   }
 
   destroy () {
-    enqueue(() => {
+    enqueue$1(() => {
       vconsoles.delete(this);
     });
   }
@@ -1448,12 +1467,6 @@ const simpleDiffString = (a, b) => {
   }
 };
 
-/**
- * @todo Remove in favor of simpleDiffString
- * @deprecated
- */
-const simpleDiff = simpleDiffString;
-
 /**
  * Create a diff between two arrays. This diff implementation is highly
  * efficient, but not very sophisticated.
@@ -1489,12 +1502,12 @@ const simpleDiffArray = (a, b, compare = equalityStrict) => {
 };
 
 /* istanbul ignore next */
-const uint32 = () => new Uint32Array(isomorphic_js.cryptoRandomBuffer(4))[0];
+const uint32$1 = () => new Uint32Array(isomorphic_js.cryptoRandomBuffer(4))[0];
 
 // @ts-ignore
 const uuidv4Template = [1e7] + -1e3 + -4e3 + -8e3 + -1e11;
 const uuidv4 = () => uuidv4Template.replace(/[018]/g, /** @param {number} c */ c =>
-  (c ^ uint32() & 15 >> c / 4).toString(16)
+  (c ^ uint32$1() & 15 >> c / 4).toString(16)
 );
 
 /* eslint-env browser */
@@ -1588,7 +1601,7 @@ const BITS31 = 0x7FFFFFFF;
  */
 const BITS32 = 0xFFFFFFFF;
 
-var binary = /*#__PURE__*/Object.freeze({
+var binary$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   BIT1: BIT1,
   BIT2: BIT2,
@@ -1821,7 +1834,7 @@ const HIGHEST_INT32 = BITS31;
 
 /* istanbul ignore next */
 const isInteger = Number.isInteger || (num => typeof num === 'number' && isFinite(num) && floor(num) === num);
-const isNaN$1 = Number.isNaN;
+const isNaN = Number.isNaN;
 
 /**
  * Efficient schema-less binary encoding with support for variable length encoding.
@@ -1878,7 +1891,7 @@ const createEncoder = () => new Encoder();
  * @param {Encoder} encoder
  * @return {number}
  */
-const length$1 = encoder => {
+const length = encoder => {
   let len = encoder.cpos;
   for (let i = 0; i < encoder.bufs.length; i++) {
     len += encoder.bufs[i].length;
@@ -1894,7 +1907,7 @@ const length$1 = encoder => {
  * @return {Uint8Array} The created ArrayBuffer.
  */
 const toUint8Array = encoder => {
-  const uint8arr = new Uint8Array(length$1(encoder));
+  const uint8arr = new Uint8Array(length(encoder));
   let curPos = 0;
   for (let i = 0; i < encoder.bufs.length; i++) {
     const d = encoder.bufs[i];
@@ -2193,19 +2206,19 @@ const writeOnDataView = (encoder, len) => {
  * @param {Encoder} encoder
  * @param {number} num
  */
-const writeFloat32 = (encoder, num) => writeOnDataView(encoder, 4).setFloat32(0, num);
+const writeFloat32 = (encoder, num) => writeOnDataView(encoder, 4).setFloat32(0, num, false);
 
 /**
  * @param {Encoder} encoder
  * @param {number} num
  */
-const writeFloat64 = (encoder, num) => writeOnDataView(encoder, 8).setFloat64(0, num);
+const writeFloat64 = (encoder, num) => writeOnDataView(encoder, 8).setFloat64(0, num, false);
 
 /**
  * @param {Encoder} encoder
  * @param {bigint} num
  */
-const writeBigInt64 = (encoder, num) => /** @type {any} */ (writeOnDataView(encoder, 8)).setBigInt64(0, num);
+const writeBigInt64 = (encoder, num) => /** @type {any} */ (writeOnDataView(encoder, 8)).setBigInt64(0, num, false);
 
 const floatTestBed = new DataView(new ArrayBuffer(4));
 /**
@@ -2443,6 +2456,7 @@ class RleIntDiffEncoder extends Encoder {
  * @param {UintOptRleEncoder} encoder
  */
 const flushUintOptRleEncoder = encoder => {
+  /* istanbul ignore else */
   if (encoder.count > 0) {
     // flush counter, unless this is the first value (count = 0)
     // case 1: just a single value. set sign to positive
@@ -2783,7 +2797,7 @@ const readUint32BigEndian = decoder => {
 };
 
 /**
- * Look ahead without incrementing position.
+ * Look ahead without incrementing the position
  * to the next byte and read it as unsigned integer.
  *
  * @function
@@ -2793,7 +2807,7 @@ const readUint32BigEndian = decoder => {
 const peekUint8 = decoder => decoder.arr[decoder.pos];
 
 /**
- * Look ahead without incrementing position.
+ * Look ahead without incrementing the position
  * to the next byte and read it as unsigned integer.
  *
  * @function
@@ -2805,7 +2819,7 @@ const peekUint16 = decoder =>
   (decoder.arr[decoder.pos + 1] << 8);
 
 /**
- * Look ahead without incrementing position.
+ * Look ahead without incrementing the position
  * to the next byte and read it as unsigned integer.
  *
  * @function
@@ -2851,7 +2865,7 @@ const readVarUint = decoder => {
  * 1/8th of the storage is used as encoding overhead.
  *  * numbers < 2^7 is stored in one bytlength
  *  * numbers < 2^14 is stored in two bylength
- * @todo This should probably create the inverse ~num if unmber is negative - but this would be a breaking change.
+ * @todo This should probably create the inverse ~num if number is negative - but this would be a breaking change.
  *
  * @function
  * @param {Decoder} decoder
@@ -2974,17 +2988,17 @@ const readFromDataView = (decoder, len) => {
 /**
  * @param {Decoder} decoder
  */
-const readFloat32 = decoder => readFromDataView(decoder, 4).getFloat32(0);
+const readFloat32 = decoder => readFromDataView(decoder, 4).getFloat32(0, false);
 
 /**
  * @param {Decoder} decoder
  */
-const readFloat64 = decoder => readFromDataView(decoder, 8).getFloat64(0);
+const readFloat64 = decoder => readFromDataView(decoder, 8).getFloat64(0, false);
 
 /**
  * @param {Decoder} decoder
  */
-const readBigInt64 = decoder => /** @type {any} */ (readFromDataView(decoder, 8)).getBigInt64(0);
+const readBigInt64 = decoder => /** @type {any} */ (readFromDataView(decoder, 8)).getBigInt64(0, false);
 
 /**
  * @type {Array<function(Decoder):any>}
@@ -3348,7 +3362,7 @@ const DefaultPRNG = Xoroshiro128plus;
  * @param {number} seed A positive 32bit integer. Do not use negative numbers.
  * @return {PRNG}
  */
-const create$4 = seed => new DefaultPRNG(seed);
+const create$3 = seed => new DefaultPRNG(seed);
 
 /**
  * Generates a single random bool.
@@ -3396,7 +3410,7 @@ const int32 = (gen, min, max) => floor(gen.next() * (max + 1 - min) + min);
  * @param {Number} max The upper bound of the allowed return values (inclusive).
  * @return {Number} A random integer on [min, max]
  */
-const uint32$1 = (gen, min, max) => int32(gen, min, max) >>> 0;
+const uint32 = (gen, min, max) => int32(gen, min, max) >>> 0;
 
 /**
  * @deprecated
@@ -3519,7 +3533,7 @@ const median = arr => arr.length === 0 ? NaN : (arr.length % 2 === 1 ? arr[(arr.
  * @param {Array<number>} arr
  * @return {number}
  */
-const average = arr => arr.reduce(add, 0) / arr.length;
+const average = arr => arr.reduce(add$1, 0) / arr.length;
 
 /**
  * Utility helpers to work with promises.
@@ -3538,7 +3552,7 @@ const average = arr => arr.reduce(add, 0) / arr.length;
  * @param {function(PromiseResolve<T>,function(Error):void):any} f
  * @return {Promise<T>}
  */
-const create$5 = f => /** @type {Promise<T>} */ (new Promise(f));
+const create$2 = f => /** @type {Promise<T>} */ (new Promise(f));
 
 /**
  * @param {function(function():void,function(Error):void):void} f
@@ -3575,7 +3589,7 @@ const resolve = res => Promise.resolve(res);
  * @param {number} [intervalResolution]
  * @return {Promise<void>}
  */
-const until = (timeout, check, intervalResolution = 10) => create$5((resolve, reject) => {
+const until = (timeout, check, intervalResolution = 10) => create$2((resolve, reject) => {
   const startTime = getUnixTime();
   const hasTimeout = timeout > 0;
   const untilInterval = () => {
@@ -3597,7 +3611,7 @@ const until = (timeout, check, intervalResolution = 10) => create$5((resolve, re
  * @param {number} timeout
  * @return {Promise<undefined>}
  */
-const wait = timeout => create$5((resolve, reject) => setTimeout(resolve, timeout));
+const wait = timeout => create$2((resolve, reject) => setTimeout(resolve, timeout));
 
 /**
  * Checks if an object is a promise using ducktyping.
@@ -3691,7 +3705,7 @@ class TestCase {
     /* istanbul ignore else */
     if (this._seed === null) {
       /* istanbul ignore next */
-      this._seed = envSeed === null ? uint32() : envSeed;
+      this._seed = envSeed === null ? uint32$1() : envSeed;
     }
     return this._seed
   }
@@ -3704,13 +3718,13 @@ class TestCase {
   get prng () {
     /* istanbul ignore else */
     if (this._prng === null) {
-      this._prng = create$4(this.seed);
+      this._prng = create$3(this.seed);
     }
     return this._prng
   }
 }
 
-const repititionTime = Number(getParam('--repitition-time', '50'));
+const repetitionTime = Number(getParam('--repetition-time', '50'));
 /* istanbul ignore next */
 const testFilter = hasParam('--filter') ? getParam('--filter', '') : null;
 
@@ -3740,11 +3754,14 @@ const run = async (moduleName, name, f, i, numberOfTests) => {
   if (testFilter === null) {
     groupCollapsed(...groupArgs);
   } else {
-    group(...groupArgs);
+    group$1(...groupArgs);
   }
   const times = [];
   const start = isomorphic_js.performance.now();
   let lastTime = start;
+  /**
+   * @type {any}
+   */
   let err = null;
   isomorphic_js.performance.mark(`${name}-start`);
   do {
@@ -3759,12 +3776,12 @@ const run = async (moduleName, name, f, i, numberOfTests) => {
     const currTime = isomorphic_js.performance.now();
     times.push(currTime - lastTime);
     lastTime = currTime;
-    if (repeat && err === null && (lastTime - start) < repititionTime) {
+    if (repeat && err === null && (lastTime - start) < repetitionTime) {
       tc.resetSeed();
     } else {
       break
     }
-  } while (err === null && (lastTime - start) < repititionTime)
+  } while (err === null && (lastTime - start) < repetitionTime)
   isomorphic_js.performance.mark(`${name}-end`);
   /* istanbul ignore if */
   if (err !== null && err.constructor !== SkipError) {
@@ -3780,7 +3797,7 @@ const run = async (moduleName, name, f, i, numberOfTests) => {
     ? `     - ${window.location.href}?filter=\\[${i + 1}/${tc._seed === null ? '' : `&seed=${tc._seed}`}`
     : `\nrepeat: npm run test -- --filter "\\[${i + 1}/" ${tc._seed === null ? '' : `--seed ${tc._seed}`}`;
   const timeInfo = (repeat && err === null)
-    ? ` - ${times.length} repititions in ${humanizeDuration(duration)} (best: ${humanizeDuration(times[0])}, worst: ${humanizeDuration(last(times))}, median: ${humanizeDuration(median(times))}, average: ${humanizeDuration(average(times))})`
+    ? ` - ${times.length} repetitions in ${humanizeDuration(duration)} (best: ${humanizeDuration(times[0])}, worst: ${humanizeDuration(last(times))}, median: ${humanizeDuration(median(times))}, average: ${humanizeDuration(average(times))})`
     : ` in ${humanizeDuration(duration)}`;
   if (err !== null) {
     /* istanbul ignore else */
@@ -3822,7 +3839,7 @@ const describe = (description, info = '') => print(BLUE, description, ' ', GREY,
  */
 const info = info => describe('', info);
 
-const printCanvas$1 = printCanvas;
+const printCanvas = printCanvas$1;
 
 /**
  * Group outputs in a collapsible category.
@@ -3842,8 +3859,8 @@ const printCanvas$1 = printCanvas;
  * @param {string} description
  * @param {function(void):void} f
  */
-const group$1 = (description, f) => {
-  group(BLUE, description);
+const group = (description, f) => {
+  group$1(BLUE, description);
   try {
     f();
   } finally {
@@ -3870,7 +3887,7 @@ const group$1 = (description, f) => {
  * @param {function(void):Promise<any>} f
  */
 const groupAsync = async (description, f) => {
-  group(BLUE, description);
+  group$1(BLUE, description);
   try {
     await f();
   } finally {
@@ -3965,7 +3982,7 @@ const compareArrays = (as, bs, m = 'Arrays match') => {
  */
 const compareStrings = (a, b, m = 'Strings match') => {
   if (a !== b) {
-    const diff = simpleDiff(a, b);
+    const diff = simpleDiffString(a, b);
     print(GREY, a.slice(0, diff.index), RED, a.slice(diff.index, diff.remove), GREEN, diff.insert, GREY, a.slice(diff.index + diff.remove));
     fail(m);
   }
@@ -3978,7 +3995,7 @@ const compareStrings = (a, b, m = 'Strings match') => {
  * @param {string} [m]
  * @throws {TestError} Throws if test fails
  */
-const compareObjects = (a, b, m = 'Objects match') => { equalFlat$1(a, b) || fail(m); };
+const compareObjects = (a, b, m = 'Objects match') => { equalFlat(a, b) || fail(m); };
 
 /**
  * @param {any} constructor
@@ -4062,10 +4079,10 @@ const _compare = (a, b, path, message, customCompare) => {
       break
     }
     case Object:
-      if (length(a) !== length(b)) {
+      if (length$1(a) !== length$1(b)) {
         _failMessage(message, 'Objects have a different number of attributes', path);
       }
-      forEach$1(a, (value, key) => {
+      forEach(a, (value, key) => {
         if (!hasProperty(b, key)) {
           _failMessage(message, `Property ${path} does not exist on second argument`, path);
         }
@@ -4128,7 +4145,7 @@ const fails = f => {
  * @param {Object<string, Object<string, function(TestCase):void|Promise<any>>>} tests
  */
 const runTests = async tests => {
-  const numberOfTests = map$2(tests, mod => map$2(mod, f => /* istanbul ignore next */ f ? 1 : 0).reduce(add, 0)).reduce(add, 0);
+  const numberOfTests = map$1(tests, mod => map$1(mod, f => /* istanbul ignore next */ f ? 1 : 0).reduce(add$1, 0)).reduce(add$1, 0);
   let successfulTests = 0;
   let testnumber = 0;
   const start = isomorphic_js.performance.now();
@@ -4317,8 +4334,8 @@ let genAnyLookupTable = [
   gen => false, // TYPE 120
   gen => utf16String(gen), // TYPE 119
   (gen, depth, toJsonCompatible) => ({ val: genAny(gen, depth + 1, toJsonCompatible) }), // TYPE 118
-  (gen, depth, toJsonCompatible) => Array.from({ length: uint32$1(gen, 0, 20 - depth) }).map(() => genAny(gen, depth + 1, toJsonCompatible)), // TYPE 117
-  gen => uint8Array(gen, uint32$1(gen, 0, 50)) // TYPE 116
+  (gen, depth, toJsonCompatible) => Array.from({ length: uint32(gen, 0, 20 - depth) }).map(() => genAny(gen, depth + 1, toJsonCompatible)), // TYPE 117
+  gen => uint8Array(gen, uint32(gen, 0, 50)) // TYPE 116
 ];
 
 const genAnyLookupTableJsonCompatible = genAnyLookupTable.slice(1);
@@ -4387,7 +4404,7 @@ function test (testname, write, read, val, doLog = true) {
   const reader = createDecoder(toUint8Array(encoder));
   const result = read(reader);
   const utf8ByteLength$1 = utf8ByteLength(val + '');
-  const binaryByteLength = length$1(encoder);
+  const binaryByteLength = length(encoder);
   if (doLog) {
     describe(testname, ` utf8 encode: ${utf8ByteLength$1} bytes / binary encode: ${binaryByteLength} bytes`);
   }
@@ -4553,7 +4570,7 @@ const testRepeatVarUintEncoding = tc => {
  * @param {t.TestCase} tc
  */
 const testRepeatVarIntEncoding = tc => {
-  const n = uint32$1(tc.prng, 0, BITS32);
+  const n = uint32(tc.prng, 0, BITS32);
   test(`varInt of ${n}`, writeVarInt, readVarInt, n, false);
 };
 
@@ -4577,7 +4594,7 @@ const testRepeatPeekVarUintEncoding = tc => {
  * @param {t.TestCase} tc
  */
 const testRepeatPeekVarIntEncoding = tc => {
-  const n = uint32$1(tc.prng, 0, BITS32);
+  const n = uint32(tc.prng, 0, BITS32);
   test(`varInt of ${n}`, writeVarInt, peekVarInt, n, false);
 };
 
@@ -4668,12 +4685,12 @@ const strictComparison = (a, b) => a === b;
  */
 const encodingPairs = [
   { name: 'uint8Array', read: decoder => readUint8Array(decoder, defLen), write: writeUint8Array, gen: gen => uint8Array(gen, defLen), compare: compare },
-  { name: 'varUint8Array', read: readVarUint8Array, write: writeVarUint8Array, gen: gen => uint8Array(gen, uint32$1(gen, 0, defLen)), compare: compare },
-  { name: 'uint8', read: readUint8, write: writeUint8, gen: gen => uint32$1(gen, 0, BITS8), compare: strictComparison },
-  { name: 'uint16', read: readUint16, write: writeUint16, gen: gen => uint32$1(gen, 0, BITS16), compare: strictComparison },
-  { name: 'uint32', read: readUint32, write: writeUint32, gen: gen => uint32$1(gen, 0, BITS32), compare: strictComparison },
-  { name: 'uint32bigEndian', read: readUint32BigEndian, write: writeUint32BigEndian, gen: gen => uint32$1(gen, 0, BITS32), compare: strictComparison },
-  { name: 'varString', read: readVarString, write: writeVarString, gen: gen => utf16String(gen, uint32$1(gen, 0, defLen)), compare: strictComparison },
+  { name: 'varUint8Array', read: readVarUint8Array, write: writeVarUint8Array, gen: gen => uint8Array(gen, uint32(gen, 0, defLen)), compare: compare },
+  { name: 'uint8', read: readUint8, write: writeUint8, gen: gen => uint32(gen, 0, BITS8), compare: strictComparison },
+  { name: 'uint16', read: readUint16, write: writeUint16, gen: gen => uint32(gen, 0, BITS16), compare: strictComparison },
+  { name: 'uint32', read: readUint32, write: writeUint32, gen: gen => uint32(gen, 0, BITS32), compare: strictComparison },
+  { name: 'uint32bigEndian', read: readUint32BigEndian, write: writeUint32BigEndian, gen: gen => uint32(gen, 0, BITS32), compare: strictComparison },
+  { name: 'varString', read: readVarString, write: writeVarString, gen: gen => utf16String(gen, uint32(gen, 0, defLen)), compare: strictComparison },
   { name: 'varUint', read: readVarUint, write: writeVarUint, gen: gen => uint53(gen, 0, BITS32), compare: strictComparison },
   { name: 'varInt', read: readVarInt, write: writeVarInt, gen: gen => int53(gen, LOWEST_INT32, HIGHEST_INT32), compare: strictComparison },
   { name: 'Any', read: readAny, write: writeAny, gen: genAny, compare: compare }
@@ -4702,7 +4719,7 @@ const testRepeatRandomWrites = tc => {
   writeUint8Array(encoder, tailData);
   const buf = toUint8Array(encoder);
   const decoder = createDecoder(buf);
-  assert(length$1(encoder) === buf.byteLength);
+  assert(length(encoder) === buf.byteLength);
   for (let i = 0; i < ops.length; i++) {
     const o = ops[i];
     const val = o.read(decoder);
@@ -4740,7 +4757,7 @@ const testSetOnOverflow = tc => {
   encoder.cpos = initialLen - 2;
   writeUint32(encoder, BITS32);
   const buf = toUint8Array(encoder);
-  assert(length$1(encoder) === initialLen + 2);
+  assert(length(encoder) === initialLen + 2);
   const decoder = createDecoder(buf);
   const space = createUint8ArrayFromArrayBuffer(readUint8Array(decoder, initialLen - 2));
   for (let i = 0; i < initialLen - 2; i++) {
@@ -5065,7 +5082,7 @@ const testComparing = tc => {
   compare([1, 2], [1, 2], 'simple compare (array)');
   compare({ a: [1, 2] }, { a: [1, 2] }, 'simple compare nested');
   compare(new Set(['3', 1234]), new Set(['3', 1234]), 'compare Sets');
-  const map1 = create();
+  const map1 = create$7();
   map1.set(1, 2);
   map1.set('x', {});
   map1.set(98, 'tst');
@@ -5169,17 +5186,17 @@ const testSkipping = () => {
 };
 
 const testAsync = async () => {
-  await measureTimeAsync('time', () => create$5(r => setTimeout(r)));
+  await measureTimeAsync('time', () => create$2(r => setTimeout(r)));
   await groupAsync('some description', () => wait(1));
 };
 
-const testRepeatRepitition = () => {
+const testRepeatRepetition = () => {
   const arr = [];
   const n = 100;
   for (let i = 1; i <= n; i++) {
     arr.push(i);
   }
-  assert(arr.reduce(add, 0) === (n + 1) * n / 2);
+  assert(arr.reduce(add$1, 0) === (n + 1) * n / 2);
 };
 
 var testing = /*#__PURE__*/Object.freeze({
@@ -5188,7 +5205,7 @@ var testing = /*#__PURE__*/Object.freeze({
   testFailing: testFailing,
   testSkipping: testSkipping,
   testAsync: testAsync,
-  testRepeatRepitition: testRepeatRepitition
+  testRepeatRepetition: testRepeatRepetition
 });
 
 /**
@@ -5197,23 +5214,23 @@ var testing = /*#__PURE__*/Object.freeze({
  * @module error
  */
 
+/* istanbul ignore next */
 /**
  * @param {string} s
  * @return {Error}
  */
-/* istanbul ignore next */
-const create$6 = s => new Error(s);
+const create$1 = s => new Error(s);
 
 /* eslint-env browser */
 
+/* istanbul ignore next */
 /**
  * IDB Request to Promise transformer
  *
  * @param {IDBRequest} request
  * @return {Promise<any>}
  */
-/* istanbul ignore next */
-const rtop = request => create$5((resolve, reject) => {
+const rtop = request => create$2((resolve, reject) => {
   /* istanbul ignore next */
   // @ts-ignore
   request.onerror = event => reject(new Error(event.target.error));
@@ -5224,13 +5241,13 @@ const rtop = request => create$5((resolve, reject) => {
   request.onsuccess = event => resolve(event.target.result);
 });
 
+/* istanbul ignore next */
 /**
  * @param {string} name
  * @param {function(IDBDatabase):any} initDB Called when the database is first created
  * @return {Promise<IDBDatabase>}
  */
-/* istanbul ignore next */
-const openDB = (name, initDB) => create$5((resolve, reject) => {
+const openDB = (name, initDB) => create$2((resolve, reject) => {
   const request = indexedDB.open(name);
   /**
    * @param {any} event
@@ -5240,7 +5257,7 @@ const openDB = (name, initDB) => create$5((resolve, reject) => {
   /**
    * @param {any} event
    */
-  request.onerror = event => reject(create$6(event.target.error));
+  request.onerror = event => reject(create$1(event.target.error));
   /* istanbul ignore next */
   request.onblocked = () => location.reload();
   /**
@@ -5261,82 +5278,82 @@ const openDB = (name, initDB) => create$5((resolve, reject) => {
   };
 });
 
+/* istanbul ignore next */
 /**
  * @param {string} name
  */
-/* istanbul ignore next */
 const deleteDB = name => rtop(indexedDB.deleteDatabase(name));
 
+/* istanbul ignore next */
 /**
  * @param {IDBDatabase} db
  * @param {Array<Array<string>|Array<string|IDBObjectStoreParameters|undefined>>} definitions
  */
-/* istanbul ignore next */
 const createStores = (db, definitions) => definitions.forEach(d =>
   // @ts-ignore
   db.createObjectStore.apply(db, d)
 );
 
+/* istanbul ignore next */
 /**
  * @param {IDBObjectStore} store
  * @param {String | number | ArrayBuffer | Date | Array<any> } key
  * @return {Promise<String | number | ArrayBuffer | Date | Array<any>>}
  */
-/* istanbul ignore next */
 const get = (store, key) =>
   rtop(store.get(key));
 
+/* istanbul ignore next */
 /**
  * @param {IDBObjectStore} store
  * @param {String | number | ArrayBuffer | Date | IDBKeyRange | Array<any> } key
  */
-/* istanbul ignore next */
 const del = (store, key) =>
   rtop(store.delete(key));
 
+/* istanbul ignore next */
 /**
  * @param {IDBObjectStore} store
  * @param {String | number | ArrayBuffer | Date | boolean} item
  * @param {String | number | ArrayBuffer | Date | Array<any>} [key]
  */
-/* istanbul ignore next */
 const put = (store, item, key) =>
   rtop(store.put(item, key));
 
+/* istanbul ignore next */
 /**
  * @param {IDBObjectStore} store
  * @param {String | number | ArrayBuffer | Date | boolean}  item
  * @param {String | number | ArrayBuffer | Date | Array<any>}  key
  * @return {Promise<any>}
  */
-/* istanbul ignore next */
-const add$1 = (store, item, key) =>
+const add = (store, item, key) =>
   rtop(store.add(item, key));
 
+/* istanbul ignore next */
 /**
  * @param {IDBObjectStore} store
  * @param {String | number | ArrayBuffer | Date}  item
  * @return {Promise<number>} Returns the generated key
  */
-/* istanbul ignore next */
 const addAutoKey = (store, item) =>
   rtop(store.add(item));
 
+/* istanbul ignore next */
 /**
  * @param {IDBObjectStore} store
  * @param {IDBKeyRange} [range]
  * @return {Promise<Array<any>>}
  */
-/* istanbul ignore next */
 const getAll = (store, range) =>
   rtop(store.getAll(range));
 
+/* istanbul ignore next */
 /**
  * @param {IDBObjectStore} store
  * @param {IDBKeyRange} [range]
  * @return {Promise<Array<any>>}
  */
-/* istanbul ignore next */
 const getAllKeys = (store, range) =>
   rtop(store.getAllKeys(range));
 
@@ -5347,23 +5364,23 @@ const getAllKeys = (store, range) =>
  * @property {any} v Value
  */
 
+/* istanbul ignore next */
 /**
  * @param {IDBObjectStore} store
  * @param {IDBKeyRange} [range]
  * @return {Promise<Array<KeyValuePair>>}
  */
-/* istanbul ignore next */
 const getAllKeysValues = (store, range) =>
   // @ts-ignore
   all([getAllKeys(store, range), getAll(store, range)]).then(([ks, vs]) => ks.map((k, i) => ({ k, v: vs[i] })));
 
+/* istanbul ignore next */
 /**
  * @param {any} request
  * @param {function(IDBCursorWithValue):void|boolean} f
  * @return {Promise<void>}
  */
-/* istanbul ignore next */
-const iterateOnRequest = (request, f) => create$5((resolve, reject) => {
+const iterateOnRequest = (request, f) => create$2((resolve, reject) => {
   /* istanbul ignore next */
   request.onerror = reject;
   /**
@@ -5378,6 +5395,7 @@ const iterateOnRequest = (request, f) => create$5((resolve, reject) => {
   };
 });
 
+/* istanbul ignore next */
 /**
  * Iterate on keys and values
  * @param {IDBObjectStore} store
@@ -5385,10 +5403,10 @@ const iterateOnRequest = (request, f) => create$5((resolve, reject) => {
  * @param {function(any,any):void|boolean} f Callback that receives (value, key)
  * @param {'next'|'prev'|'nextunique'|'prevunique'} direction
  */
-/* istanbul ignore next */
 const iterate = (store, keyrange, f, direction = 'next') =>
   iterateOnRequest(store.openCursor(keyrange, direction), cursor => f(cursor.value, cursor.key));
 
+/* istanbul ignore next */
 /**
  * Iterate on the keys (no values)
  *
@@ -5397,26 +5415,25 @@ const iterate = (store, keyrange, f, direction = 'next') =>
  * @param {function(any):void|boolean} f callback that receives the key
  * @param {'next'|'prev'|'nextunique'|'prevunique'} direction
  */
-/* istanbul ignore next */
 const iterateKeys = (store, keyrange, f, direction = 'next') =>
   iterateOnRequest(store.openKeyCursor(keyrange, direction), cursor => f(cursor.key));
 
+/* istanbul ignore next */
 /**
  * Open store from transaction
  * @param {IDBTransaction} t
  * @param {String} store
  * @returns {IDBObjectStore}
  */
-/* istanbul ignore next */
-const getStore = (t, store) => t.objectStore(store);
+const getStore$1 = (t, store) => t.objectStore(store);
 
+/* istanbul ignore next */
 /**
  * @param {any} lower
  * @param {any} upper
  * @param {boolean} lowerOpen
  * @param {boolean} upperOpen
  */
-/* istanbul ignore next */
 const createIDBKeyRangeBound = (lower, upper, lowerOpen, upperOpen) => IDBKeyRange.bound(lower, upper, lowerOpen, upperOpen);
 
 /* istanbul ignore next */
@@ -5437,7 +5454,7 @@ const createTransaction = db => db.transaction(['test'], 'readwrite');
  * @param {IDBTransaction} t
  * @return {IDBObjectStore}
  */
-const getStore$1 = t => getStore(t, 'test');
+const getStore = t => getStore$1(t, 'test');
 
 /* istanbul ignore next */
 const testRetrieveElements = async () => {
@@ -5446,7 +5463,7 @@ const testRetrieveElements = async () => {
   await deleteDB(testDBName);
   const db = await openDB(testDBName, initTestDB);
   const transaction = createTransaction(db);
-  const store = getStore$1(transaction);
+  const store = getStore(transaction);
   await put(store, 0, ['t', 1]);
   await put(store, 1, ['t', 2]);
   const expectedKeys = [['t', 1], ['t', 2]];
@@ -5501,7 +5518,7 @@ const testRetrieveElements = async () => {
   const getVDel = await get(store, ['t', 0]);
   assert(getVDel === undefined);
   describe('idb.add');
-  await add$1(store, 99, 42);
+  await add(store, 99, 42);
   const idbVAdd = await get(store, 42);
   assert(idbVAdd === 99);
   describe('idb.addAutoKey');
@@ -5598,7 +5615,7 @@ const genTestData = 5000;
  * @param {prng.PRNG} gen
  */
 const runGenTest = (tc, gen) => {
-  group$1('next - average distribution', () => {
+  group('next - average distribution', () => {
     let sum = 0;
     for (let i = 0; i < genTestData; i++) {
       const next = gen.next();
@@ -5612,7 +5629,7 @@ const runGenTest = (tc, gen) => {
     assert(avg <= 0.55);
   });
 
-  group$1('bool - bool distribution is fair', () => {
+  group('bool - bool distribution is fair', () => {
     let head = 0;
     let tail = 0;
     let b;
@@ -5630,12 +5647,12 @@ const runGenTest = (tc, gen) => {
     assert(tail >= floor(genTestData * 0.45), 'Generated enough tails.');
     assert(head >= floor(genTestData * 0.45), 'Generated enough heads.');
   });
-  group$1('int31 - integers average correctly', () => {
+  group('int31 - integers average correctly', () => {
     let count = 0;
     let i;
 
     for (i = 0; i < genTestData; i++) {
-      count += uint32$1(gen, 0, 100);
+      count += uint32(gen, 0, 100);
     }
     const average = count / genTestData;
     const expectedAverage = 100 / 2;
@@ -5643,7 +5660,7 @@ const runGenTest = (tc, gen) => {
     assert(abs(average - expectedAverage) <= 2, 'Expected average is at most 1 off.');
   });
 
-  group$1('int32 - generates integer with 32 bits', () => {
+  group('int32 - generates integer with 32 bits', () => {
     let largest = 0;
     let smallest = 0;
     let i;
@@ -5664,12 +5681,12 @@ const runGenTest = (tc, gen) => {
     assert((smallest & BIT32) !== 0, 'Largest number is 32 bits long'); // largest.. assuming we convert int to uint
   });
 
-  group$1('uint32 - generates unsigned integer with 32 bits', () => {
+  group('uint32 - generates unsigned integer with 32 bits', () => {
     let num = 0;
     let i;
     let newNum;
     for (i = 0; i < genTestData; i++) {
-      newNum = uint32$1(gen, 0, BITS32);
+      newNum = uint32(gen, 0, BITS32);
       if (newNum > num) {
         num = newNum;
       }
@@ -5678,7 +5695,7 @@ const runGenTest = (tc, gen) => {
     assert((num & BIT32) !== 0, 'Largest number is 32 bits long.');
   });
 
-  group$1('int53 - generates integer exceeding 32 bits', () => {
+  group('int53 - generates integer exceeding 32 bits', () => {
     let largest = 0;
     let smallest = 0;
     let i;
@@ -5700,7 +5717,7 @@ const runGenTest = (tc, gen) => {
     assert(smallest < BITS32, 'Smallest Number is smaller than BITS32 (negative)');
   });
 
-  group$1('uint53 - generates integer exceeding 32 bits', () => {
+  group('uint53 - generates integer exceeding 32 bits', () => {
     let largest = 0;
     let smallest = 10000;
     let i;
@@ -5722,12 +5739,12 @@ const runGenTest = (tc, gen) => {
     assert(largest > (BITS32 >>> 0), 'Largest number exceeds BITS32');
   });
 
-  group$1('int31 - generates integer with 31 bits', () => {
+  group('int31 - generates integer with 31 bits', () => {
     let num = 0;
     let i;
     let newNum;
     for (i = 0; i < genTestData; i++) {
-      newNum = uint32$1(gen, 0, BITS31);
+      newNum = uint32(gen, 0, BITS31);
       if (newNum > num) {
         num = newNum;
       }
@@ -5736,7 +5753,7 @@ const runGenTest = (tc, gen) => {
     assert((num & BIT31) !== 0, 'Largest number is 31 bits long.');
   });
 
-  group$1('real - has 53 bit resolution', () => {
+  group('real - has 53 bit resolution', () => {
     let num = 0;
     let i;
     let newNum;
@@ -5750,7 +5767,7 @@ const runGenTest = (tc, gen) => {
     assert((MAX_SAFE_INTEGER - num) / MAX_SAFE_INTEGER < 0.01, 'Largest number is close to MAX_SAFE_INTEGER (at most 1% off).');
   });
 
-  group$1('char - generates all ascii characters', () => {
+  group('char - generates all ascii characters', () => {
     const charSet = new Set();
     const chars = ' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[/]^_`abcdefghijklmnopqrstuvwxyz{|}~"';
     for (let i = chars.length - 1; i >= 0; i--) {
@@ -5804,7 +5821,7 @@ const printDistribution = (gen, tc) => {
     const y = int32(gen, 0, DIAMETER);
     ctx.fillRect(x, y, 1, 2);
   }
-  printCanvas$1(canvas$1, DIAMETER);
+  printCanvas(canvas$1, DIAMETER);
 };
 
 /* istanbul ignore next */
@@ -5813,9 +5830,9 @@ const printDistribution = (gen, tc) => {
  */
 const testNumberDistributions = tc => {
   skip(!isBrowser);
-  group$1('Xoroshiro128plus', () => printDistribution(new Xoroshiro128plus(tc.seed), tc));
-  group$1('Xorshift32', () => printDistribution(new Xorshift32(tc.seed), tc));
-  group$1('MT19937', () => printDistribution(new Mt19937(tc.seed), tc));
+  group('Xoroshiro128plus', () => printDistribution(new Xoroshiro128plus(tc.seed), tc));
+  group('Xorshift32', () => printDistribution(new Xorshift32(tc.seed), tc));
+  group('MT19937', () => printDistribution(new Mt19937(tc.seed), tc));
 };
 
 var prng = /*#__PURE__*/Object.freeze({
@@ -5830,7 +5847,7 @@ var prng = /*#__PURE__*/Object.freeze({
  * @param {t.TestCase} tc
  */
 const testMedian = tc => {
-  assert(isNaN(median([])), 'median([]) = NaN');
+  assert(isNaN$1(median([])), 'median([]) = NaN');
   assert(median([1]) === 1, 'median([x]) = x');
   assert(median([1, 2, 3]) === 2, 'median([a,b,c]) = b');
   assert(median([1, 2, 3, 4]) === (2 + 3) / 2, 'median([a,b,c,d]) = (b+c)/2');
@@ -5849,7 +5866,7 @@ var statistics = /*#__PURE__*/Object.freeze({
 const testBitx = tc => {
   for (let i = 1; i <= 32; i++) {
     // @ts-ignore
-    assert(binary[`BIT${i}`] === (1 << (i - 1)), `BIT${i}=${1 << (i - 1)}`);
+    assert(binary$1[`BIT${i}`] === (1 << (i - 1)), `BIT${i}=${1 << (i - 1)}`);
   }
 };
 
@@ -5861,13 +5878,13 @@ const testBitsx = tc => {
   for (let i = 1; i < 32; i++) {
     const expected = ((1 << i) - 1) >>> 0;
     // @ts-ignore
-    const have = binary[`BITS${i}`];
+    const have = binary$1[`BITS${i}`];
     assert(have === expected, `BITS${i}=${have}=${expected}`);
   }
   assert(BITS32 === 0xFFFFFFFF);
 };
 
-var binary$1 = /*#__PURE__*/Object.freeze({
+var binary = /*#__PURE__*/Object.freeze({
   __proto__: null,
   testBitx: testBitx,
   testBitsx: testBitsx
@@ -5884,7 +5901,7 @@ const testUint32 = tc => {
   let lenSum = 0;
   let ones = 0;
   for (let i = 0; i < iterations; i++) {
-    newNum = uint32();
+    newNum = uint32$1();
     lenSum += newNum.toString().length;
     ones += newNum.toString(2).split('').filter(x => x === '1').length;
     if (newNum > largest) {
@@ -5956,7 +5973,7 @@ const measureP = (p, min, max) => {
  * @param {Promise<T>} p
  * @return {Promise<T>}
  */
-const failsP = p => create$5((resolve, reject) => p.then(() => reject(create$6('Promise should fail')), resolve));
+const failsP = p => create$2((resolve, reject) => p.then(() => reject(create$1('Promise should fail')), resolve));
 
 /**
  * @param {t.TestCase} tc
@@ -5982,7 +5999,7 @@ const testRepeatPromise = async tc => {
  */
 const testispromise = tc => {
   assert(isPromise(new Promise(() => {})));
-  assert(isPromise(create$5(() => {})));
+  assert(isPromise(create$2(() => {})));
   const rej = reject();
   assert(isPromise(rej));
   rej.catch(() => {});
@@ -6027,7 +6044,7 @@ class Queue {
  *
  * @return {Queue}
  */
-const create$7 = () => new Queue();
+const create = () => new Queue();
 
 /**
  * @param {Queue} queue
@@ -6038,7 +6055,7 @@ const isEmpty = queue => queue.start === null;
  * @param {Queue} queue
  * @param {QueueNode} n
  */
-const enqueue$1 = (queue, n) => {
+const enqueue = (queue, n) => {
   if (queue.end !== null) {
     queue.end.next = n;
     queue.end = n;
@@ -6080,11 +6097,11 @@ const testEnqueueDequeue = tc => {
   /**
    * @type {queue.Queue}
    */
-  const q = create$7();
+  const q = create();
   assert(isEmpty(q));
   assert(dequeue(q) === null);
   for (let i = 0; i < N; i++) {
-    enqueue$1(q, new QueueItem(i));
+    enqueue(q, new QueueItem(i));
     assert(!isEmpty(q));
   }
   for (let i = 0; i < N; i++) {
@@ -6094,7 +6111,7 @@ const testEnqueueDequeue = tc => {
   assert(dequeue(q) === null);
 };
 
-var queue$1 = /*#__PURE__*/Object.freeze({
+var queue = /*#__PURE__*/Object.freeze({
   __proto__: null,
   testEnqueueDequeue: testEnqueueDequeue
 });
@@ -6103,10 +6120,10 @@ var queue$1 = /*#__PURE__*/Object.freeze({
  * @param {t.TestCase} tc
  */
 const testMap = tc => {
-  const m = create();
+  const m = create$7();
   m.set(1, 2);
   m.set(2, 3);
-  assert(map(m, (value, key) => value * 2 + key).reduce(add) === 13);
+  assert(map$3(m, (value, key) => value * 2 + key).reduce(add$1) === 13);
   let numberOfWrites = 0;
   const createT = () => {
     numberOfWrites++;
@@ -6119,7 +6136,7 @@ const testMap = tc => {
   assert(numberOfWrites === 1);
 };
 
-var map$3 = /*#__PURE__*/Object.freeze({
+var map = /*#__PURE__*/Object.freeze({
   __proto__: null,
   testMap: testMap
 });
@@ -6131,16 +6148,16 @@ const testEventloopOrder = tc => {
   let currI = 0;
   for (let i = 0; i < 10; i++) {
     const bi = i;
-    enqueue(() => {
+    enqueue$1(() => {
       assert(currI++ === bi);
     });
   }
-  enqueue(() => {
+  enqueue$1(() => {
     assert(currI === 10);
   });
   assert(currI === 0);
   return all([
-    createEmpty(resolve => enqueue(resolve)),
+    createEmpty(resolve => enqueue$1(resolve)),
     until(0, () => currI === 10)
   ])
 };
@@ -6154,7 +6171,7 @@ const testTimeout = async tc => {
     set = true;
   });
   timeout$1.destroy();
-  await create$5(resolve => {
+  await create$2(resolve => {
     timeout(10, resolve);
   });
   assert(set === false);
@@ -6192,7 +6209,7 @@ const testAnimationFrame = async tc => {
  * @param {t.TestCase} tc
  */
 const testIdleCallback = async tc => {
-  await create$5(resolve => {
+  await create$2(resolve => {
     idleCallback(resolve);
   });
 };
@@ -6247,18 +6264,18 @@ var time = /*#__PURE__*/Object.freeze({
  * @param {t.TestCase} tc
  */
 const testPair = tc => {
-  const ps = [create$2(1, 2), create$2(3, 4), createReversed(6, 5)];
+  const ps = [create$5(1, 2), create$5(3, 4), createReversed(6, 5)];
   describe('Counting elements in pair list');
   let countLeft = 0;
   let countRight = 0;
-  forEach(ps, (left, right) => {
+  forEach$1(ps, (left, right) => {
     countLeft += left;
     countRight += right;
   });
   assert(countLeft === 9);
   assert(countRight === 12);
-  assert(countLeft === map$1(ps, left => left).reduce(add));
-  assert(countRight === map$1(ps, (left, right) => right).reduce(add));
+  assert(countLeft === map$2(ps, left => left).reduce(add$1));
+  assert(countRight === map$2(ps, (left, right) => right).reduce(add$1));
 };
 
 var pair = /*#__PURE__*/Object.freeze({
@@ -6270,17 +6287,17 @@ var pair = /*#__PURE__*/Object.freeze({
  * @param {t.TestCase} tc
  */
 const testObject = tc => {
-  assert(create$3().constructor === undefined, 'object.create creates an empty object without constructor');
+  assert(create$4().constructor === undefined, 'object.create creates an empty object without constructor');
   describe('object.equalFlat');
-  assert(equalFlat$1({}, {}), 'comparing equal objects');
-  assert(equalFlat$1({ x: 1 }, { x: 1 }), 'comparing equal objects');
-  assert(equalFlat$1({ x: 'dtrn' }, { x: 'dtrn' }), 'comparing equal objects');
-  assert(!equalFlat$1({ x: {} }, { x: {} }), 'flatEqual does not dive deep');
-  assert(equalFlat$1({ x: undefined }, { x: undefined }), 'flatEqual handles undefined');
-  assert(!equalFlat$1({ x: undefined }, { y: {} }), 'flatEqual handles undefined');
+  assert(equalFlat({}, {}), 'comparing equal objects');
+  assert(equalFlat({ x: 1 }, { x: 1 }), 'comparing equal objects');
+  assert(equalFlat({ x: 'dtrn' }, { x: 'dtrn' }), 'comparing equal objects');
+  assert(!equalFlat({ x: {} }, { x: {} }), 'flatEqual does not dive deep');
+  assert(equalFlat({ x: undefined }, { x: undefined }), 'flatEqual handles undefined');
+  assert(!equalFlat({ x: undefined }, { y: {} }), 'flatEqual handles undefined');
   describe('object.every');
-  assert(every$1({ a: 1, b: 3 }, (v, k) => (v % 2) === 1 && k !== 'c'));
-  assert(!every$1({ a: 1, b: 3, c: 5 }, (v, k) => (v % 2) === 1 && k !== 'c'));
+  assert(every({ a: 1, b: 3 }, (v, k) => (v % 2) === 1 && k !== 'c'));
+  assert(!every({ a: 1, b: 3, c: 5 }, (v, k) => (v % 2) === 1 && k !== 'c'));
   describe('object.some');
   assert(some({ a: 1, b: 3 }, (v, k) => v === 3 && k === 'b'));
   assert(!some({ a: 1, b: 5 }, (v, k) => v === 3));
@@ -6288,13 +6305,13 @@ const testObject = tc => {
   assert(!some({ a: 1, b: 5 }, (v, k) => false));
   describe('object.forEach');
   let forEachSum = 0;
-  forEach$1({ x: 1, y: 3 }, (v, k) => { forEachSum += v; });
+  forEach({ x: 1, y: 3 }, (v, k) => { forEachSum += v; });
   assert(forEachSum === 4);
   describe('object.map');
-  assert(map$2({ x: 1, z: 5 }, (v, k) => v).reduce(add) === 6);
+  assert(map$1({ x: 1, z: 5 }, (v, k) => v).reduce(add$1) === 6);
   describe('object.length');
-  assert(length({}) === 0);
-  assert(length({ x: 1 }) === 1);
+  assert(length$1({}) === 0);
+  assert(length$1({ x: 1 }) === 1);
 };
 
 var object = /*#__PURE__*/Object.freeze({
@@ -6311,7 +6328,7 @@ const testMath = tc => {
   assert(abs(Number.MIN_SAFE_INTEGER) === Number.MAX_SAFE_INTEGER);
   assert(abs(Number.MAX_SAFE_INTEGER) === Number.MAX_SAFE_INTEGER);
   describe('math.add');
-  assert([1, 2, 3, 4, 5].reduce(add) === 15);
+  assert([1, 2, 3, 4, 5].reduce(add$1) === 15);
   describe('math.ceil');
   assert(ceil(1.5) === 2);
   assert(ceil(-1.5) === -1);
@@ -6319,9 +6336,9 @@ const testMath = tc => {
   assert(floor(1.5) === 1);
   assert(floor(-1.5) === -2);
   describe('math.isNaN');
-  assert(isNaN(NaN));
+  assert(isNaN$1(NaN));
   // @ts-ignore
-  assert(!isNaN(null));
+  assert(!isNaN$1(null));
   describe('math.max');
   assert([1, 3, 65, 1, 314, 25, 3475, 2, 1].reduce(max) === 3475);
   describe('math.min');
@@ -6341,11 +6358,11 @@ var math = /*#__PURE__*/Object.freeze({
  */
 const testNumber = tc => {
   describe('isNaN');
-  assert(isNaN$1(NaN));
-  assert(!isNaN$1(1 / 0));
+  assert(isNaN(NaN));
+  assert(!isNaN(1 / 0));
   // @ts-ignore
-  assert(isNaN$1('a' / 0));
-  assert(!isNaN$1(0));
+  assert(isNaN('a' / 0));
+  assert(!isNaN(0));
   describe('isInteger');
   assert(!isInteger(1 / 0));
   assert(!isInteger(NaN));
@@ -6683,7 +6700,7 @@ const decodeQueryParams = url => {
  * @return {string}
  */
 const encodeQueryParams = params =>
-  map$2(params, (val, key) => `${encodeURIComponent(key)}=${encodeURIComponent(val)}`).join('&');
+  map$1(params, (val, key) => `${encodeURIComponent(key)}=${encodeURIComponent(val)}`).join('&');
 
 /**
  * @param {Object<string,any>} params
@@ -6826,6 +6843,27 @@ var func = /*#__PURE__*/Object.freeze({
   testDeepEquality: testDeepEquality
 });
 
+/**
+ * @param {t.TestCase} tc
+ */
+const testStorageModule = tc => {
+  const s = varStorage;
+  /**
+   * @type {any}
+   */
+  let lastEvent = null;
+  onChange(event => {
+    lastEvent = event;
+  });
+  s.setItem('key', 'value');
+  assert(lastEvent === null);
+};
+
+var storage = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  testStorageModule: testStorageModule
+});
+
 /* istanbul ignore if */
 if (isBrowser) {
   createVConsole(document.body);
@@ -6841,11 +6879,11 @@ runTests({
   indexeddb,
   prng,
   statistics,
-  binary: binary$1,
+  binary,
   random,
   promise,
-  queue: queue$1,
-  map: map$3,
+  queue,
+  map,
   eventloop,
   time,
   pair,
@@ -6856,7 +6894,8 @@ runTests({
   sort,
   url,
   metric,
-  func
+  func,
+  storage
 }).then(success => {
   /* istanbul ignore next */
   if (isNode) {