lib0 0.2.41 → 0.2.44

package/dist/test.cjs

@@ -16,7 +16,7 @@ var isomorphic_js = require('isomorphic.js');
  *
  * @function
  */
-const create$7 = () => new Map();
+const create$a = () => new Map();
 
 /**
  * Copy a Map object into a fresh Map object.
@@ -27,7 +27,7 @@ const create$7 = () => new Map();
  * @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
 };
@@ -47,7 +47,7 @@ const copy = m => {
  * @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());
@@ -66,7 +66,7 @@ const setIfUndefined = (map, key, createT) => {
  * @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));
@@ -189,6 +189,14 @@ const _decodeUtf8Native = buf => /** @type {TextDecoder} */ (utf8TextDecoder).de
 /* 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.
  *
@@ -289,7 +297,7 @@ let params;
 const computeParams = () => {
   if (params === undefined) {
     if (isNode) {
-      params = create$7();
+      params = create$a();
       const pargs = process.argv;
       let currParamName = null;
       /* istanbul ignore next */
@@ -312,7 +320,7 @@ const computeParams = () => {
       }
     // in ReactNative for example this would not be true (unless connected to the Remote Debugger)
     } else if (typeof location === 'object') {
-      params = create$7()
+      params = create$a()
       // eslint-disable-next-line no-undef
       ;(location.search || '?').slice(1).split('&').forEach(kv => {
         if (kv.length !== 0) {
@@ -322,7 +330,7 @@ const computeParams = () => {
         }
       });
     } else {
-      params = create$7();
+      params = create$a();
     }
   }
   return params
@@ -372,7 +380,7 @@ const production = hasConf('production');
  *
  * @return {Symbol}
  */
-const create$6 = Symbol;
+const create$9 = Symbol;
 
 /**
  * Working with value pairs.
@@ -400,7 +408,7 @@ class Pair {
  * @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
@@ -423,7 +431,7 @@ const forEach$1 = (arr, f) => arr.forEach(p => f(p.left, p.right));
  * @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 */
 
@@ -542,7 +550,7 @@ const text = createTextNode;
  * @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
@@ -552,6 +560,14 @@ const mapToStyleString = m => map$3(m, (value, key) => `${key}:${value};`).join(
 /* istanbul ignore next */
 const appendChild = (parent, child) => parent.appendChild(child);
 
+doc.ELEMENT_NODE;
+doc.TEXT_NODE;
+doc.CDATA_SECTION_NODE;
+doc.COMMENT_NODE;
+doc.DOCUMENT_NODE;
+doc.DOCUMENT_TYPE_NODE;
+doc.DOCUMENT_FRAGMENT_NODE;
+
 /**
  * JSON utility functions.
  *
@@ -856,7 +872,7 @@ const flatten = arr => arr.reduce((acc, val) => acc.concat(val), []);
 /**
  * @return {Object<string,any>} obj
  */
-const create$4 = () => Object.create(null);
+const create$7 = () => Object.create(null);
 
 /**
  * Object.assign
@@ -884,7 +900,7 @@ const forEach = (obj, f) => {
  * @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));
@@ -1051,29 +1067,29 @@ const equalityDeep = (a, b) => {
  * @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 = {
@@ -1096,7 +1112,7 @@ const _nodeStyleMap = {
 const computeBrowserLoggingArgs = args => {
   const strBuilder = [];
   const styles = [];
-  const currentStyle = create$7();
+  const currentStyle = create$a();
   /**
    * @type {Array<string|Object|number>}
    */
@@ -1274,7 +1290,7 @@ const _computeLineSpans = args => {
     } 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;';
         }
@@ -1320,10 +1336,10 @@ class VConsole {
    */
   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;
@@ -1359,7 +1375,7 @@ class VConsole {
    */
   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))]);
     });
   }
 
