lib0 0.2.42 → 0.2.45

package/dist/test.js

@@ -15,7 +15,7 @@
    *
    * @function
    */
-  const create$7 = () => new Map();
+  const create$a = () => 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$7();
+    const r = create$a();
     m.forEach((v, k) => { r.set(k, v); });
     return r
   };
@@ -46,7 +46,7 @@
    * @param {function():T} createT
    * @return {T}
    */
-  const setIfUndefined = (map, key, createT) => {
+  const setIfUndefined$1 = (map, key, createT) => {
     let set = map.get(key);
     if (set === undefined) {
       map.set(key, set = createT());
@@ -65,7 +65,7 @@
    * @param {function(V,K):R} f
    * @return {Array<R>}
    */
-  const map$3 = (m, f) => {
+  const map$4 = (m, f) => {
     const res = [];
     for (const [key, value] of m) {
       res.push(f(value, key));
@@ -188,6 +188,14 @@
   /* istanbul ignore next */
   const decodeUtf8 = utf8TextDecoder ? _decodeUtf8Native : _decodeUtf8Polyfill;
 
+  /**
+   * @param {string} str The initial string
+   * @param {number} index Starting position
+   * @param {number} remove Number of characters to remove
+   * @param {string} insert New content to insert
+   */
+  const splice = (str, index, remove, insert = '') => str.slice(0, index) + insert + str.slice(index + remove);
+
   /**
    * Often used conditions.
    *
@@ -288,7 +296,7 @@
   const computeParams = () => {
     if (params === undefined) {
       if (isNode) {
-        params = create$7();
+        params = create$a();
         const pargs = process.argv;
         let currParamName = null;
         /* istanbul ignore next */
@@ -311,7 +319,7 @@
         }
       // in ReactNative for example this would not be true (unless connected to the Remote Debugger)
       } else if (typeof location === 'object') {
-        params = create$7()
+        params = create$a()
         // eslint-disable-next-line no-undef
         ;(location.search || '?').slice(1).split('&').forEach(kv => {
           if (kv.length !== 0) {
@@ -321,7 +329,7 @@
           }
         });
       } else {
-        params = create$7();
+        params = create$a();
       }
     }
     return params
@@ -371,7 +379,7 @@
    *
    * @return {Symbol}
    */
-  const create$6 = Symbol;
+  const create$9 = Symbol;
 
   /**
    * Working with value pairs.
@@ -399,7 +407,7 @@
    * @param {R} right
    * @return {Pair<L,R>}
    */
-  const create$5 = (left, right) => new Pair(left, right);
+  const create$8 = (left, right) => new Pair(left, right);
 
   /**
    * @template L,R
@@ -422,7 +430,7 @@
    * @param {function(L, R):X} f
    * @return {Array<X>}
    */
-  const map$2 = (arr, f) => arr.map(p => f(p.left, p.right));
+  const map$3 = (arr, f) => arr.map(p => f(p.left, p.right));
 
   /* eslint-env browser */
 
@@ -541,7 +549,7 @@
    * @return {string}
    */
   /* istanbul ignore next */
-  const mapToStyleString = m => map$3(m, (value, key) => `${key}:${value};`).join('');
+  const mapToStyleString = m => map$4(m, (value, key) => `${key}:${value};`).join('');
 
   /**
    * @param {Node} parent
@@ -551,6 +559,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.
    *
@@ -855,7 +871,7 @@
   /**
    * @return {Object<string,any>} obj
    */
-  const create$4 = () => Object.create(null);
+  const create$7 = () => Object.create(null);
 
   /**
    * Object.assign
@@ -883,7 +899,7 @@
    * @param {function(any,string):R} f
    * @return {Array<R>}
    */
-  const map$1 = (obj, f) => {
+  const map$2 = (obj, f) => {
     const results = [];
     for (const key in obj) {
       results.push(f(obj[key], key));
@@ -1050,29 +1066,29 @@
    * @module logging
    */
 
-  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();
+  const BOLD = create$9();
+  const UNBOLD = create$9();
+  const BLUE = create$9();
+  const GREY = create$9();
+  const GREEN = create$9();
+  const RED = create$9();
+  const PURPLE = create$9();
+  const ORANGE = create$9();
+  const UNCOLOR = create$9();
 
   /**
    * @type {Object<Symbol,pair.Pair<string,string>>}
    */
   const _browserStyleMap = {
-    [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')
+    [BOLD]: create$8('font-weight', 'bold'),
+    [UNBOLD]: create$8('font-weight', 'normal'),
+    [BLUE]: create$8('color', 'blue'),
+    [GREEN]: create$8('color', 'green'),
+    [GREY]: create$8('color', 'grey'),
+    [RED]: create$8('color', 'red'),
+    [PURPLE]: create$8('color', 'purple'),
+    [ORANGE]: create$8('color', 'orange'), // not well supported in chrome when debugging node with inspector - TODO: deprecate
+    [UNCOLOR]: create$8('color', 'black')
   };
 
   const _nodeStyleMap = {
@@ -1095,7 +1111,7 @@
   const computeBrowserLoggingArgs = args => {
     const strBuilder = [];
     const styles = [];
-    const currentStyle = create$7();
+    const currentStyle = create$a();
     /**
      * @type {Array<string|Object|number>}
      */
@@ -1273,7 +1289,7 @@
       } else {
         if (arg.constructor === String || arg.constructor === Number) {
           // @ts-ignore
-          const span = element('span', [create$5('style', mapToStyleString(currentStyle))], [text(arg)]);
+          const span = element('span', [create$8('style', mapToStyleString(currentStyle))], [text(arg)]);
           if (span.innerHTML === '') {
             span.innerHTML = '&nbsp;';
           }
@@ -1319,10 +1335,10 @@
      */
     group (args, collapsed = false) {
       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 triangleDown = element('span', [create$8('hidden', collapsed), create$8('style', 'color:grey;font-size:120%;')], [text('▼')]);
+        const triangleRight = element('span', [create$8('hidden', !collapsed), create$8('style', 'color:grey;font-size:125%;')], [text('▶')]);
+        const content = element('div', [create$8('style', `${lineStyle};padding-left:${this.depth * 10}px`)], [triangleDown, triangleRight, text(' ')].concat(_computeLineSpans(args)));
+        const nextContainer = element('div', [create$8('hidden', collapsed)]);
         const nextLine = element('div', [], [content, nextContainer]);
         append(this.ccontainer, [nextLine]);
         this.ccontainer = nextContainer;
@@ -1358,7 +1374,7 @@
      */
     print (args) {
       enqueue$1(() => {
-        append(this.ccontainer, [element('div', [create$5('style', `${lineStyle};padding-left:${this.depth * 10}px`)], _computeLineSpans(args))]);
+        append(this.ccontainer, [element('div', [create$8('style', `${lineStyle};padding-left:${this.depth * 10}px`)], _computeLineSpans(args))]);
       });
     }
 
@@ -1375,7 +1391,7 @@
      */
     printImg (url, height) {
       enqueue$1(() => {
-        append(this.ccontainer, [element('img', [create$5('src', url), create$5('height', `${round(height * 1.5)}px`)])]);
+        append(this.ccontainer, [element('img', [create$8('src', url), create$8('height', `${round(height * 1.5)}px`)])]);
       });
     }
 
@@ -1445,11 +1461,8 @@
     while (left < a.length && left < b.length && a[left] === b[left]) {
       left++;
     }
-    if (left !== a.length || left !== b.length) {
-      // Only check right if a !== b
-      while (right + left < a.length && right + left < b.length && a[a.length - right - 1] === b[b.length - right - 1]) {
-        right++;
-      }
+    while (right + left < a.length && right + left < b.length && a[a.length - right - 1] === b[b.length - right - 1]) {
+      right++;
     }
     return {
       index: left,
@@ -1458,12 +1471,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.
@@ -1485,11 +1492,51 @@
     while (left < a.length && left < b.length && compare(a[left], b[left])) {
       left++;
     }
-    if (left !== a.length || left !== b.length) {
-      // Only check right if a !== b
-      while (right + left < a.length && right + left < b.length && compare(a[a.length - right - 1], b[b.length - right - 1])) {
-        right++;
-      }
+    while (right + left < a.length && right + left < b.length && compare(a[a.length - right - 1], b[b.length - right - 1])) {
+      right++;
+    }
+    return {
+      index: left,
+      remove: a.length - left - right,
+      insert: b.slice(left, b.length - right)
+    }
+  };
+
+  /**
+   * Diff text and try to diff at the current cursor position.
+   *
+   * @param {string} a
+   * @param {string} b
+   * @param {number} cursor This should refer to the current left cursor-range position
+   */
+  const simpleDiffStringWithCursor = (a, b, cursor) => {
+    let left = 0; // number of same characters counting from left
+    let right = 0; // number of same characters counting from right
+    // Iterate left to the right until we find a changed character
+    // First iteration considers the current cursor position
+    while (
+      left < a.length &&
+      left < b.length &&
+      a[left] === b[left] &&
+      left < cursor
+    ) {
+      left++;
+    }
+    // Iterate right to the left until we find a changed character
+    while (
+      right + left < a.length &&
+      right + left < b.length &&
+      a[a.length - right - 1] === b[b.length - right - 1]
+    ) {
+      right++;
+    }
+    // Try to iterate left further to the right without caring about the current cursor position
+    while (
+      right + left < a.length &&
+      right + left < b.length &&
+      a[left] === b[left]
+    ) {
+      left++;
     }
     return {
       index: left,
@@ -1983,7 +2030,7 @@
    * @param {number} pos Position to which to write data
    * @param {number} num Unsigned 8-bit integer
    */
-  const set = (encoder, pos, num) => {
+  const set$2 = (encoder, pos, num) => {
     let buffer = null;
     // iterate all buffers and adjust position
     for (let i = 0; i < encoder.bufs.length && buffer === null; i++) {
@@ -2018,7 +2065,7 @@
    * @param {number} pos The location where the data will be written.
    * @param {number} num The number that is to be encoded.
    */
-  const setUint8 = set;
+  const setUint8 = set$2;
 
   /**
    * Write two bytes as an unsigned integer.
@@ -2040,8 +2087,8 @@
    * @param {number} num The number that is to be encoded.
    */
   const setUint16 = (encoder, pos, num) => {
-    set(encoder, pos, num & BITS8);
-    set(encoder, pos + 1, (num >>> 8) & BITS8);
+    set$2(encoder, pos, num & BITS8);
+    set$2(encoder, pos + 1, (num >>> 8) & BITS8);
   };
 
   /**
@@ -2082,7 +2129,7 @@
    */
   const setUint32 = (encoder, pos, num) => {
     for (let i = 0; i < 4; i++) {
-      set(encoder, pos + i, num & BITS8);
+      set$2(encoder, pos + i, num & BITS8);
       num >>>= 8;
     }
   };
@@ -3385,7 +3432,7 @@
    * @param {number} seed A positive 32bit integer. Do not use negative numbers.
    * @return {PRNG}
    */
-  const create$3 = seed => new DefaultPRNG(seed);
+  const create$6 = seed => new DefaultPRNG(seed);
 
   /**
    * Generates a single random bool.
@@ -3575,7 +3622,7 @@
    * @param {function(PromiseResolve<T>,function(Error):void):any} f
    * @return {Promise<T>}
    */
-  const create$2 = f => /** @type {Promise<T>} */ (new Promise(f));
+  const create$5 = f => /** @type {Promise<T>} */ (new Promise(f));
 
   /**
    * @param {function(function():void,function(Error):void):void} f
@@ -3604,6 +3651,13 @@
    */
   const resolve = res => Promise.resolve(res);
 
+  /**
+   * @template T
+   * @param {T} res
+   * @return {Promise<T>}
+   */
+  const resolveWith = res => Promise.resolve(res);
+
   /**
    * @todo Next version, reorder parameters: check, [timeout, [intervalResolution]]
    *
@@ -3612,7 +3666,7 @@
    * @param {number} [intervalResolution]
    * @return {Promise<void>}
    */
-  const until = (timeout, check, intervalResolution = 10) => create$2((resolve, reject) => {
+  const until = (timeout, check, intervalResolution = 10) => create$5((resolve, reject) => {
     const startTime = getUnixTime();
     const hasTimeout = timeout > 0;
     const untilInterval = () => {
@@ -3634,7 +3688,7 @@
    * @param {number} timeout
    * @return {Promise<undefined>}
    */
-  const wait = timeout => create$2((resolve, reject) => setTimeout(resolve, timeout));
+  const wait = timeout => create$5((resolve, reject) => setTimeout(resolve, timeout));
 
   /**
    * Checks if an object is a promise using ducktyping.
@@ -3741,7 +3795,7 @@
     get prng () {
       /* istanbul ignore else */
       if (this._prng === null) {
-        this._prng = create$3(this.seed);
+        this._prng = create$6(this.seed);
       }
       return this._prng
     }
@@ -3782,6 +3836,9 @@
     const times = [];
     const start = performance.now();
     let lastTime = start;
+    /**
+     * @type {any}
+     */
     let err = null;
     performance.mark(`${name}-start`);
     do {
@@ -4002,7 +4059,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);
     }
@@ -4165,7 +4222,7 @@
    * @param {Object<string, Object<string, function(TestCase):void|Promise<any>>>} tests
    */
   const runTests = async tests => {
-    const numberOfTests = map$1(tests, mod => map$1(mod, f => /* istanbul ignore next */ f ? 1 : 0).reduce(add$1, 0)).reduce(add$1, 0);
+    const numberOfTests = map$2(tests, mod => map$2(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();
@@ -4331,12 +4388,22 @@
     }
   };
 
+  /**
+   * @param {t.TestCase} tc
+   */
+  const testSplice = tc => {
+    const initial = 'xyz';
+    compareStrings(splice(initial, 0, 2), 'z');
+    compareStrings(splice(initial, 0, 2, 'u'), 'uz');
+  };
+
   var string = /*#__PURE__*/Object.freeze({
     __proto__: null,
     testLowercaseTransformation: testLowercaseTransformation,
     testRepeatStringUtf8Encoding: testRepeatStringUtf8Encoding,
     testRepeatStringUtf8Decoding: testRepeatStringUtf8Decoding,
-    testBomEncodingDecoding: testBomEncodingDecoding
+    testBomEncodingDecoding: testBomEncodingDecoding,
+    testSplice: testSplice
   });
 
   /* global BigInt */
@@ -5046,6 +5113,7 @@
   function runDiffTest (a, b, expected) {
     const result = simpleDiffString(a, b);
     compare(result, expected);
+    compare(result, simpleDiffStringWithCursor(a, b, a.length)); // check that the withCursor approach returns the same result
     const arrResult = simpleDiffArray(a.split(''), b.split(''));
     compare(arrResult, assign({}, result, { insert: result.insert.split('') }));
   }
@@ -5071,10 +5139,43 @@
     const a = word(tc.prng);
     const b = word(tc.prng);
     const change = simpleDiffString(a, b);
-    const recomposed = `${a.slice(0, change.index)}${change.insert}${a.slice(change.index + change.remove)}`;
+    const recomposed = splice(a, change.index, change.remove, change.insert);
     compareStrings(recomposed, b);
   };
 
+  /**
+   * @param {t.TestCase} tc
+   */
+  const testSimpleDiffWithCursor = tc => {
+    const initial = 'Hello WorldHello World';
+    const expected = 'Hello World';
+    {
+      const change = simpleDiffStringWithCursor(initial, 'Hello World', 0); // should delete the first hello world
+      compare(change, { insert: '', remove: 11, index: 0 });
+      const recomposed = splice(initial, change.index, change.remove, change.insert);
+      compareStrings(expected, recomposed);
+    }
+    {
+      const change = simpleDiffStringWithCursor(initial, 'Hello World', 11); // should delete the second hello world
+      compare(change, { insert: '', remove: 11, index: 11 });
+      const recomposedSecond = splice(initial, change.index, change.remove, change.insert);
+      compareStrings(recomposedSecond, expected);
+    }
+    {
+      const change = simpleDiffStringWithCursor(initial, 'Hello World', 5); // should delete in the midst of Hello World
+      compare(change, { insert: '', remove: 11, index: 5 });
+      const recomposed = splice(initial, change.index, change.remove, change.insert);
+      compareStrings(expected, recomposed);
+    }
+    {
+      const initial = 'Hello my World';
+      const change = simpleDiffStringWithCursor(initial, 'Hello World', 0); // Should delete after the current cursor position
+      compare(change, { insert: '', remove: 3, index: 5 });
+      const recomposed = splice(initial, change.index, change.remove, change.insert);
+      compareStrings(expected, recomposed);
+    }
+  };
+
   /**
    * @param {t.TestCase} tc
    */
@@ -5090,6 +5191,7 @@
     __proto__: null,
     testDiffing: testDiffing,
     testRepeatDiffing: testRepeatDiffing,
+    testSimpleDiffWithCursor: testSimpleDiffWithCursor,
     testArrayDiffing: testArrayDiffing
   });
 
@@ -5102,7 +5204,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$7();
+    const map1 = create$a();
     map1.set(1, 2);
     map1.set('x', {});
     map1.set(98, 'tst');
@@ -5206,7 +5308,7 @@
   };
 
   const testAsync = async () => {
-    await measureTimeAsync('time', () => create$2(r => setTimeout(r)));
+    await measureTimeAsync('time', () => create$5(r => setTimeout(r)));
     await groupAsync('some description', () => wait(1));
   };
 
@@ -5234,23 +5336,32 @@
    * @module error
    */
 
+  /* istanbul ignore next */
   /**
    * @param {string} s
    * @return {Error}
    */
+  const create$4 = s => new Error(s);
+
   /* istanbul ignore next */
-  const create$1 = s => new Error(s);
+  /**
+   * @throws {Error}
+   * @return {never}
+   */
+  const unexpectedCase = () => {
+    throw create$4('Unexpected case')
+  };
 
   /* eslint-env browser */
 
+  /* istanbul ignore next */
   /**
    * IDB Request to Promise transformer
    *
    * @param {IDBRequest} request
    * @return {Promise<any>}
    */
-  /* istanbul ignore next */
-  const rtop = request => create$2((resolve, reject) => {
+  const rtop = request => create$5((resolve, reject) => {
     /* istanbul ignore next */
     // @ts-ignore
     request.onerror = event => reject(new Error(event.target.error));
@@ -5261,13 +5372,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$2((resolve, reject) => {
+  const openDB = (name, initDB) => create$5((resolve, reject) => {
     const request = indexedDB.open(name);
     /**
      * @param {any} event
@@ -5277,7 +5388,7 @@
     /**
      * @param {any} event
      */
-    request.onerror = event => reject(create$1(event.target.error));
+    request.onerror = event => reject(create$4(event.target.error));
     /* istanbul ignore next */
     request.onblocked = () => location.reload();
     /**
@@ -5298,82 +5409,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) =>
+  const get$1 = (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 = (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));
 
@@ -5384,23 +5495,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$2((resolve, reject) => {
+  const iterateOnRequest = (request, f) => create$5((resolve, reject) => {
     /* istanbul ignore next */
     request.onerror = reject;
     /**
@@ -5415,6 +5526,7 @@
     };
   });
 
+  /* istanbul ignore next */
   /**
    * Iterate on keys and values
    * @param {IDBObjectStore} store
@@ -5422,10 +5534,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)
    *
@@ -5434,26 +5546,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$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 */
@@ -5531,19 +5642,19 @@
     await iterateTests('range!=null', range);
 
     describe('idb.get');
-    const getV = await get(store, ['t', 1]);
+    const getV = await get$1(store, ['t', 1]);
     assert(getV === 0);
     describe('idb.del');
     await del(store, ['t', 0]);
-    const getVDel = await get(store, ['t', 0]);
+    const getVDel = await get$1(store, ['t', 0]);
     assert(getVDel === undefined);
     describe('idb.add');
     await add(store, 99, 42);
-    const idbVAdd = await get(store, 42);
+    const idbVAdd = await get$1(store, 42);
     assert(idbVAdd === 99);
     describe('idb.addAutoKey');
     const key = await addAutoKey(store, 1234);
-    const retrieved = await get(store, key);
+    const retrieved = await get$1(store, key);
     assert(retrieved === 1234);
   };
 
@@ -5993,7 +6104,7 @@
    * @param {Promise<T>} p
    * @return {Promise<T>}
    */
-  const failsP = p => create$2((resolve, reject) => p.then(() => reject(create$1('Promise should fail')), resolve));
+  const failsP = p => create$5((resolve, reject) => p.then(() => reject(create$4('Promise should fail')), resolve));
 
   /**
    * @param {t.TestCase} tc
@@ -6019,7 +6130,7 @@
    */
   const testispromise = tc => {
     assert(isPromise(new Promise(() => {})));
-    assert(isPromise(create$2(() => {})));
+    assert(isPromise(create$5(() => {})));
     const rej = reject();
     assert(isPromise(rej));
     rej.catch(() => {});
@@ -6064,12 +6175,12 @@
    *
    * @return {Queue}
    */
-  const create = () => new Queue();
+  const create$3 = () => new Queue();
 
   /**
    * @param {Queue} queue
    */
-  const isEmpty = queue => queue.start === null;
+  const isEmpty$1 = queue => queue.start === null;
 
   /**
    * @param {Queue} queue
@@ -6094,12 +6205,15 @@
     if (n !== null) {
       // @ts-ignore
       queue.start = n.next;
+      if (queue.start === null) {
+        queue.end = null;
+      }
       return n
     }
     return null
   };
 
-  class QueueItem extends QueueNode {
+  class QueueItem$1 extends QueueNode {
     /**
      * @param {number} v
      */
@@ -6112,51 +6226,62 @@
   /**
    * @param {t.TestCase} tc
    */
-  const testEnqueueDequeue = tc => {
+  const testEnqueueDequeue$1 = tc => {
     const N = 30;
     /**
      * @type {queue.Queue}
      */
-    const q = create();
-    assert(isEmpty(q));
+    const q = create$3();
+    assert(isEmpty$1(q));
     assert(dequeue(q) === null);
     for (let i = 0; i < N; i++) {
-      enqueue(q, new QueueItem(i));
-      assert(!isEmpty(q));
+      enqueue(q, new QueueItem$1(i));
+      assert(!isEmpty$1(q));
+    }
+    for (let i = 0; i < N; i++) {
+      const item = /** @type {QueueItem} */ (dequeue(q));
+      assert(item !== null && item.v === i);
+    }
+    assert(isEmpty$1(q));
+    assert(dequeue(q) === null);
+    for (let i = 0; i < N; i++) {
+      enqueue(q, new QueueItem$1(i));
+      assert(!isEmpty$1(q));
     }
     for (let i = 0; i < N; i++) {
       const item = /** @type {QueueItem} */ (dequeue(q));
       assert(item !== null && item.v === i);
     }
+    assert(isEmpty$1(q));
     assert(dequeue(q) === null);
   };
 
   var queue = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    testEnqueueDequeue: testEnqueueDequeue
+    testEnqueueDequeue: testEnqueueDequeue$1
   });
 
   /**
    * @param {t.TestCase} tc
    */
   const testMap = tc => {
-    const m = create$7();
+    const m = create$a();
     m.set(1, 2);
     m.set(2, 3);
-    assert(map$3(m, (value, key) => value * 2 + key).reduce(add$1) === 13);
+    assert(map$4(m, (value, key) => value * 2 + key).reduce(add$1) === 13);
     let numberOfWrites = 0;
     const createT = () => {
       numberOfWrites++;
       return {}
     };
-    setIfUndefined(m, 3, createT);
-    setIfUndefined(m, 3, createT);
-    setIfUndefined(m, 3, createT);
+    setIfUndefined$1(m, 3, createT);
+    setIfUndefined$1(m, 3, createT);
+    setIfUndefined$1(m, 3, createT);
     compare(copy(m), m);
     assert(numberOfWrites === 1);
   };
 
-  var map = /*#__PURE__*/Object.freeze({
+  var map$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     testMap: testMap
   });
@@ -6191,7 +6316,7 @@
       set = true;
     });
     timeout$1.destroy();
-    await create$2(resolve => {
+    await create$5(resolve => {
       timeout(10, resolve);
     });
     assert(set === false);
@@ -6229,7 +6354,7 @@
    * @param {t.TestCase} tc
    */
   const testIdleCallback = async tc => {
-    await create$2(resolve => {
+    await create$5(resolve => {
       idleCallback(resolve);
     });
   };
@@ -6284,7 +6409,7 @@
    * @param {t.TestCase} tc
    */
   const testPair = tc => {
-    const ps = [create$5(1, 2), create$5(3, 4), createReversed(6, 5)];
+    const ps = [create$8(1, 2), create$8(3, 4), createReversed(6, 5)];
     describe('Counting elements in pair list');
     let countLeft = 0;
     let countRight = 0;
@@ -6294,8 +6419,8 @@
     });
     assert(countLeft === 9);
     assert(countRight === 12);
-    assert(countLeft === map$2(ps, left => left).reduce(add$1));
-    assert(countRight === map$2(ps, (left, right) => right).reduce(add$1));
+    assert(countLeft === map$3(ps, left => left).reduce(add$1));
+    assert(countRight === map$3(ps, (left, right) => right).reduce(add$1));
   };
 
   var pair = /*#__PURE__*/Object.freeze({
@@ -6307,7 +6432,7 @@
    * @param {t.TestCase} tc
    */
   const testObject = tc => {
-    assert(create$4().constructor === undefined, 'object.create creates an empty object without constructor');
+    assert(create$7().constructor === undefined, 'object.create creates an empty object without constructor');
     describe('object.equalFlat');
     assert(equalFlat({}, {}), 'comparing equal objects');
     assert(equalFlat({ x: 1 }, { x: 1 }), 'comparing equal objects');
@@ -6328,7 +6453,7 @@
     forEach({ x: 1, y: 3 }, (v, k) => { forEachSum += v; });
     assert(forEachSum === 4);
     describe('object.map');
-    assert(map$1({ x: 1, z: 5 }, (v, k) => v).reduce(add$1) === 6);
+    assert(map$2({ x: 1, z: 5 }, (v, k) => v).reduce(add$1) === 6);
     describe('object.length');
     assert(length$1({}) === 0);
     assert(length$1({ x: 1 }) === 1);
@@ -6428,6 +6553,50 @@
     testAnyEncoding: testAnyEncoding
   });
 
+  /**
+   * Utility module to work with sets.
+   *
+   * @module set
+   */
+
+  const create$2 = () => new Set();
+
+  /**
+   * @template T
+   * @param {Set<T>} set
+   * @return {T}
+   */
+  const first = set => {
+    return set.values().next().value || undefined
+  };
+
+  /**
+   * @template T
+   * @param {Iterable<T>} entries
+   * @return {Set<T>}
+   */
+  const from = entries => {
+    return new Set(entries)
+  };
+
+  /**
+   * @template T
+   * @param {t.TestCase} tc
+   */
+  const testFirst = tc => {
+    const two = from(['a', 'b']);
+    const one = from(['b']);
+    const zero = create$2();
+    assert(first(two) === 'a');
+    assert(first(one) === 'b');
+    assert(first(zero) === undefined);
+  };
+
+  var set$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    testFirst: testFirst
+  });
+
   /**
    * Efficient sort implementations.
    *
@@ -6720,7 +6889,7 @@
    * @return {string}
    */
   const encodeQueryParams = params =>
-    map$1(params, (val, key) => `${encodeURIComponent(key)}=${encodeURIComponent(val)}`).join('&');
+    map$2(params, (val, key) => `${encodeURIComponent(key)}=${encodeURIComponent(val)}`).join('&');
 
   /**
    * @param {Object<string,any>} params
@@ -6884,6 +7053,488 @@
     testStorageModule: testStorageModule
   });
 
+  class ListNode {
+    constructor () {
+      /**
+       * @type {this|null}
+       */
+      this.next = null;
+      /**
+       * @type {this|null}
+       */
+      this.prev = null;
+    }
+  }
+
+  /**
+   * @template {ListNode} N
+   */
+  class List {
+    constructor () {
+      /**
+       * @type {N | null}
+       */
+      this.start = null;
+      /**
+       * @type {N | null}
+       */
+      this.end = null;
+    }
+  }
+
+  /**
+   * @note The queue implementation is experimental and unfinished.
+   * Don't use this in production yet.
+   *
+   * @template {ListNode} N
+   *
+   * @return {List<N>}
+   */
+  const create$1 = () => new List();
+
+  /**
+   * @template {ListNode} N
+   *
+   * @param {List<N>} queue
+   */
+  const isEmpty = queue => queue.start === null;
+
+  /**
+   * Remove a single node from the queue. Only works with Queues that operate on Doubly-linked lists of nodes.
+   *
+   * @template {ListNode} N
+   *
+   * @param {List<N>} queue
+   * @param {N} node
+   */
+  const removeNode = (queue, node) => {
+    const prev = node.prev;
+    const next = node.next;
+    if (prev) {
+      prev.next = next;
+    } else {
+      queue.start = next;
+    }
+    if (next) {
+      next.prev = prev;
+    } else {
+      queue.end = prev;
+    }
+    return node
+  };
+
+  /**
+   * @template {ListNode} N
+   *
+   * @param {List<N>} queue
+   * @param {N| null} left
+   * @param {N| null} right
+   * @param {N} node
+   */
+  const insertBetween = (queue, left, right, node) => {
+    /* istanbul ignore if */
+    if (left != null && left.next !== right) {
+      throw unexpectedCase()
+    }
+    if (left) {
+      left.next = node;
+    } else {
+      queue.start = node;
+    }
+    if (right) {
+      right.prev = node;
+    } else {
+      queue.end = node;
+    }
+    node.prev = left;
+    node.next = right;
+  };
+
+  /**
+   * @template {ListNode} N
+   *
+   * @param {List<N>} queue
+   * @param {N} n
+   */
+  const pushEnd = (queue, n) =>
+    insertBetween(queue, queue.end, null, n);
+
+  /**
+   * @template {ListNode} N
+   *
+   * @param {List<N>} queue
+   * @param {N} n
+   */
+  const pushFront = (queue, n) =>
+    insertBetween(queue, null, queue.start, n);
+
+  /**
+   * @template {ListNode} N
+   *
+   * @param {List<N>} list
+   * @return {N| null}
+   */
+  const popFront = list =>
+    list.start ? removeNode(list, list.start) : null;
+
+  /**
+   * @template {ListNode} N
+   *
+   * @param {List<N>} list
+   * @return {N| null}
+   */
+  const popEnd = list =>
+    list.end ? removeNode(list, list.end) : null;
+
+  /**
+   * @template {ListNode} N
+   * @template M
+   *
+   * @param {List<N>} list
+   * @param {function(N):M} f
+   * @return {Array<M>}
+   */
+  const map = (list, f) => {
+    /**
+     * @type {Array<M>}
+     */
+    const arr = [];
+    let n = list.start;
+    while (n) {
+      arr.push(f(n));
+      n = n.next;
+    }
+    return arr
+  };
+
+  class QueueItem extends ListNode {
+    /**
+     * @param {number} v
+     */
+    constructor (v) {
+      super();
+      this.v = v;
+    }
+  }
+
+  /**
+   * @param {t.TestCase} tc
+   */
+  const testEnqueueDequeue = tc => {
+    const N = 30;
+    /**
+     * @type {list.List<QueueItem>}
+     */
+    const q = create$1();
+    assert(isEmpty(q));
+    assert(popFront(q) === null);
+    for (let i = 0; i < N; i++) {
+      pushEnd(q, new QueueItem(i));
+      assert(!isEmpty(q));
+    }
+    for (let i = 0; i < N; i++) {
+      const item = /** @type {QueueItem} */ (popFront(q));
+      assert(item !== null && item.v === i);
+    }
+    assert(isEmpty(q));
+    assert(popFront(q) === null);
+    for (let i = 0; i < N; i++) {
+      pushEnd(q, new QueueItem(i));
+      assert(!isEmpty(q));
+    }
+    for (let i = 0; i < N; i++) {
+      const item = /** @type {QueueItem} */ (popFront(q));
+      assert(item !== null && item.v === i);
+    }
+    assert(isEmpty(q));
+    assert(popFront(q) === null);
+  };
+
+  /**
+   * @param {t.TestCase} tc
+   */
+  const testSelectivePop = tc => {
+    /**
+     * @type {list.List<QueueItem>}
+     */
+    const l = create$1();
+    pushFront(l, new QueueItem(1));
+    pushEnd(l, new QueueItem(3));
+    const middleNode = new QueueItem(2);
+    insertBetween(l, l.start, l.end, middleNode);
+    compare(map(l, n => n.v), [1, 2, 3]);
+    assert(removeNode(l, middleNode) === middleNode);
+    compare(/** @type {QueueItem} */ (popEnd(l)).v, 3);
+    compare(/** @type {QueueItem} */ (popEnd(l)).v, 1);
+    compare(popEnd(l), null);
+    assert(l.start === null);
+    assert(l.end === null);
+  };
+
+  var list = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    testEnqueueDequeue: testEnqueueDequeue,
+    testSelectivePop: testSelectivePop
+  });
+
+  /**
+   * @template K, V
+   *
+   * @implements {list.ListNode}
+   */
+  class Entry {
+    /**
+     * @param {K} key
+     * @param {V | Promise<V>} val
+     */
+    constructor (key, val) {
+      /**
+       * @type {this | null}
+       */
+      this.prev = null;
+      /**
+       * @type {this | null}
+       */
+      this.next = null;
+      this.created = getUnixTime();
+      this.val = val;
+      this.key = key;
+    }
+  }
+
+  /**
+   * @template K, V
+   */
+  class Cache {
+    /**
+     * @param {number} timeout
+     */
+    constructor (timeout) {
+      this.timeout = timeout;
+      /**
+       * @type list.List<Entry<K, V>>
+       */
+      this._q = create$1();
+      /**
+       * @type {Map<K, Entry<K, V>>}
+       */
+      this._map = create$a();
+    }
+  }
+
+  /**
+   * @template K, V
+   *
+   * @param {Cache<K, V>} cache
+   * @return {number} Returns the current timestamp
+   */
+  const removeStale = cache => {
+    const now = getUnixTime();
+    const q = cache._q;
+    while (q.start && now - q.start.created > cache.timeout) {
+      cache._map.delete(q.start.key);
+      popFront(q);
+    }
+    return now
+  };
+
+  /**
+   * @template K, V
+   *
+   * @param {Cache<K, V>} cache
+   * @param {K} key
+   * @param {V} value
+   */
+  const set = (cache, key, value) => {
+    const now = removeStale(cache);
+    const q = cache._q;
+    const n = cache._map.get(key);
+    if (n) {
+      removeNode(q, n);
+      pushEnd(q, n);
+      n.created = now;
+      n.val = value;
+    } else {
+      const node = new Entry(key, value);
+      pushEnd(q, node);
+      cache._map.set(key, node);
+    }
+  };
+
+  /**
+   * @template K, V
+   *
+   * @param {Cache<K, V>} cache
+   * @param {K} key
+   * @return {Entry<K, V> | undefined}
+   */
+  const getNode = (cache, key) => {
+    const now = removeStale(cache);
+    const q = cache._q;
+    const n = cache._map.get(key);
+    if (n) {
+      removeNode(q, n);
+      pushEnd(q, n);
+      n.created = now;
+      return n
+    }
+  };
+
+  /**
+   * @template K, V
+   *
+   * @param {Cache<K, V>} cache
+   * @param {K} key
+   * @return {V | undefined}
+   */
+  const get = (cache, key) => {
+    const n = getNode(cache, key);
+    return n && !(n.val instanceof Promise) ? n.val : undefined
+  };
+
+  /**
+   * Works well in conjunktion with setIfUndefined which has an async init function.
+   * Using getAsync & setIfUndefined ensures that the init function is only called once.
+   *
+   * @template K, V
+   *
+   * @param {Cache<K, V>} cache
+   * @param {K} key
+   * @return {V | Promise<V> | undefined}
+   */
+  const getAsync = (cache, key) => {
+    const n = getNode(cache, key);
+    return n ? n.val : undefined
+  };
+
+  /**
+   * @template K, V
+   *
+   * @param {Cache<K, V>} cache
+   * @param {K} key
+   */
+  const remove = (cache, key) => {
+    const n = cache._map.get(key);
+    if (n) {
+      removeNode(cache._q, n);
+      cache._map.delete(key);
+      return n.val && !(n.val instanceof Promise) ? n.val : undefined
+    }
+  };
+
+  /**
+   * @template K, V
+   *
+   * @param {Cache<K, V>} cache
+   * @param {K} key
+   * @param {function():Promise<V>} init
+   * @param {boolean} removeNull Optional argument that automatically removes values that resolve to null/undefined from the cache.
+   * @return {Promise<V> | V}
+   */
+  const setIfUndefined = (cache, key, init, removeNull = false) => {
+    const now = removeStale(cache);
+    const q = cache._q;
+    const n = cache._map.get(key);
+    if (n) {
+      removeNode(q, n);
+      pushEnd(q, n);
+      n.created = now;
+      return n.val
+    } else {
+      const p = init();
+      const node = new Entry(key, p);
+      pushEnd(q, node);
+      cache._map.set(key, node);
+      p.then(v => {
+        if (p === node.val) {
+          node.val = v;
+        }
+        if (removeNull && v == null) {
+          remove(cache, key);
+        }
+      });
+      return p
+    }
+  };
+
+  /**
+   * @param {number} timeout
+   */
+  const create = timeout => new Cache(timeout);
+
+  /**
+   * @param {t.TestCase} tc
+   */
+  const testCache = async tc => {
+    /**
+     * @type {cache.Cache<string, string>}
+     */
+    const c = create(50);
+    set(c, 'a', '1');
+    assert(get(c, 'a') === '1');
+    assert(await getAsync(c, 'a') === '1');
+    const p = setIfUndefined(c, 'b', () => resolveWith('2'));
+    const q = setIfUndefined(c, 'b', () => resolveWith('3'));
+    assert(p === q);
+    assert(get(c, 'b') == null);
+    assert(getAsync(c, 'b') === p);
+    assert(await p === '2');
+    assert(get(c, 'b') === '2');
+    assert(getAsync(c, 'b') === '2');
+
+    await wait(5); // keys shouldn't be timed out yet
+    assert(get(c, 'a') === '1');
+    assert(get(c, 'b') === '2');
+
+    /**
+     * @type {any}
+     */
+    const m = c._map;
+    const aTimestamp1 = m.get('a').created;
+    const bTimestamp1 = m.get('b').created;
+
+    // write new values and check later if the creation-timestamp was updated
+    set(c, 'a', '11');
+    await setIfUndefined(c, 'b', () => resolveWith('22')); // this shouldn't override, but update the timestamp
+
+    await wait(5); // keys should be updated and not timed out. Hence the creation time should be updated
+    assert(get(c, 'a') === '11');
+    assert(get(c, 'b') === '2');
+    // timestamps should be updated
+    assert(aTimestamp1 !== m.get('a').created);
+    assert(bTimestamp1 !== m.get('b').created);
+
+    await wait(60); // now the keys should be timed-out
+
+    assert(get(c, 'a') == null);
+    assert(getAsync(c, 'b') == null);
+
+    assert(c._map.size === 0);
+    assert(c._q.start === null && c._q.end === null);
+
+    // test edge case of setIfUndefined
+    const xp = setIfUndefined(c, 'a', () => resolve('x'));
+    set(c, 'a', 'y');
+    await xp;
+    // we override the Entry.val property in cache when p resolves. However, we must prevent that when the value is overriden before p is resolved.
+    assert(get(c, 'a') === 'y');
+
+    // test that we can remove properties
+    remove(c, 'a');
+    remove(c, 'does not exist'); // remove a non-existent property to achieve full test-coverage
+    assert(get(c, 'a') === undefined);
+
+    // test that the optional property in setifUndefined works
+    const yp = setIfUndefined(c, 'a', () => resolveWith(null), true);
+    assert(await yp === null);
+    assert(get(c, 'a') === undefined);
+  };
+
+  var cache = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    testCache: testCache
+  });
+
   /* istanbul ignore if */
   if (isBrowser) {
     createVConsole(document.body);
@@ -6903,7 +7554,7 @@
     random,
     promise,
     queue,
-    map,
+    map: map$1,
     eventloop,
     time,
     pair,
@@ -6911,11 +7562,14 @@
     math,
     number,
     buffer,
+    set: set$1,
     sort,
     url,
     metric,
     func,
-    storage
+    storage,
+    list,
+    cache
   }).then(success => {
     /* istanbul ignore next */
     if (isNode) {
@@ -6923,5 +7577,5 @@
     }
   });
 
-}());
+})();
 //# sourceMappingURL=test.js.map