Gecko [ c.stage.kornherr.net ]

Name	Size	Permission	Date	Action
index.js	5.01 KB	-rw-r--r--	2022-11-21 15:00

Rename

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

function _extendableBuiltin(cls) {
  function ExtendableBuiltin() {
    cls.apply(this, arguments);
  }

ExtendableBuiltin.prototype = Object.create(cls.prototype, {
    constructor: {
      value: cls,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });

if (Object.setPrototypeOf) {
    Object.setPrototypeOf(ExtendableBuiltin, cls);
  } else {
    ExtendableBuiltin.__proto__ = cls;
  }

return ExtendableBuiltin;
}

var ExtendableError = /*#__PURE__*/function (_extendableBuiltin2) {
  _inherits(ExtendableError, _extendableBuiltin2);

var _super = _createSuper(ExtendableError);

function ExtendableError() {
    var _this;

var message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';

_classCallCheck(this, ExtendableError);

_this = _super.call(this, message); // extending Error is weird and does not propagate `message`

Object.defineProperty(_assertThisInitialized(_this), 'message', {
      configurable: true,
      enumerable: false,
      value: message,
      writable: true
    });
    Object.defineProperty(_assertThisInitialized(_this), 'name', {
      configurable: true,
      enumerable: false,
      value: _this.constructor.name,
      writable: true
    });

if (Error.hasOwnProperty('captureStackTrace')) {
      Error.captureStackTrace(_assertThisInitialized(_this), _this.constructor);
      return _possibleConstructorReturn(_this);
    }

Object.defineProperty(_assertThisInitialized(_this), 'stack', {
      configurable: true,
      enumerable: false,
      value: new Error(message).stack,
      writable: true
    });
    return _this;
  }

return _createClass(ExtendableError);
}(_extendableBuiltin(Error));

var _default = ExtendableError;
exports["default"] = _default;
module.exports = exports.default;