install-nix-action/node_modules/jest-serializer/build/index.js

'use strict';

Object.defineProperty(exports, '__esModule', {
  value: true
});
exports.deserialize = deserialize;
exports.serialize = serialize;
exports.readFileSync = readFileSync;
exports.writeFileSync = writeFileSync;
exports.default = void 0;

function _fs() {
  const data = _interopRequireDefault(require('fs'));

  _fs = function _fs() {
    return data;
  };

  return data;
}

function _v() {
  const data = _interopRequireDefault(require('v8'));

  _v = function _v() {
    return data;
  };

  return data;
}

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.
 */
// TODO: Remove this
/// <reference path="../v8.d.ts" />
// JSON and V8 serializers are both stable when it comes to compatibility. The
// current JSON specification is well defined in RFC 8259, and V8 ensures that
// the versions are compatible by encoding the serialization version in the own
// generated buffer.
const JS_TYPE = '__$t__';
const JS_VALUE = '__$v__';
const JS_VF = '__$f__';

function replacer(_key, value) {
  // NaN cannot be in a switch statement, because NaN !== NaN.
  if (Number.isNaN(value)) {
    return {
      [JS_TYPE]: 'n'
    };
  }

  switch (value) {
    case undefined:
      return {
        [JS_TYPE]: 'u'
      };

    case +Infinity:
      return {
        [JS_TYPE]: '+'
      };

    case -Infinity:
      return {
        [JS_TYPE]: '-'
      };
  }

  switch (value && value.constructor) {
    case Date:
      return {
        [JS_TYPE]: 'd',
        [JS_VALUE]: value.getTime()
      };

    case RegExp:
      return {
        [JS_TYPE]: 'r',
        [JS_VALUE]: value.source,
        [JS_VF]: value.flags
      };

    case Set:
      return {
        [JS_TYPE]: 's',
        [JS_VALUE]: Array.from(value)
      };

    case Map:
      return {
        [JS_TYPE]: 'm',
        [JS_VALUE]: Array.from(value)
      };

    case Buffer:
      return {
        [JS_TYPE]: 'b',
        [JS_VALUE]: value.toString('latin1')
      };
  }

  return value;
}

function reviver(_key, value) {
  if (!value || (typeof value !== 'object' && !value.hasOwnProperty(JS_TYPE))) {
    return value;
  }

  switch (value[JS_TYPE]) {
    case 'u':
      return undefined;

    case 'n':
      return NaN;

    case '+':
      return +Infinity;

    case '-':
      return -Infinity;

    case 'd':
      return new Date(value[JS_VALUE]);

    case 'r':
      return new RegExp(value[JS_VALUE], value[JS_VF]);

    case 's':
      return new Set(value[JS_VALUE]);

    case 'm':
      return new Map(value[JS_VALUE]);

    case 'b':
      return Buffer.from(value[JS_VALUE], 'latin1');
  }

  return value;
}

function jsonStringify(content) {
  // Not pretty, but the ES JSON spec says that "toJSON" will be called before
  // getting into your replacer, so we have to remove them beforehand. See
  // https://www.ecma-international.org/ecma-262/#sec-serializejsonproperty
  // section 2.b for more information.
  const dateToJSON = Date.prototype.toJSON;
  const bufferToJSON = Buffer.prototype.toJSON;
  /* eslint-disable no-extend-native */

  try {
    // @ts-ignore intentional removal of "toJSON" property.
    Date.prototype.toJSON = undefined; // @ts-ignore intentional removal of "toJSON" property.

    Buffer.prototype.toJSON = undefined;
    return JSON.stringify(content, replacer);
  } finally {
    Date.prototype.toJSON = dateToJSON;
    Buffer.prototype.toJSON = bufferToJSON;
  }
  /* eslint-enable no-extend-native */
}

function jsonParse(content) {
  return JSON.parse(content, reviver);
} // In memory functions.

function deserialize(buffer) {
  return _v().default.deserialize
    ? _v().default.deserialize(buffer)
    : jsonParse(buffer.toString('utf8'));
}

function serialize(content) {
  return _v().default.serialize
    ? _v().default.serialize(content)
    : Buffer.from(jsonStringify(content));
} // Synchronous filesystem functions.

function readFileSync(filePath) {
  return _v().default.deserialize
    ? _v().default.deserialize(_fs().default.readFileSync(filePath))
    : jsonParse(_fs().default.readFileSync(filePath, 'utf8'));
}

function writeFileSync(filePath, content) {
  return _v().default.serialize
    ? _fs().default.writeFileSync(filePath, _v().default.serialize(content))
    : _fs().default.writeFileSync(filePath, jsonStringify(content), 'utf8');
}

var _default = {
  deserialize,
  readFileSync,
  serialize,
  writeFileSync
};
exports.default = _default;