@@ -1376,7 +1392,7 @@ class VConsole {
    */
   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`)])]);
     });
   }
 
@@ -1446,11 +1462,8 @@ const simpleDiffString = (a, b) => {
   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,
@@ -1459,12 +1472,6 @@ const simpleDiffString = (a, b) => {
   }
 };
 
-/**
- * @todo Remove in favor of simpleDiffString
- * @deprecated
- */
-const simpleDiff = simpleDiffString;
-
 /**
  * Create a diff between two arrays. This diff implementation is highly
  * efficient, but not very sophisticated.
@@ -1486,11 +1493,51 @@ const simpleDiffArray = (a, b, compare = equalityStrict) => {
   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,
@@ -1958,7 +2005,7 @@ const write = (encoder, num) => {
  * @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++) {
@@ -1993,7 +2040,7 @@ const writeUint8 = write;
  * @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.
@@ -2015,8 +2062,8 @@ const writeUint16 = (encoder, num) => {
  * @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);
 };
 
 /**
@@ -2057,7 +2104,7 @@ const writeUint32BigEndian = (encoder, num) => {
  */
 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;
   }
 };
@@ -3360,7 +3407,7 @@ const DefaultPRNG = Xoroshiro128plus;
  * @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.
@@ -3550,7 +3597,7 @@ const average = arr => arr.reduce(add$1, 0) / arr.length;
  * @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
@@ -3579,6 +3626,13 @@ const reject = reason => Promise.reject(reason);
  */
 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]]
  *
@@ -3587,7 +3641,7 @@ const resolve = res => Promise.resolve(res);
  * @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 = () => {
@@ -3609,7 +3663,7 @@ const until = (timeout, check, intervalResolution = 10) => create$2((resolve, re
  * @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.
@@ -3716,7 +3770,7 @@ class TestCase {
   get prng () {
     /* istanbul ignore else */
     if (this._prng === null) {
-      this._prng = create$3(this.seed);
+      this._prng = create$6(this.seed);
     }
     return this._prng
   }
@@ -3757,6 +3811,9 @@ const run = async (moduleName, name, f, i, numberOfTests) => {
   const times = [];
   const start = isomorphic_js.performance.now();
   let lastTime = start;
+  /**
+   * @type {any}
+   */
   let err = null;
   isomorphic_js.performance.mark(`${name}-start`);
   do {
@@ -3977,7 +4034,7 @@ const compareArrays = (as, bs, m = 'Arrays match') => {
  */
 const compareStrings = (a, b, m = 'Strings match') => {
   if (a !== b) {
-    const diff = simpleDiff(a, b);
+    const diff = simpleDiffString(a, b);
     print(GREY, a.slice(0, diff.index), RED, a.slice(diff.index, diff.remove), GREEN, diff.insert, GREY, a.slice(diff.index + diff.remove));
     fail(m);
   }
@@ -4140,7 +4197,7 @@ const fails = f => {
  * @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 = isomorphic_js.performance.now();
@@ -4306,12 +4363,22 @@ const testBomEncodingDecoding = tc => {
   }
 };
 
+/**
+ * @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 */
@@ -5021,6 +5088,7 @@ var encoding = /*#__PURE__*/Object.freeze({
 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('') }));
 }
@@ -5046,10 +5114,43 @@ const testRepeatDiffing = tc => {
   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
  */
@@ -5065,6 +5166,7 @@ var diff = /*#__PURE__*/Object.freeze({
   __proto__: null,
   testDiffing: testDiffing,
   testRepeatDiffing: testRepeatDiffing,
+  testSimpleDiffWithCursor: testSimpleDiffWithCursor,
   testArrayDiffing: testArrayDiffing
 });
 
@@ -5077,7 +5179,7 @@ const testComparing = tc => {
   compare([1, 2], [1, 2], 'simple compare (array)');
   compare({ a: [1, 2] }, { a: [1, 2] }, 'simple compare nested');
   compare(new Set(['3', 1234]), new Set(['3', 1234]), 'compare Sets');
-  const map1 = create$7();
+  const map1 = create$a();
   map1.set(1, 2);
   map1.set('x', {});
   map1.set(98, 'tst');
@@ -5181,7 +5283,7 @@ const testSkipping = () => {
 };
 
 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));
 };
 
@@ -5209,23 +5311,32 @@ var testing = /*#__PURE__*/Object.freeze({
  * @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));
@@ -5236,13 +5347,13 @@ const rtop = request => create$2((resolve, reject) => {
   request.onsuccess = event => resolve(event.target.result);
 });
 
+/* istanbul ignore next */
 /**
  * @param {string} name
  * @param {function(IDBDatabase):any} initDB Called when the database is first created
  * @return {Promise<IDBDatabase>}
  */
-/* istanbul ignore next */
-const openDB = (name, initDB) => create$2((resolve, reject) => {
+const openDB = (name, initDB) => create$5((resolve, reject) => {
   const request = indexedDB.open(name);
   /**
    * @param {any} event
@@ -5252,7 +5363,7 @@ const openDB = (name, initDB) => create$2((resolve, reject) => {
   /**
    * @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();
   /**
@@ -5273,82 +5384,82 @@ const openDB = (name, initDB) => create$2((resolve, reject) => {
   };
 });
 
+/* istanbul ignore next */
 /**
  * @param {string} name
  */
-/* istanbul ignore next */
 const deleteDB = name => rtop(indexedDB.deleteDatabase(name));
 
+/* istanbul ignore next */
 /**
  * @param {IDBDatabase} db
  * @param {Array<Array<string>|Array<string|IDBObjectStoreParameters|undefined>>} definitions
  */
-/* istanbul ignore next */
 const createStores = (db, definitions) => definitions.forEach(d =>
   // @ts-ignore
   db.createObjectStore.apply(db, d)
 );
 
+/* istanbul ignore next */
 /**
  * @param {IDBObjectStore} store
  * @param {String | number | ArrayBuffer | Date | Array<any> } key
  * @return {Promise<String | number | ArrayBuffer | Date | Array<any>>}
  */
-/* istanbul ignore next */
-const get = (store, key) =>
+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));
 
@@ -5359,23 +5470,23 @@ const getAllKeys = (store, range) =>
  * @property {any} v Value
  */
 
+/* istanbul ignore next */
 /**
  * @param {IDBObjectStore} store
  * @param {IDBKeyRange} [range]
  * @return {Promise<Array<KeyValuePair>>}
  */
-/* istanbul ignore next */
 const getAllKeysValues = (store, range) =>
   // @ts-ignore
   all([getAllKeys(store, range), getAll(store, range)]).then(([ks, vs]) => ks.map((k, i) => ({ k, v: vs[i] })));
 
+/* istanbul ignore next */
 /**
  * @param {any} request
  * @param {function(IDBCursorWithValue):void|boolean} f
  * @return {Promise<void>}
  */
-/* istanbul ignore next */
-const iterateOnRequest = (request, f) => create$2((resolve, reject) => {
+const iterateOnRequest = (request, f) => create$5((resolve, reject) => {
   /* istanbul ignore next */
   request.onerror = reject;
   /**
@@ -5390,6 +5501,7 @@ const iterateOnRequest = (request, f) => create$2((resolve, reject) => {
   };
 });
 
+/* istanbul ignore next */
 /**
  * Iterate on keys and values
  * @param {IDBObjectStore} store
@@ -5397,10 +5509,10 @@ const iterateOnRequest = (request, f) => create$2((resolve, reject) => {
  * @param {function(any,any):void|boolean} f Callback that receives (value, key)
  * @param {'next'|'prev'|'nextunique'|'prevunique'} direction
  */
-/* istanbul ignore next */
 const iterate = (store, keyrange, f, direction = 'next') =>
   iterateOnRequest(store.openCursor(keyrange, direction), cursor => f(cursor.value, cursor.key));
 
+/* istanbul ignore next */
 /**
  * Iterate on the keys (no values)
  *
@@ -5409,26 +5521,25 @@ const iterate = (store, keyrange, f, direction = 'next') =>
  * @param {function(any):void|boolean} f callback that receives the key
  * @param {'next'|'prev'|'nextunique'|'prevunique'} direction
  */
-/* istanbul ignore next */
 const iterateKeys = (store, keyrange, f, direction = 'next') =>
   iterateOnRequest(store.openKeyCursor(keyrange, direction), cursor => f(cursor.key));
 
+/* istanbul ignore next */
 /**
  * Open store from transaction
  * @param {IDBTransaction} t
  * @param {String} store
  * @returns {IDBObjectStore}
  */
-/* istanbul ignore next */
 const getStore$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 */
@@ -5506,19 +5617,19 @@ const testRetrieveElements = async () => {
   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);
 };
 
@@ -5968,7 +6079,7 @@ const measureP = (p, min, max) => {
  * @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
@@ -5994,7 +6105,7 @@ const testRepeatPromise = async tc => {
  */
 const testispromise = tc => {
   assert(isPromise(new Promise(() => {})));
-  assert(isPromise(create$2(() => {})));
+  assert(isPromise(create$5(() => {})));
   const rej = reject();
   assert(isPromise(rej));
   rej.catch(() => {});
@@ -6039,12 +6150,12 @@ class Queue {
  *
  * @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
@@ -6069,12 +6180,15 @@ const dequeue = queue => {
   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
    */
@@ -6087,51 +6201,62 @@ class QueueItem extends QueueNode {
 /**
  * @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
 });
@@ -6166,7 +6291,7 @@ const testTimeout = async tc => {
     set = true;
   });
   timeout$1.destroy();
-  await create$2(resolve => {
+  await create$5(resolve => {
     timeout(10, resolve);
   });
   assert(set === false);
@@ -6204,7 +6329,7 @@ const testAnimationFrame = async tc => {
  * @param {t.TestCase} tc
  */
 const testIdleCallback = async tc => {
-  await create$2(resolve => {
+  await create$5(resolve => {
     idleCallback(resolve);
   });
 };
@@ -6259,7 +6384,7 @@ var time = /*#__PURE__*/Object.freeze({
  * @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;
@@ -6269,8 +6394,8 @@ const testPair = tc => {
   });
   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({
@@ -6282,7 +6407,7 @@ var pair = /*#__PURE__*/Object.freeze({
  * @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');
@@ -6303,7 +6428,7 @@ const testObject = tc => {
   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);
@@ -6403,6 +6528,50 @@ var buffer = /*#__PURE__*/Object.freeze({
   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.
  *
@@ -6695,7 +6864,7 @@ const decodeQueryParams = url => {
  * @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
@@ -6859,6 +7028,459 @@ var storage = /*#__PURE__*/Object.freeze({
   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);
@@ -6878,7 +7500,7 @@ runTests({
   random,
   promise,
   queue,
-  map,
+  map: map$1,
   eventloop,
   time,
   pair,
@@ -6886,11 +7508,14 @@ runTests({
   math,
   number,
   buffer,
+  set: set$1,
   sort,
   url,
   metric,
   func,
-  storage
+  storage,
+  list,
+  cache
 }).then(success => {
   /* istanbul ignore next */
   if (isNode) {