lib0 0.2.39 → 0.2.43

package/dist/test.js

@@ -15,7 +15,7 @@
    *
    * @function
    */
-  const create = () => new Map();
+  const create$7 = () => new Map();
 
   /**
    * Copy a Map object into a fresh Map object.
@@ -26,7 +26,7 @@
    * @return {Map<X,Y>}
    */
   const copy = m => {
-    const r = create();
+    const r = create$7();
     m.forEach((v, k) => { r.set(k, v); });
     return r
   };
@@ -65,7 +65,7 @@
    * @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));
@@ -202,7 +202,7 @@
   /* istanbul ignore next */
   const undefinedToNull = v => v === undefined ? null : v;
 
-  /* global localStorage */
+  /* global localStorage, addEventListener */
 
   /**
    * Isomorphic variable storage.
@@ -220,10 +220,10 @@
 
     /**
      * @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);
     }
 
     /**
@@ -239,12 +239,14 @@
    * @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) { }
 
@@ -254,6 +256,15 @@
    */
   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).
    *
@@ -277,7 +288,7 @@
   const computeParams = () => {
     if (params === undefined) {
       if (isNode) {
-        params = create();
+        params = create$7();
         const pargs = process.argv;
         let currParamName = null;
         /* istanbul ignore next */
@@ -300,7 +311,7 @@
         }
       // 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) {
@@ -310,7 +321,7 @@
           }
         });
       } else {
-        params = create();
+        params = create$7();
       }
     }
     return params
@@ -360,7 +371,7 @@
    *
    * @return {Symbol}
    */
-  const create$1 = Symbol;
+  const create$6 = Symbol;
 
   /**
    * Working with value pairs.
@@ -388,7 +399,7 @@
    * @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
@@ -403,7 +414,7 @@
    * @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
@@ -411,7 +422,7 @@
    * @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 */
 
@@ -451,7 +462,7 @@
    */
   /* 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) {
@@ -530,7 +541,7 @@
    * @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
@@ -540,6 +551,14 @@
   /* 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.
    *
@@ -565,21 +584,21 @@
   /**
    * @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);
     }
   };
@@ -666,7 +685,7 @@
    * @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
@@ -684,7 +703,7 @@
    */
   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.
    *
@@ -817,7 +836,7 @@
    * @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
@@ -826,7 +845,7 @@
    * @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
@@ -844,7 +863,7 @@
   /**
    * @return {Object<string,any>} obj
    */
-  const create$3 = () => Object.create(null);
+  const create$4 = () => Object.create(null);
 
   /**
    * Object.assign
@@ -860,7 +879,7 @@
    * @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);
     }
@@ -872,7 +891,7 @@
    * @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));
@@ -884,7 +903,7 @@
    * @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
@@ -905,7 +924,7 @@
    * @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
@@ -928,7 +947,7 @@
    * @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.
@@ -952,7 +971,7 @@
    * @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
@@ -1008,7 +1027,7 @@
         break
       }
       case Object:
-        if (length(a) !== length(b)) {
+        if (length$1(a) !== length$1(b)) {
           return false
         }
         for (const key in a) {
@@ -1039,29 +1058,29 @@
    * @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 = {
@@ -1084,7 +1103,7 @@
   const computeBrowserLoggingArgs = args => {
     const strBuilder = [];
     const styles = [];
-    const currentStyle = create();
+    const currentStyle = create$7();
     /**
      * @type {Array<string|Object|number>}
      */
