Initial pass

node_modules/jest-diff/build/constants.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export declare const NO_DIFF_MESSAGE: string;
+export declare const SIMILAR_MESSAGE: string;
+//# sourceMappingURL=constants.d.ts.map

node_modules/jest-diff/build/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,eAAO,MAAM,eAAe,QAE3B,CAAC;AAEF,eAAO,MAAM,eAAe,QAG3B,CAAC"}

node_modules/jest-diff/build/constants.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.SIMILAR_MESSAGE = exports.NO_DIFF_MESSAGE = void 0;
+
+var _chalk = _interopRequireDefault(require('chalk'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const NO_DIFF_MESSAGE = _chalk.default.dim(
+  'Compared values have no visual difference.'
+);
+
+exports.NO_DIFF_MESSAGE = NO_DIFF_MESSAGE;
+
+const SIMILAR_MESSAGE = _chalk.default.dim(
+  'Compared values serialize to the same structure.\n' +
+    'Printing internal object structure without calling `toJSON` instead.'
+);
+
+exports.SIMILAR_MESSAGE = SIMILAR_MESSAGE;

node_modules/jest-diff/build/diffStrings.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { DiffOptions } from './types';
+declare type Original = {
+    a: string;
+    b: string;
+};
+declare const _default: (a: string, b: string, options?: DiffOptions | undefined, original?: Original | undefined) => string;
+export default _default;
+//# sourceMappingURL=diffStrings.d.ts.map

node_modules/jest-diff/build/diffStrings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diffStrings.d.ts","sourceRoot":"","sources":["../src/diffStrings.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,EAAC,WAAW,EAAC,MAAM,SAAS,CAAC;AAIpC,aAAK,QAAQ,GAAG;IACd,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;;AAqRF,wBA6CE"}

node_modules/jest-diff/build/diffStrings.js

@@ -0,0 +1,290 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+var _chalk = _interopRequireDefault(require('chalk'));
+
+var _diffSequences = _interopRequireDefault(require('diff-sequences'));
+
+var _constants = require('./constants');
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const DIFF_CONTEXT_DEFAULT = 5;
+const fgPatchMark = _chalk.default.yellow;
+const fgDelete = _chalk.default.green;
+const fgInsert = _chalk.default.red;
+const fgCommon = _chalk.default.dim; // common lines (even indentation same)
+
+const fgIndent = _chalk.default.cyan; // common lines (only indentation different)
+
+const bgCommon = _chalk.default.bgYellow; // edge spaces in common line (even indentation same)
+
+const bgInverse = _chalk.default.inverse; // edge spaces in any other lines
+// ONLY trailing if expected value is snapshot or multiline string.
+
+const highlightTrailingSpaces = (line, bgColor) =>
+  line.replace(/\s+$/, bgColor('$&')); // BOTH leading AND trailing if expected value is data structure.
+
+const highlightLeadingTrailingSpaces = (
+  line,
+  bgColor // If line consists of ALL spaces: highlight all of them.
+) =>
+  highlightTrailingSpaces(line, bgColor).replace(
+    // If line has an ODD length of leading spaces: highlight only the LAST.
+    /^(\s\s)*(\s)(?=[^\s])/,
+    '$1' + bgColor('$2')
+  );
+
+const getHighlightSpaces = bothEdges =>
+  bothEdges ? highlightLeadingTrailingSpaces : highlightTrailingSpaces;
+
+const getAnnotation = options =>
+  fgDelete('- ' + ((options && options.aAnnotation) || 'Expected')) +
+  '\n' +
+  fgInsert('+ ' + ((options && options.bAnnotation) || 'Received')) +
+  '\n\n';
+
+// Given index interval in expected lines, put formatted delete lines.
+const formatDelete = (aStart, aEnd, aLinesUn, aLinesIn, put) => {
+  const highlightSpaces = getHighlightSpaces(aLinesUn !== aLinesIn);
+
+  for (let aIndex = aStart; aIndex !== aEnd; aIndex += 1) {
+    const aLineUn = aLinesUn[aIndex];
+    const aLineIn = aLinesIn[aIndex];
+    const indentation = aLineIn.slice(0, aLineIn.length - aLineUn.length);
+    put(fgDelete('- ' + indentation + highlightSpaces(aLineUn, bgInverse)));
+  }
+}; // Given index interval in received lines, put formatted insert lines.
+
+const formatInsert = (bStart, bEnd, bLinesUn, bLinesIn, put) => {
+  const highlightSpaces = getHighlightSpaces(bLinesUn !== bLinesIn);
+
+  for (let bIndex = bStart; bIndex !== bEnd; bIndex += 1) {
+    const bLineUn = bLinesUn[bIndex];
+    const bLineIn = bLinesIn[bIndex];
+    const indentation = bLineIn.slice(0, bLineIn.length - bLineUn.length);
+    put(fgInsert('+ ' + indentation + highlightSpaces(bLineUn, bgInverse)));
+  }
+}; // Given the number of items and starting indexes of a common subsequence,
+// put formatted common lines.
+
+const formatCommon = (
+  nCommon,
+  aCommon,
+  bCommon,
+  aLinesIn,
+  bLinesUn,
+  bLinesIn,
+  put
+) => {
+  const highlightSpaces = getHighlightSpaces(bLinesUn !== bLinesIn);
+
+  for (; nCommon !== 0; nCommon -= 1, aCommon += 1, bCommon += 1) {
+    const bLineUn = bLinesUn[bCommon];
+    const bLineIn = bLinesIn[bCommon];
+    const bLineInLength = bLineIn.length; // For common lines, received indentation seems more intuitive.
+
+    const indentation = bLineIn.slice(0, bLineInLength - bLineUn.length); // Color shows whether expected and received line has same indentation.
+
+    const hasSameIndentation = aLinesIn[aCommon].length === bLineInLength;
+    const fg = hasSameIndentation ? fgCommon : fgIndent;
+    const bg = hasSameIndentation ? bgCommon : bgInverse;
+    put(fg('  ' + indentation + highlightSpaces(bLineUn, bg)));
+  }
+}; // jest --expand
+// Return formatted diff as joined string of all lines.
+
+const diffExpand = (aLinesUn, bLinesUn, aLinesIn, bLinesIn) => {
+  const isCommon = (aIndex, bIndex) => aLinesUn[aIndex] === bLinesUn[bIndex];
+
+  const array = [];
+
+  const put = line => {
+    array.push(line);
+  };
+
+  let aStart = 0;
+  let bStart = 0;
+
+  const foundSubsequence = (nCommon, aCommon, bCommon) => {
+    formatDelete(aStart, aCommon, aLinesUn, aLinesIn, put);
+    formatInsert(bStart, bCommon, bLinesUn, bLinesIn, put);
+    formatCommon(nCommon, aCommon, bCommon, aLinesIn, bLinesUn, bLinesIn, put);
+    aStart = aCommon + nCommon;
+    bStart = bCommon + nCommon;
+  };
+
+  const aLength = aLinesUn.length;
+  const bLength = bLinesUn.length;
+  (0, _diffSequences.default)(aLength, bLength, isCommon, foundSubsequence); // After the last common subsequence, format remaining change lines.
+
+  formatDelete(aStart, aLength, aLinesUn, aLinesIn, put);
+  formatInsert(bStart, bLength, bLinesUn, bLinesIn, put);
+  return array.join('\n');
+}; // In GNU diff format, indexes are one-based instead of zero-based.
+
+const createPatchMark = (aStart, aEnd, bStart, bEnd) =>
+  fgPatchMark(
+    `@@ -${aStart + 1},${aEnd - aStart} +${bStart + 1},${bEnd - bStart} @@`
+  );
+
+const getContextLines = options =>
+  options &&
+  typeof options.contextLines === 'number' &&
+  options.contextLines >= 0
+    ? options.contextLines
+    : DIFF_CONTEXT_DEFAULT; // jest --no-expand
+// Return joined string of formatted diff for all change lines,
+// but if some common lines are omitted because there are more than the context,
+// then a “patch mark” precedes each set of adjacent changed and common lines.
+
+const diffNoExpand = (
+  aLinesUn,
+  bLinesUn,
+  aLinesIn,
+  bLinesIn,
+  nContextLines
+) => {
+  const isCommon = (aIndex, bIndex) => aLinesUn[aIndex] === bLinesUn[bIndex];
+
+  let iPatchMark = 0; // index of placeholder line for patch mark
+
+  const array = [''];
+
+  const put = line => {
+    array.push(line);
+  };
+
+  let isAtEnd = false;
+  const aLength = aLinesUn.length;
+  const bLength = bLinesUn.length;
+  const nContextLines2 = nContextLines + nContextLines; // Initialize the first patch for changes at the start,
+  // especially for edge case in which there is no common subsequence.
+
+  let aStart = 0;
+  let aEnd = 0;
+  let bStart = 0;
+  let bEnd = 0; // Given the number of items and starting indexes of each common subsequence,
+  // format any preceding change lines, and then common context lines.
+
+  const foundSubsequence = (nCommon, aStartCommon, bStartCommon) => {
+    const aEndCommon = aStartCommon + nCommon;
+    const bEndCommon = bStartCommon + nCommon;
+    isAtEnd = aEndCommon === aLength && bEndCommon === bLength; // If common subsequence is at start, re-initialize the first patch.
+
+    if (aStartCommon === 0 && bStartCommon === 0) {
+      const nLines = nContextLines < nCommon ? nContextLines : nCommon;
+      aStart = aEndCommon - nLines;
+      bStart = bEndCommon - nLines;
+      formatCommon(nLines, aStart, bStart, aLinesIn, bLinesUn, bLinesIn, put);
+      aEnd = aEndCommon;
+      bEnd = bEndCommon;
+      return;
+    } // Format preceding change lines.
+
+    formatDelete(aEnd, aStartCommon, aLinesUn, aLinesIn, put);
+    formatInsert(bEnd, bStartCommon, bLinesUn, bLinesIn, put);
+    aEnd = aStartCommon;
+    bEnd = bStartCommon; // If common subsequence is at end, then context follows preceding changes;
+    // else context follows preceding changes AND precedes following changes.
+
+    const maxContextLines = isAtEnd ? nContextLines : nContextLines2;
+
+    if (nCommon <= maxContextLines) {
+      // The patch includes all lines in the common subsequence.
+      formatCommon(nCommon, aEnd, bEnd, aLinesIn, bLinesUn, bLinesIn, put);
+      aEnd += nCommon;
+      bEnd += nCommon;
+      return;
+    } // The patch ends because context is less than number of common lines.
+
+    formatCommon(nContextLines, aEnd, bEnd, aLinesIn, bLinesUn, bLinesIn, put);
+    aEnd += nContextLines;
+    bEnd += nContextLines;
+    array[iPatchMark] = createPatchMark(aStart, aEnd, bStart, bEnd); // If common subsequence is not at end, another patch follows it.
+
+    if (!isAtEnd) {
+      iPatchMark = array.length; // index of placeholder line
+
+      array[iPatchMark] = '';
+      const nLines = nContextLines < nCommon ? nContextLines : nCommon;
+      aStart = aEndCommon - nLines;
+      bStart = bEndCommon - nLines;
+      formatCommon(nLines, aStart, bStart, aLinesIn, bLinesUn, bLinesIn, put);
+      aEnd = aEndCommon;
+      bEnd = bEndCommon;
+    }
+  };
+
+  (0, _diffSequences.default)(aLength, bLength, isCommon, foundSubsequence); // If no common subsequence or last was not at end, format remaining change lines.
+
+  if (!isAtEnd) {
+    formatDelete(aEnd, aLength, aLinesUn, aLinesIn, put);
+    formatInsert(bEnd, bLength, bLinesUn, bLinesIn, put);
+    aEnd = aLength;
+    bEnd = bLength;
+  }
+
+  if (aStart === 0 && aEnd === aLength && bStart === 0 && bEnd === bLength) {
+    array.splice(0, 1); // delete placeholder line for patch mark
+  } else {
+    array[iPatchMark] = createPatchMark(aStart, aEnd, bStart, bEnd);
+  }
+
+  return array.join('\n');
+};
+
+var _default = (a, b, options, original) => {
+  if (a === b) {
+    return _constants.NO_DIFF_MESSAGE;
+  }
+
+  let aLinesUn = a.split('\n');
+  let bLinesUn = b.split('\n'); // Indentation is unknown if expected value is snapshot or multiline string.
+
+  let aLinesIn = aLinesUn;
+  let bLinesIn = bLinesUn;
+
+  if (original) {
+    // Indentation is known if expected value is data structure:
+    // Compare lines without indentation and format lines with indentation.
+    aLinesIn = original.a.split('\n');
+    bLinesIn = original.b.split('\n');
+
+    if (
+      aLinesUn.length !== aLinesIn.length ||
+      bLinesUn.length !== bLinesIn.length
+    ) {
+      // Fall back if unindented and indented lines are inconsistent.
+      aLinesUn = aLinesIn;
+      bLinesUn = bLinesIn;
+    }
+  }
+
+  return (
+    getAnnotation(options) +
+    (options && options.expand === false
+      ? diffNoExpand(
+          aLinesUn,
+          bLinesUn,
+          aLinesIn,
+          bLinesIn,
+          getContextLines(options)
+        )
+      : diffExpand(aLinesUn, bLinesUn, aLinesIn, bLinesIn))
+  );
+};
+
+exports.default = _default;

node_modules/jest-diff/build/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { DiffOptions as JestDiffOptions } from './types';
+declare function diff(a: any, b: any, options?: JestDiffOptions): string | null;
+declare namespace diff {
+    type DiffOptions = JestDiffOptions;
+}
+export = diff;
+//# sourceMappingURL=index.d.ts.map

node_modules/jest-diff/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,OAAO,EAAC,WAAW,IAAI,eAAe,EAAC,MAAM,SAAS,CAAC;AAgCvD,iBAAS,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,MAAM,GAAG,IAAI,CAgDtE;AAiED,kBAAU,IAAI,CAAC;IACb,KAAY,WAAW,GAAG,eAAe,CAAC;CAC3C;AAED,SAAS,IAAI,CAAC"}

node_modules/jest-diff/build/index.js

@@ -0,0 +1,196 @@
+'use strict';
+
+var _prettyFormat = _interopRequireDefault(require('pretty-format'));
+
+var _chalk = _interopRequireDefault(require('chalk'));
+
+var _jestGetType = _interopRequireDefault(require('jest-get-type'));
+
+var _diffStrings = _interopRequireDefault(require('./diffStrings'));
+
+var _constants = require('./constants');
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+
+function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    var ownKeys = Object.keys(source);
+    if (typeof Object.getOwnPropertySymbols === 'function') {
+      ownKeys = ownKeys.concat(
+        Object.getOwnPropertySymbols(source).filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        })
+      );
+    }
+    ownKeys.forEach(function(key) {
+      _defineProperty(target, key, source[key]);
+    });
+  }
+  return target;
+}
+
+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;
+}
+
+const _prettyFormat$plugins = _prettyFormat.default.plugins,
+  AsymmetricMatcher = _prettyFormat$plugins.AsymmetricMatcher,
+  DOMCollection = _prettyFormat$plugins.DOMCollection,
+  DOMElement = _prettyFormat$plugins.DOMElement,
+  Immutable = _prettyFormat$plugins.Immutable,
+  ReactElement = _prettyFormat$plugins.ReactElement,
+  ReactTestComponent = _prettyFormat$plugins.ReactTestComponent;
+const PLUGINS = [
+  ReactTestComponent,
+  ReactElement,
+  DOMElement,
+  DOMCollection,
+  Immutable,
+  AsymmetricMatcher
+];
+const FORMAT_OPTIONS = {
+  plugins: PLUGINS
+};
+
+const FORMAT_OPTIONS_0 = _objectSpread({}, FORMAT_OPTIONS, {
+  indent: 0
+});
+
+const FALLBACK_FORMAT_OPTIONS = {
+  callToJSON: false,
+  maxDepth: 10,
+  plugins: PLUGINS
+};
+
+const FALLBACK_FORMAT_OPTIONS_0 = _objectSpread({}, FALLBACK_FORMAT_OPTIONS, {
+  indent: 0
+}); // Generate a string that will highlight the difference between two values
+// with green and red. (similar to how github does code diffing)
+
+function diff(a, b, options) {
+  if (Object.is(a, b)) {
+    return _constants.NO_DIFF_MESSAGE;
+  }
+
+  const aType = (0, _jestGetType.default)(a);
+  let expectedType = aType;
+  let omitDifference = false;
+
+  if (aType === 'object' && typeof a.asymmetricMatch === 'function') {
+    if (a.$$typeof !== Symbol.for('jest.asymmetricMatcher')) {
+      // Do not know expected type of user-defined asymmetric matcher.
+      return null;
+    }
+
+    if (typeof a.getExpectedType !== 'function') {
+      // For example, expect.anything() matches either null or undefined
+      return null;
+    }
+
+    expectedType = a.getExpectedType(); // Primitive types boolean and number omit difference below.
+    // For example, omit difference for expect.stringMatching(regexp)
+
+    omitDifference = expectedType === 'string';
+  }
+
+  if (expectedType !== (0, _jestGetType.default)(b)) {
+    return (
+      '  Comparing two different types of values.' +
+      ` Expected ${_chalk.default.green(expectedType)} but ` +
+      `received ${_chalk.default.red((0, _jestGetType.default)(b))}.`
+    );
+  }
+
+  if (omitDifference) {
+    return null;
+  }
+
+  switch (aType) {
+    case 'string':
+      return (0, _diffStrings.default)(a, b, options);
+
+    case 'boolean':
+    case 'number':
+      return comparePrimitive(a, b, options);
+
+    case 'map':
+      return compareObjects(sortMap(a), sortMap(b), options);
+
+    case 'set':
+      return compareObjects(sortSet(a), sortSet(b), options);
+
+    default:
+      return compareObjects(a, b, options);
+  }
+}
+
+function comparePrimitive(a, b, options) {
+  return (0, _diffStrings.default)(
+    (0, _prettyFormat.default)(a, FORMAT_OPTIONS),
+    (0, _prettyFormat.default)(b, FORMAT_OPTIONS),
+    options
+  );
+}
+
+function sortMap(map) {
+  return new Map(Array.from(map.entries()).sort());
+}
+
+function sortSet(set) {
+  return new Set(Array.from(set.values()).sort());
+}
+
+function compareObjects(a, b, options) {
+  let diffMessage;
+  let hasThrown = false;
+
+  try {
+    diffMessage = (0, _diffStrings.default)(
+      (0, _prettyFormat.default)(a, FORMAT_OPTIONS_0),
+      (0, _prettyFormat.default)(b, FORMAT_OPTIONS_0),
+      options,
+      {
+        a: (0, _prettyFormat.default)(a, FORMAT_OPTIONS),
+        b: (0, _prettyFormat.default)(b, FORMAT_OPTIONS)
+      }
+    );
+  } catch (e) {
+    hasThrown = true;
+  } // If the comparison yields no results, compare again but this time
+  // without calling `toJSON`. It's also possible that toJSON might throw.
+
+  if (!diffMessage || diffMessage === _constants.NO_DIFF_MESSAGE) {
+    diffMessage = (0, _diffStrings.default)(
+      (0, _prettyFormat.default)(a, FALLBACK_FORMAT_OPTIONS_0),
+      (0, _prettyFormat.default)(b, FALLBACK_FORMAT_OPTIONS_0),
+      options,
+      {
+        a: (0, _prettyFormat.default)(a, FALLBACK_FORMAT_OPTIONS),
+        b: (0, _prettyFormat.default)(b, FALLBACK_FORMAT_OPTIONS)
+      }
+    );
+
+    if (diffMessage !== _constants.NO_DIFF_MESSAGE && !hasThrown) {
+      diffMessage = _constants.SIMILAR_MESSAGE + '\n\n' + diffMessage;
+    }
+  }
+
+  return diffMessage;
+} // eslint-disable-next-line no-redeclare
+
+module.exports = diff;

node_modules/jest-diff/build/types.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export declare type DiffOptions = {
+    aAnnotation?: string;
+    bAnnotation?: string;
+    expand?: boolean;
+    contextLines?: number;
+};
+//# sourceMappingURL=types.d.ts.map

node_modules/jest-diff/build/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,oBAAY,WAAW,GAAG;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC"}

node_modules/jest-diff/build/types.js

@@ -0,0 +1 @@
+'use strict';