@checkly/playwright-core 1.48.22 → 1.48.23

package/lib/server/harBackend.js

@@ -0,0 +1,157 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HarBackend = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _crypto = require("./utils/crypto");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the 'License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const redirectStatus = [301, 302, 303, 307, 308];
+class HarBackend {
+  constructor(harFile, baseDir, zipFile) {
+    this.id = void 0;
+    this._harFile = void 0;
+    this._zipFile = void 0;
+    this._baseDir = void 0;
+    this.id = (0, _crypto.createGuid)();
+    this._harFile = harFile;
+    this._baseDir = baseDir;
+    this._zipFile = zipFile;
+  }
+  async lookup(url, method, headers, postData, isNavigationRequest) {
+    let entry;
+    try {
+      entry = await this._harFindResponse(url, method, headers, postData);
+    } catch (e) {
+      return {
+        action: 'error',
+        message: 'HAR error: ' + e.message
+      };
+    }
+    if (!entry) return {
+      action: 'noentry'
+    };
+
+    // If navigation is being redirected, restart it with the final url to ensure the document's url changes.
+    if (entry.request.url !== url && isNavigationRequest) return {
+      action: 'redirect',
+      redirectURL: entry.request.url
+    };
+    const response = entry.response;
+    try {
+      const buffer = await this._loadContent(response.content);
+      return {
+        action: 'fulfill',
+        status: response.status,
+        headers: response.headers,
+        body: buffer
+      };
+    } catch (e) {
+      return {
+        action: 'error',
+        message: e.message
+      };
+    }
+  }
+  async _loadContent(content) {
+    const file = content._file;
+    let buffer;
+    if (file) {
+      if (this._zipFile) buffer = await this._zipFile.read(file);else buffer = await _fs.default.promises.readFile(_path.default.resolve(this._baseDir, file));
+    } else {
+      buffer = Buffer.from(content.text || '', content.encoding === 'base64' ? 'base64' : 'utf-8');
+    }
+    return buffer;
+  }
+  async _harFindResponse(url, method, headers, postData) {
+    const harLog = this._harFile.log;
+    const visited = new Set();
+    while (true) {
+      const entries = [];
+      for (const candidate of harLog.entries) {
+        if (candidate.request.url !== url || candidate.request.method !== method) continue;
+        if (method === 'POST' && postData && candidate.request.postData) {
+          const buffer = await this._loadContent(candidate.request.postData);
+          if (!buffer.equals(postData)) {
+            const boundary = multipartBoundary(headers);
+            if (!boundary) continue;
+            const candidataBoundary = multipartBoundary(candidate.request.headers);
+            if (!candidataBoundary) continue;
+            // Try to match multipart/form-data ignroing boundary as it changes between requests.
+            if (postData.toString().replaceAll(boundary, '') !== buffer.toString().replaceAll(candidataBoundary, '')) continue;
+          }
+        }
+        entries.push(candidate);
+      }
+      if (!entries.length) return;
+      let entry = entries[0];
+
+      // Disambiguate using headers - then one with most matching headers wins.
+      if (entries.length > 1) {
+        const list = [];
+        for (const candidate of entries) {
+          const matchingHeaders = countMatchingHeaders(candidate.request.headers, headers);
+          list.push({
+            candidate,
+            matchingHeaders
+          });
+        }
+        list.sort((a, b) => b.matchingHeaders - a.matchingHeaders);
+        entry = list[0].candidate;
+      }
+      if (visited.has(entry)) throw new Error(`Found redirect cycle for ${url}`);
+      visited.add(entry);
+
+      // Follow redirects.
+      const locationHeader = entry.response.headers.find(h => h.name.toLowerCase() === 'location');
+      if (redirectStatus.includes(entry.response.status) && locationHeader) {
+        const locationURL = new URL(locationHeader.value, url);
+        url = locationURL.toString();
+        if ((entry.response.status === 301 || entry.response.status === 302) && method === 'POST' || entry.response.status === 303 && !['GET', 'HEAD'].includes(method)) {
+          // HTTP-redirect fetch step 13 (https://fetch.spec.whatwg.org/#http-redirect-fetch)
+          method = 'GET';
+        }
+        continue;
+      }
+      return entry;
+    }
+  }
+  dispose() {
+    var _this$_zipFile;
+    (_this$_zipFile = this._zipFile) === null || _this$_zipFile === void 0 || _this$_zipFile.close();
+  }
+}
+exports.HarBackend = HarBackend;
+function countMatchingHeaders(harHeaders, headers) {
+  const set = new Set(headers.map(h => h.name.toLowerCase() + ':' + h.value));
+  let matches = 0;
+  for (const h of harHeaders) {
+    if (set.has(h.name.toLowerCase() + ':' + h.value)) ++matches;
+  }
+  return matches;
+}
+function multipartBoundary(headers) {
+  const contentType = headers.find(h => h.name.toLowerCase() === 'content-type');
+  if (!(contentType !== null && contentType !== void 0 && contentType.value.includes('multipart/form-data'))) return undefined;
+  const boundary = contentType.value.match(/boundary=(\S+)/);
+  if (boundary) return boundary[1];
+  return undefined;
+}

