text: 'use strict';
  
  
  
  
  
  
  
  
  
  
  
  
  var _fs = require('fs');var _fs2 = _interopRequireDefault(_fs);
  var _path = require('path');var _path2 = _interopRequireDefault(_path);
  var _jestDiff = require('jest-diff');var _jestDiff2 = _interopRequireDefault(_jestDiff);
  var _jestMatcherUtils = require('jest-matcher-utils');
  var _State = require('./State');var _State2 = _interopRequireDefault(_State);
  var _plugins = require('./plugins');
  var _utils = require('./utils');var utils = _interopRequireWildcard(_utils);function _interopRequireWildcard(obj) {if (obj && obj.__esModule) {return obj;} else {var newObj = {};if (obj != null) {for (var key in obj) {if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];}}newObj.default = obj;return newObj;}}function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { default: obj };} /**
                                                                                                                                                                                                                                                                                                                                                                                                                                             * Copyright (c) 2014-present, Facebook, Inc. 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 fileExists = (filePath, hasteFS) => hasteFS.exists(filePath) || _fs2.default.existsSync(filePath);const cleanup = (hasteFS, update) => {const pattern = '\\.' + utils.SNAPSHOT_EXTENSION + '$';const files = hasteFS.matchFiles(pattern);
    const filesRemoved = files.
    filter(
    snapshotFile =>
    !fileExists(
    _path2.default.resolve(
    _path2.default.dirname(snapshotFile),
    '..',
    _path2.default.basename(snapshotFile, '.' + utils.SNAPSHOT_EXTENSION)),
  
    hasteFS)).
  
  
    map(snapshotFile => {
      if (update === 'all') {
        _fs2.default.unlinkSync(snapshotFile);
      }
    }).length;
  
    return {
      filesRemoved };
  
  };
  
  const toMatchSnapshot = function (received, testName) {
    this.dontThrow && this.dontThrow();const
  
    currentTestName = this.currentTestName,isNot = this.isNot,snapshotState = this.snapshotState;
  
    if (isNot) {
      throw new Error('Jest: `.not` cannot be used with `.toMatchSnapshot()`.');
    }
  
    if (!snapshotState) {
      throw new Error('Jest: snapshot state must be initialized.');
    }
  
    const result = snapshotState.match(
    testName && currentTestName ?
    `${currentTestName}: ${testName}` :
    currentTestName || '',
    received);const
  
    count = result.count,pass = result.pass;let
    actual = result.actual,expected = result.expected;
  
    let report;
    if (pass) {
      return { message: () => '', pass: true };
    } else if (!expected) {
      report = () =>
      `New snapshot was ${(0, _jestMatcherUtils.RECEIVED_COLOR)('not written')}. The update flag ` +
      `must be explicitly passed to write a new snapshot.\n\n` +
      `This is likely because this test is run in a continuous integration ` +
      `(CI) environment in which snapshots are not written by default.\n\n` +
      `${(0, _jestMatcherUtils.RECEIVED_COLOR)('Received value')}` +
      `${actual}`;
    } else {
      expected = (expected || '').trim();
      actual = (actual || '').trim();
      const diffMessage = (0, _jestDiff2.default)(expected, actual, {
        aAnnotation: 'Snapshot',
        bAnnotation: 'Received',
        expand: snapshotState.expand });
  
  
      report = () =>
      `${(0, _jestMatcherUtils.RECEIVED_COLOR)('Received value')} does not match ` +
      `${(0, _jestMatcherUtils.EXPECTED_COLOR)('stored snapshot ' + count)}.\n\n` + (
      diffMessage ||
      (0, _jestMatcherUtils.EXPECTED_COLOR)('- ' + (expected || '')) +
      '\n' +
      (0, _jestMatcherUtils.RECEIVED_COLOR)('+ ' + actual));
    }
    // Passing the the actual and expected objects so that a custom reporter
    // could access them, for example in order to display a custom visual diff,
    // or create a different error message
    return {
      actual,
      expected,
      message: () =>
      (0, _jestMatcherUtils.matcherHint)('.toMatchSnapshot', 'value', '') + '\n\n' + report(),
      name: 'toMatchSnapshot',
      pass: false,
      report };
  
  };
  
  const toThrowErrorMatchingSnapshot = function (
  received,
  testName,
  fromPromise)
  {
    this.dontThrow && this.dontThrow();const
  
    isNot = this.isNot;
  
    if (isNot) {
      throw new Error(
      'Jest: `.not` cannot be used with `.toThrowErrorMatchingSnapshot()`.');
  
    }
  
    let error;
  
    if (fromPromise) {
      error = received;
    } else {
      try {
        received();
      } catch (e) {
        error = e;
      }
    }
  
    if (error === undefined) {
      throw new Error(
      (0, _jestMatcherUtils.matcherHint)('.toThrowErrorMatchingSnapshot', '() => {}', '') +
      '\n\n' +
      `Expected the function to throw an error.\n` +
      `But it didn't throw anything.`);
  
    }
  
    return toMatchSnapshot.call(this, error.message, testName);
  };
  
  module.exports = {
    EXTENSION: utils.SNAPSHOT_EXTENSION,
    SnapshotState: _State2.default,
    addSerializer: _plugins.addSerializer,
    cleanup,
    getSerializers: _plugins.getSerializers,
    toMatchSnapshot,
    toThrowErrorMatchingSnapshot,
    utils };