@@ -1213,7 +1232,7 @@
   /**
    * @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));
@@ -1239,7 +1258,7 @@
    * @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();
 
@@ -1262,7 +1281,7 @@
       } 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;';
           }
@@ -1307,11 +1326,11 @@
      * @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;
@@ -1333,7 +1352,7 @@
     }
 
     groupEnd () {
-      enqueue(() => {
+      enqueue$1(() => {
         if (this.depth > 0) {
           this.depth--;
           // @ts-ignore
@@ -1346,8 +1365,8 @@
      * @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))]);
       });
     }
 
@@ -1363,8 +1382,8 @@
      * @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`)])]);
       });
     }
 
@@ -1372,13 +1391,13 @@
      * @param {Node} node
      */
     printDom (node) {
-      enqueue(() => {
+      enqueue$1(() => {
         append(this.ccontainer, [node]);
       });
     }
 
     destroy () {
-      enqueue(() => {
+      enqueue$1(() => {
         vconsoles.delete(this);
       });
     }
@@ -1447,12 +1466,6 @@
     }
   };
 
-  /**
-   * @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.
@@ -1488,7 +1501,7 @@
   };
 
   /* eslint-env browser */
-  const performance = typeof window !== 'undefined' && typeof window.performance === 'undefined' ? null : window.performance;
+  const performance = typeof window === 'undefined' ? null : (typeof window.performance !== 'undefined' && window.performance) || null;
 
   const isoCrypto = typeof crypto === 'undefined' ? null : crypto;
 
@@ -1514,12 +1527,12 @@
     };
 
   /* istanbul ignore next */
-  const uint32 = () => new Uint32Array(cryptoRandomBuffer(4))[0];
+  const uint32$1 = () => new Uint32Array(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 */
@@ -1613,7 +1626,7 @@
    */
   const BITS32 = 0xFFFFFFFF;
 
-  var binary = /*#__PURE__*/Object.freeze({
+  var binary$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     BIT1: BIT1,
     BIT2: BIT2,
@@ -1846,7 +1859,7 @@
 
   /* 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.
@@ -1903,7 +1916,7 @@
    * @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;
@@ -1919,7 +1932,7 @@
    * @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];
@@ -2218,19 +2231,19 @@
    * @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));
   /**
@@ -2468,6 +2481,7 @@
    * @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
@@ -2808,7 +2822,7 @@
   };
 
   /**
-   * Look ahead without incrementing position.
+   * Look ahead without incrementing the position
    * to the next byte and read it as unsigned integer.
    *
    * @function
@@ -2818,7 +2832,7 @@
   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
@@ -2830,7 +2844,7 @@
     (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
@@ -2876,7 +2890,7 @@
    * 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
@@ -2999,17 +3013,17 @@
   /**
    * @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>}
@@ -3373,7 +3387,7 @@
    * @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.
@@ -3421,7 +3435,7 @@
    * @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
@@ -3544,7 +3558,7 @@
    * @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.
@@ -3563,7 +3577,7 @@
    * @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
@@ -3600,7 +3614,7 @@
    * @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 = () => {
@@ -3622,7 +3636,7 @@
    * @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.
@@ -3716,7 +3730,7 @@
       /* 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
     }
@@ -3729,13 +3743,13 @@
     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;
 
@@ -3765,11 +3779,14 @@
     if (testFilter === null) {
       groupCollapsed(...groupArgs);
     } else {
-      group(...groupArgs);
+      group$1(...groupArgs);
     }
     const times = [];
     const start = performance.now();
     let lastTime = start;
+    /**
+     * @type {any}
+     */
     let err = null;
     performance.mark(`${name}-start`);
     do {
@@ -3784,12 +3801,12 @@
       const currTime = 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)
     performance.mark(`${name}-end`);
     /* istanbul ignore if */
     if (err !== null && err.constructor !== SkipError) {
@@ -3805,7 +3822,7 @@
       ? `     - ${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 */
@@ -3847,7 +3864,7 @@
    */
   const info = info => describe('', info);
 
-  const printCanvas$1 = printCanvas;
+  const printCanvas = printCanvas$1;
 
   /**
    * Group outputs in a collapsible category.
@@ -3867,8 +3884,8 @@
    * @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 {
@@ -3895,7 +3912,7 @@
    * @param {function(void):Promise<any>} f
    */
   const groupAsync = async (description, f) => {
-    group(BLUE, description);
+    group$1(BLUE, description);
     try {
       await f();
     } finally {
@@ -3990,7 +4007,7 @@
    */
   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);
     }
@@ -4003,7 +4020,7 @@
    * @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
@@ -4087,10 +4104,10 @@
         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);
           }
@@ -4153,7 +4170,7 @@
    * @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 = performance.now();
@@ -4342,8 +4359,8 @@
     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);
@@ -4412,7 +4429,7 @@
     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`);
     }
@@ -4578,7 +4595,7 @@
    * @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);
   };
 
@@ -4602,7 +4619,7 @@
    * @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);
   };
 
@@ -4693,12 +4710,12 @@
    */
   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 }
@@ -4727,7 +4744,7 @@
     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);
@@ -4765,7 +4782,7 @@
     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++) {
@@ -5090,7 +5107,7 @@
     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');
@@ -5194,17 +5211,17 @@
   };
 
   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({
@@ -5213,7 +5230,7 @@
     testFailing: testFailing,
     testSkipping: testSkipping,
     testAsync: testAsync,
-    testRepeatRepitition: testRepeatRepitition
+    testRepeatRepetition: testRepeatRepetition
   });
 
   /**
@@ -5222,23 +5239,23 @@
    * @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));
@@ -5249,13 +5266,13 @@
     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
@@ -5265,7 +5282,7 @@
     /**
      * @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();
     /**
@@ -5286,82 +5303,82 @@
     };
   });
 
+  /* 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));
 
@@ -5372,23 +5389,23 @@
    * @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;
     /**
@@ -5403,6 +5420,7 @@
     };
   });
 
+  /* istanbul ignore next */
   /**
    * Iterate on keys and values
    * @param {IDBObjectStore} store
@@ -5410,10 +5428,10 @@
    * @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)
    *
@@ -5422,26 +5440,25 @@
    * @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 */
