cypress 4.12.0 → 5.2.0

package/lib/errors.js

@@ -121,7 +121,7 @@ function _templateObject6() {
 }
 
 function _templateObject5() {
-  var data = _taggedTemplateLiteral(["\n\n    Reasons this may happen:\n\n    - node was installed as 'root' or with 'sudo'\n    - the cypress npm package as 'root' or with 'sudo'\n\n    Please check that you have the appropriate user permissions.\n  "], ["\\n\n    Reasons this may happen:\n\n    - node was installed as 'root' or with 'sudo'\n    - the cypress npm package as 'root' or with 'sudo'\n\n    Please check that you have the appropriate user permissions.\n  "]);
+  var data = _taggedTemplateLiteral(["\n\n    Reasons this may happen:\n\n    - node was installed as 'root' or with 'sudo'\n    - the cypress npm package as 'root' or with 'sudo'\n\n    Please check that you have the appropriate user permissions.\n\n    You can also try clearing the cache with 'cypress cache clear' and reinstalling. \n  "], ["\\n\n    Reasons this may happen:\n\n    - node was installed as 'root' or with 'sudo'\n    - the cypress npm package as 'root' or with 'sudo'\n\n    Please check that you have the appropriate user permissions.\n\n    You can also try clearing the cache with 'cypress cache clear' and reinstalling. \n  "]);
 
   _templateObject5 = function _templateObject5() {
     return data;

package/lib/tasks/install.js

@@ -1,5 +1,7 @@
 "use strict";
 
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
 function _templateObject7() {
   var data = _taggedTemplateLiteral(["\n          ", " Warning: Forcing a binary version different than the default.\n\n            The CLI expected to install version: ", "\n\n            Instead we will install version: ", "\n\n            These versions may not work properly together.\n        "]);
 
@@ -20,6 +22,18 @@ function _templateObject6() {
   return data;
 }
 
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
 function _templateObject5() {
   var data = _taggedTemplateLiteral(["\n    Failed to access ", ":\n\n    ", "\n    "]);
 
@@ -72,10 +86,32 @@ function _templateObject() {
 
 function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
 
+function _wrapRegExp(re, groups) { _wrapRegExp = function _wrapRegExp(re, groups) { return new BabelRegExp(re, undefined, groups); }; var _RegExp = _wrapNativeSuper(RegExp); var _super = RegExp.prototype; var _groups = new WeakMap(); function BabelRegExp(re, flags, groups) { var _this = _RegExp.call(this, re, flags); _groups.set(_this, groups || _groups.get(re)); return _this; } _inherits(BabelRegExp, _RegExp); BabelRegExp.prototype.exec = function (str) { var result = _super.exec.call(this, str); if (result) result.groups = buildGroups(result, this); return result; }; BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { if (typeof substitution === "string") { var groups = _groups.get(this); return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { return "$" + groups[name]; })); } else if (typeof substitution === "function") { var _this = this; return _super[Symbol.replace].call(this, str, function () { var args = []; args.push.apply(args, arguments); if (_typeof(args[args.length - 1]) !== "object") { args.push(buildGroups(args, _this)); } return substitution.apply(this, args); }); } else { return _super[Symbol.replace].call(this, str, substitution); } }; function buildGroups(result, re) { var g = _groups.get(re); return Object.keys(g).reduce(function (groups, name) { groups[name] = result[g[name]]; return groups; }, Object.create(null)); } return _wrapRegExp.apply(this, arguments); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+
+function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
 var _ = require('lodash');
 
 var os = require('os');
 
+var url = require('url');
+
 var path = require('path');
 
 var chalk = require('chalk');
@@ -109,6 +145,102 @@ var _require2 = require('../errors'),
     throwFormErrorText = _require2.throwFormErrorText,
     errors = _require2.errors;
 
+var getNpmArgv = function getNpmArgv() {
+  var json = process.env.npm_config_argv;
+
+  if (!json) {
+    return;
+  }
+
+  debug('found npm argv json %o', json);
+
+  try {
+    return JSON.parse(json).original || [];
+  } catch (e) {
+    return [];
+  }
+}; // attempt to discover the version specifier used to install Cypress
+// for example: "^5.0.0", "https://cdn.cypress.io/...", ...
+
+
+var getVersionSpecifier = function getVersionSpecifier() {
+  var startDir = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : path.resolve(__dirname, '../..');
+  var argv = getNpmArgv();
+
+  if (argv) {
+    var tgz = _.find(argv, function (t) {
+      return t.endsWith('cypress.tgz');
+    });
+
+    if (tgz) {
+      return tgz;
+    }
+  }
+
+  var getVersionSpecifierFromPkg = function getVersionSpecifierFromPkg(dir) {
+    debug('looking for versionSpecifier %o', {
+      dir: dir
+    });
+
+    var tryParent = function tryParent() {
+      var parentPath = path.resolve(dir, '..');
+
+      if (parentPath === dir) {
+        debug('reached FS root with no versionSpecifier found');
+        return;
+      }
+
+      return getVersionSpecifierFromPkg(parentPath);
+    };
+
+    return fs.readJSON(path.join(dir, 'package.json'))["catch"](function () {
+      return {};
+    }).then(function (pkg) {
+      var specifier = _.chain(['dependencies', 'devDependencies', 'optionalDependencies']).map(function (prop) {
+        return _.get(pkg, "".concat(prop, ".cypress"));
+      }).compact().first().value();
+
+      return specifier || tryParent();
+    });
+  }; // recurse through parent directories until package.json with `cypress` is found
+
+
+  return getVersionSpecifierFromPkg(startDir).then(function (versionSpecifier) {
+    debug('finished looking for versionSpecifier', {
+      versionSpecifier: versionSpecifier
+    });
+    return versionSpecifier;
+  });
+};
+
+var betaNpmUrlRe = /*#__PURE__*/_wrapRegExp(/^\/beta\/npm\/([\.0-9]+)\/([\0-\.0-\uFFFF]+)\/cypress\.tgz$/, {
+  version: 1,
+  artifactSlug: 2
+}); // convert a prerelease NPM package .tgz URL to the corresponding binary .zip URL
+
+
+var getBinaryUrlFromPrereleaseNpmUrl = function getBinaryUrlFromPrereleaseNpmUrl(npmUrl) {
+  var parsed;
+
+  try {
+    parsed = url.parse(npmUrl);
+  } catch (e) {
+    return;
+  }
+
+  var matches = betaNpmUrlRe.exec(parsed.pathname);
+
+  if (parsed.hostname !== 'cdn.cypress.io' || !matches) {
+    return;
+  }
+
+  var _matches$groups = matches.groups,
+      version = _matches$groups.version,
+      artifactSlug = _matches$groups.artifactSlug;
+  parsed.pathname = "/beta/binary/".concat(version, "/").concat(os.platform(), "-").concat(os.arch(), "/").concat(artifactSlug, "/cypress.zip");
+  return parsed.format();
+};
+
 var alreadyInstalledMsg = function alreadyInstalledMsg() {
   if (!util.isPostInstall()) {
     logger.log(stripIndent(_templateObject(), chalk.yellow('--force')));
@@ -204,6 +336,7 @@ var start = function start() {
 
   var pkgVersion = util.pkgVersion();
   var needVersion = pkgVersion;
+  var binaryUrlOverride;
   debug('version in package.json is', needVersion); // let this environment variable reset the binary version we need
 
   if (util.getEnv('CYPRESS_INSTALL_BINARY')) {
@@ -218,14 +351,9 @@ var start = function start() {
       logger.log(stripIndent(_templateObject3(), chalk.yellow('Note:')));
       logger.log();
       return Promise.resolve();
-    } // if this doesn't match the expected version
-    // then print warning to the user
-
-
-    if (envVarVersion !== needVersion) {
-      // reset the version to the env var version
-      needVersion = envVarVersion;
     }
+
+    binaryUrlOverride = envVarVersion;
   }
 
   if (util.getEnv('CYPRESS_CACHE_FOLDER')) {
@@ -242,14 +370,32 @@ var start = function start() {
   }, function (err) {
     return throwFormErrorText(errors.invalidCacheDirectory)(stripIndent(_templateObject5(), chalk.cyan(cacheDir), err.message));
   }).then(function () {
-    return state.getBinaryPkgVersionAsync(binaryDir);
-  }).then(function (binaryVersion) {
+    return Promise.all([state.getBinaryPkgVersionAsync(binaryDir), getVersionSpecifier()]);
+  }).then(function (_ref2) {
+    var _ref3 = _slicedToArray(_ref2, 2),
+        binaryVersion = _ref3[0],
+        versionSpecifier = _ref3[1];
+
+    if (!binaryUrlOverride && versionSpecifier) {
+      var computedBinaryUrl = getBinaryUrlFromPrereleaseNpmUrl(versionSpecifier);
+
+      if (computedBinaryUrl) {
+        debug('computed binary url from version specifier %o', {
+          computedBinaryUrl: computedBinaryUrl,
+          needVersion: needVersion
+        });
+        binaryUrlOverride = computedBinaryUrl;
+      }
+    }
+
+    needVersion = binaryUrlOverride || needVersion;
+    debug('installed version is', binaryVersion, 'version needed is', needVersion);
+
     if (!binaryVersion) {
       debug('no binary installed under cli version');
       return true;
     }
 
-    debug('installed version is', binaryVersion, 'version needed is', needVersion);
     logger.log();
     logger.log(stripIndent(_templateObject6(), chalk.green(binaryVersion), chalk.cyan(installDir)));
     logger.log();
@@ -332,14 +478,16 @@ var start = function start() {
 };
 
 module.exports = {
-  start: start
+  start: start,
+  _getVersionSpecifier: getVersionSpecifier,
+  _getBinaryUrlFromPrereleaseNpmUrl: getBinaryUrlFromPrereleaseNpmUrl
 };
 
-var unzipTask = function unzipTask(_ref2) {
-  var zipFilePath = _ref2.zipFilePath,
-      installDir = _ref2.installDir,
-      progress = _ref2.progress,
-      rendererOptions = _ref2.rendererOptions;
+var unzipTask = function unzipTask(_ref4) {
+  var zipFilePath = _ref4.zipFilePath,
+      installDir = _ref4.installDir,
+      progress = _ref4.progress,
+      rendererOptions = _ref4.rendererOptions;
   return {
     title: util.titleize('Unzipping Cypress'),
     task: function task(ctx, _task3) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cypress",
-  "version": "4.12.0",
+  "version": "5.2.0",
   "main": "index.js",
   "scripts": {
     "postinstall": "node index.js --exec install",
@@ -13,26 +13,27 @@
     "@types/sinonjs__fake-timers": "^6.0.1",
     "@types/sizzle": "^2.3.2",
     "arch": "^2.1.2",
+    "blob-util": "2.0.2",
     "bluebird": "^3.7.2",
     "cachedir": "^2.3.0",
-    "chalk": "^2.4.2",
+    "chalk": "^4.1.0",
     "check-more-types": "^2.24.0",
-    "cli-table3": "~0.5.1",
+    "cli-table3": "~0.6.0",
     "commander": "^4.1.1",
     "common-tags": "^1.8.0",
     "debug": "^4.1.1",
     "eventemitter2": "^6.4.2",
-    "execa": "^1.0.0",
+    "execa": "^4.0.2",
     "executable": "^4.1.1",
     "extract-zip": "^1.7.0",
-    "fs-extra": "^8.1.0",
+    "fs-extra": "^9.0.1",
     "getos": "^3.2.1",
     "is-ci": "^2.0.0",
     "is-installed-globally": "^0.3.2",
     "lazy-ass": "^1.6.0",
     "listr": "^0.14.3",
     "lodash": "^4.17.19",
-    "log-symbols": "^3.0.0",
+    "log-symbols": "^4.0.0",
     "minimist": "^1.2.5",
     "moment": "^2.27.0",
     "ospath": "^1.2.2",
@@ -40,7 +41,7 @@
     "ramda": "~0.26.1",
     "request-progress": "^3.0.0",
     "supports-color": "^7.1.0",
-    "tmp": "~0.1.0",
+    "tmp": "~0.2.1",
     "untildify": "^4.0.0",
     "url": "^0.11.0",
     "yauzl": "^2.10.0"
@@ -49,13 +50,14 @@
     "bin",
     "lib",
     "index.js",
-    "types/**/*.d.ts"
+    "types/**/*.d.ts",
+    "types/net-stubbing.ts"
   ],
   "bin": {
     "cypress": "bin/cypress"
   },
   "engines": {
-    "node": ">=8.0.0"
+    "node": ">=10.0.0"
   },
   "types": "types",
   "description": "Cypress.io end to end testing tool",

package/types/cy-blob-util.d.ts

@@ -3,7 +3,7 @@
 // so that Cypress can get and use the Blob type
 
 // tslint:disable-next-line:no-implicit-dependencies
-import * as blobUtil from './blob-util'
+import * as blobUtil from 'blob-util'
 
 export = BlobUtil
 export as namespace BlobUtil

package/types/cypress-npm-api.d.ts

@@ -7,6 +7,12 @@
 // but for now describe it as an ambient module
 
 declare namespace CypressCommandLine {
+  type HookName = 'before' | 'beforeEach' | 'afterEach' | 'after'
+  interface TestError {
+    name: string
+    message: string
+    stack: string
+  }
   /**
    * All options that one can pass to "cypress.run"
    * @see https://on.cypress.io/module-api#cypress-run
@@ -154,39 +160,36 @@ declare namespace CypressCommandLine {
   // small utility types to better express meaning of other types
   type dateTimeISO = string
   type ms = number
-  type hookId = string
-  type testId = string
   type pixels = number
 
   /**
    * Cypress single test result
    */
   interface TestResult {
-    testId: testId
     title: string[]
     state: string
     body: string
-    /**
-     * Error stack string if there is an error
-     */
-    stack: string | null
-    /**
-     * Error message if there is an error
+     /**
+     * Error string as it's presented in console if the test fails
      */
-    error: string | null
-    timings: any
-    failedFromHookId: hookId | null
-    wallClockStartedAt: dateTimeISO
-    wallClockDuration: ms
+    displayError: string | null
+    attempts: AttemptResult[]
+  }
+
+  interface AttemptResult {
+    state: string
+    error: TestError | null
+    startedAt: dateTimeISO
+    duration: ms
     videoTimestamp: ms
+    screenshots: ScreenshotInformation[]
   }
 
   /**
    * Information about a single "before", "beforeEach", "afterEach" and "after" hook.
   */
   interface HookInformation {
-    hookId: hookId
-    hookName: 'before' | 'beforeEach' | 'afterEach' | 'after'
+    hookName: HookName
     title: string[]
     body: string
   }
@@ -195,9 +198,7 @@ declare namespace CypressCommandLine {
    * Information about a single screenshot.
    */
   interface ScreenshotInformation {
-    screenshotId: string
     name: string
-    testId: testId
     takenAt: dateTimeISO
     /**
      * Absolute path to the saved image
@@ -221,9 +222,9 @@ declare namespace CypressCommandLine {
       pending: number
       skipped: number
       failures: number
-      wallClockStartedAt: dateTimeISO
-      wallClockEndedAt: dateTimeISO
-      wallClockDuration: ms
+      startedAt: dateTimeISO
+      endedAt: dateTimeISO
+      duration: ms
     },
     /**
      * Reporter name like "spec"
@@ -238,7 +239,6 @@ declare namespace CypressCommandLine {
     tests: TestResult[]
     error: string | null
     video: string | null
-    screenshots: ScreenshotInformation[]
     /**
      * information about the spec test file.
     */

package/types/cypress.d.ts

@@ -1,10 +1,10 @@
 declare namespace Cypress {
   type FileContents = string | any[] | object
-  type HistoryDirection = "back" | "forward"
+  type HistoryDirection = 'back' | 'forward'
   type HttpMethod = string
   type RequestBody = string | object
-  type ViewportOrientation = "portrait" | "landscape"
-  type PrevSubject = "optional" | "element" | "document" | "window"
+  type ViewportOrientation = 'portrait' | 'landscape'
+  type PrevSubject = 'optional' | 'element' | 'document' | 'window'
   type PluginConfig = (on: PluginEvents, config: PluginConfigOptions) => void | ConfigOptions | Promise<ConfigOptions>
 
   interface CommandOptions {
@@ -26,6 +26,7 @@ declare namespace Cypress {
      * @see https://on.cypress.io/firefox-gc-issue
      */
     (task: 'firefox:force:gc'): Promise<void>
+    (task: 'net', eventName: string, frame: any): Promise<void>
   }
 
   type BrowserName = 'electron' | 'chrome' | 'chromium' | 'firefox' | 'edge' | string
@@ -107,6 +108,24 @@ declare namespace Cypress {
     fromAutWindow: WindowPosition & { x: number, y: number }
   }
 
+  /**
+   * Spec type for the given test. "integration" is the default, but
+   * tests run using experimentalComponentTesting will be "component"
+   *
+   * @see https://on.cypress.io/experiments
+   */
+  type CypressSpecType = 'integration' | 'component'
+
+  /**
+   * Window type for Application Under Test(AUT)
+   */
+  type AUTWindow = Window & typeof globalThis & ApplicationWindow
+
+  /**
+   * The interface for user-defined properties in Window object under test.
+   */
+  interface ApplicationWindow {} // tslint:disable-line
+
   /**
    * Several libraries are bundled with Cypress by default.
    *
@@ -211,6 +230,7 @@ declare namespace Cypress {
     //  name: "config_passing_spec.coffee",
     //  relative: "cypress/integration/config_passing_spec.coffee",
     //  absolute: "/users/smith/projects/web/cypress/integration/config_passing_spec.coffee"
+    //  specType: "integration"
     // }
     ```
      */
@@ -219,6 +239,7 @@ declare namespace Cypress {
       relative: string // "cypress/integration/config_passing_spec.coffee" or "__all" if clicked all specs button
       absolute: string
       specFilter?: string // optional spec filter used by the user
+      specType?: CypressSpecType
     }
 
     /**
@@ -324,6 +345,11 @@ declare namespace Cypress {
      */
     getFirefoxGcInterval(): number | null | undefined
 
+    /**
+     * @returns the number of test retries currently enabled for the run
+     */
+    getTestRetries(): number | null
+
     /**
      * Checks if a variable is a valid instance of `cy` or a `cy` chainable.
      *
@@ -387,7 +413,7 @@ declare namespace Cypress {
        * Returns a boolean indicating whether an object is a DOM object.
        */
       isDom(obj: any): boolean
-      isType(element: JQuery | HTMLElement , type: string): boolean
+      isType(element: JQuery | HTMLElement, type: string): boolean
       /**
        * Returns a boolean indicating whether an element is visible.
        */
@@ -492,7 +518,7 @@ declare namespace Cypress {
     off: Actions
   }
 
-  type CanReturnChainable = void | Chainable
+  type CanReturnChainable = void | Chainable | Promise<unknown>
   type ThenReturn<S, R> =
     R extends void ? Chainable<S> :
     R extends R | undefined ? Chainable<S | Exclude<R, undefined>> :
@@ -1062,7 +1088,7 @@ declare namespace Cypress {
      *
      * @see https://on.cypress.io/go
      */
-    go(direction: HistoryDirection | number, options?: Partial<Loggable & Timeoutable>): Chainable<Window>
+    go(direction: HistoryDirection | number, options?: Partial<Loggable & Timeoutable>): Chainable<AUTWindow>
 
     /**
      * Get the current URL hash of the page that is currently active.
@@ -1399,7 +1425,7 @@ declare namespace Cypress {
      * @example
      *    cy.reload()
      */
-    reload(options?: Partial<Loggable & Timeoutable>): Chainable<Window>
+    reload(options?: Partial<Loggable & Timeoutable>): Chainable<AUTWindow>
     /**
      * Reload the page without cache
      *
@@ -1410,7 +1436,7 @@ declare namespace Cypress {
      *    cy.visit('http://localhost:3000/admin')
      *    cy.reload(true)
      */
-    reload(forceReload: boolean): Chainable<Window>
+    reload(forceReload: boolean): Chainable<AUTWindow>
 
     /**
      * Make an HTTP GET request.
@@ -1581,15 +1607,12 @@ declare namespace Cypress {
 
     /**
      * Traverse into an element's shadow root.
-     * Requires `experimentalShadowDomSupport: true` config option
      *
-    @example
-    ```js
-    cy.get('.top-level > my-component')
-      .shadow()
-      .find('.my-button')
-      .click()
-    ```
+     * @example
+     *    cy.get('my-component')
+     *    .shadow()
+     *    .find('.my-button')
+     *    .click()
      * @see https://on.cypress.io/experimental
      */
     shadow(): Chainable<Subject>
@@ -1976,8 +1999,8 @@ declare namespace Cypress {
      *    })
      *
      */
-    visit(url: string, options?: Partial<VisitOptions>): Chainable<Window>
-    visit(options: Partial<VisitOptions> & { url: string }): Chainable<Window>
+    visit(url: string, options?: Partial<VisitOptions>): Chainable<AUTWindow>
+    visit(options: Partial<VisitOptions> & { url: string }): Chainable<AUTWindow>
 
     /**
      * Wait for a number of milliseconds.
@@ -2048,7 +2071,7 @@ declare namespace Cypress {
     })
     ```
      */
-    window(options?: Partial<Loggable & Timeoutable>): Chainable<Window>
+    window(options?: Partial<Loggable & Timeoutable>): Chainable<AUTWindow>
 
     /**
      * Scopes all subsequent cy commands to within this element.
@@ -2177,7 +2200,7 @@ declare namespace Cypress {
   type Agent<T extends sinon.SinonSpy> = SinonSpyAgent<T> & T
 
   interface CookieDefaults {
-    whitelist: string | string[] | RegExp | ((cookie: any) => boolean)
+    preserve: string | string[] | RegExp | ((cookie: any) => boolean)
   }
 
   interface Failable {
@@ -2276,7 +2299,7 @@ declare namespace Cypress {
      * @default {@link Timeoutable#timeout}
      * @see https://docs.cypress.io/guides/references/configuration.html#Timeouts
      */
-    requestTimeout: number,
+    requestTimeout: number
     /**
      * Time to wait for the response (ms)
      *
@@ -2319,6 +2342,54 @@ declare namespace Cypress {
      * @default false
      */
     multiple: boolean
+    /**
+     * Activates the control key during click
+     *
+     * @default false
+     */
+    ctrlKey: boolean
+    /**
+     * Activates the control key during click
+     *
+     * @default false
+     */
+    controlKey: boolean
+    /**
+     * Activates the alt key (option key for Mac) during click
+     *
+     * @default false
+     */
+    altKey: boolean
+    /**
+     * Activates the alt key (option key for Mac) during click
+     *
+     * @default false
+     */
+    optionKey: boolean
+    /**
+     * Activates the shift key during click
+     *
+     * @default false
+     */
+    shiftKey: boolean
+    /**
+     * Activates the meta key (Windows key or command key for Mac) during click
+     *
+     * @default false
+     */
+    metaKey: boolean
+    /**
+     * Activates the meta key (Windows key or command key for Mac) during click
+     *
+     * @default false
+     */
+    commandKey: boolean
+    /**
+     * Activates the meta key (Windows key or command key for Mac) during click
+     *
+     * @default false
+     */
+    cmdKey: boolean
   }
 
   interface ResolvedConfigOptions {
@@ -2353,7 +2424,12 @@ declare namespace Cypress {
      */
     reporter: string
     /**
-     * Whether to take a screenshot on test failure when running headlessly or in CI
+     * Some reporters accept [reporterOptions](https://on.cypress.io/reporters) that customize their behavior
+     * @default "spec"
+     */
+    reporterOptions: { [key: string]: any }
+    /**
+     * Whether Cypress will watch and restart tests on test file changes
      * @default true
      */
     watchForFileChanges: boolean
@@ -2406,7 +2482,7 @@ declare namespace Cypress {
      * If set to `system`, Cypress will try to find a `node` executable on your path to use when executing your plugins. Otherwise, Cypress will use the Node version bundled with Cypress.
      * @default "bundled"
      */
-    nodeVersion: "system" | "bundled"
+    nodeVersion: 'system' | 'bundled'
     /**
      * Path to plugins file. (Pass false to disable)
      * @default "cypress/plugins/index.js"
@@ -2494,12 +2570,6 @@ declare namespace Cypress {
      * @default { runMode: 1, openMode: null }
      */
     firefoxGcInterval: Nullable<number | { runMode: Nullable<number>, openMode: Nullable<number> }>
-    /**
-     * If `true`, Cypress will add `sameSite` values to the objects yielded from `cy.setCookie()`,
-     * `cy.getCookie()`, and `cy.getCookies()`. This will become the default behavior in Cypress 5.0.
-     * @default false
-     */
-    experimentalGetCookiesSameSite: boolean
     /**
      * Enables AST-based JS/HTML rewriting. This may fix issues caused by the existing regex-based JS/HTML replacement
      * algorithm.
@@ -2507,14 +2577,28 @@ declare namespace Cypress {
      */
     experimentalSourceRewriting: boolean
     /**
-     * Enables shadow DOM support. Adds the `cy.shadow()` command and
-     * the `includeShadowDom` option to some DOM commands.
+     * Enables `cy.route2`, which can be used to dynamically intercept/stub/await any HTTP request or response (XHRs, fetch, beacons, etc.)
+     * @default false
+     */
+    experimentalNetworkStubbing: boolean
+    /**
+     * Number of times to retry a failed test.
+     * If a number is set, tests will retry in both runMode and openMode.
+     * To enable test retries only in runMode, set e.g. `{ openMode: null, runMode: 2 }`
+     * @default null
+     */
+    retries: Nullable<number | {runMode: Nullable<number>, openMode: Nullable<number>}>
+    /**
+     * Enables including elements within the shadow DOM when using querying
+     * commands (e.g. cy.get(), cy.find()). Can be set globally in cypress.json,
+     * per-suite or per-test in the test configuration object, or programmatically
+     * with Cypress.config()
+     * @default false
      */
-    experimentalShadowDomSupport: boolean
+    includeShadowDom: boolean
   }
 
-  interface TestConfigOverrides extends Partial<Pick<ConfigOptions, 'baseUrl' | 'defaultCommandTimeout' | 'taskTimeout' | 'animationDistanceThreshold' | 'waitForAnimations' | 'viewportHeight' | 'viewportWidth' | 'requestTimeout' | 'execTimeout' | 'env' | 'responseTimeout'>> {
-    // retries?: number
+  interface TestConfigOverrides extends Partial<Pick<ConfigOptions, 'baseUrl' | 'defaultCommandTimeout' | 'taskTimeout' | 'animationDistanceThreshold' | 'waitForAnimations' | 'viewportHeight' | 'viewportWidth' | 'requestTimeout' | 'execTimeout' | 'env' | 'responseTimeout' | 'retries' | 'includeShadowDom'>> {
     browser?: IsBrowserMatcher | IsBrowserMatcher[]
   }
 
@@ -2614,18 +2698,18 @@ declare namespace Cypress {
     scale: boolean
     onBeforeScreenshot: ($el: JQuery) => void
     onAfterScreenshot: ($el: JQuery, props: {
-      path: string,
-      size: number,
+      path: string
+      size: number
       dimensions: {
-        width: number,
+        width: number
         height: number
-      },
-      multipart: boolean,
-      pixelRatio: number,
-      takenAt: string,
-      name: string,
-      blackout: string[],
-      duration: number,
+      }
+      multipart: boolean
+      pixelRatio: number
+      takenAt: string
+      name: string
+      blackout: string[]
+      duration: number
       testAttemptIndex: number
     }) => void
   }
@@ -2646,13 +2730,13 @@ declare namespace Cypress {
      *
      * @default 'swing'
      */
-    easing: 'swing' | 'linear',
+    easing: 'swing' | 'linear'
     /**
      * Ensure element is scrollable. Error if element is not scrollable
      *
      * @default true
      */
-    ensureScrollable: boolean,
+    ensureScrollable: boolean
   }
 
   interface ScrollIntoViewOptions extends ScrollToOptions {
@@ -2684,7 +2768,7 @@ declare namespace Cypress {
     enable: boolean
     force404: boolean
     urlMatchingOptions: object
-    whitelist(xhr: Request): void
+    ignore(xhr: Request): void
     onAnyRequest(route: RouteOptions, proxy: any): void
     onAnyResponse(route: RouteOptions, proxy: any): void
     onAnyAbort(route: RouteOptions, proxy: any): void
@@ -2701,6 +2785,10 @@ declare namespace Cypress {
     sameSite: SameSiteStatus
   }
 
+  interface ShadowDomOptions {
+    includeShadowDom?: boolean
+  }
+
   /**
    * Options that control `cy.type` command
    *
@@ -2783,16 +2871,16 @@ declare namespace Cypress {
     /**
      * Called before your page has loaded all of its resources.
      *
-     * @param {Window} contentWindow the remote page's window object
+     * @param {AUTWindow} contentWindow the remote page's window object
      */
-    onBeforeLoad(win: Window): void
+    onBeforeLoad(win: AUTWindow): void
 
     /**
      * Called once your page has fired its load event.
      *
-     * @param {Window} contentWindow the remote page's window object
+     * @param {AUTWindow} contentWindow the remote page's window object
      */
-    onLoad(win: Window): void
+    onLoad(win: AUTWindow): void
 
     /**
      * Cypress will automatically apply the right authorization headers
@@ -2831,6 +2919,12 @@ declare namespace Cypress {
      * @default true
      */
     cancelable: boolean
+    /**
+     * The type of the event you want to trigger
+     *
+     * @default 'Event'
+     */
+    eventConstructor: string
   }
 
   /** Options to change the default behavior of .writeFile */
@@ -4857,9 +4951,9 @@ declare namespace Cypress {
   }
 
   interface BrowserLaunchOptions {
-    extensions: string[],
+    extensions: string[]
     preferences: { [key: string]: any }
-    args: string[],
+    args: string[]
   }
 
   interface Dimensions {
@@ -4983,12 +5077,12 @@ declare namespace Cypress {
      * Fires as the page begins to load, but before any of your applications JavaScript has executed. This fires at the exact same time as `cy.visit()` `onBeforeLoad` callback. Useful to modify the window on a page transition.
      * @see https://on.cypress.io/catalog-of-events#App-Events
      */
-    (action: 'window:before:load', fn: (win: Window) => void): void
+    (action: 'window:before:load', fn: (win: AUTWindow) => void): void
     /**
      * Fires after all your resources have finished loading after a page transition. This fires at the exact same time as a `cy.visit()` `onLoad` callback.
      * @see https://on.cypress.io/catalog-of-events#App-Events
      */
-    (action: 'window:load', fn: (win: Window) => void): void
+    (action: 'window:load', fn: (win: AUTWindow) => void): void
     /**
      * Fires when your application is about to navigate away. The real event object is provided to you. Your app may have set a `returnValue` on the event, which is useful to assert on.
      * @see https://on.cypress.io/catalog-of-events#App-Events
@@ -5169,7 +5263,7 @@ declare namespace Cypress {
 
   interface Server extends RouteOptions {
     enable: boolean
-    whitelist: (xhr: any) => boolean
+    ignore: (xhr: any) => boolean
   }
 
   interface Viewport {
@@ -5200,10 +5294,10 @@ declare namespace Cypress {
   }
 
   type Encodings = 'ascii' | 'base64' | 'binary' | 'hex' | 'latin1' | 'utf8' | 'utf-8' | 'ucs2' | 'ucs-2' | 'utf16le' | 'utf-16le'
-  type PositionType = "topLeft" | "top" | "topRight" | "left" | "center" | "right" | "bottomLeft" | "bottom" | "bottomRight"
+  type PositionType = 'topLeft' | 'top' | 'topRight' | 'left' | 'center' | 'right' | 'bottomLeft' | 'bottom' | 'bottomRight'
   type ViewportPreset = 'macbook-15' | 'macbook-13' | 'macbook-11' | 'ipad-2' | 'ipad-mini' | 'iphone-xr' | 'iphone-x' | 'iphone-6+' | 'iphone-6' | 'iphone-5' | 'iphone-4' | 'iphone-3' | 'samsung-s10' | 'samsung-note9'
   interface Offset {
-    top: number,
+    top: number
     left: number
   }
 
@@ -5236,39 +5330,39 @@ declare namespace Cypress {
 declare namespace Mocha {
   interface TestFunction {
         /**
-         * Describe a specification or test-case with the given `title`, TestCptions, and callback `fn` acting
+         * Describe a specification or test-case with the given `title`, TestOptions, and callback `fn` acting
          * as a thunk.
          */
         (title: string, config: Cypress.TestConfigOverrides, fn?: Func): Test
 
         /**
-         * Describe a specification or test-case with the given `title`, TestCptions, and callback `fn` acting
+         * Describe a specification or test-case with the given `title`, TestOptions, and callback `fn` acting
          * as a thunk.
          */
         (title: string, config: Cypress.TestConfigOverrides, fn?: AsyncFunc): Test
   }
   interface ExclusiveTestFunction {
         /**
-         * Describe a specification or test-case with the given `title`, TestCptions, and callback `fn` acting
+         * Describe a specification or test-case with the given `title`, TestOptions, and callback `fn` acting
          * as a thunk.
          */
         (title: string, config: Cypress.TestConfigOverrides, fn?: Func): Test
 
         /**
-         * Describe a specification or test-case with the given `title`, TestCptions, and callback `fn` acting
+         * Describe a specification or test-case with the given `title`, TestOptions, and callback `fn` acting
          * as a thunk.
          */
         (title: string, config: Cypress.TestConfigOverrides, fn?: AsyncFunc): Test
   }
   interface PendingTestFunction {
         /**
-         * Describe a specification or test-case with the given `title`, TestCptions, and callback `fn` acting
+         * Describe a specification or test-case with the given `title`, TestOptions, and callback `fn` acting
          * as a thunk.
          */
         (title: string, config: Cypress.TestConfigOverrides, fn?: Func): Test
 
         /**
-         * Describe a specification or test-case with the given `title`, TestCptions, and callback `fn` acting
+         * Describe a specification or test-case with the given `title`, TestOptions, and callback `fn` acting
          * as a thunk.
          */
         (title: string, config: Cypress.TestConfigOverrides, fn?: AsyncFunc): Test
@@ -5276,7 +5370,7 @@ declare namespace Mocha {
 
   interface SuiteFunction {
     /**
-     * Describe a "suite" with the given `title`, TestCptions, and callback `fn` containing
+     * Describe a "suite" with the given `title`, TestOptions, and callback `fn` containing
      * nested suites.
      */
     (title: string, config: Cypress.TestConfigOverrides, fn: (this: Suite) => void): Suite
@@ -5284,13 +5378,13 @@ declare namespace Mocha {
 
   interface ExclusiveSuiteFunction {
     /**
-     * Describe a "suite" with the given `title`, TestCptions, and callback `fn` containing
+     * Describe a "suite" with the given `title`, TestOptions, and callback `fn` containing
      * nested suites. Indicates this suite should be executed exclusively.
      */
     (title: string, config: Cypress.TestConfigOverrides, fn: (this: Suite) => void): Suite
   }
 
   interface PendingSuiteFunction {
-    (title: string,  config: Cypress.TestConfigOverrides, fn: (this: Suite) => void): Suite | void
+    (title: string, config: Cypress.TestConfigOverrides, fn: (this: Suite) => void): Suite | void
   }
 }

package/types/index.d.ts

@@ -4,7 +4,7 @@
 //                 Mike Woudenberg <https://github.com/mikewoudenberg>
 //                 Robbert van Markus <https://github.com/rvanmarkus>
 //                 Nicholas Boll <https://github.com/nicholasboll>
-// TypeScript Version: 3.0
+// TypeScript Version: 3.4
 // Updated by the Cypress team: https://www.cypress.io/about/
 
 /// <reference path="./cy-blob-util.d.ts" />
@@ -27,6 +27,7 @@
 // hmm, how to load it better?
 /// <reference path="./cypress-npm-api.d.ts" />
 
+/// <reference path="./net-stubbing.ts" />
 /// <reference path="./cypress.d.ts" />
 /// <reference path="./cypress-global-vars.d.ts" />
 /// <reference path="./cypress-type-helpers.d.ts" />

package/types/net-stubbing.ts

@@ -0,0 +1,257 @@
+/**
+ * HTTP request/response types.
+ */
+export namespace CyHttpMessages {
+  interface BaseMessage {
+    // as much stuff from `incomingmessage` as makes sense to serialize and send
+    body?: any
+    headers: { [key: string]: string }
+    url: string
+    method?: string
+    httpVersion?: string
+  }
+
+  export type IncomingResponse = BaseMessage & {
+    statusCode: number
+    statusMessage: string
+  }
+
+  export type IncomingHttpResponse = IncomingResponse & {
+    /**
+     * Continue the HTTP response, merging the supplied values with the real response.
+     */
+    send(status: number, body?: string | number | object, headers?: { [key: string]: string }): void
+    send(body: string | object, headers?: { [key: string]: string }): void
+    send(staticResponse: StaticResponse): void
+    /**
+     * Continue the HTTP response to the browser, including any modifications made to `res`.
+     */
+    send(): void
+    /**
+     * Wait for `delayMs` milliseconds before sending the response to the client.
+     */
+    delay: (delayMs: number) => IncomingHttpResponse
+    /**
+     * Serve the response at `throttleKbps` kilobytes per second.
+     */
+    throttle: (throttleKbps: number) => IncomingHttpResponse
+  }
+
+  export type IncomingRequest = BaseMessage & {
+    responseTimeout?: number
+    /**
+     * Set if redirects should be followed when this request is made. By default, requests will
+     * not follow redirects before yielding the response (the 3xx redirect is yielded)
+     */
+    followRedirect?: boolean
+  }
+
+  export interface IncomingHttpRequest extends IncomingRequest {
+    destroy(): void
+    reply(interceptor?: StaticResponse | HttpResponseInterceptor): void
+    reply(body: string | object, headers?: { [key: string]: string }): void
+    reply(status: number, body?: string | object, headers?: { [key: string]: string }): void
+    redirect(location: string, statusCode: number): void
+  }
+}
+
+export interface DictMatcher<T> {
+  [key: string]: T
+}
+
+/**
+ * Matches a string using glob (`*`) matching.
+ */
+export type GlobPattern = string
+
+export type HttpRequestInterceptor = (req: CyHttpMessages.IncomingHttpRequest) => void | Promise<void>
+
+export type HttpResponseInterceptor = (res: CyHttpMessages.IncomingHttpResponse, send?: () => void) => void | Promise<void>
+
+/**
+ * Matches a single number or any of an array of acceptable numbers.
+ */
+export type NumberMatcher = number | number[]
+
+/**
+ * Request/response cycle.
+ */
+export interface Request {
+  id: string
+  /* @internal */
+  log: any
+  request: CyHttpMessages.IncomingRequest
+  /**
+   * Was `cy.wait()` used to wait on this request?
+   * @internal
+   */
+  requestWaited: boolean
+  response?: CyHttpMessages.IncomingResponse
+  /* @internal */
+  responseHandler?: HttpResponseInterceptor
+  /**
+   * Was `cy.wait()` used to wait on the response to this request?
+   * @internal
+   */
+  responseWaited: boolean
+  /* @internal */
+  state: RequestState
+}
+
+export type RequestState =
+  'Received' |
+  'Intercepted' |
+  'ResponseReceived' |
+  'ResponseIntercepted' |
+  'Complete' |
+  'Errored'
+
+export interface Route {
+  alias?: string
+  log: any
+  options: RouteMatcherOptions
+  handler: RouteHandler
+  hitCount: number
+  requests: { [key: string]: Request }
+}
+
+export interface RouteMap { [key: string]: Route }
+
+/**
+ * A `RouteMatcher` describes a filter for HTTP requests.
+ */
+export type RouteMatcher = StringMatcher | RouteMatcherOptions
+
+export interface RouteMatcherCompatOptions {
+  response?: string | object
+}
+
+export type RouteMatcherOptions = RouteMatcherOptionsGeneric<StringMatcher>
+
+export interface RouteMatcherOptionsGeneric<S> extends RouteMatcherCompatOptions {
+  /**
+   * Match HTTP basic authentication.
+   */
+  auth?: { username: S, password: S }
+  /**
+   * Match client request headers.
+   */
+  headers?: DictMatcher<S>
+  /**
+   * Match based on requested hostname.
+   */
+  hostname?: S
+  /**
+   * Match requests served via HTTPS only.
+   */
+  https?: boolean
+  /**
+   * @default 'GET'
+   */
+  method?: S
+  /**
+   * Match on request path after the hostname, including query params.
+   */
+  path?: S
+  /**
+   * Matches like `path`, but without query params.
+   */
+  pathname?: S
+  /**
+   * Match based on requested port.
+   */
+  port?: NumberMatcher
+  /**
+   * Match on parsed querystring parameters.
+   */
+  query?: DictMatcher<S>
+  /**
+   * Match based on full request URL.
+   */
+  url?: S
+}
+
+export type RouteHandlerController = HttpRequestInterceptor
+
+export type RouteHandler = string | StaticResponse | RouteHandlerController | object
+
+/**
+ * Describes a response that will be sent back to the browser to fulfill the request.
+ */
+export type StaticResponse = GenericStaticResponse<string, string | object> & {
+  /**
+  * If set, `delayMs` will pass before the response is sent.
+  */
+ delayMs?: number
+}
+
+export interface GenericStaticResponse<Fixture, Body> {
+  /**
+   * If set, serve a fixture as the response body.
+   */
+  fixture?: Fixture
+  /**
+   * If set, serve a static string/JSON object as the response body.
+   */
+  body?: Body
+  /**
+   * @default {}
+   */
+  headers?: { [key: string]: string }
+  /**
+   * @default 200
+   */
+  statusCode?: number
+  /**
+   * If `forceNetworkError` is truthy, Cypress will destroy the connection to the browser and send no response. Useful for simulating a server that is not reachable. Must not be set in combination with other options.
+   */
+  forceNetworkError?: boolean
+  /**
+   * If set, the `body` will be sent at `throttleKbps` kbps.
+   */
+  throttleKbps?: number
+}
+
+/**
+ * Either a `GlobPattern` string or a `RegExp`.
+ */
+export type StringMatcher = GlobPattern | RegExp
+
+declare global {
+  namespace Cypress {
+    interface Chainable<Subject = any> {
+      /**
+       * Use `cy.route2()` to stub and intercept HTTP requests and responses.
+       *
+       * Note: this command is only available if you have set the `experimentalNetworkStubbing`
+       * configuration option to `true`.
+       *
+       * @see https://on.cypress.io/route2
+       * @example
+       *    cy.route2('https://localhost:7777/users', [{id: 1, name: 'Pat'}])
+       * @example
+       *    cy.route2('https://localhost:7777/protected-endpoint', (req) => {
+       *      req.headers['authorization'] = 'basic fooabc123'
+       *    })
+       * @example
+       *    cy.route2('https://localhost:7777/some-response', (req) => {
+       *      req.reply(res => {
+       *        res.body = 'some new body'
+       *      })
+       *    })
+       */
+      route2(url: RouteMatcher, response?: RouteHandler): Chainable<null>
+      /**
+       * Use `cy.route2()` to stub and intercept HTTP requests and responses.
+       *
+       * Note: this command is only available if you have set the `experimentalNetworkStubbing`
+       * configuration option to `true`.
+       *
+       * @see https://on.cypress.io/route2
+       * @example
+       *    cy.route2('GET', 'http://foo.com/fruits', ['apple', 'banana', 'cherry'])
+       */
+      route2(method: string, url: RouteMatcher, response?: RouteHandler): Chainable<null>
+    }
+  }
+}

package/types/blob-util/index.d.ts

@@ -1,97 +0,0 @@
-// Type definitions for blob-util 1.3
-// Project: https://github.com/nolanlawson/blob-util#readme
-// Definitions by: Max Battcher <https://github.com/WorldMaker>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.1
-
-/**
- * Shim for new Blob() to support older browsers that use the deprecated BlobBuilder API.
- *
- * @param parts content of the Blob
- * @param options usually just `{ type: mimeType }`
- */
-export function createBlob(parts: any[], options?: { type: string }): Blob;
-
-/**
- * Shim for URL.createObjectURL() to support browsers that only have the prefixed webkitURL (e.g. Android <4.4).
- */
-export function createObjectURL(blob: Blob): string;
-
-/**
- * Shim for URL.revokeObjectURL() to support browsers that only have the prefixed webkitURL (e.g. Android <4.4).
- */
-export function revokeObjectURL(url: string): void;
-
-/**
- * Convert a Blob to a binary string.
- */
-export function blobToBinaryString(blob: Blob): Promise<string>;
-
-/**
- * Convert a binary string to a Blob.
- * @param type the content type
- */
-export function binaryStringToBlob(binary: string, type?: string): Promise<Blob>;
-
-/**
- * Convert a Blob to a base-64 string.
- */
-export function blobToBase64String(blob: Blob): Promise<string>;
-
-/**
- * Convert a base-64 string to a Blob.
- * @param type the content type
- */
-export function base64StringToBlob(base64: string, type?: string): Promise<Blob>;
-
-/**
- * Convert a data URL string (e.g. `'data:image/png;base64,iVBORw0KG...'`) to a Blob.
- */
-export function dataURLToBlob(dataURL: string): Promise<Blob>;
-
-/**
- * Convert a Blob to a data URL string (e.g. `'data:image/png;base64,iVBORw0KG...'`).
- */
-export function blobToDataURL(blob: Blob): Promise<string>;
-
-/**
- * Convert an image's src URL to a data URL by loading the image and painting it to a canvas.
- *
- * Note: this will coerce the image to the desired content type, and it will only paint the first frame of an animated GIF.
- *
- * @param type the content type (optional, defaults to 'image/png')
- * @param crossOrigin for CORS-enabled images, set this to 'Anonymous' to avoid "tainted canvas" errors
- * @param quality a number between 0 and 1 indicating image quality if the requested type is 'image/jpeg' or 'image/webp'
- */
-export function imgSrcToDataURL(src: string, type?: string, crossOrigin?: string, quality?: number): Promise<string>;
-
-/**
- * Convert a canvas to a Blob.
- *
- * @param type the content type (optional, defaults to 'image/png')
- * @param quality a number between 0 and 1 indicating image quality if the requested type is 'image/jpeg' or 'image/webp'
- */
-export function canvasToBlob(canvas: HTMLCanvasElement, type?: string, quality?: number): Promise<Blob>;
-
-/**
- * Convert an image's src URL to a Blob by loading the image and painting it to a canvas.
- *
- * Note: this will coerce the image to the desired content type, and it will only paint the first frame of an animated GIF.
- *
- * @param type the content type (optional, defaults to 'image/png')
- * @param crossOrigin for CORS-enabled images, set this to 'Anonymous' to avoid "tainted canvas" errors
- * @param quality a number between 0 and 1 indicating image quality if the requested type is 'image/jpeg' or 'image/webp'
- */
-export function imgSrcToBlob(src: string, type?: string, crossOrigin?: string, quality?: number): Promise<Blob>;
-
-/**
- * Convert an ArrayBuffer to a Blob.
- *
- * @param type the content type
- */
-export function arrayBufferToBlob(arrayBuff: ArrayBuffer, type?: string): Promise<Blob>;
-
-/**
- * Convert a Blob to an ArrayBuffer.
- */
-export function blobToArrayBuffer(blob: Blob): Promise<ArrayBuffer>;