@percy/core 1.26.2 → 1.26.3-alpha.4

package/dist/percy.js

@@ -1,3 +1,9 @@
+const _excluded = ["loglevel", "delayUploads", "deferUploads", "skipUploads", "skipDiscovery", "dryRun", "testing", "config", "token", "clientInfo", "environmentInfo", "server", "port", "projectType"],
+  _excluded2 = ["percy"],
+  _excluded3 = ["clientInfo", "environmentInfo"],
+  _excluded4 = ["clientInfo", "environmentInfo"];
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
 import PercyClient from '@percy/client';
 import PercyConfig from '@percy/config';
 import logger from '@percy/logger';
@@ -22,43 +28,46 @@ export class Percy {
     await instance.start();
     return instance;
   }
-  constructor({
-    // initial log level
-    loglevel,
-    // process uploads before the next snapshot
-    delayUploads,
-    // process uploads after all snapshots
-    deferUploads,
-    // run without uploading anything
-    skipUploads,
-    // run without asset discovery
-    skipDiscovery,
-    // implies `skipUploads` and `skipDiscovery`
-    dryRun,
-    // implies `dryRun`, silent logs, and adds extra api endpoints
-    testing,
-    // configuration filepath
-    config: configFile,
-    // provided to @percy/client
-    token,
-    clientInfo = '',
-    environmentInfo = '',
-    // snapshot server options
-    server = true,
-    port = 5338,
-    projectType = null,
-    // options such as `snapshot` and `discovery` that are valid Percy config
-    // options which will become accessible via the `.config` property
-    ...options
-  } = {}) {
+  constructor(_ref = {}) {
+    var _deferUploads;
     let {
-      percy,
-      ...config
-    } = PercyConfig.load({
-      overrides: options,
-      path: configFile
-    });
-    deferUploads ?? (deferUploads = percy === null || percy === void 0 ? void 0 : percy.deferUploads);
+        // initial log level
+        loglevel,
+        // process uploads before the next snapshot
+        delayUploads,
+        // process uploads after all snapshots
+        deferUploads,
+        // run without uploading anything
+        skipUploads,
+        // run without asset discovery
+        skipDiscovery,
+        // implies `skipUploads` and `skipDiscovery`
+        dryRun,
+        // implies `dryRun`, silent logs, and adds extra api endpoints
+        testing,
+        // configuration filepath
+        config: configFile,
+        // provided to @percy/client
+        token,
+        clientInfo = '',
+        environmentInfo = '',
+        // snapshot server options
+        server = true,
+        port = 5338,
+        projectType = null
+        // options such as `snapshot` and `discovery` that are valid Percy config
+        // options which will become accessible via the `.config` property
+      } = _ref,
+      options = _objectWithoutProperties(_ref, _excluded);
+    let _PercyConfig$load = PercyConfig.load({
+        overrides: options,
+        path: configFile
+      }),
+      {
+        percy
+      } = _PercyConfig$load,
+      config = _objectWithoutProperties(_PercyConfig$load, _excluded2);
+    (_deferUploads = deferUploads) !== null && _deferUploads !== void 0 ? _deferUploads : deferUploads = percy === null || percy === void 0 ? void 0 : percy.deferUploads;
     this.config = config;
     if (testing) loglevel = 'silent';
     if (loglevel) this.loglevel(loglevel);
@@ -99,11 +108,12 @@ export class Percy {
   }
 
   // Set client & environment info, and override loaded config options
-  set({
-    clientInfo,
-    environmentInfo,
-    ...config
-  }) {
+  set(_ref2) {
+    let {
+        clientInfo,
+        environmentInfo
+      } = _ref2,
+      config = _objectWithoutProperties(_ref2, _excluded3);
     this.client.addClientInfo(clientInfo);
     this.client.addEnvironmentInfo(environmentInfo);
 
@@ -339,10 +349,10 @@ export class Percy {
       // normalize, migrate, and remove certain properties from validating
       options = PercyConfig.migrate(options, '/comparison');
       let {
-        clientInfo,
-        environmentInfo,
-        ...comparison
-      } = options;
+          clientInfo,
+          environmentInfo
+        } = options,
+        comparison = _objectWithoutProperties(options, _excluded4);
       let errors = PercyConfig.validate(comparison, '/comparison');
       if (errors) {
         this.log.warn('Invalid upload options:');

package/dist/queue.js

@@ -1,7 +1,9 @@
 function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
 function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
 function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
 function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
 function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
@@ -73,7 +75,7 @@ export class Queue {
       value: null
     });
     _defineProperty(this, "readyState", 0);
-  }
+  } // item concurrency
   // Configure queue properties
   set({
     concurrency
@@ -148,25 +150,27 @@ export class Queue {
 
   // Returns an item task matching the provided subject.
 
+  // keep track of start and end tasks
+
   // Initialize a starting task or return an existing one.
   start() {
-    var _classPrivateFieldGet2;
-    _classPrivateFieldGet(this, _start) ?? _classPrivateFieldSet(this, _start, deferred({
+    var _classPrivateFieldGet2, _classPrivateFieldGet3, _classPrivateFieldGet4;
+    (_classPrivateFieldGet2 = _classPrivateFieldGet(this, _start)) !== null && _classPrivateFieldGet2 !== void 0 ? _classPrivateFieldGet2 : _classPrivateFieldSet(this, _start, deferred({
       readyState: 1
     }));
-    (_classPrivateFieldGet2 = _classPrivateFieldGet(this, _start)).handler ?? (_classPrivateFieldGet2.handler = _classPrivateFieldGet(this, _end) // wait for any ending task to complete first
-    ? () => _classPrivateFieldGet(this, _end).promise.then(_classPrivateFieldGet(this, _handlers).start) : _classPrivateFieldGet(this, _handlers).start);
+    (_classPrivateFieldGet4 = (_classPrivateFieldGet3 = _classPrivateFieldGet(this, _start)).handler) !== null && _classPrivateFieldGet4 !== void 0 ? _classPrivateFieldGet4 : _classPrivateFieldGet3.handler = _classPrivateFieldGet(this, _end) // wait for any ending task to complete first
+    ? () => _classPrivateFieldGet(this, _end).promise.then(_classPrivateFieldGet(this, _handlers).start) : _classPrivateFieldGet(this, _handlers).start;
     return _classPrivateMethodGet(this, _process, _process2).call(this, _classPrivateFieldGet(this, _start)).deferred;
   }
 
   // intialize an ending task or return an existing one
   end() {
-    var _classPrivateFieldGet3;
-    _classPrivateFieldGet(this, _end) ?? _classPrivateFieldSet(this, _end, deferred({
+    var _classPrivateFieldGet5, _classPrivateFieldGet6, _classPrivateFieldGet7;
+    (_classPrivateFieldGet5 = _classPrivateFieldGet(this, _end)) !== null && _classPrivateFieldGet5 !== void 0 ? _classPrivateFieldGet5 : _classPrivateFieldSet(this, _end, deferred({
       readyState: 0
     }));
-    (_classPrivateFieldGet3 = _classPrivateFieldGet(this, _end)).handler ?? (_classPrivateFieldGet3.handler = _classPrivateFieldGet(this, _start) // wait for any starting task to complete first
-    ? () => _classPrivateFieldGet(this, _start).promise.then(_classPrivateFieldGet(this, _handlers).end) : _classPrivateFieldGet(this, _handlers).end);
+    (_classPrivateFieldGet7 = (_classPrivateFieldGet6 = _classPrivateFieldGet(this, _end)).handler) !== null && _classPrivateFieldGet7 !== void 0 ? _classPrivateFieldGet7 : _classPrivateFieldGet6.handler = _classPrivateFieldGet(this, _start) // wait for any starting task to complete first
+    ? () => _classPrivateFieldGet(this, _start).promise.then(_classPrivateFieldGet(this, _handlers).end) : _classPrivateFieldGet(this, _handlers).end;
     return _classPrivateMethodGet(this, _process, _process2).call(this, _classPrivateFieldGet(this, _end)).deferred;
   }
 
@@ -190,9 +194,9 @@ export class Queue {
 
   // close a running queue, optionally aborting it
   close(abort) {
-    var _classPrivateFieldGet4;
+    var _classPrivateFieldGet8;
     // when starting, state is updated afterwards
-    if ((_classPrivateFieldGet4 = _classPrivateFieldGet(this, _start)) !== null && _classPrivateFieldGet4 !== void 0 && _classPrivateFieldGet4.pending) _classPrivateFieldGet(this, _start).readyState = 3;
+    if ((_classPrivateFieldGet8 = _classPrivateFieldGet(this, _start)) !== null && _classPrivateFieldGet8 !== void 0 && _classPrivateFieldGet8.pending) _classPrivateFieldGet(this, _start).readyState = 3;
     if (this.readyState < 3) this.readyState = 3;
     if (abort) this.clear();
     return this;
@@ -210,10 +214,10 @@ export class Queue {
 
   // process a single item task when started
   process(item) {
-    var _classPrivateFieldGet5;
+    var _classPrivateFieldGet9;
     let task = _classPrivateMethodGet(this, _find, _find2).call(this, item);
     if (task && !_classPrivateFieldGet(this, _start)) this.start();
-    (_classPrivateFieldGet5 = _classPrivateFieldGet(this, _start)) === null || _classPrivateFieldGet5 === void 0 ? void 0 : _classPrivateFieldGet5.promise.then(() => _classPrivateMethodGet(this, _process, _process2).call(this, task));
+    (_classPrivateFieldGet9 = _classPrivateFieldGet(this, _start)) === null || _classPrivateFieldGet9 === void 0 ? void 0 : _classPrivateFieldGet9.promise.then(() => _classPrivateMethodGet(this, _process, _process2).call(this, task));
     return task === null || task === void 0 ? void 0 : task.deferred;
   }
 
@@ -223,9 +227,9 @@ export class Queue {
   // callback every 10ms during checks with the current number of pending tasks
   idle(callback) {
     return yieldFor(() => {
-      var _classPrivateFieldGet6;
+      var _classPrivateFieldGet10;
       callback === null || callback === void 0 ? void 0 : callback(_classPrivateFieldGet(this, _pending).size);
-      let starting = ((_classPrivateFieldGet6 = _classPrivateFieldGet(this, _start)) === null || _classPrivateFieldGet6 === void 0 ? void 0 : _classPrivateFieldGet6.pending) === true;
+      let starting = ((_classPrivateFieldGet10 = _classPrivateFieldGet(this, _start)) === null || _classPrivateFieldGet10 === void 0 ? void 0 : _classPrivateFieldGet10.pending) === true;
       return !starting && !_classPrivateFieldGet(this, _pending).size;
     }, {
       idle: 10
@@ -235,14 +239,14 @@ export class Queue {
   // process items up to the latest queued item, starting the queue if necessary;
   // returns a generator that yields until the flushed item has finished processing
   flush(callback) {
-    let interrupt =
-    // check for existing interrupts
-    [..._classPrivateFieldGet(this, _pending)].find(t => t.stop) ?? [..._classPrivateFieldGet(this, _queued)].find(t => t.stop);
+    var _find3, _pop, _interrupt$stop;
+    let interrupt = // check for existing interrupts
+    (_find3 = [..._classPrivateFieldGet(this, _pending)].find(t => t.stop)) !== null && _find3 !== void 0 ? _find3 : [..._classPrivateFieldGet(this, _queued)].find(t => t.stop);
 
     // get the latest queued or pending task to track
-    let flush = [..._classPrivateFieldGet(this, _queued)].pop() ?? [..._classPrivateFieldGet(this, _pending)].pop();
+    let flush = (_pop = [..._classPrivateFieldGet(this, _queued)].pop()) !== null && _pop !== void 0 ? _pop : [..._classPrivateFieldGet(this, _pending)].pop();
     // determine if the queue should be stopped after flushing
-    if (flush) flush.stop = (interrupt === null || interrupt === void 0 ? void 0 : interrupt.stop) ?? this.readyState < 2;
+    if (flush) flush.stop = (_interrupt$stop = interrupt === null || interrupt === void 0 ? void 0 : interrupt.stop) !== null && _interrupt$stop !== void 0 ? _interrupt$stop : this.readyState < 2;
     // remove the old interrupt to avoid stopping early
     if (interrupt) delete interrupt.stop;
     // start the queue if not started
@@ -263,6 +267,7 @@ function _dequeue2() {
   return _classPrivateMethodGet(this, _process, _process2).call(this, task);
 }
 function _find2(subject) {
+  var _find4;
   let find = _classPrivateFieldGet(this, _handlers).find
   // use any configured find handler to match items
   ? ({
@@ -270,9 +275,8 @@ function _find2(subject) {
   }) => _classPrivateFieldGet(this, _handlers).find(subject, item) : ({
     item
   }) => subject === item;
-  return (
-    // look at queued then pending items
-    [..._classPrivateFieldGet(this, _queued)].find(find) ?? [..._classPrivateFieldGet(this, _pending)].find(find)
+  return (// look at queued then pending items
+    (_find4 = [..._classPrivateFieldGet(this, _queued)].find(find)) !== null && _find4 !== void 0 ? _find4 : [..._classPrivateFieldGet(this, _pending)].find(find)
   );
 }
 function _process2(task) {
@@ -299,7 +303,7 @@ function _process2(task) {
     // clean up internal tasks after ending
     if (!this.readyState) _classPrivateFieldSet(this, _start, _classPrivateFieldSet(this, _end, null));
     // resolve or reject the deferred task promise
-    task[err ? 'reject' : 'resolve'](err ?? val);
+    task[err ? 'reject' : 'resolve'](err !== null && err !== void 0 ? err : val);
     // keep dequeuing when running
     if (this.readyState === 2) this.run();
     // mark pending task done
@@ -310,8 +314,8 @@ function _process2(task) {
 async function* _until2(task, callback) {
   try {
     yield* yieldFor(() => {
-      var _classPrivateFieldGet7;
-      if ((_classPrivateFieldGet7 = _classPrivateFieldGet(this, _start)) !== null && _classPrivateFieldGet7 !== void 0 && _classPrivateFieldGet7.pending) return false;
+      var _classPrivateFieldGet11, _queued2, _pending2;
+      if ((_classPrivateFieldGet11 = _classPrivateFieldGet(this, _start)) !== null && _classPrivateFieldGet11 !== void 0 && _classPrivateFieldGet11.pending) return false;
       let queued,
         pending = _classPrivateFieldGet(this, _pending).size;
       // calculate the position within queued when not pending
@@ -319,7 +323,7 @@ async function* _until2(task, callback) {
       // calculate the position within pending when not stopping
       if (!(task !== null && task !== void 0 && task.stop) && (task === null || task === void 0 ? void 0 : task.pending) != null) pending = positionOf(_classPrivateFieldGet(this, _pending), task);
       // call the callback and return true when not queued or pending
-      let position = (queued ?? 0) + (pending ?? 0);
+      let position = ((_queued2 = queued) !== null && _queued2 !== void 0 ? _queued2 : 0) + ((_pending2 = pending) !== null && _pending2 !== void 0 ? _pending2 : 0);
       callback === null || callback === void 0 ? void 0 : callback(position);
       return !position;
     }, {

package/dist/server.js

@@ -1,3 +1,6 @@
+const _excluded = ["serve", "port", "baseUrl"];
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
 function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
 function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
 function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
@@ -159,8 +162,8 @@ export class Server extends http.Server {
 
   // return the listening port or any default port
   get port() {
-    var _super$address;
-    return ((_super$address = super.address()) === null || _super$address === void 0 ? void 0 : _super$address.port) ?? _classPrivateFieldGet(this, _defaultPort);
+    var _super$address$port, _super$address;
+    return (_super$address$port = (_super$address = super.address()) === null || _super$address === void 0 ? void 0 : _super$address.port) !== null && _super$address$port !== void 0 ? _super$address$port : _classPrivateFieldGet(this, _defaultPort);
   }
 
   // return a string representation of the server address
@@ -189,6 +192,8 @@ export class Server extends http.Server {
 
   // initial routes include cors and 404 handling
 
+  // adds a route in the correct priority order
+
   // set request routing and handling for pathnames and methods
   route(method, pathname, handle) {
     if (arguments.length === 1) [handle, method] = [method];
@@ -251,8 +256,9 @@ function _route2(route) {
   return this;
 }
 async function _handleRequest2(req, res) {
+  var _res$req;
   // support node < 15.7.0
-  res.req ?? (res.req = req);
+  (_res$req = res.req) !== null && _res$req !== void 0 ? _res$req : res.req = req;
   try {
     // invoke routes like middleware
     await async function cont(routes, i = 0) {
@@ -299,9 +305,9 @@ function createRewriter(rewrites = [], cb) {
       apply: r => toPath(r.params)
     };
   })).reduceRight((next, rule) => pathname => {
-    var _rule$match;
+    var _rule$match, _rule$match2;
     // compose all rewrites into a single function
-    let result = ((_rule$match = rule.match) === null || _rule$match === void 0 ? void 0 : _rule$match.call(rule, pathname)) ?? pathname;
+    let result = (_rule$match = (_rule$match2 = rule.match) === null || _rule$match2 === void 0 ? void 0 : _rule$match2.call(rule, pathname)) !== null && _rule$match !== void 0 ? _rule$match : pathname;
     if (result) pathname = rule.apply(result);
     return next(pathname);
   }, p => p);
@@ -331,7 +337,8 @@ async function getFile(root, pathname, cleanUrls) {
 // returns the start and end of a byte range or undefined if unable to parse
 const RANGE_REGEXP = /^bytes=(\d*)?-(\d*)?(?:\b|$)/;
 function parseByteRange(range, size) {
-  let [, start, end = size] = (range === null || range === void 0 ? void 0 : range.match(RANGE_REGEXP)) ?? [0, 0, 0];
+  var _range$match;
+  let [, start, end = size] = (_range$match = range === null || range === void 0 ? void 0 : range.match(RANGE_REGEXP)) !== null && _range$match !== void 0 ? _range$match : [0, 0, 0];
   start = Math.max(parseInt(start, 10), 0);
   end = Math.min(parseInt(end, 10), size - 1);
   if (isNaN(start)) [start, end] = [size - end, size - 1];
@@ -344,11 +351,11 @@ function parseByteRange(range, size) {
 // shorthand function for creating a new server with specific options
 export function createServer(options = {}) {
   let {
-    serve,
-    port,
-    baseUrl = '/',
-    ...opts
-  } = options;
+      serve,
+      port,
+      baseUrl = '/'
+    } = options,
+    opts = _objectWithoutProperties(options, _excluded);
   let server = new Server({
     port
   });

package/dist/session.js

@@ -89,7 +89,8 @@ export class Session extends EventEmitter {
 
   /* istanbul ignore next: encountered during closing races */
   _handleClosedError = error => {
-    if (!(error.message ?? error).endsWith(this.closedReason)) {
+    var _error$message;
+    if (!((_error$message = error.message) !== null && _error$message !== void 0 ? _error$message : error).endsWith(this.closedReason)) {
       this.log.debug(error, this.meta);
     }
   };

package/dist/snapshot.js

@@ -1,3 +1,16 @@
+const _excluded = ["include", "exclude"],
+  _excluded2 = ["prefix", "suffix"],
+  _excluded3 = ["clientInfo", "environmentInfo", "snapshots"],
+  _excluded4 = ["resources"],
+  _excluded5 = ["resources", "widths", "width"],
+  _excluded6 = ["resources"];
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
 import logger from '@percy/logger';
 import PercyConfig from '@percy/config';
 import micromatch from 'micromatch';
@@ -70,15 +83,18 @@ function mapSnapshotOptions(snapshots, context) {
   if (!(snapshots !== null && snapshots !== void 0 && snapshots.length)) return [];
 
   // reduce options into a single function
-  let applyOptions = [].concat((context === null || context === void 0 ? void 0 : context.options) || []).reduceRight((next, {
-    include,
-    exclude,
-    ...opts
-  }) => snap => next(
-  // assign additional options to included snaphots
-  snapshotMatches(snap, include, exclude) ? Object.assign(snap, opts) : snap), snap => getSnapshotOptions(snap, context));
-
-  // reduce snapshots with overrides
+  let applyOptions = [].concat((context === null || context === void 0 ? void 0 : context.options) || []).reduceRight((next, _ref) => {
+    let {
+        include,
+        exclude
+      } = _ref,
+      opts = _objectWithoutProperties(_ref, _excluded);
+    return snap => next(
+    // assign additional options to included snaphots
+    snapshotMatches(snap, include, exclude) ? Object.assign(snap, opts) : snap);
+  }, snap => getSnapshotOptions(snap, context));
+
+  // reduce snapshots with options
   return snapshots.reduce((acc, snapshot) => {
     var _snapshot;
     // transform snapshot URL shorthand into an object
@@ -109,12 +125,11 @@ function getSnapshotOptions(options, {
     discovery: {
       allowedHostnames: [validURL(options.url).hostname]
     },
-    meta: {
-      ...meta,
+    meta: _objectSpread(_objectSpread({}, meta), {}, {
       snapshot: {
         name: options.name
       }
-    }
+    })
   }, config.snapshot, {
     // only specific discovery options are used per-snapshot
     discovery: {
@@ -141,20 +156,19 @@ function getSnapshotOptions(options, {
         return Array.isArray(next) || typeof next !== 'object' ? [path.concat('beforeSnapshot'), next] : [path];
       case 'discovery.disallowedHostnames':
         // prevent disallowing the root hostname
-        return [path, !((_next2 = next) !== null && _next2 !== void 0 && _next2.length) ? prev : (prev ?? []).concat(next).filter(h => !hostnameMatches(h, options.url))];
+        return [path, !((_next2 = next) !== null && _next2 !== void 0 && _next2.length) ? prev : (prev !== null && prev !== void 0 ? prev : []).concat(next).filter(h => !hostnameMatches(h, options.url))];
     }
 
     // ensure additional snapshots have complete names
     if (path[0] === 'additionalSnapshots' && path.length === 2) {
       let {
-        prefix = '',
-        suffix = '',
-        ...n
-      } = next;
-      next = {
-        name: `${prefix}${options.name}${suffix}`,
-        ...n
-      };
+          prefix = '',
+          suffix = ''
+        } = next,
+        n = _objectWithoutProperties(next, _excluded2);
+      next = _objectSpread({
+        name: `${prefix}${options.name}${suffix}`
+      }, n);
       return [path, next];
     }
   });
@@ -164,18 +178,19 @@ function getSnapshotOptions(options, {
 // properties. Eagerly throws an error when missing a URL for any snapshot, and warns about all
 // other invalid options which are also scrubbed from the returned migrated options.
 export function validateSnapshotOptions(options) {
-  var _migrated$baseUrl, _migrated$domSnapshot;
+  var _migrated$baseUrl, _migrated$domSnapshot, _migrated$snapshots;
   let log = logger('core:snapshot');
 
   // decide which schema to validate against
   let schema = ['domSnapshot', 'dom-snapshot', 'dom_snapshot'].some(k => k in options) && '/snapshot/dom' || 'url' in options && '/snapshot' || 'sitemap' in options && '/snapshot/sitemap' || 'serve' in options && '/snapshot/server' || 'snapshots' in options && '/snapshot/list' || '/snapshot';
-  let {
-    // normalize, migrate, and remove certain properties from validating
-    clientInfo,
-    environmentInfo,
-    snapshots,
-    ...migrated
-  } = PercyConfig.migrate(options, schema);
+  let _PercyConfig$migrate = PercyConfig.migrate(options, schema),
+    {
+      // normalize, migrate, and remove certain properties from validating
+      clientInfo,
+      environmentInfo,
+      snapshots
+    } = _PercyConfig$migrate,
+    migrated = _objectWithoutProperties(_PercyConfig$migrate, _excluded3);
 
   // maintain a trailing slash for base URLs to normalize them
   if (((_migrated$baseUrl = migrated.baseUrl) === null || _migrated$baseUrl === void 0 ? void 0 : _migrated$baseUrl.endsWith('/')) === false) migrated.baseUrl += '/';
@@ -211,18 +226,18 @@ export function validateSnapshotOptions(options) {
   // add back the snapshots function if there was one
   if (typeof snapshots === 'function') migrated.snapshots = snapshots;
   // add back an empty array if all server snapshots were scrubbed
-  if ('serve' in options && 'snapshots' in options) migrated.snapshots ?? (migrated.snapshots = []);
-  return {
+  if ('serve' in options && 'snapshots' in options) (_migrated$snapshots = migrated.snapshots) !== null && _migrated$snapshots !== void 0 ? _migrated$snapshots : migrated.snapshots = [];
+  return _objectSpread({
     clientInfo,
-    environmentInfo,
-    ...migrated
-  };
+    environmentInfo
+  }, migrated);
 }
 
 // Fetches a sitemap and parses it into a list of URLs for taking snapshots. Duplicate URLs,
 // including a trailing slash, are removed from the resulting list.
 async function getSitemapSnapshots(options) {
   return request(options.sitemap, (body, res) => {
+    var _body$match;
     // validate sitemap content-type
     let [contentType] = res.headers['content-type'].split(';');
     if (!/^(application|text)\/xml$/.test(contentType)) {
@@ -230,7 +245,7 @@ async function getSitemapSnapshots(options) {
     }
 
     // parse XML content into a list of URLs
-    let urls = body.match(/(?<=<loc>)(.*?)(?=<\/loc>)/ig) ?? [];
+    let urls = (_body$match = body.match(/(?<=<loc>)(.*?)(?=<\/loc>)/ig)) !== null && _body$match !== void 0 ? _body$match : [];
 
     // filter out duplicate URLs that differ by a trailing slash
     return urls.filter((url, i) => {
@@ -259,10 +274,7 @@ export async function* gatherSnapshots(options, context) {
   }
 
   // map snapshots with snapshot options
-  snapshots = mapSnapshotOptions(snapshots, {
-    ...options,
-    ...context
-  });
+  snapshots = mapSnapshotOptions(snapshots, _objectSpread(_objectSpread({}, options), context));
   if (!snapshots.length) throw new Error('No snapshots found');
   return snapshots;
 }
@@ -271,15 +283,15 @@ export async function* gatherSnapshots(options, context) {
 // resources are deduplicated by widths, and all other resources are deduplicated by their URL.
 function mergeSnapshotOptions(prev = {}, next) {
   let {
-    resources: oldResources = [],
-    ...existing
-  } = prev;
+      resources: oldResources = []
+    } = prev,
+    existing = _objectWithoutProperties(prev, _excluded4);
   let {
-    resources: newResources = [],
-    widths = [],
-    width,
-    ...incoming
-  } = next;
+      resources: newResources = [],
+      widths = [],
+      width
+    } = next,
+    incoming = _objectWithoutProperties(next, _excluded5);
 
   // prioritize singular widths over mutilple widths
   widths = width ? [width] : widths;
@@ -290,8 +302,7 @@ function mergeSnapshotOptions(prev = {}, next) {
     if (!resource.root && all.some(r => r.url === resource.url)) return all;
     resource.widths = resource.widths.filter(w => !widths.includes(w));
     return all.concat(resource);
-  }, newResources.map(r => ({
-    ...r,
+  }, newResources.map(r => _objectSpread(_objectSpread({}, r), {}, {
     widths
   })));
 
@@ -394,10 +405,11 @@ export function createSnapshotsQueue(percy) {
     return mergeSnapshotOptions(existing, snapshot);
   })
   // send snapshots to be uploaded to the build
-  .handle('task', async function* ({
-    resources,
-    ...snapshot
-  }) {
+  .handle('task', async function* (_ref2) {
+    let {
+        resources
+      } = _ref2,
+      snapshot = _objectWithoutProperties(_ref2, _excluded6);
     let {
       name,
       meta
@@ -410,18 +422,16 @@ export function createSnapshotsQueue(percy) {
     let send = 'tag' in snapshot ? 'sendComparison' : 'sendSnapshot';
     let response = yield percy.client[send](build.id, snapshot);
     if (percy.deferUploads) percy.log.info(`Snapshot uploaded: ${name}`, meta);
-    return {
-      ...snapshot,
+    return _objectSpread(_objectSpread({}, snapshot), {}, {
       response
-    };
+    });
   })
   // handle possible build errors returned by the API
   .handle('error', (snapshot, error) => {
     var _error$response;
-    let result = {
-      ...snapshot,
+    let result = _objectSpread(_objectSpread({}, snapshot), {}, {
       error
-    };
+    });
     let {
       name,
       meta