@@ -5462,7 +5479,7 @@
    * @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 () => {
@@ -5471,7 +5488,7 @@
     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]];
@@ -5526,7 +5543,7 @@
     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');
@@ -5623,7 +5640,7 @@
    * @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();
@@ -5637,7 +5654,7 @@
       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;
@@ -5655,12 +5672,12 @@
       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;
@@ -5668,7 +5685,7 @@
       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;
@@ -5689,12 +5706,12 @@
       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;
         }
@@ -5703,7 +5720,7 @@
       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;
@@ -5725,7 +5742,7 @@
       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;
@@ -5747,12 +5764,12 @@
       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;
         }
@@ -5761,7 +5778,7 @@
       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;
@@ -5775,7 +5792,7 @@
       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--) {
@@ -5829,7 +5846,7 @@
       const y = int32(gen, 0, DIAMETER);
       ctx.fillRect(x, y, 1, 2);
     }
-    printCanvas$1(canvas$1, DIAMETER);
+    printCanvas(canvas$1, DIAMETER);
   };
 
   /* istanbul ignore next */
@@ -5838,9 +5855,9 @@
    */
   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({
@@ -5855,7 +5872,7 @@
    * @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');
@@ -5874,7 +5891,7 @@
   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)}`);
     }
   };
 
@@ -5886,13 +5903,13 @@
     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
@@ -5909,7 +5926,7 @@
     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) {
@@ -5981,7 +5998,7 @@
    * @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
@@ -6007,7 +6024,7 @@
    */
   const testispromise = tc => {
     assert(isPromise(new Promise(() => {})));
-    assert(isPromise(create$5(() => {})));
+    assert(isPromise(create$2(() => {})));
     const rej = reject();
     assert(isPromise(rej));
     rej.catch(() => {});
@@ -6052,7 +6069,7 @@
    *
    * @return {Queue}
    */
-  const create$7 = () => new Queue();
+  const create = () => new Queue();
 
   /**
    * @param {Queue} queue
@@ -6063,7 +6080,7 @@
    * @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;
@@ -6105,11 +6122,11 @@
     /**
      * @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++) {
@@ -6119,7 +6136,7 @@
     assert(dequeue(q) === null);
   };
 
-  var queue$1 = /*#__PURE__*/Object.freeze({
+  var queue = /*#__PURE__*/Object.freeze({
     __proto__: null,
     testEnqueueDequeue: testEnqueueDequeue
   });
@@ -6128,10 +6145,10 @@
    * @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++;
@@ -6144,7 +6161,7 @@
     assert(numberOfWrites === 1);
   };
 
-  var map$3 = /*#__PURE__*/Object.freeze({
+  var map = /*#__PURE__*/Object.freeze({
     __proto__: null,
     testMap: testMap
   });
@@ -6156,16 +6173,16 @@
     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)
     ])
   };
@@ -6179,7 +6196,7 @@
       set = true;
     });
     timeout$1.destroy();
-    await create$5(resolve => {
+    await create$2(resolve => {
       timeout(10, resolve);
     });
     assert(set === false);
@@ -6217,7 +6234,7 @@
    * @param {t.TestCase} tc
    */
   const testIdleCallback = async tc => {
-    await create$5(resolve => {
+    await create$2(resolve => {
       idleCallback(resolve);
     });
   };
@@ -6272,18 +6289,18 @@
    * @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({
@@ -6295,17 +6312,17 @@
    * @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));
@@ -6313,13 +6330,13 @@
     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({
@@ -6336,7 +6353,7 @@
     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);
@@ -6344,9 +6361,9 @@
     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');
@@ -6366,11 +6383,11 @@
    */
   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));
@@ -6708,7 +6725,7 @@
    * @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
@@ -6851,6 +6868,27 @@
     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);
@@ -6866,11 +6904,11 @@
     indexeddb,
     prng,
     statistics,
-    binary: binary$1,
+    binary,
     random,
     promise,
-    queue: queue$1,
-    map: map$3,
+    queue,
+    map,
     eventloop,
     time,
     pair,
@@ -6881,7 +6919,8 @@
     sort,
     url,
     metric,
-    func
+    func,
+    storage
   }).then(success => {
     /* istanbul ignore next */
     if (isNode) {
@@ -6889,5 +6928,5 @@
     }
   });
 
-}());
+})();
 //# sourceMappingURL=test.js.map