crypto-conditions/dist/node/errors/base-error.js

Implementation of crypto-conditions in JavaScript

"use strict";

var _Reflect$construct = require("@babel/runtime-corejs3/core-js-stable/reflect/construct");

var _Object$defineProperty2 = require("@babel/runtime-corejs3/core-js-stable/object/define-property");

var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");

_Object$defineProperty2(exports, "__esModule", {
  value: true
});

exports.default = void 0;

var _defineProperty = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/define-property"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/createClass"));

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/classCallCheck"));

var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/assertThisInitialized"));

var _inherits2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/inherits"));

var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/possibleConstructorReturn"));

var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/getPrototypeOf"));

var _wrapNativeSuper2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/wrapNativeSuper"));

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = _Reflect$construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !_Reflect$construct) return false; if (_Reflect$construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

/**
 * @module util
 */

/**
 * Extensible error class.
 *
 * The built-in Error class is not actually a constructor, but a factory. It
 * doesn't operate on `this`, so if we call it as `super()` it doesn't do
 * anything useful.
 *
 * Nonetheless it does create objects that are instanceof Error. In order to
 * easily subclass error we need our own base class which mimics that behavior
 * but with a true constructor.
 *
 * Note that this code is specific to V8 (due to `Error.captureStackTrace`).
 */
var BaseError = /*#__PURE__*/function (_Error) {
  (0, _inherits2.default)(BaseError, _Error);

  var _super = _createSuper(BaseError);

  function BaseError(message) {
    var _this;

    (0, _classCallCheck2.default)(this, BaseError);
    _this = _super.call(this); // Set this.message

    (0, _defineProperty.default)((0, _assertThisInitialized2.default)(_this), 'message', {
      configurable: true,
      enumerable: false,
      value: message !== undefined ? String(message) : ''
    }); // Set this.name

    (0, _defineProperty.default)((0, _assertThisInitialized2.default)(_this), 'name', {
      configurable: true,
      enumerable: false,
      value: _this.constructor.name
    }); // Set this.stack

    if (Error.captureStackTrace) {
      Error.captureStackTrace((0, _assertThisInitialized2.default)(_this), _this.constructor);
    }

    return _this;
  }

  return (0, _createClass2.default)(BaseError);
}( /*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));

var _default = BaseError;
exports.default = _default;