vitest 0.12.8 → 0.13.0

package/dist/{chunk-api-setup.9ccd19b5.js → chunk-api-setup.554e8dcb.js}

@@ -1,5 +1,5 @@
 import { promises } from 'fs';
-import { c as createBirpc } from './chunk-vite-node-utils.46e2a803.js';
+import { c as createBirpc } from './chunk-vite-node-utils.6856b365.js';
 import require$$0$1 from 'stream';
 import require$$0 from 'zlib';
 import require$$3 from 'net';
@@ -9,11 +9,11 @@ import require$$2 from 'events';
 import require$$1 from 'https';
 import require$$2$1 from 'http';
 import url from 'url';
-import { A as API_PATH } from './chunk-constants.3570739f.js';
-import { r as interpretSourcePos, b as parseStacktrace } from './chunk-utils-timers.da6ac0a6.js';
+import { A as API_PATH } from './chunk-constants.d60bb984.js';
+import { j as interpretSourcePos, b as parseStacktrace } from './chunk-utils-source-map.ded50c88.js';
 import 'module';
 import 'vm';
-import './chunk-utils-global.2fab7e5c.js';
+import './chunk-utils-global.b9f8edf8.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
@@ -3268,6 +3268,7 @@ function initAsClient(websocket, address, protocols, options) {
 
   if (opts.followRedirects) {
     if (websocket._redirects === 0) {
+      websocket._originalSecure = isSecure;
       websocket._originalHost = parsedUrl.host;
 
       const headers = options && options.headers;
@@ -3283,18 +3284,21 @@ function initAsClient(websocket, address, protocols, options) {
           options.headers[key.toLowerCase()] = value;
         }
       }
-    } else if (
-      websocket.listenerCount('redirect') === 0 &&
-      parsedUrl.host !== websocket._originalHost
-    ) {
-      //
-      // Match curl 7.77.0 behavior and drop the following headers. These
-      // headers are also dropped when following a redirect to a subdomain.
-      //
-      delete opts.headers.authorization;
-      delete opts.headers.cookie;
-      delete opts.headers.host;
-      opts.auth = undefined;
+    } else if (websocket.listenerCount('redirect') === 0) {
+      const isSameHost = parsedUrl.host === websocket._originalHost;
+
+      if (!isSameHost || (websocket._originalSecure && !isSecure)) {
+        //
+        // Match curl 7.77.0 behavior and drop the following headers. These
+        // headers are also dropped when following a redirect to a subdomain.
+        //
+        delete opts.headers.authorization;
+        delete opts.headers.cookie;
+
+        if (!isSameHost) delete opts.headers.host;
+
+        opts.auth = undefined;
+      }
     }
 
     //
@@ -3386,6 +3390,11 @@ function initAsClient(websocket, address, protocols, options) {
 
     req = websocket._req = null;
 
+    if (res.headers.upgrade.toLowerCase() !== 'websocket') {
+      abortHandshake$1(websocket, socket, 'Invalid Upgrade header');
+      return;
+    }
+
     const digest = createHash$1('sha1')
       .update(key + GUID$1)
       .digest('base64');
@@ -4071,21 +4080,36 @@ class WebSocketServer extends EventEmitter {
   handleUpgrade(req, socket, head, cb) {
     socket.on('error', socketOnError);
 
-    const key =
-      req.headers['sec-websocket-key'] !== undefined
-        ? req.headers['sec-websocket-key']
-        : false;
+    const key = req.headers['sec-websocket-key'];
     const version = +req.headers['sec-websocket-version'];
 
-    if (
-      req.method !== 'GET' ||
-      req.headers.upgrade.toLowerCase() !== 'websocket' ||
-      !key ||
-      !keyRegex.test(key) ||
-      (version !== 8 && version !== 13) ||
-      !this.shouldHandle(req)
-    ) {
-      return abortHandshake(socket, 400);
+    if (req.method !== 'GET') {
+      const message = 'Invalid HTTP method';
+      abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
+      return;
+    }
+
+    if (req.headers.upgrade.toLowerCase() !== 'websocket') {
+      const message = 'Invalid Upgrade header';
+      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+      return;
+    }
+
+    if (!key || !keyRegex.test(key)) {
+      const message = 'Missing or invalid Sec-WebSocket-Key header';
+      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+      return;
+    }
+
+    if (version !== 8 && version !== 13) {
+      const message = 'Missing or invalid Sec-WebSocket-Version header';
+      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+      return;
+    }
+
+    if (!this.shouldHandle(req)) {
+      abortHandshake(socket, 400);
+      return;
     }
 
     const secWebSocketProtocol = req.headers['sec-websocket-protocol'];
@@ -4095,7 +4119,9 @@ class WebSocketServer extends EventEmitter {
       try {
         protocols = subprotocol.parse(secWebSocketProtocol);
       } catch (err) {
-        return abortHandshake(socket, 400);
+        const message = 'Invalid Sec-WebSocket-Protocol header';
+        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+        return;
       }
     }
 
@@ -4120,7 +4146,10 @@ class WebSocketServer extends EventEmitter {
           extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
         }
       } catch (err) {
-        return abortHandshake(socket, 400);
+        const message =
+          'Invalid or unacceptable Sec-WebSocket-Extensions header';
+        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+        return;
       }
     }
 
@@ -4287,7 +4316,7 @@ function emitClose(server) {
 }
 
 /**
- * Handle premature socket errors.
+ * Handle socket errors.
  *
  * @private
  */
@@ -4305,27 +4334,54 @@ function socketOnError() {
  * @private
  */
 function abortHandshake(socket, code, message, headers) {
-  if (socket.writable) {
-    message = message || http.STATUS_CODES[code];
-    headers = {
-      Connection: 'close',
-      'Content-Type': 'text/html',
-      'Content-Length': Buffer.byteLength(message),
-      ...headers
-    };
+  //
+  // The socket is writable unless the user destroyed or ended it before calling
+  // `server.handleUpgrade()` or in the `verifyClient` function, which is a user
+  // error. Handling this does not make much sense as the worst that can happen
+  // is that some of the data written by the user might be discarded due to the
+  // call to `socket.end()` below, which triggers an `'error'` event that in
+  // turn causes the socket to be destroyed.
+  //
+  message = message || http.STATUS_CODES[code];
+  headers = {
+    Connection: 'close',
+    'Content-Type': 'text/html',
+    'Content-Length': Buffer.byteLength(message),
+    ...headers
+  };
 
-    socket.write(
-      `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r\n` +
-        Object.keys(headers)
-          .map((h) => `${h}: ${headers[h]}`)
-          .join('\r\n') +
-        '\r\n\r\n' +
-        message
-    );
-  }
+  socket.once('finish', socket.destroy);
 
-  socket.removeListener('error', socketOnError);
-  socket.destroy();
+  socket.end(
+    `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r\n` +
+      Object.keys(headers)
+        .map((h) => `${h}: ${headers[h]}`)
+        .join('\r\n') +
+      '\r\n\r\n' +
+      message
+  );
+}
+
+/**
+ * Emit a `'wsClientError'` event on a `WebSocketServer` if there is at least
+ * one listener for it, otherwise call `abortHandshake()`.
+ *
+ * @param {WebSocketServer} server The WebSocket server
+ * @param {http.IncomingMessage} req The request object
+ * @param {(net.Socket|tls.Socket)} socket The socket of the upgrade request
+ * @param {Number} code The HTTP response status code
+ * @param {String} message The HTTP response body
+ * @private
+ */
+function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
+  if (server.listenerCount('wsClientError')) {
+    const err = new Error(message);
+    Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
+
+    server.emit('wsClientError', err, socket, req);
+  } else {
+    abortHandshake(socket, code, message);
+  }
 }
 
 function setup(ctx) {

package/dist/{chunk-constants.3570739f.js → chunk-constants.d60bb984.js}

@@ -1,5 +1,5 @@
 import { fileURLToPath } from 'url';
-import { h as resolve } from './chunk-utils-global.2fab7e5c.js';
+import { l as resolve } from './chunk-utils-global.b9f8edf8.js';
 
 const distDir = resolve(fileURLToPath(import.meta.url), "../../dist");
 const defaultPort = 51204;

package/dist/{chunk-defaults.7d81a6ca.js → chunk-defaults.c11f632f.js}

@@ -1,7 +1,7 @@
 import { existsSync, promises } from 'fs';
 import { createRequire } from 'module';
 import { pathToFileURL } from 'url';
-import { t as toArray, h as resolve } from './chunk-utils-global.2fab7e5c.js';
+import { t as toArray, l as resolve } from './chunk-utils-global.b9f8edf8.js';
 
 const defaultInclude = ["**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"];
 const defaultExclude = ["**/node_modules/**", "**/dist/**", "**/cypress/**", "**/.{idea,git,cache,output,temp}/**"];

package/dist/{chunk-install-pkg.fd8d1022.js → chunk-install-pkg.8a034cf6.js}

@@ -2,7 +2,7 @@ import path$2 from 'path';
 import fs$2 from 'fs';
 import require$$0 from 'util';
 import childProcess$1 from 'child_process';
-import { p as pathKey, s as signalExit, m as mergeStream$1, g as getStream$1, c as crossSpawn$1, o as onetime$1 } from './vendor-index.6c69a0a8.js';
+import { p as pathKey, s as signalExit, m as mergeStream$1, g as getStream$1, c as crossSpawn$1, o as onetime$1 } from './vendor-index.42fcc02c.js';
 import require$$0$1 from 'os';
 import './vendor-_commonjsHelpers.addc3445.js';
 import 'assert';

package/dist/{chunk-integrations-globals.23cc66c3.js → chunk-integrations-globals.f7036c09.js}

@@ -1,20 +1,20 @@
-import { g as globalApis } from './chunk-constants.3570739f.js';
-import { i as index } from './vendor-entry.ca05c118.js';
+import { g as globalApis } from './chunk-constants.d60bb984.js';
+import { i as index } from './vendor-entry.6072d652.js';
 import 'url';
-import './chunk-utils-global.2fab7e5c.js';
+import './chunk-utils-global.b9f8edf8.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
 import 'fs';
-import './chunk-runtime-chain.5021a6b6.js';
+import './chunk-runtime-chain.db87de48.js';
 import 'chai';
 import './vendor-_commonjsHelpers.addc3445.js';
-import './chunk-runtime-rpc.47bae3f9.js';
-import './chunk-utils-timers.da6ac0a6.js';
+import './chunk-runtime-rpc.6e6614a9.js';
+import './chunk-utils-source-map.ded50c88.js';
 import './chunk-integrations-spy.bee66426.js';
 import 'tinyspy';
 import 'util';
-import './chunk-defaults.7d81a6ca.js';
+import './chunk-defaults.c11f632f.js';
 import 'module';
 
 function registerApiGlobally() {

package/dist/{chunk-runtime-chain.5021a6b6.js → chunk-runtime-chain.db87de48.js}

@@ -1,9 +1,9 @@
 import chai$1, { expect as expect$1, AssertionError, util } from 'chai';
 import { c as commonjsGlobal } from './vendor-_commonjsHelpers.addc3445.js';
-import { r as rpc } from './chunk-runtime-rpc.47bae3f9.js';
-import { i as isObject, j as join, d as dirname, g as getCallLastIndex, s as slash, a as getWorkerState, b as getNames, c as assertTypes, p as picocolors, n as noop, t as toArray, r as resetModules } from './chunk-utils-global.2fab7e5c.js';
+import { r as rpc } from './chunk-runtime-rpc.6e6614a9.js';
+import { i as isObject, j as join, d as dirname, g as getCallLastIndex, s as slash, a as getWorkerState, b as getNames, c as assertTypes, p as picocolors, e as safeSetTimeout, f as safeClearTimeout, n as noop, t as toArray, r as resetModules } from './chunk-utils-global.b9f8edf8.js';
 import fs, { promises } from 'fs';
-import { p as plugins_1, f as format_1, g as getOriginalPos, a as posToNumber, n as numberToPos, l as lineSplitRE, b as parseStacktrace, u as unifiedDiff, s as stringify, m as matcherUtils, c as setTimeout, d as clearTimeout } from './chunk-utils-timers.da6ac0a6.js';
+import { p as plugins_1, f as format_1, g as getOriginalPos, a as posToNumber, n as numberToPos, l as lineSplitRE, b as parseStacktrace, u as unifiedDiff, s as stringify, m as matcherUtils } from './chunk-utils-source-map.ded50c88.js';
 import { i as isMockFunction, s as spyOn, f as fn, a as spies } from './chunk-integrations-spy.bee66426.js';
 import require$$0, { format } from 'util';
 
@@ -329,7 +329,7 @@ const hasPropertyInObject = (object, key) => {
     return false;
   return Object.prototype.hasOwnProperty.call(object, key) || hasPropertyInObject(Object.getPrototypeOf(object), key);
 };
-const isObjectWithKeys = (a) => isObject(a) && !(a instanceof Error) && !(a instanceof Array) && !(a instanceof Date);
+const isObjectWithKeys = (a) => isObject(a) && !(a instanceof Error) && !Array.isArray(a) && !(a instanceof Date);
 const subsetEquality = (object, subset) => {
   const subsetEqualityWithContext = (seenReferences = /* @__PURE__ */ new WeakMap()) => (object2, subset2) => {
     if (!isObjectWithKeys(subset2))
@@ -1223,7 +1223,7 @@ const JestChaiExpect = (chai, utils) => {
     } else if (received === -Infinity && expected === -Infinity) {
       pass = true;
     } else {
-      expectedDiff = Math.pow(10, -precision) / 2;
+      expectedDiff = 10 ** -precision / 2;
       receivedDiff = Math.abs(expected - received);
       pass = receivedDiff < expectedDiff;
     }
@@ -1406,8 +1406,8 @@ Number of calls: ${picocolors.exports.bold(spy.mock.calls.length)}
     const nthCallReturn = equals(callResult, value);
     this.assert(nthCallReturn, `expected ${ordinalCall} "${spyName}" call to return #{exp}`, `expected ${ordinalCall} "${spyName}" call to not return #{exp}`, value, callResult);
   });
-  def("toSatisfy", function() {
-    return this.be.satisfy;
+  def("toSatisfy", function(matcher, message) {
+    return this.be.satisfy(matcher, message);
   });
   utils.addProperty(chai.Assertion.prototype, "resolves", function __VITEST_RESOLVES__() {
     utils.flag(this, "promise", "resolves");
@@ -1717,7 +1717,8 @@ const getMatcherState = (assertion) => {
     utils: jestUtils,
     promise,
     equals,
-    suppressedErrors: []
+    suppressedErrors: [],
+    snapshotState: getSnapshotClient().snapshotState
   });
   return {
     state: matcherState,
@@ -1838,8 +1839,8 @@ function withTimeout(fn, timeout = getDefaultTestTimeout(), isHook = false) {
   return (...args) => {
     return Promise.race([fn(...args), new Promise((resolve, reject) => {
       var _a;
-      const timer = setTimeout(() => {
-        clearTimeout(timer);
+      const timer = safeSetTimeout(() => {
+        safeClearTimeout(timer);
         reject(new Error(makeTimeoutMsg(isHook, timeout)));
       }, timeout);
       (_a = timer.unref) == null ? void 0 : _a.call(timer);
@@ -4850,6 +4851,16 @@ class VitestUtils {
     resetModules();
     return this;
   }
+  async dynamicImportSettled() {
+    const state = getWorkerState();
+    const promises = [];
+    for (const mod of state.moduleCache.values()) {
+      if (mod.promise)
+        promises.push(mod.promise);
+    }
+    await Promise.allSettled(promises);
+    await new Promise((resolve) => safeSetTimeout(resolve, 1)).then(() => Promise.resolve());
+  }
 }
 const vitest = new VitestUtils();
 const vi = vitest;

package/dist/{chunk-runtime-mocker.d26f8110.js → chunk-runtime-mocker.8436db18.js}

@@ -1,8 +1,8 @@
-import { n as normalizeRequestId, i as isNodeBuiltin, t as toFilePath, V as ViteNodeRunner } from './chunk-vite-node-utils.46e2a803.js';
+import { n as normalizeRequestId, i as isNodeBuiltin, t as toFilePath, V as ViteNodeRunner } from './chunk-vite-node-utils.6856b365.js';
 import { normalizePath } from 'vite';
-import { a as getWorkerState, D as isWindows, E as mergeSlashes, d as dirname, h as resolve, f as basename, F as getType, G as getAllProperties, s as slash } from './chunk-utils-global.2fab7e5c.js';
+import { a as getWorkerState, J as isWindows, K as mergeSlashes, d as dirname, l as resolve, k as basename, L as getType, M as getAllProperties, s as slash } from './chunk-utils-global.b9f8edf8.js';
 import { existsSync, readdirSync } from 'fs';
-import { d as distDir } from './chunk-constants.3570739f.js';
+import { d as distDir } from './chunk-constants.d60bb984.js';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;

package/dist/chunk-runtime-rpc.6e6614a9.js

@@ -0,0 +1,15 @@
+import { a as getWorkerState, w as withSafeTimers } from './chunk-utils-global.b9f8edf8.js';
+
+const rpc = () => {
+  const { rpc: rpc2 } = getWorkerState();
+  return new Proxy(rpc2, {
+    get(target, p, handler) {
+      const sendCall = Reflect.get(target, p, handler);
+      const safeSendCall = (...args) => withSafeTimers(() => sendCall(...args));
+      safeSendCall.asEvent = sendCall.asEvent;
+      return safeSendCall;
+    }
+  });
+};
+
+export { rpc as r };

package/dist/{chunk-utils-global.2fab7e5c.js → chunk-utils-global.b9f8edf8.js}

@@ -385,6 +385,32 @@ function getNames(task) {
   return names;
 }
 
+const {
+  setTimeout: safeSetTimeout,
+  setInterval: safeSetInterval,
+  clearInterval: safeClearInterval,
+  clearTimeout: safeClearTimeout
+} = globalThis;
+function withSafeTimers(fn) {
+  const currentSetTimeout = globalThis.setTimeout;
+  const currentSetInterval = globalThis.setInterval;
+  const currentClearInterval = globalThis.clearInterval;
+  const currentClearTimeout = globalThis.clearTimeout;
+  try {
+    globalThis.setTimeout = safeSetTimeout;
+    globalThis.setInterval = safeSetInterval;
+    globalThis.clearInterval = safeClearInterval;
+    globalThis.clearTimeout = safeClearTimeout;
+    const result = fn();
+    return result;
+  } finally {
+    globalThis.setTimeout = currentSetTimeout;
+    globalThis.setInterval = currentSetInterval;
+    globalThis.clearInterval = currentClearInterval;
+    globalThis.clearTimeout = currentClearTimeout;
+  }
+}
+
 const isNode = typeof process !== "undefined" && typeof process.platform !== "undefined";
 const isWindows = isNode && process.platform === "win32";
 function partitionSuiteChildren(suite) {
@@ -433,7 +459,7 @@ async function ensurePackageInstalled(dependency, promptInstall = !process.env.C
     message: picocolors.exports.reset(`Do you want to install ${picocolors.exports.green(dependency)}?`)
   });
   if (install) {
-    await (await import('./chunk-install-pkg.fd8d1022.js')).installPackage(dependency, { dev: true });
+    await (await import('./chunk-install-pkg.8a034cf6.js')).installPackage(dependency, { dev: true });
     process.stderr.write(picocolors.exports.yellow(`
 Package ${dependency} installed, re-run the command to start.
 `));
@@ -470,5 +496,11 @@ function getCallLastIndex(code) {
   }
   return null;
 }
+class AggregateErrorPonyfill extends Error {
+  constructor(errors, message = "") {
+    super(message);
+    this.errors = [...errors];
+  }
+}
 
-export { ensurePackageInstalled as A, stdout as B, extname as C, isWindows as D, mergeSlashes as E, getType as F, getAllProperties as G, clone as H, partitionSuiteChildren as I, hasTests as J, getWorkerState as a, getNames as b, assertTypes as c, dirname as d, notNullish as e, basename as f, getCallLastIndex as g, resolve as h, isObject as i, join as j, isAbsolute as k, relative as l, isNode as m, noop as n, getTests as o, picocolors as p, getFullName as q, resetModules as r, slash as s, toArray as t, hasFailed as u, hasFailedSnapshot as v, getSuites as w, normalize as x, deepMerge as y, toNamespacedPath as z };
+export { AggregateErrorPonyfill as A, safeSetInterval as B, safeClearInterval as C, normalize as D, deepMerge as E, toNamespacedPath as F, ensurePackageInstalled as G, stdout as H, extname as I, isWindows as J, mergeSlashes as K, getType as L, getAllProperties as M, clone as N, partitionSuiteChildren as O, hasTests as P, getWorkerState as a, getNames as b, assertTypes as c, dirname as d, safeSetTimeout as e, safeClearTimeout as f, getCallLastIndex as g, notNullish as h, isObject as i, join as j, basename as k, resolve as l, isAbsolute as m, noop as n, relative as o, picocolors as p, isNode as q, resetModules as r, slash as s, toArray as t, getTests as u, getFullName as v, withSafeTimers as w, hasFailed as x, hasFailedSnapshot as y, getSuites as z };

package/dist/{chunk-utils-timers.da6ac0a6.js → chunk-utils-source-map.ded50c88.js}

@@ -1,9 +1,4 @@
-import { s as slash, e as notNullish, p as picocolors } from './chunk-utils-global.2fab7e5c.js';
-
-const setTimeout$1 = globalThis.setTimeout;
-const setInterval = globalThis.setInterval;
-const clearInterval = globalThis.clearInterval;
-const clearTimeout = globalThis.clearTimeout;
+import { s as slash, h as notNullish, p as picocolors } from './chunk-utils-global.b9f8edf8.js';
 
 var build = {};
 
@@ -5765,6 +5760,11 @@ Diff.prototype = {
         oldLen = oldString.length;
     var editLength = 1;
     var maxEditLength = newLen + oldLen;
+
+    if (options.maxEditLength) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+
     var bestPath = [{
       newPos: -1,
       components: []
@@ -5829,15 +5829,13 @@ Diff.prototype = {
       editLength++;
     } // Performs the length of edit iteration. Is a bit fugly as this has to support the
     // sync and async mode which is never fun. Loops over execEditLength until a value
-    // is produced.
+    // is produced, or until the edit length exceeds options.maxEditLength (if given),
+    // in which case it will return undefined.
 
 
     if (callback) {
       (function exec() {
         setTimeout(function () {
-          // This should not happen, but we want to be safe.
-
-          /* istanbul ignore next */
           if (editLength > maxEditLength) {
             return callback();
           }
@@ -6236,6 +6234,11 @@ function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, ne
   }
 
   var diff = diffLines(oldStr, newStr, options);
+
+  if (!diff) {
+    return;
+  }
+
   diff.push({
     value: '',
     lines: []
@@ -7425,4 +7428,4 @@ var matcherUtils = /*#__PURE__*/Object.freeze({
 	diff: diff
 });
 
-export { posToNumber as a, parseStacktrace as b, setTimeout$1 as c, clearTimeout as d, stripAnsi as e, format_1 as f, getOriginalPos as g, stringWidth as h, ansiStyles as i, sliceAnsi as j, setInterval as k, lineSplitRE as l, matcherUtils as m, numberToPos as n, clearInterval as o, plugins_1 as p, cliTruncate as q, interpretSourcePos as r, stringify as s, unifiedDiff as u };
+export { posToNumber as a, parseStacktrace as b, stripAnsi as c, stringWidth as d, ansiStyles as e, format_1 as f, getOriginalPos as g, sliceAnsi as h, cliTruncate as i, interpretSourcePos as j, lineSplitRE as l, matcherUtils as m, numberToPos as n, plugins_1 as p, stringify as s, unifiedDiff as u };