lib0 0.2.43 → 0.2.44

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
@@ -863,7 +871,7 @@
   /**
    * @return {Object<string,any>} obj
    */
-  const create$4 = () => Object.create(null);
+  const create$7 = () => Object.create(null);
 
   /**
    * Object.assign
@@ -891,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));
@@ -1058,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 = {
@@ -1103,7 +1111,7 @@
   const computeBrowserLoggingArgs = args => {
     const strBuilder = [];
     const styles = [];
-    const currentStyle = create$7();
+    const currentStyle = create$a();
     /**
      * @type {Array<string|Object|number>}
      */
@@ -1281,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;';
           }
@@ -1327,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;
@@ -1366,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))]);
       });
     }
 
@@ -1383,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`)])]);
       });
     }
 
@@ -1453,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,
@@ -1487,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,
@@ -1985,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++) {
@@ -2020,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.
@@ -2042,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);
   };
 
   /**
@@ -2084,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;
     }
   };
@@ -3387,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.
@@ -3577,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
@@ -3606,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]]
    *
@@ -3614,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 = () => {
@@ -3636,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.
@@ -3743,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
     }
@@ -4170,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();
@@ -4336,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 */
@@ -5051,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('') }));
   }
@@ -5076,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
    */
@@ -5095,6 +5191,7 @@
     __proto__: null,
     testDiffing: testDiffing,
     testRepeatDiffing: testRepeatDiffing,
+    testSimpleDiffWithCursor: testSimpleDiffWithCursor,
     testArrayDiffing: testArrayDiffing
   });
 
@@ -5107,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');
@@ -5211,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));
   };
 
@@ -5244,7 +5341,16 @@
    * @param {string} s
    * @return {Error}
    */
-  const create$1 = s => new Error(s);
+  const create$4 = s => new Error(s);
+
+  /* istanbul ignore next */
+  /**
+   * @throws {Error}
+   * @return {never}
+   */
+  const unexpectedCase = () => {
+    throw create$4('Unexpected case')
+  };
 
   /* eslint-env browser */
 
@@ -5255,7 +5361,7 @@
    * @param {IDBRequest} request
    * @return {Promise<any>}
    */
-  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));
@@ -5272,7 +5378,7 @@
    * @param {function(IDBDatabase):any} initDB Called when the database is first created
    * @return {Promise<IDBDatabase>}
    */
-  const openDB = (name, initDB) => create$2((resolve, reject) => {
+  const openDB = (name, initDB) => create$5((resolve, reject) => {
     const request = indexedDB.open(name);
     /**
      * @param {any} event
@@ -5282,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();
     /**
@@ -5325,7 +5431,7 @@
    * @param {String | number | ArrayBuffer | Date | Array<any> } key
    * @return {Promise<String | number | ArrayBuffer | Date | Array<any>>}
    */
-  const get = (store, key) =>
+  const get$1 = (store, key) =>
     rtop(store.get(key));
 
   /* istanbul ignore next */
@@ -5405,7 +5511,7 @@
    * @param {function(IDBCursorWithValue):void|boolean} f
    * @return {Promise<void>}
    */
-  const iterateOnRequest = (request, f) => create$2((resolve, reject) => {
+  const iterateOnRequest = (request, f) => create$5((resolve, reject) => {
     /* istanbul ignore next */
     request.onerror = reject;
     /**
@@ -5536,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);
   };
 
@@ -5998,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
@@ -6024,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(() => {});
@@ -6069,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
@@ -6099,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
      */
@@ -6117,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
   });
@@ -6196,7 +6316,7 @@
       set = true;
     });
     timeout$1.destroy();
-    await create$2(resolve => {
+    await create$5(resolve => {
       timeout(10, resolve);
     });
     assert(set === false);
@@ -6234,7 +6354,7 @@
    * @param {t.TestCase} tc
    */
   const testIdleCallback = async tc => {
-    await create$2(resolve => {
+    await create$5(resolve => {
       idleCallback(resolve);
     });
   };
@@ -6289,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;
@@ -6299,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({
@@ -6312,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');
@@ -6333,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);
@@ -6433,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.
    *
@@ -6725,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
@@ -6889,6 +7053,459 @@
     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
+   * @param {function():Promise<V>} init
+   * @return {Promise<V> | V}
+   */
+  const setIfUndefined = (cache, key, init) => {
+    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;
+        }
+      });
+      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');
+  };
+
+  var cache = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    testCache: testCache
+  });
+
   /* istanbul ignore if */
   if (isBrowser) {
     createVConsole(document.body);
@@ -6908,7 +7525,7 @@
     random,
     promise,
     queue,
-    map,
+    map: map$1,
     eventloop,
     time,
     pair,
@@ -6916,11 +7533,14 @@
     math,
     number,
     buffer,
+    set: set$1,
     sort,
     url,
     metric,
     func,
-    storage
+    storage,
+    list,
+    cache
   }).then(success => {
     /* istanbul ignore next */
     if (isNode) {