package/lib/server/localUtils.js

@@ -0,0 +1,203 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addStackToTracingNoReply = addStackToTracingNoReply;
+exports.harClose = harClose;
+exports.harLookup = harLookup;
+exports.harOpen = harOpen;
+exports.harUnzip = harUnzip;
+exports.traceDiscarded = traceDiscarded;
+exports.tracingStarted = tracingStarted;
+exports.zip = zip;
+var _fs = _interopRequireDefault(require("fs"));
+var _os = _interopRequireDefault(require("os"));
+var _path = _interopRequireDefault(require("path"));
+var _crypto = require("./utils/crypto");
+var _harBackend = require("./harBackend");
+var _manualPromise = require("../utils/isomorphic/manualPromise");
+var _zipFile = require("./utils/zipFile");
+var _zipBundle = require("../zipBundle");
+var _traceUtils = require("../utils/isomorphic/traceUtils");
+var _assert = require("../utils/isomorphic/assert");
+var _fileUtils = require("./utils/fileUtils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the 'License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+async function zip(stackSessions, params) {
+  const promise = new _manualPromise.ManualPromise();
+  const zipFile = new _zipBundle.yazl.ZipFile();
+  zipFile.on('error', error => promise.reject(error));
+  const addFile = (file, name) => {
+    try {
+      if (_fs.default.statSync(file).isFile()) zipFile.addFile(file, name);
+    } catch (e) {}
+  };
+  for (const entry of params.entries) addFile(entry.value, entry.name);
+
+  // Add stacks and the sources.
+  const stackSession = params.stacksId ? stackSessions.get(params.stacksId) : undefined;
+  if (stackSession !== null && stackSession !== void 0 && stackSession.callStacks.length) {
+    await stackSession.writer;
+    if (process.env.PW_LIVE_TRACE_STACKS) {
+      zipFile.addFile(stackSession.file, 'trace.stacks');
+    } else {
+      const buffer = Buffer.from(JSON.stringify((0, _traceUtils.serializeClientSideCallMetadata)(stackSession.callStacks)));
+      zipFile.addBuffer(buffer, 'trace.stacks');
+    }
+  }
+
+  // Collect sources from stacks.
+  if (params.includeSources) {
+    const sourceFiles = new Set();
+    for (const {
+      stack
+    } of (stackSession === null || stackSession === void 0 ? void 0 : stackSession.callStacks) || []) {
+      if (!stack) continue;
+      for (const {
+        file
+      } of stack) sourceFiles.add(file);
+    }
+    for (const sourceFile of sourceFiles) addFile(sourceFile, 'resources/src@' + (await (0, _crypto.calculateSha1)(sourceFile)) + '.txt');
+  }
+  if (params.mode === 'write') {
+    // New file, just compress the entries.
+    await _fs.default.promises.mkdir(_path.default.dirname(params.zipFile), {
+      recursive: true
+    });
+    zipFile.end(undefined, () => {
+      zipFile.outputStream.pipe(_fs.default.createWriteStream(params.zipFile)).on('close', () => promise.resolve()).on('error', error => promise.reject(error));
+    });
+    await promise;
+    await deleteStackSession(stackSessions, params.stacksId);
+    return;
+  }
+
+  // File already exists. Repack and add new entries.
+  const tempFile = params.zipFile + '.tmp';
+  await _fs.default.promises.rename(params.zipFile, tempFile);
+  _zipBundle.yauzl.open(tempFile, (err, inZipFile) => {
+    if (err) {
+      promise.reject(err);
+      return;
+    }
+    (0, _assert.assert)(inZipFile);
+    let pendingEntries = inZipFile.entryCount;
+    inZipFile.on('entry', entry => {
+      inZipFile.openReadStream(entry, (err, readStream) => {
+        if (err) {
+          promise.reject(err);
+          return;
+        }
+        zipFile.addReadStream(readStream, entry.fileName);
+        if (--pendingEntries === 0) {
+          zipFile.end(undefined, () => {
+            zipFile.outputStream.pipe(_fs.default.createWriteStream(params.zipFile)).on('close', () => {
+              _fs.default.promises.unlink(tempFile).then(() => {
+                promise.resolve();
+              }).catch(error => promise.reject(error));
+            });
+          });
+        }
+      });
+    });
+  });
+  await promise;
+  await deleteStackSession(stackSessions, params.stacksId);
+}
+async function deleteStackSession(stackSessions, stacksId) {
+  const session = stacksId ? stackSessions.get(stacksId) : undefined;
+  if (!session) return;
+  await session.writer;
+  if (session.tmpDir) await (0, _fileUtils.removeFolders)([session.tmpDir]);
+  stackSessions.delete(stacksId);
+}
+async function harOpen(harBackends, params) {
+  let harBackend;
+  if (params.file.endsWith('.zip')) {
+    const zipFile = new _zipFile.ZipFile(params.file);
+    const entryNames = await zipFile.entries();
+    const harEntryName = entryNames.find(e => e.endsWith('.har'));
+    if (!harEntryName) return {
+      error: 'Specified archive does not have a .har file'
+    };
+    const har = await zipFile.read(harEntryName);
+    const harFile = JSON.parse(har.toString());
+    harBackend = new _harBackend.HarBackend(harFile, null, zipFile);
+  } else {
+    const harFile = JSON.parse(await _fs.default.promises.readFile(params.file, 'utf-8'));
+    harBackend = new _harBackend.HarBackend(harFile, _path.default.dirname(params.file), null);
+  }
+  harBackends.set(harBackend.id, harBackend);
+  return {
+    harId: harBackend.id
+  };
+}
+async function harLookup(harBackends, params) {
+  const harBackend = harBackends.get(params.harId);
+  if (!harBackend) return {
+    action: 'error',
+    message: `Internal error: har was not opened`
+  };
+  return await harBackend.lookup(params.url, params.method, params.headers, params.postData, params.isNavigationRequest);
+}
+async function harClose(harBackends, params) {
+  const harBackend = harBackends.get(params.harId);
+  if (harBackend) {
+    harBackends.delete(harBackend.id);
+    harBackend.dispose();
+  }
+}
+async function harUnzip(params) {
+  const dir = _path.default.dirname(params.zipFile);
+  const zipFile = new _zipFile.ZipFile(params.zipFile);
+  for (const entry of await zipFile.entries()) {
+    const buffer = await zipFile.read(entry);
+    if (entry === 'har.har') await _fs.default.promises.writeFile(params.harFile, buffer);else await _fs.default.promises.writeFile(_path.default.join(dir, entry), buffer);
+  }
+  zipFile.close();
+  await _fs.default.promises.unlink(params.zipFile);
+}
+async function tracingStarted(stackSessions, params) {
+  let tmpDir = undefined;
+  if (!params.tracesDir) tmpDir = await _fs.default.promises.mkdtemp(_path.default.join(_os.default.tmpdir(), 'playwright-tracing-'));
+  const traceStacksFile = _path.default.join(params.tracesDir || tmpDir, params.traceName + '.stacks');
+  stackSessions.set(traceStacksFile, {
+    callStacks: [],
+    file: traceStacksFile,
+    writer: Promise.resolve(),
+    tmpDir
+  });
+  return {
+    stacksId: traceStacksFile
+  };
+}
+async function traceDiscarded(stackSessions, params) {
+  await deleteStackSession(stackSessions, params.stacksId);
+}
+async function addStackToTracingNoReply(stackSessions, params) {
+  for (const session of stackSessions.values()) {
+    session.callStacks.push(params.callData);
+    if (process.env.PW_LIVE_TRACE_STACKS) {
+      session.writer = session.writer.then(() => {
+        const buffer = Buffer.from(JSON.stringify((0, _traceUtils.serializeClientSideCallMetadata)(session.callStacks)));
+        return _fs.default.promises.writeFile(session.file, buffer);
+      });
+    }
+  }
+}

package/lib/server/recorder/chat.js

@@ -0,0 +1,177 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Chat = void 0;
+exports.asString = asString;
+var _transport = require("../transport");
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class Chat {
+  constructor(wsEndpoint) {
+    this._history = [];
+    this._connectionPromise = void 0;
+    this._chatSinks = new Map();
+    this._wsEndpoint = void 0;
+    this._wsEndpoint = wsEndpoint;
+  }
+  clearHistory() {
+    this._history = [];
+  }
+  async post(prompt) {
+    await this._append('user', prompt);
+    let text = await asString(await this._post());
+    if (text.startsWith('```json') && text.endsWith('```')) text = text.substring('```json'.length, text.length - '```'.length);
+    for (let i = 0; i < 3; ++i) {
+      try {
+        return JSON.parse(text);
+      } catch (e) {
+        await this._append('user', String(e));
+      }
+    }
+    throw new Error('Failed to parse response: ' + text);
+  }
+  async _append(user, content) {
+    this._history.push({
+      user,
+      content
+    });
+  }
+  async _connection() {
+    if (!this._connectionPromise) {
+      this._connectionPromise = _transport.WebSocketTransport.connect(undefined, this._wsEndpoint).then(transport => {
+        return new Connection(transport, (method, params) => this._dispatchEvent(method, params), () => {});
+      });
+    }
+    return this._connectionPromise;
+  }
+  _dispatchEvent(method, params) {
+    if (method === 'chatChunk') {
+      const {
+        chatId,
+        chunk
+      } = params;
+      const chunkSink = this._chatSinks.get(chatId);
+      chunkSink(chunk);
+      if (!chunk) this._chatSinks.delete(chatId);
+    }
+  }
+  async _post() {
+    const connection = await this._connection();
+    const result = await connection.send('chat', {
+      history: this._history
+    });
+    const {
+      chatId
+    } = result;
+    const {
+      iterable,
+      addChunk
+    } = iterablePump();
+    this._chatSinks.set(chatId, addChunk);
+    return iterable;
+  }
+}
+exports.Chat = Chat;
+async function asString(stream) {
+  let result = '';
+  for await (const chunk of stream) result += chunk;
+  return result;
+}
+function iterablePump() {
+  let controller;
+  const stream = new ReadableStream({
+    start: c => controller = c
+  });
+  const iterable = async function* () {
+    const reader = stream.getReader();
+    while (true) {
+      const {
+        done,
+        value
+      } = await reader.read();
+      if (done) break;
+      yield value;
+    }
+  }();
+  return {
+    iterable,
+    addChunk: chunk => {
+      if (chunk) controller.enqueue(chunk);else controller.close();
+    }
+  };
+}
+class Connection {
+  constructor(transport, onEvent, onClose) {
+    this._transport = void 0;
+    this._lastId = 0;
+    this._closed = false;
+    this._pending = new Map();
+    this._onEvent = void 0;
+    this._onClose = void 0;
+    this._transport = transport;
+    this._onEvent = onEvent;
+    this._onClose = onClose;
+    this._transport.onmessage = this._dispatchMessage.bind(this);
+    this._transport.onclose = this._close.bind(this);
+  }
+  send(method, params) {
+    const id = this._lastId++;
+    const message = {
+      id,
+      method,
+      params
+    };
+    this._transport.send(message);
+    return new Promise((resolve, reject) => {
+      this._pending.set(id, {
+        resolve,
+        reject
+      });
+    });
+  }
+  _dispatchMessage(message) {
+    if (message.id === undefined) {
+      this._onEvent(message.method, message.params);
+      return;
+    }
+    const callback = this._pending.get(message.id);
+    this._pending.delete(message.id);
+    if (!callback) return;
+    if (message.error) {
+      callback.reject(new Error(message.error.message));
+      return;
+    }
+    callback.resolve(message.result);
+  }
+  _close() {
+    this._closed = true;
+    this._transport.onmessage = undefined;
+    this._transport.onclose = undefined;
+    for (const {
+      reject
+    } of this._pending.values()) reject(new Error('Connection closed'));
+    this._onClose();
+  }
+  isClosed() {
+    return this._closed;
+  }
+  close() {
+    if (!this._closed) this._transport.close();
+  }
+}

package/lib/server/storageScript.js

@@ -0,0 +1,160 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.collect = collect;
+exports.restore = restore;
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+async function collect(serializers, isFirefox, recordIndexedDB) {
+  async function collectDB(dbInfo) {
+    if (!dbInfo.name) throw new Error('Database name is empty');
+    if (!dbInfo.version) throw new Error('Database version is unset');
+    function idbRequestToPromise(request) {
+      return new Promise((resolve, reject) => {
+        request.addEventListener('success', () => resolve(request.result));
+        request.addEventListener('error', () => reject(request.error));
+      });
+    }
+    function isPlainObject(v) {
+      const ctor = v === null || v === void 0 ? void 0 : v.constructor;
+      if (isFirefox) {
+        const constructorImpl = ctor === null || ctor === void 0 ? void 0 : ctor.toString();
+        if (constructorImpl.startsWith('function Object() {') && constructorImpl.includes('[native code]')) return true;
+      }
+      return ctor === Object;
+    }
+    function trySerialize(value) {
+      let trivial = true;
+      const encoded = serializers.serializeAsCallArgument(value, v => {
+        const isTrivial = isPlainObject(v) || Array.isArray(v) || typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean' || Object.is(v, null);
+        if (!isTrivial) trivial = false;
+        return {
+          fallThrough: v
+        };
+      });
+      if (trivial) return {
+        trivial: value
+      };
+      return {
+        encoded
+      };
+    }
+    const db = await idbRequestToPromise(indexedDB.open(dbInfo.name));
+    const transaction = db.transaction(db.objectStoreNames, 'readonly');
+    const stores = await Promise.all([...db.objectStoreNames].map(async storeName => {
+      const objectStore = transaction.objectStore(storeName);
+      const keys = await idbRequestToPromise(objectStore.getAllKeys());
+      const records = await Promise.all(keys.map(async key => {
+        const record = {};
+        if (objectStore.keyPath === null) {
+          const {
+            encoded,
+            trivial
+          } = trySerialize(key);
+          if (trivial) record.key = trivial;else record.keyEncoded = encoded;
+        }
+        const value = await idbRequestToPromise(objectStore.get(key));
+        const {
+          encoded,
+          trivial
+        } = trySerialize(value);
+        if (trivial) record.value = trivial;else record.valueEncoded = encoded;
+        return record;
+      }));
+      const indexes = [...objectStore.indexNames].map(indexName => {
+        const index = objectStore.index(indexName);
+        return {
+          name: index.name,
+          keyPath: typeof index.keyPath === 'string' ? index.keyPath : undefined,
+          keyPathArray: Array.isArray(index.keyPath) ? index.keyPath : undefined,
+          multiEntry: index.multiEntry,
+          unique: index.unique
+        };
+      });
+      return {
+        name: storeName,
+        records: records,
+        indexes,
+        autoIncrement: objectStore.autoIncrement,
+        keyPath: typeof objectStore.keyPath === 'string' ? objectStore.keyPath : undefined,
+        keyPathArray: Array.isArray(objectStore.keyPath) ? objectStore.keyPath : undefined
+      };
+    }));
+    return {
+      name: dbInfo.name,
+      version: dbInfo.version,
+      stores
+    };
+  }
+  return {
+    localStorage: Object.keys(localStorage).map(name => ({
+      name,
+      value: localStorage.getItem(name)
+    })),
+    indexedDB: recordIndexedDB ? await Promise.all((await indexedDB.databases()).map(collectDB)).catch(e => {
+      throw new Error('Unable to serialize IndexedDB: ' + e.message);
+    }) : undefined
+  };
+}
+async function restore(originState, serializers) {
+  var _originState$indexedD;
+  for (const {
+    name,
+    value
+  } of originState.localStorage || []) localStorage.setItem(name, value);
+  await Promise.all(((_originState$indexedD = originState.indexedDB) !== null && _originState$indexedD !== void 0 ? _originState$indexedD : []).map(async dbInfo => {
+    const openRequest = indexedDB.open(dbInfo.name, dbInfo.version);
+    openRequest.addEventListener('upgradeneeded', () => {
+      const db = openRequest.result;
+      for (const store of dbInfo.stores) {
+        var _store$keyPathArray;
+        const objectStore = db.createObjectStore(store.name, {
+          autoIncrement: store.autoIncrement,
+          keyPath: (_store$keyPathArray = store.keyPathArray) !== null && _store$keyPathArray !== void 0 ? _store$keyPathArray : store.keyPath
+        });
+        for (const index of store.indexes) {
+          var _index$keyPathArray;
+          objectStore.createIndex(index.name, (_index$keyPathArray = index.keyPathArray) !== null && _index$keyPathArray !== void 0 ? _index$keyPathArray : index.keyPath, {
+            unique: index.unique,
+            multiEntry: index.multiEntry
+          });
+        }
+      }
+    });
+    function idbRequestToPromise(request) {
+      return new Promise((resolve, reject) => {
+        request.addEventListener('success', () => resolve(request.result));
+        request.addEventListener('error', () => reject(request.error));
+      });
+    }
+
+    // after `upgradeneeded` finishes, `success` event is fired.
+    const db = await idbRequestToPromise(openRequest);
+    const transaction = db.transaction(db.objectStoreNames, 'readwrite');
+    await Promise.all(dbInfo.stores.map(async store => {
+      const objectStore = transaction.objectStore(store.name);
+      await Promise.all(store.records.map(async record => {
+        var _record$value, _record$key;
+        await idbRequestToPromise(objectStore.add((_record$value = record.value) !== null && _record$value !== void 0 ? _record$value : serializers.parseEvaluationResultValue(record.valueEncoded), (_record$key = record.key) !== null && _record$key !== void 0 ? _record$key : serializers.parseEvaluationResultValue(record.keyEncoded)));
+      }));
+    }));
+  })).catch(e => {
+    throw new Error('Unable to restore IndexedDB: ' + e.message);
+  });
+}